openframe-oss-tenant README

The project's README from github.com/flamingo-stack/openframe-oss-tenant. As one markdown file: README.md.

OpenFrame

License

OpenFrame OSS Tenant

OpenFrame OSS Tenant is the multi-service, multi-tenant open-source foundation of the OpenFrame platform — an AI-powered MSP (Managed Service Provider) platform built by Flamingo that replaces expensive proprietary software with intelligent automation.

It integrates device management, real-time messaging, AI-assisted support (Mingo AI for technicians, Fae for clients), and event-driven automation across a polyglot microservice architecture built on Spring Boot (Java) and Rust.

OpenFrame v0.7.8: Fleet MDM Integration & Platform Architecture Deep Dive

✨ Features

🏗️ Architecture

All client traffic passes through the Spring Cloud Gateway. Backend services communicate via HTTP/GraphQL internally and asynchronously via Kafka and NATS JetStream. The Rust agent communicates exclusively over NATS.

graph TB
    subgraph Clients["Client Layer"]
        FrontendUI["openframe-frontend\n(Web UI)"]
    end

    subgraph Gateway["Edge Layer"]
        GW["Gateway Service :8081\n(Spring Cloud Gateway)"]
    end

    subgraph CoreServices["Core Services"]
        API["API Service :8080\n(Spring Boot + GraphQL)"]
        AuthServer["Auth Server :8082\n(OAuth2 / OIDC)"]
        ExtAPI["External API :8083\n(Spring Boot REST)"]
        StreamSvc["Stream Service :8085\n(Kafka Streams)"]
        ClientSvc["Client Service :8084\n(Spring Boot + NATS)"]
    end

    subgraph AgentLayer["Agent Layer"]
        OFClient["openframe-client\n(Rust System Agent)"]
    end

    subgraph DataLayer["Data Layer"]
        Mongo[("MongoDB")]
        Cassandra[("Cassandra")]
        Pinot[("Apache Pinot")]
        Redis[("Redis")]
        Kafka[("Apache Kafka")]
        NATS[("NATS JetStream")]
    end

    FrontendUI --> GW
    GW --> API
    GW --> AuthServer
    GW --> ExtAPI
    API --> Mongo
    API --> Pinot
    API --> Kafka
    StreamSvc --> Kafka
    StreamSvc --> Cassandra
    StreamSvc --> Pinot
    ClientSvc --> Mongo
    ClientSvc --> NATS
    AuthServer --> Mongo
    OFClient --> NATS
    OFClient --> API

Core Components

Component Language Port Responsibility
API Service Java / Spring Boot 3.3 8080 REST + GraphQL APIs; tickets, dialogs, AI settings, tenant management
Authorization Server Java / Spring Authorization Server 8082 Multi-tenant OAuth2/OIDC; RSA-signed JWT issuance; SSO (Google, Microsoft)
Gateway Java / Spring Cloud Gateway 8081 Security enforcement, JWT validation, routing, WebSocket proxy
External API Java / Spring Boot 8083 Rate-limited public API endpoints with API key management
Stream Service Java / Kafka Streams 8085 Real-time event normalization, enrichment, Cassandra/Pinot writes
Client Service Java / Spring Boot + NATS 8084 Agent lifecycle management, tool orchestration
openframe-client Rust — Cross-platform system agent; device registration, script execution, self-update

🚀 Quick Start

Prerequisites

Clone and Build

# 1. Clone the repository
git clone https://github.com/flamingo-stack/openframe-oss-tenant.git
cd openframe-oss-tenant

# 2. Build all backend services (Java / Spring Boot)
mvn clean install -DskipTests

# 3. Build the Rust agent
cd clients/openframe-client
OPENFRAME_VERSION=0.0.0-dev cargo build

# 4. Return to root
cd ../..

Run a Backend Service

# Start the API service
mvn spring-boot:run -pl openframe/services/openframe-api

Verify the Rust Agent

./clients/openframe-client/target/debug/openframe-client --help

Agent Doctor Check

cd clients/openframe-client
./target/debug/openframe-client doctor

Install Agent as a System Service

sudo ./target/release/openframe-client install \
  --serverUrl https://your-openframe-instance.example.com \
  --initialKey YOUR_INITIAL_KEY \
  --orgId YOUR_ORG_ID

🛠️ Technology Stack

