Ops-Center

The AI Infrastructure Command Center

Manage users, billing, LLMs, and services from one dashboard.

Quick Start · Features · Roadmap · Used in Production · Documentation

What is Ops-Center?

Ops-Center is an open source operations dashboard for AI infrastructure. It provides centralized management for users, subscriptions, LLM routing, and integrated services.

Think of it as your infrastructure control panel: user management, billing, API routing, and service orchestration in one place.

Why Ops-Center?

Building an AI SaaS typically requires stitching together a dozen services. Ops-Center consolidates them into one self-hosted platform.

What It Replaces

Ops-Center Feature	Replaces	Typical Cost
LiteLLM integration	OpenRouter, Portkey, Helicone	$50-500/mo + API markup
Keycloak SSO	Auth0, Okta, Clerk, Cognito	$100-1000+/mo
Lago + Stripe	Metronome, Orb, Amberflo	$500-2000+/mo
Built-in dashboards	Datadog, Splunk, Mixpanel	$100-1000+/mo
Rate limiting, keys	Kong, Apigee, AWS API Gateway	$200-500+/mo
Full admin UI	Retool, Appsmith, custom dev	$50-500/mo
Cloudflare + Namecheap	Multiple dashboards	Management overhead
Prometheus + Grafana	Datadog, Grafana Cloud	$50-500/mo
Self-service dashboard	Custom user portals, Stripe Portal	Dev time
Role-based access control	Permit.io, Oso, custom RBAC	$100-500/mo
Apps dashboard with SSO	Okta Dashboard, custom app portals	$50-200/mo

Cost Comparison

Without Ops-Center

Service	Monthly Cost
Auth0 / Clerk	$200
OpenRouter	API markup fees
Metronome / Orb	$500
Datadog	$200
Retool	$100
Kong / API Gateway	$200
Custom integration	Dev time
Total	$1,200+ /mo

With Ops-Center

Component	Cost
Self-hosted	$0
Your infrastructure	Your servers
No per-seat fees	$0
No API markup	$0
No vendor lock-in	$0
Total	$0 platform fees*

_{*You pay only for your own infrastructure and any LLM provider API costs (OpenAI, Anthropic, etc.)}

What Makes It Different

BYOK Support
Let users bring their own API keys. No platform markup. Unique feature most platforms lack.

Unified System
Credit system tied directly to LLM usage with automatic cost tracking per user and org.

Dynamic Access
Apps appear based on subscription tier. Database-driven, no code deploys needed.

One Interface
DNS, users, billing, LLMs, services. One dashboard instead of 10 browser tabs.

Features

Identity and Access

Keycloak SSO with Google, GitHub, and Microsoft providers
Role-based access control (RBAC) with 5-tier permission hierarchy
Multi-tenant organization and team management
User impersonation for admin support
Complete audit logging across all operations

User Self-Service

Personal dashboard with usage stats and activity
Self-service profile and account management
API key generation and management
Subscription upgrades, downgrades, and cancellations
Invoice history and payment method management

LLM Management

1500+ models via LiteLLM (OpenAI, Anthropic, Google, Meta, and more)*
BYOK support: bring your own API keys with no platform markup
Credit system with automatic usage tracking
Image generation with DALL-E and Stable Diffusion
Smart routing to cheapest or fastest provider

_{*Model availability depends on configured providers (OpenRouter, direct API keys, self-hosted models, etc.)}

Billing and Subscriptions

Lago + Stripe integration
Usage-based billing with real-time metering
Tiered subscription plans with feature gating
Per-user and per-organization cost tracking
Automated invoicing and payment processing

Apps Dashboard

Centralized launcher for all integrated services
Dynamic tier-based access control
Single sign-on across all apps
Admin control over which tiers access which apps
Database-driven configuration (no code deploys needed)

Infrastructure

Cloudflare DNS management and zone control
Namecheap domain management with migration support
Traefik reverse proxy integration
Prometheus and Grafana monitoring
Docker-native deployment

Screenshots

Apps Marketplace	LLM Model Catalog
User Management	BYOK API Keys
Billing & Subscriptions	SSO Login

Quick Start

Prerequisites

Requirement	Included
Docker & Docker Compose	Required
PostgreSQL	✅ In compose
Redis	✅ In compose
Keycloak	Configure yours

System Requirements

Resource	Minimum
CPU	2 cores
RAM	4 GB
Disk	20 GB
OS	Linux, macOS, Windows (WSL2)

git clone https://github.com/saashqdev/ops-center.git
cd ops-center

