LobeHub: Chief Agent Operator for multi-agent orchestration

LobeHub is your Chief Agent Operator (CAO), organizing your agents into 7×24 operations by hiring, scheduling, and reporting on your entire AI team. Unlike single-purpose chat interfaces, LobeHub treats Agents as the unit of work, providing infrastructure where humans and agents co-evolve.

Key capabilities:

• Agent Builder: Create custom agents that auto-configure based on your needs
• Agent Groups: Enable parallel collaboration with multiple agents sharing context
• Personal Memory: White-box, structured memory that adapts to your workflows
• IM Gateway: Integrate agents into messaging platforms (Discord, Telegram, Slack, etc.)
• Pages & Projects: Write and refine content with agents in shared spaces
• Scheduling: Schedule agent runs to execute tasks while you're away
• 10,000+ Skills: Access to a vast library of MCP-compatible tools and plugins

LobeHub is built on a production-grade, monorepo architecture:

Frontend:

• Next.js 16.1.5 with app router
• React 19.2.5 with Vite 8.0.14
• TypeScript 6.0.3
• Ant Design 6.3.5 UI components
• Zustand for state management
• TanStack Query for data fetching
• Lexical editor (0.42.0) for rich text
• PWA capabilities with offline support

Backend:

• Next.js API routes + tRPC 11.8.1 for server communication
• Hono 4.11.1 for edge functions
• Drizzle ORM 0.45.1 for database access
• Better Auth 1.4.6 for authentication
• Redis (ioredis 5.9.2) for caching
• Upstash QStash for reliable scheduled tasks

Database:

• PostgreSQL (primary) via drizzle-orm
• Neo4j / NeoServerless for graph-based memory
• Redis for session caching
• Neon serverless (optional managed option)

AI Infrastructure:

• ModelContextProtocol (MCP) SDK 1.26.0
• Vercel AI SDK integration
• Support for 50+ model providers:
  • OpenAI, Anthropic, Google Gemini
  • AWS Bedrock, Azure AI, Nvidia NIM
  • Ollama, Mistral, xAI, DeepSeek
  • ModelScope, Qwen, 01.AI, Zhipu
• LangFuse observability for tracing
• OpenTelemetry for metrics

Agent & Tooling:

• Built-in agent gateway client
• Heterogeneous agent support
• Python interpreter for code execution
• Web crawling capabilities
• Cloud sandbox for secure execution

Desktop:

• Electron-based desktop app
• System tray integration
• Native shortcuts and notifications

LobeHub Architecture
├── Frontend (Next.js 16)
│   ├── React 19 + Vite
│   ├── Ant Design 6
│   ├── Lexical Editor
│   ├── Zustand (state)
│   └── PWA Support
│
├── Backend
│   ├── tRPC 11 (API)
│   ├── Hono (edge)
│   ├── Drizzle ORM
│   ├── Better Auth
│   └── Redis + QStash
│
├── Database
│   ├── PostgreSQL (primary)
│   ├── Neo4j (memory graph)
│   ├── Redis (cache)
│   └── File storage (S3-compatible)
│
├── AI Layer
│   ├── MCP SDK 1.26
│   ├── 50+ Model Providers
│   ├── LangFuse Tracing
│   └── OpenTelemetry
│
├── Agent System
│   ├── Agent Gateway
│   ├── Heterogeneous Agents
│   ├── Python Interpreter
│   ├── Cloud Sandbox
│   └── 10,000+ Skills
│
└── Desktop App
    ├── Electron
    ├── System Integration
    └── Native Features

Before installing LobeHub, ensure you have:

For Docker deployment (recommended):

• Docker Engine 24.0+
• Docker Compose 2.0+
• At least 4GB of free memory
• Port 3210 available

For development:

• Node.js 24.x (or Bun 1.0+)
• pnpm 10.x
• PostgreSQL 15+ running locally or accessible
• Redis 7.x (optional, for caching)
• Git for cloning repository

For self-hosting:

• Domains configured with SSL/TLS
• Database hosting (Neon, Supabase, or self-hosted Postgres)
• File storage (S3-compatible: AWS S3, MinIO, etc.)
• SMTP server for email notifications (optional)

# Check Docker installation
docker --version
docker compose version