Layer Technology
Backend services Java 21, Spring Boot 3.3, Spring Cloud Gateway, Spring Authorization Server, Netflix DGS (GraphQL)
Endpoint agent Rust (stable), async-nats, tokio, Velopack
Event streaming Apache Kafka, Kafka Streams
Agent messaging NATS JetStream
Primary datastore MongoDB (multi-tenant, tenant-scoped)
Time-series storage Apache Cassandra
Real-time analytics Apache Pinot
Cache / sessions Redis
Shared UI library @flamingo-stack/openframe-frontend-core (npm)

📁 Repository Structure

openframe-oss-tenant/
├── openframe/
│   └── services/              # Spring Boot microservices
│       ├── openframe-api/     # Core REST + GraphQL API (port 8080)
│       ├── openframe-gateway/ # Spring Cloud Gateway (port 8081)
│       ├── openframe-authorization-server/ # OAuth2/OIDC (port 8082)
│       ├── openframe-external-api/         # Public API (port 8083)
│       ├── openframe-client/  # Agent lifecycle service (port 8084)
│       ├── openframe-stream/  # Kafka Streams (port 8085)
│       ├── openframe-management/
│       └── openframe-config/
├── clients/
│   └── openframe-client/      # Rust cross-platform agent
├── manifests/                 # Kubernetes manifests & data service configs
└── pom.xml                    # Parent Maven POM

🔧 CLI Tools

The OpenFrame CLI tools are maintained in a separate repository:

📚 Documentation

Full documentation is available in the docs/ directory:

🤝 Community

All support, feature requests, bug reports, and development discussions happen in the OpenMSP Slack community — GitHub Issues and GitHub Discussions are not used.

Built with 💛 by the Flamingo team

openframe-oss-tenant (flamingo-stack/openframe-oss-tenant)

Searching Database…

1.1K ·GitHub
Openframe-oss-tenant
What is this?OpenFrame OSS Tenant is the open-source, multi-tenant foundation of OpenFrame, an AI-powered MSP (Managed Service Provider) platform that replaces expensive proprietary RMM/support software with intelligent automation, device management, and AI-assisted support.
Is this one app or a bunch of connected services?It is a polyglot microservice platform: multiple Spring Boot (Java) backend services (API, Gateway, Auth Server, Stream, Client) plus a separate Rust-based endpoint agent, all wired together with Kafka, NATS, and shared datastores.
How do I get it running locally?You clone the repo and build the Java services with Maven and the Rust agent with Cargo, then start individual backend services and verify/install the Rust agent as a system service, following the Quick Start section.
What do I need installed before building it?You need JDK 21, Apache Maven 3.9+, and Rust 1.78+ (installed via rustup) before you can build any of the components.
Is self-hosting this a quick setup or a real project?Running it requires juggling seven backend services plus MongoDB, Cassandra, Apache Pinot, Redis, Kafka, and NATS JetStream — there's no single Docker-compose one-liner shown, just per-service Maven/Rust build steps, so self-hosting takes real infrastructure effort.
Who is this platform built for?It's built for MSP technicians who need remote management, scripting (bash, PowerShell, Python, Nushell), and compliance checking across managed client endpoints, plus the clients they support.
Does the endpoint agent run the same way on Windows, macOS, and Linux?Yes, the Rust-based openframe-client runs as a native system service on all three, handling script execution, tool management, and self-updating via Velopack.
How is data kept separate between different customers (tenants)?Each tenant gets its own OAuth2 clients, RSA-signed JWTs, and tenant-scoped MongoDB access via TenantAwareMongoTemplate, so data doesn't leak across tenant boundaries.
What is Mingo AI and what is Fae?Mingo AI is the AI assistant aimed at MSP technicians, while Fae is the AI assistant for end clients; both are powered by streaming LLMs that deliver responses in real time.
Why does the platform use both Kafka and NATS?Apache Kafka (with Kafka Streams) handles durable, high-volume event processing like device events and analytics writes, while NATS JetStream carries lower-latency agent messaging and streamed AI response chunks.
Where are the OpenFrame CLI tools?The command-line tools are not in this repo — they live in a separate project, flamingo-stack/openframe-cli, with their own installation guide and docs.
What are similar projects?SpringAll, JeecgBoot, SpringBoot-Labs, anythingmcp, emqx, spring-boot-demo, turnstone, Sa-Token
Which topics is it in?kafka, jwt, sso, oauth2, graphql, mongodb, microservices, redis, websocket, distributed-systems, shell, rest-api
Creator
flamingo-stack
Size
327.4 MB
Stars
1.1K
Updated
CommitOct 16Release1.1.5Aug 14
Age
1y
Commits · 90 Days