cp .env.example .env.auth
# Edit .env.auth with your settings

docker compose -f docker-compose.direct.yml up -d

🎉 Access your dashboard at `http://localhost:8084`

Keycloak Setup

Ops-Center requires Keycloak for authentication. You can use an existing Keycloak instance or deploy one alongside.

Manual Setup

Step	Action
1	Create Realm: `ops-center`
2	Create Client: `ops-center` (confidential, OIDC)
3	Set Valid Redirect URIs: `http://localhost:8084/*`
4	Set Web Origins: `http://localhost:8084`
5	Enable identity providers (Google, GitHub, Microsoft)
6	Create realm roles: `admin`, `user`, `org-admin`
7	Copy Client Secret → `KEYCLOAK_CLIENT_SECRET` in `.env.auth`

Quick Import (Recommended)

# Import pre-configured realm
docker exec -it keycloak \
  /opt/keycloak/bin/kc.sh import \
  --file /tmp/realm-export.json

The included keycloak/realm-export.json provides:

✅ Pre-configured ops-center client
✅ Google, GitHub, Microsoft providers (add your keys)
✅ Default roles and permissions
✅ Recommended session settings

Tip: For local development, you can run Keycloak in Docker:

docker run -d --name keycloak -p 8080:8080 \
  -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin \
  quay.io/keycloak/keycloak:latest start-dev

Deployment Options

Choose the right configuration for your use case:

Goal	Command	Description
Local Development	`docker compose -f docker-compose.direct.yml up -d`	Fastest setup, direct port access
Behind Traefik	`docker compose -f docker-compose.traefik.yml up -d`	Reverse proxy with automatic TLS
With Monitoring	`docker compose -f docker-compose.monitoring.yml up -d`	Adds Prometheus + Grafana
With LiteLLM	`docker compose -f docker-compose.litellm.yml up -d`	Includes LiteLLM proxy container
Production	`docker compose -f docker-compose.prod.yml up -d`	Optimized for production
CenterDeep	`docker compose -f docker-compose.centerdeep.yml up -d`	Specialized search configuration

You can combine configurations:

docker compose -f docker-compose.direct.yml -f docker-compose.monitoring.yml up -d

Ports & URLs

Service	Port	Default URL	Notes
Dashboard	8084	http://localhost:8084	Main Ops-Center UI
Frontend Dev	5173	http://localhost:5173	Vite dev server (npm run dev)
API Docs	8084	http://localhost:8084/docs	FastAPI OpenAPI docs
Keycloak	8080	http://localhost:8080	Your Keycloak instance
PostgreSQL	5432	-	Internal, not exposed by default
Redis	6379	-	Internal, not exposed by default
Prometheus	9090	http://localhost:9090	With monitoring compose
Grafana	3000	http://localhost:3000	With monitoring compose

Security Notes

⚠️ Production Checklist

Run behind TLS/HTTPS (use Traefik or nginx)
Never expose PostgreSQL/Redis to public internet
Use strong, unique values for all secrets
Configure Keycloak on a private network
Enable rate limiting on public endpoints
Review SECURITY.md before deploying

🔐 Secret Management

# Generate secure secrets
openssl rand -hex 32  # SESSION_SECRET_KEY
openssl rand -hex 32  # ENCRYPTION_KEY

# Never commit .env files
echo ".env*" >> .gitignore

Store production secrets in:

Environment variables
Docker secrets
Vault/AWS Secrets Manager

Configuration

# 🔐 Authentication (Keycloak)
KEYCLOAK_URL=http://your-keycloak:8080
KEYCLOAK_REALM=your-realm
KEYCLOAK_CLIENT_ID=ops-center
KEYCLOAK_CLIENT_SECRET=your-secret

# 🐘 Database
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_USER=ops
POSTGRES_PASSWORD=secure-password
POSTGRES_DB=ops_center

# 💳 Billing
LAGO_API_KEY=your-lago-key
STRIPE_SECRET_KEY=your-stripe-key

# 🤖 LLM Proxy
LITELLM_MASTER_KEY=your-litellm-key
OPENROUTER_API_KEY=your-openrouter-key

# ☁️ DNS Management
CLOUDFLARE_API_TOKEN=your-cloudflare-token
NAMECHEAP_API_KEY=your-namecheap-key

📄 See .env.example for all configuration options

Architecture