# Check Node.js version (for development)
node --version  # Should be 24.x
pnpm --version  # Should be 10.x

# Check PostgreSQL (for development)
psql --version  # Should be 15+

# Check Redis (optional, for development)
redis-cli --version

The fastest way to deploy LobeHub is using Docker. This sets up the complete application with PostgreSQL and Redis in isolated containers.

The official Docker image includes pre-built production assets and supports environment variable configuration.

# Quick start with a single command
docker run -d \
  --name lobehub \
  -p 3210:3210 \
  -v lobehub_data:/app/data \
  -e DATABASE_URL="postgresql://postgres:password@localhost:5432/lobehub" \
  -e AUTH_SECRET="$(openssl rand -base64 32)" \
  -e ENABLED_OPENAI=true \
  -e OPENAI_API_KEY="sk-your-api-key" \
  lobehub/lobehub:latest

# Access at http://localhost:3210

# Or use docker-compose for full stack
cat > docker-compose.yml << 'EOF'
name: lobehub

services:
  lobehub:
    image: lobehub/lobehub:latest
    container_name: lobehub
    ports:
      - 3210:3210
    restart: always
    environment:
      - OPENAI_API_KEY=YOUR_API_KEY
      - ENABLED_OPENAI=true
    volumes:
      - lobehub_data:/app/data

  postgresql:
    image: postgres:16-alpine
    container_name: lobehub_postgres
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=lobehub
    ports:
      - 5432:5432
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: always

  redis:
    image: redis:7-alpine
    container_name: lobehub_redis
    ports:
      - 6379:6379
    volumes:
      - redis_data:/data
    restart: always

volumes:
  lobehub_data:
  postgres_data:
  redis_data:
EOF

docker compose up -d

echo "LobeHub is running at http://localhost:3210"

To contribute or run LobeHub from source, clone the repository and follow the development setup. LobeHub uses a monorepo structure with pnpm workspaces.

The development environment requires local PostgreSQL and optionally Redis for caching.

# Clone the repository (canary branch is the default)
git clone https://github.com/lobehub/lobehub.git
cd lobehub

# Enable corepack for package management
corepack enable
corepack prepare

# Install dependencies
pnpm i

# Copy environment file and configure
cp .env.example .env.local

# Edit .env.local with your settings:
# - OPENAI_API_KEY=sk-your-key
# - DATABASE_URL=postgresql://user:pass@localhost:5432/lobehub
# - AUTH_SECRET=$(openssl rand -base64 32)

# Start local database services (if using docker-compose/dev)
# Make sure PostgreSQL and Redis are running

# Run database migrations
pnpm db:migrate

# Start development server
pnpm dev

# Access at http://localhost:3010

# For desktop app development:
pnpm run dev:desktop

LobeHub is highly configurable via environment variables. The main categories are:

Core Configuration:

• APP_URL: Base URL for the application
• NEXT_PUBLIC_BASE_PATH: For subpath deployments
• AUTH_SECRET: Secret key for session encryption (required)
• ENABLED_SIGNUP: Allow user registration

Database:

• DATABASE_URL: PostgreSQL connection string
• NEO_SERVERLESS_URL: Neo4j/NeoServerless for memory graph
• REDIS_URL: Redis connection for caching

AI Providers (pattern: ENABLED_{PROVIDER} + PROVIDER_API_KEY):

• ENABLED_OPENAI, OPENAI_API_KEY
• ENABLED_ANTHROPIC, ANTHROPIC_API_KEY
• ENABLED_GOOGLE, GOOGLE_GENERATIVE_AI_API_KEY
• ENABLED_OLLAMA, OLLAMA_PROXY_URL
• ENABLED_AZURE, AZURE_API_KEY
• And 45+ other providers

Storage:

• S3_ENDPOINT, S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY
• S3_BUCKET, S3_REGION

Observability:

• LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY
• NEXT_PUBLIC_SENTRY_DSN

Analytics:

• NEXT_PUBLIC_ANALYTICS_POSTHOG

# Copy the example environment file
cp .env.example .env.local

# Minimal configuration for getting started
cat > .env.local << 'EOF'
# App settings
APP_URL="http://localhost:3010"
ENABLED_SIGNUP=true

# Authentication (REQUIRED)
AUTH_SECRET="$(openssl rand -base64 32)"