flowchart TB
    subgraph External["External Services"]
        KC[("🔐 Keycloak<br/>SSO")]
        LAGO[("💳 Lago<br/>Billing")]
        STRIPE[("💰 Stripe<br/>Payments")]
        LLM[("🤖 LiteLLM<br/>1500+ Models")]
        CF[("☁️ Cloudflare<br/>DNS")]
    end

    subgraph OpsCenter["Ops-Center"]
        direction TB
        API["⚡ FastAPI Backend"]
        UI["🎨 React Dashboard"]

        subgraph Features["Core Features"]
            AUTH["🔑 Auth & RBAC"]
            BILL["📊 Usage & Credits"]
            APPS["📱 Apps Launcher"]
            USERS["👥 User Management"]
            ADMIN["⚙️ Admin Panel"]
        end
    end

    subgraph Data["Data Layer"]
        PG[("🐘 PostgreSQL")]
        REDIS[("⚡ Redis")]
    end

    subgraph UserApps["Integrated Apps"]
        CHAT["💬 Chat UI"]
        SEARCH["🔍 Search"]
        AGENTS["🤖 Agents"]
        CUSTOM["📦 Your Apps"]
    end

    KC --> API
    LAGO --> API
    STRIPE --> API
    LLM --> API
    CF --> API

    API --> PG
    API --> REDIS
    API --> UI

    UI --> Features

    API --> UserApps

    style OpsCenter fill:#1a1a2e,stroke:#8b5cf6,stroke-width:2px
    style External fill:#0d1117,stroke:#30363d,stroke-width:1px
    style Data fill:#0d1117,stroke:#30363d,stroke-width:1px
    style UserApps fill:#0d1117,stroke:#30363d,stroke-width:1px
    style Features fill:#2d1b4e,stroke:#8b5cf6,stroke-width:1px

Stack

Backend
Frontend
Database
Auth
Billing
Infrastructure

Integrations

Service	Purpose	Integration
	Identity and SSO	`Native OIDC`
	Usage-based billing	`REST API`
	Payment processing	`Webhooks`
	LLM routing (1500+ models)	`OpenAI-compatible`
	DNS management	`REST API`
	Domain management	`REST API`
	Metrics collection	`/metrics endpoint`
	Dashboards	`Prometheus datasource`
	Reverse proxy	`Docker labels`

Development

Frontend (hot reload)

npm install
npm run dev  # http://localhost:5173

Backend

cd backend
pip install -r requirements.txt
uvicorn server:app --reload --port 8084

Build and Deploy

npm run build
docker compose -f docker-compose.direct.yml up -d --build

Verify

docker ps | grep ops-center
curl http://localhost:8084/health

Project Structure

ops-center/
├── 📂 backend/               # FastAPI application
│   ├── 📄 server.py          # Main entry point
│   ├── 📄 *_api.py           # API routers (50+ modules)
│   └── 📂 migrations/        # Database migrations
├── 📂 src/                   # React frontend
│   ├── 📂 pages/             # Page components
│   ├── 📂 components/        # Reusable components
│   └── 📂 contexts/          # React contexts
├── 📂 public/                # Static assets
├── 📂 docs/                  # Documentation
│   └── 📂 screenshots/       # App screenshots
└── 🐳 docker-compose.*.yml   # Docker configurations

Documentation

CLAUDE.md

Version History

Guidelines

Full Documentation

Roadmap

🎖️ Coming Soon: The Colonel Agent

An AI Platform Engineer that integrates apps, configures billing, and manages organizations—via conversation.

"Colonel, set up a new client with org-admin, manager, and user tiers."

Phase 1
Foundation

CLI tool
Webhooks
Docker Hub images

Phase 2
Intelligence

🎖️ The Colonel v1
Smart alerts
Cost optimization

Phase 3
Scale

Multi-server mgmt
Kubernetes
Terraform/IaC

Phase 4
Enterprise

Mobile app
Advanced RBAC
HA deployment

📍 View Full Roadmap →

Contributing

We welcome contributions! See CONTRIBUTING.md for detailed guidelines.

flowchart LR
    A[🍴 Fork] --> B[🌿 Branch]
    B --> C[💻 Code]
    C --> D[✅ Test]
    D --> E[📤 Push]
    E --> F[🔀 PR]

    style A fill:#6366f1,color:#fff
    style B fill:#8b5cf6,color:#fff
    style C fill:#a855f7,color:#fff
    style D fill:#d946ef,color:#fff
    style E fill:#ec4899,color:#fff
    style F fill:#f43f5e,color:#fff

git checkout -b feature/your-feature    # Create branch
# Make your changes
git commit -m 'feat: add your feature'  # Commit
git push origin feature/your-feature    # Push
# Open a Pull Request on GitHub