# Database (PostgreSQL required)
DATABASE_URL="postgresql://postgres:postgres@localhost:5432/lobehub"

# Redis (optional but recommended)
REDIS_URL="redis://localhost:6379"

# OpenAI (example provider)
ENABLED_OPENAI=true
OPENAI_API_KEY="sk-your-openai-key-here"

# Optional: NeoServerless for advanced memory
# NEO_SERVERLESS_URL="wss://your-neo-instance.url"

# Optional: File storage (S3 compatible)
# S3_ENDPOINT="https://your-s3.endpoint"
# S3_ACCESS_KEY_ID="your-access-key"
# S3_SECRET_ACCESS_KEY="your-secret-key"
# S3_BUCKET="lobehub-files"
EOF

# For production, generate secure secrets:
# AUTH_SECRET=$(openssl rand -base64 32)
# S3_ACCESS_KEY_ID=$(openssl rand -base64 16)
# S3_SECRET_ACCESS_KEY=$(openssl rand -base64 40)

LobeHub provides powerful capabilities for agent orchestration:

Agent Builder: Create custom agents by describing their role. The system auto-configures the agent with appropriate models, skills, and context templates. Agents can be given specialized personas, knowledge bases, and tool access.

Agent Groups: Assemble multiple agents into collaborative teams. Each agent brings specialized capabilities while sharing a common context. Agents can:

• Work in parallel on subtasks
• Iterate on each other's work
• Maintain specialized sub-discussions
• Report back with consolidated results

Pages (Collaborative Documents): Shared writing spaces where you and agents collaborate on documents. Features include:

• Real-time editing with Lexical editor
• Per-section agent collaboration
• Version history and diffs
• Markdown export
• Rich formatting support

Projects & Workspaces: Organize work into projects with:

• Project-scoped agent teams
• Shared context and history
• Progress tracking
• Team-level workspaces with permission controls

Personal Memory: LobeHub builds understanding of you and your preferences:

• Continual learning from interactions
• White-box, editable memory structure
• Context-aware recall
• Cross-conversation knowledge

Scheduling: Schedule agent runs for:

• Automated monitoring tasks
• Regular reports
• Time-sensitive actions
• Background processing

LobeHub integrates with messaging platforms so agents live where you chat. Supported platforms include:

Supported Platforms:

• Discord (webhook or bot)
• Telegram
• Slack (via chat-adapter)
• Feishu/Lark (Chinese platform)
• QQ (Chinese platform)
• Line
• iMessage

Usage: Configure the platform credentials and LobeHub routes messages to appropriate agents. Agents maintain conversation state and can use all standard tools.

Features:

• Message routing to specific agents
• Conversation history preservation
• File sharing support
• Rich response formatting

# Discord integration
cat >> .env.local << 'EOF'
# Discord webhook (simple mode)
DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/..."

# OR Discord bot (full integration)
DISCORD_BOT_TOKEN="your-bot-token"
DISCORD_BOT_GUILD_ID="your-guild-id"
EOF

# Telegram integration
cat >> .env.local << 'EOF'
TELEGRAM_BOT_TOKEN="your-telegram-bot-token"
# Telegram bot must be added to chat for messages to work
EOF

# Feishu (Lark) integration
cat >> .env.local << 'EOF'
ENABLED_FEISHU=true
FEISHU_APP_ID="cli_..."
FEISHU_APP_SECRET="your-secret"
FEISHU_VERIFY_TOKEN="verification-token"
EOF

# After adding credentials, messages sent to the platform
# are routed to LobeHub agents for response

LobeHub fully supports the Model Context Protocol (MCP) - an open standard for connecting AI models to tools and data sources.

Built-in MCP Tools:

• File system access (read/write)
• Code execution sandbox
• Database queries
• Web search and browsing
• Calendar and schedules
• Email access
• Custom tool definitions

MCP Server: Deploy LobeHub as an MCP server to expose agent capabilities to other MCP-compatible clients like:

• Claude Desktop
• Continue / Copilot
• Custom MCP clients

Extending with Custom Tools: Create custom MCP tools by defining tool schemas. Tools can be:

• Pre-built (from LobeHub's 10,000+ library)
• Custom (defined in your workspace)
• External (via HTTP endpoints)

LobeHub supports RAG (Retrieval-Augmented Generation) with knowledge bases:

Supported Sources:

• PDF, DOCX, PPTX documents
• Markdown files
• Notion pages
• GitHub repositories
• Web pages (via crawling)
• EPUB books
• Audio transcripts
• CSV/JSON data files

Features:

• Automatic chunking and indexing
• Semantic search with embeddings
• Source attribution in responses
• Incremental updates
• Multi-format support

Vector Storage: LobeHub integrates with various vector databases for efficient retrieval:

# Upload documents to knowledge base
# Via UI: Settings > Knowledge Base > Upload

# Or programmatically via API:
# POST /api/knowledge/upload
# multipart/form-data with 'file' field

# Knowledge sources are automatically:
# 1. Chunked into digestible segments
# 2. Converted to embeddings
# 3. Stored in vector database
# 4. Linked to agent context

# Access knowledge in agent prompts:
# {% knowledge query="user question" %}

LobeHub offers multiple deployment options:

Vercel (Hosted):

• Free tier available
• Automatic deployments
• Managed serverless database
• URL: https://app.lobehub.com

Docker Self-Hosted:

• Full control over data
• No vendor lock-in
• Requires your own database
• Docker Compose for full stack

Production (VPS/Cloud):

• Deploy on DigitalOcean, AWS, GCP
• Use Docker with reverse proxy
• Configure SSL with Let's Encrypt
• Set up monitoring and backups

Electron Desktop:

• Native desktop application
• System tray integration
• Offline capabilities
• Local-first architecture

Kubernetes:

• Helm charts available
• Horizontal scaling
• Service mesh integration

# Vercel deployment (auto-deploy from GitHub)
# Link your GitHub repo in Vercel dashboard
# Set environment variables in Vercel project settings

# Docker Compose for production
cat > docker-compose.prod.yml << 'EOF'
name: lobehub-prod

services:
  traefik:
    image: traefik:latest
    command:
      - '--providers.docker=true'
      - '--providers.docker.exposedbydefault=false'
      - '--entrypoints.web.address=:80'
      - '--entryports.webhttp.address=:443'
    ports:
      - 80:80
      - 443:443
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - traefik_acme:/acme
    labels:
      - 'traefik.enable=true'
      - 'traefik.http.routers.traefik.rule=Host(traefik.yourdomain.com)'
    restart: always

  lobehub:
    image: lobehub/lobehub:latest
    labels:
      - 'traefik.enable=true'
      - 'traefik.http.routers.lobehub.rule=Host(app.yourdomain.com)'
      - 'traefik.http.routers.lobehub.tls=true'
    environment:
      - APP_URL=https://app.yourdomain.com
      - DATABASE_URL=postgresql://user:pass@postgresql:5432/lobehub
      - AUTH_SECRET=${AUTH_SECRET}
    depends_on:
      - postgresql
    restart: always

  postgresql:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=lobehub
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=lobehub
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: always

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    restart: always

volumes:
  traefik_acme:
  postgres_data:
  redis_data:
EOF

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

For enterprise deployments, LobeHub provides advanced configuration options:

Multi-tenancy:

• Workspace isolation
• Custom branding per tenant
• Separate data schemas
• Quota management

Observability:

• LangFuse integration for LLM tracing
• OpenTelemetry metrics export
• Sentry error tracking
• Custom webhook notifications

Security:

• Role-based access control (RBAC)
• OAuth providers (GitHub, Google, etc.)
• SSO via OIDC
• Content Moderation API
• Audit logging

Performance:

• Redis caching layer
• CDN for static assets
• Database connection pooling
• Streaming responses

# Enterprise configuration example

cat >> .env.local << 'EOF'
# Observability
LANGFUSE_PUBLIC_KEY="pk-lf-..."
LANGFUSE_SECRET_KEY="sk-lf-..."
LANGFUSE_HOST="https://cloud.langfuse.com"

# Sentry Error Tracking
SENTRY_ORG="your-org"
SENTRY_PROJECT="lobehub"
SENTRY_AUTH_TOKEN="your-sentry-token"
NEXT_PUBLIC_SENTRY_DSN="https://key@sentry.io/123"

# OpenTelemetry (Jaeger)
OTEL_EXPORTER_JAEGER_ENDPOINT="http://jaeger:14250"
OTEL_SERVICE_NAME="lobehub-prod"

# Content Moderation
MODERATION_API_URL="https://api.moderation.com/v1"  
MODERATION_API_KEY="mod-key"
ENABLED_MODERATION=true

# RBAC Configuration
RBAC_ENABLED=true
ADMIN_ROLE_IDS="admin-id-1,admin-id-2"

# Audit Logging
AUDIT_LOG_ENABLED=true
AUDIT_LOG_RETENTION_DAYS=90
EOF

Common issues and solutions:

Database connection errors:

• Verify PostgreSQL is running and accessible
• Check DATABASE_URL format
• Ensure database exists or enable auto-creation

Authentication fails:

• AUTH_SECRET must be a secure random string
• Change if session issues occur
• Regenerate with: AUTH_SECRET=$(openssl rand -base64 32)

Model provider errors:

• Verify API keys are correct
• Check provider is enabled (ENABLED_OPENAI=true)
• Review provider-specific requirements (rate limits, quota)

Docker startup failures:

• Check port 3210 is available
• Verify volumes are writable
• Review logs: docker logs lobehub

Memory issues:

• Increase max memory: NODE_OPTIONS=--max-old-space-size=8192
• For large deployments, use database connection pooling

# Debug container (exec into running container)
docker exec -it lobehub sh

# View logs
docker logs lobehub --tail 100
docker compose logs -f lobehub

# Check database connection
docker exec lobehub psql $DATABASE_URL -c "SELECT version();"

# Test API health
curl http://localhost:3210/api/health

# Verify environment variables
docker exec lobehub env | grep -E "DATABASE|AUTH|OPENAI"

# Reset data (caution: deletes all data)
docker compose down -v
docker compose up -d

# For development, check console errors
# Browser DevTools > Console
# Terminal output for server errors

Join the LobeHub community and access resources:

Official Resources:

• Documentation: https://lobehub.com (official site with guides)
• GitHub: https://github.com/lobehub/lobehub
• Changelog: https://github.com/lobehub/lobehub/blob/canary/CHANGELOG.md

Community:

• Discord: https://discord.gg/lobehub (active community, ~10,000+ members)
• Issues: https://github.com/lobehub/lobehub/issues
• Discussions: https://github.com/lobehub/lobehub/discussions

Deployment Guides:

• Vercel Deploy: https://vercel.com/templates/lobehub
• Docker Hub: https://hub.docker.com/r/lobehub/lobehub
• Sealos Guide: https://sealos.io (one-click deploy)
• Alibaba Cloud: Cloud marketplace listing

Support:

• Product Hunt: #1 Product of the Day
• TrendShift trending repository
• Vercel Open Source Program participant

Resources:
- Docs: https://lobehub.com
- GitHub: https://github.com/lobehub/lobehub  
- Discord: https://discord.gg/lobehub
- Docker Hub: https://hub.docker.com/r/lobehub/lobehub
- Vercel Deploy: https://vercel.com/templates/lobehub
- Changelog: https://github.com/lobehub/lobehub/blob/canary/CHANGELOG.md
- Issues: https://github.com/lobehub/lobehub/issues

Community Recognition:
- Product Hunt #1
- 77,800+ GitHub Stars
- 15,300+ Forks
- Vercel OSS Program
- TrendShift Trending

Current version: 2.2.0

Key version highlights:

• Full MCP 1.26 support
• NeoServerless integration for memory graph
• Enhanced heterogeneous agent capabilities
• Desktop app with system integration
• Support for 50+ AI model providers
• 10,000+ ready-to-use skills

The canary branch is the default and receives the latest features. For stability, tag-specific releases are available on Docker Hub.

Version: 2.2.0
Branch: canary (default) / main (stable)

Latest Features:
- MCP 1.26 SDK integration
- NeoServerless memory graph
- Enhanced agent collaboration
- Desktop app (Electron)
- 50+ AI model providers
- 10,000+ skills library
- Production observability
- Enterprise security features

Repository Stats:
- Stars: 77,814
- Forks: 15,303
- Languages: TypeScript, HTML, JavaScript
- Size: 767MB
- Contributors: 100+)

License: MIT