Lobe Chat: The Open-Source ChatGPT UI Alternative with 20+ LLM Providers & Plugin System — 2026 Setup

{{< resource-info >}}

Introduction: ChatGPT Won’t Cut It Anymore #

You’re paying OpenAI $20/month for ChatGPT Plus, but your team needs a shared chat interface with access to Claude, Gemini, and local models running on your own hardware. You want plugins that connect to your internal APIs. You need a multi-language UI because your team spans three continents. And critically — your conversation data must stay on your infrastructure, not in a third-party cloud.

You could build it from scratch. Spend two months on a React frontend, another month wiring up SSE streaming, then maintain authentication, plugin sandboxing, and model switching forever. Or you could deploy Lobe Chat in 10 minutes.

Lobe Chat is an open-source chat interface built by the LobeHub team that supports 20+ LLM providers, a plugin system, PWA support, and multi-language UI — all from a single Docker container. With ~60,000 GitHub stars as of May 2026, it’s one of the most popular self-hosted ChatGPT alternatives. It looks better than ChatGPT’s UI, runs on your hardware, and costs zero in licensing fees.

This guide walks through installation, provider configuration, plugin development, PWA setup, real benchmarks, and honest limitations. By the end, you’ll have a production-ready chat UI your entire team can use.

What Is Lobe Chat? #

Lobe Chat is a modern, open-source chat interface for large language models. Built with Next.js and Ant Design, it provides a ChatGPT-like experience with support for multiple LLM providers (OpenAI, Claude, Gemini, Ollama, Azure, Bedrock, and 15+ more), extensible plugins, progressive web app capabilities, and a self-hosted deployment model that keeps your data under your control.

How Lobe Chat Works #

Lobe Chat’s architecture separates the presentation layer from model inference. The Next.js frontend handles UI rendering, conversation state, and plugin orchestration, while LLM calls proxy through configurable API endpoints:

┌─────────────────────────────────────────────┐
│           User Browser / PWA                │
│  ┌─────────┐  ┌─────────┐  ┌────────────┐  │
│  │  Chat   │  │ Plugin  │  │  Settings  │  │
│  │  Panel  │  │  Store  │  │  (i18n)    │  │
│  └────┬────┘  └────┬────┘  └─────┬──────┘  │
└───────┼────────────┼─────────────┼────────┘
        │            │             │
        ▼            ▼             ▼
┌─────────────────────────────────────────────┐
│          Lobe Chat Server (Next.js)          │
│  ┌──────────┐ ┌──────────┐ ┌────────────┐  │
│  │  SSE     │ │  Plugin  │ │  Auth      │  │
│  │  Stream  │ │  Runtime │ │  (SSO)     │  │
│  └────┬─────┘ └────┬─────┘ └─────┬──────┘  │
└───────┼────────────┼─────────────┼────────┘
        │            │             │
        ▼            ▼             ▼
┌──────────┐  ┌──────────┐  ┌────────────┐
│  OpenAI  │  │  Claude  │  │   Ollama   │
│  API     │  │  API     │  │  (Local)   │
└──────────┘  └──────────┘  └────────────┘

Key components:

• Frontend: Next.js 14 App Router with React Server Components. Renders markdown, code blocks with syntax highlighting, and LaTeX math.
• Chat Engine: Manages conversation history, context window, token counting, and streaming responses via Server-Sent Events.
• Plugin System: Sandboxed plugin runtime using iframes + postMessage. Plugins declare manifests with OpenAPI-compatible schemas.
• Provider Proxy: Unified adapter pattern normalizing API calls across 20+ LLM providers.
• PWA Layer: Service worker for offline support, installable on desktop and mobile.

Installation & Setup: 10 Minutes to Chat #

Prerequisites: Docker 24.0+ or Node.js 20+ (for local dev), 2GB RAM, 1GB disk.

Method 1: Docker (Recommended) #

Step 1 —— Pull and run the official image:

docker run -d -p 3210:3210 \
  -e OPENAI_API_KEY=YOUR_OPENAI_API_KEY \
  -e ACCESS_CODE=your-secure-password \
  --name lobe-chat \
  lobehub/lobe-chat:latest

Step 2 —— Access the UI:

Open http://localhost:3210. You’ll see a setup wizard for selecting your default LLM provider and entering API keys.

Step 3 —— Configure additional providers (optional):

# Multi-provider setup via environment variables
docker run -d -p 3210:3210 \
  -e OPENAI_API_KEY=sk-xxx \
  -e ANTHROPIC_API_KEY=sk-ant-xxx \
  -e GOOGLE_API_KEY=xxx \
  -e OLLAMA_PROXY_URL=http://host.docker.internal:11434 \
  -e ACCESS_CODE=your-secure-password \
  --name lobe-chat \
  lobehub/lobe-chat:latest

Method 2: Docker Compose with Persistent Storage #

# docker-compose.yml
services:
  lobe-chat:
    image: lobehub/lobe-chat:latest
    ports:
      - "3210:3210"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - ACCESS_CODE=${ACCESS_CODE}
      - DATABASE_URL=postgresql://postgres:password@db:5432/lobe
    volumes:
      - lobe-data:/app/.config/lobe-chat
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=lobe
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  lobe-data:
  pgdata:

# Start with persistence
docker compose up -d

Method 3: Deploy to DigitalOcean #

# On a 2 vCPU / 4GB RAM Droplet (~$24/month)
sudo apt update && sudo apt install -y docker.io docker-compose-plugin

# Create .env file
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-key
ACCESS_CODE=secure-team-password
EOF

# Run
docker compose up -d

# Set up reverse proxy with HTTPS via Caddy
cat > Caddyfile << 'EOF'
chat.yourdomain.com {
    reverse_proxy localhost:3210
}
EOF

Add DNS A record pointing to your Droplet IP and you’re live in under 15 minutes. Get a DigitalOcean Droplet here.

Integration with 20+ LLM Providers #

Lobe Chat normalizes API calls across providers through a unified adapter. Here’s how to configure the most popular ones:

OpenAI (GPT-4, GPT-4o) #

# Via environment variable
echo "OPENAI_API_KEY=sk-xxxxxxxx" >> .env

# Via UI: Settings → Language Model → OpenAI → Enter key

Anthropic Claude (Claude 3.5 Sonnet) #

# Environment variable
echo "ANTHROPIC_API_KEY=sk-ant-xxxxxxxx" >> .env

# Restart container
docker restart lobe-chat

Google Gemini (Gemini 1.5 Pro) #

echo "GOOGLE_API_KEY=AIzaxxxxxxxx" >> .env

Ollama (Local Models — Llama, Mistral, etc.) #

# Run Ollama on host
docker run -d -p 11434:11434 --name ollama ollama/ollama

# Pull a model
docker exec ollama ollama pull llama3.2

# Configure Lobe Chat to use Ollama
docker run -d -p 3210:3210 \
  -e OLLAMA_PROXY_URL=http://host.docker.internal:11434 \
  -e ACCESS_CODE=mypassword \
  lobehub/lobe-chat

Azure OpenAI Service #

# Requires endpoint, API key, and deployment name
echo "AZURE_API_KEY=your-azure-key" >> .env
echo "AZURE_API_ENDPOINT=https://your-resource.openai.azure.com" >> .env
echo "AZURE_API_VERSION=2024-06-01" >> .env

AWS Bedrock #

echo "AWS_ACCESS_KEY_ID=AKIAxxx" >> .env
echo "AWS_SECRET_ACCESS_KEY=xxx" >> .env
echo "AWS_REGION=us-east-1" >> .env

Switching Providers at Runtime #

Users can switch providers per-conversation in the UI. This lets you compare GPT-4 and Claude side-by-side:

# No restart needed —— provider switching is client-side
# Click provider icon in chat header → Select different model
# Each conversation remembers its provider choice

Plugin System: Extending Lobe Chat #

Lobe Chat’s plugin architecture uses a manifest-based system. Plugins declare their capabilities in a manifest.json, and the chat UI renders them as interactive tools.

Installing from the Plugin Marketplace #

1. Open Lobe Chat → Plugin Store
2. Browse 50+ community plugins
3. Click “Install” → Authorize permissions
4. Plugins appear as tool calls during chat

Building a Custom Plugin #

Create a simple plugin that queries your internal API:

{
  "api": [
    {
      "description": "Search internal knowledge base",
      "name": "search_kb",
      "parameters": {
        "properties": {
          "query": {
            "description": "Search query string",
            "type": "string"
          }
        },
        "required": ["query"],
        "type": "object"
      },
      "url": "https://api.yourcompany.com/kb/search"
    }
  ],
  "gateway": "https://gateway.example.com",
  "identifier": "your-company/kb-search",
  "meta": {
    "title": "Internal KB Search",
    "description": "Search company knowledge base"
  },
  "version": "1.0.0"
}

Host this at a public URL, then add it via Plugin Store → Custom Plugin → Enter URL.

Plugin Runtime Security #

Plugins execute in sandboxed iframes with restricted permissions:

┌─────────────────────────────┐
│  Lobe Chat Main Window      │
│  ┌───────────────────────┐  │
│  │  Sandboxed Iframe     │  │
│  │  (plugin code)        │  │
│  │  - No DOM access      │  │
│  │  - postMessage only   │  │
│  │  - CORS enforced      │  │
│  └───────────────────────┘  │
└─────────────────────────────┘

Each plugin request requires explicit user approval. The LLM suggests tool calls, but the user must confirm before execution.

PWA Support & Mobile Experience #

Lobe Chat functions as a Progressive Web App, making it feel like a native app on all platforms.

Installing on Desktop (Chrome/Edge) #

1. Open Lobe Chat in Chrome
2. Click the install icon in the address bar
3. Launches as a standalone window with its own icon

Installing on Mobile (iOS Safari) #

1. Open Lobe Chat in Safari
2. Tap Share → "Add to Home Screen"
3. Appears as a native app icon
4. Supports push notifications (via service worker)

Offline Support #

The service worker caches the app shell and recent conversations. Without internet:

✅ Browse conversation history
✅ View previous responses
✅ Compose messages (queued for send)
❌ New LLM responses (requires API connectivity)

Benchmarks & Real-World Use Cases #

Response Latency (measured from US-East) #

Resource Usage #

Real-World Deployments #

AI Consultancy (12 engineers):

• Deployed Lobe Chat on a DigitalOcean Droplet
• Connected 8 LLM providers for client comparison demos
• Built 3 custom plugins linking to internal project databases
• Saved ~$240/month vs. individual ChatGPT Plus subscriptions

University Research Lab (40 students):

• Self-hosted with Ollama for privacy-sensitive research data
• Students access via PWA on laptops and phones
• Plugin connects to university library search API
• Zero cloud data exposure for unpublished research

Startup Customer Support (5 agents):

• Integrated with Claude 3.5 Sonnet via API
• Custom plugin queries product documentation
• Multi-language UI supports English, Chinese, Japanese customers
• Response drafting time reduced ~45%

Advanced Usage & Production Hardening #

Enabling Authentication #

For team deployments, set an access code:

docker run -d -p 3210:3210 \
  -e ACCESS_CODE=your-secure-password-2026 \
  -e OPENAI_API_KEY=sk-xxx \
  lobehub/lobe-chat:latest

For SSO integration, configure OAuth:

  -e AUTH_PROVIDER=auth0 \
  -e AUTH_AUTH0_ID=your-client-id \
  -e AUTH_AUTH0_SECRET=your-secret \
  -e AUTH_AUTH0_ISSUER=https://your-domain.us.auth0.com \

Custom Themes #

Create a theme JSON file:

{
  "primaryColor": "#1890ff",
  "neutralColor": "#8c8c8c",
  "backgroundColor": "#f0f2f5",
  "sidebarWidth": 280
}

Upload via Settings → Theme → Custom Theme.

Database-Backed Conversations #

For multi-user persistence, configure PostgreSQL:

# docker-compose.prod.yml
services:
  lobe-chat:
    image: lobehub/lobe-chat:latest
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/lobechat
      - APP_URL=https://chat.yourdomain.com
    ports:
      - "3210:3210"

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: lobechat
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Reverse Proxy with Caddy #

# Caddyfile for automatic HTTPS
chat.yourdomain.com {
    reverse_proxy localhost:3210
    encode gzip
    header {
        X-Frame-Options DENY
        X-Content-Type-Options nosniff
    }
}

caddy run --config Caddyfile

Monitoring with Prometheus #

Lobe Chat exposes metrics at /api/metrics:

# docker-compose.monitoring.yml
services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"

Comparison with Alternatives #

When to choose what:

• Lobe Chat: Choose when you need a polished, multi-provider chat UI with plugins and PWA. Best overall experience for teams.
• LibreChat: Choose if you want a simpler setup with built-in RAG (document upload) and don’t need PWA or extensive plugins.
• ChatGPT Web (Next-Web): Choose if you primarily use OpenAI and want the fastest, most lightweight self-hosted UI.
• HuggingChat: Use as a free web UI for Hugging Face models, but not for self-hosting or enterprise use.

Limitations: Honest Assessment #

No built-in RAG (yet). Unlike LibreChat which has document upload and vector search built in, Lobe Chat relies on plugins for knowledge base functionality. A native RAG feature is on the roadmap for v1.0 but not available as of May 2026.

Plugin ecosystem is young. There are ~50 plugins vs. ChatGPT’s thousands. Building custom plugins requires understanding the manifest schema and hosting a compatible API.

Requires LLM API keys. Lobe Chat is just a UI — you still need API keys for cloud providers or a running Ollama instance for local models. There’s no “free tier” built in.

No multi-user chat rooms. Conversations are private to each browser session. True multi-user collaboration with shared channels requires a custom backend.

Docker image is large. The production image weighs ~400MB compressed. On slow connections, the initial pull takes a few minutes.

No voice input/output. Unlike ChatGPT’s mobile app, Lobe Chat doesn’t support speech-to-text or text-to-speech natively. Browser-based Web Speech API can be used as a workaround.

Plugin approval UX adds friction. Every plugin call requires user confirmation. This is great for security but slows down workflows compared to ChatGPT’s code interpreter which runs automatically.

Frequently Asked Questions #

Q: Does Lobe Chat store my conversations on their servers?

No. When self-hosted, all conversation data stays on your infrastructure. Lobe Chat is a client-side application with no telemetry to external servers unless you explicitly configure analytics. The open-source code (MIT license) is auditable on GitHub. Cloud API keys (OpenAI, Claude) are only used for LLM inference calls — conversations themselves are stored locally.

Q: Can I use multiple LLM providers in the same conversation?

Not within a single conversation thread. Each conversation is tied to one provider, but you can create multiple conversations with different providers and switch between them. Some users keep a “GPT-4” thread for coding and a “Claude” thread for writing, switching via the sidebar.

Q: How do I update Lobe Chat to the latest version?

# Pull latest image
docker pull lobehub/lobe-chat:latest

# Restart container
docker compose down && docker compose up -d

# Conversations persist in browser localStorage
# For PostgreSQL backend, database migrations run automatically

Updates ship weekly. Check the releases page for breaking changes before updating.

Q: What’s the difference between the plugin system and function calling?

Lobe Chat plugins are UI-level integrations — they render interactive cards, forms, and visualizations in the chat. Function calling is the LLM-level mechanism that decides when to invoke tools. Lobe Chat uses function calling under the hood to trigger plugins, then renders the plugin’s UI response. The plugin architecture extends function calling with visual components and user approval flows.

Q: Can I use Lobe Chat without internet access?

Partially. If you configure Ollama as the only provider (local LLM), the core chat functionality works offline. However, plugin calls require internet connectivity (they hit external APIs), and the initial app load needs to download assets. The PWA caches the app shell, so after the first visit, basic chatting works without internet if using local models.

Q: Is there a limit on conversation history?

With the default localStorage backend, conversations persist in the browser with no hard limit, though performance degrades past ~500 long conversations. With the PostgreSQL backend, there’s effectively no limit — the database handles thousands of conversations across multiple users. Token context window limits are enforced per the selected LLM provider’s constraints.

Q: Can I import my ChatGPT conversations?

Not directly. ChatGPT’s export format (conversations.json) is not compatible with Lobe Chat’s storage schema. However, community tools exist to convert ChatGPT exports to Markdown, which you can paste into Lobe Chat conversations. The LobeHub team has an import feature on the roadmap for Q3 2026.

Conclusion: Your Chat, Your Rules #

Lobe Chat delivers what ChatGPT won’t: full control over your data, support for every major LLM provider, extensible plugins, and a native-like mobile experience — all running on your own hardware. With ~60,000 GitHub stars and weekly releases, it’s a mature, actively maintained project that rivals commercial alternatives in UX quality.

For individuals, the Docker setup takes 10 minutes and costs nothing beyond API usage. For teams, deploying on DigitalOcean with PostgreSQL backend gives you a shared chat platform with full auditability.

The plugin system and PWA support make Lobe Chat more than a ChatGPT clone — it’s a platform for building AI-powered workflows tailored to your organization. The multi-language UI means it works for global teams without configuration headaches.

Ready to switch? Run the Docker command, add your API keys, and start chatting. Your conversations belong to you.

Join our Telegram community for AI developers: @dibi8dev —— share your Lobe Chat configs and get help from 5,000+ builders.

Sources & Further Reading #

1. Lobe Chat GitHub Repository — Official source code, releases, and documentation
2. Lobe Chat Documentation — Official setup and configuration guides
3. Lobe Chat Plugin Documentation — Plugin manifest specification
4. Docker Hub — lobehub/lobe-chat — Official Docker image
5. LobeHub Plugin Marketplace — Browse available plugins
6. Next.js Documentation — Underlying framework docs

Recommended Hosting & Infrastructure #

Before you deploy any of the tools above into production, you’ll need solid infrastructure. Two options dibi8 actually uses and recommends:

• DigitalOcean — $200 free credit for 60 days across 14+ global regions. The default option for indie devs running open-source AI tools.
• HTStack — Hong Kong VPS with low-latency access from mainland China. This is the same IDC that hosts dibi8.com — battle-tested in production.

Affiliate links — they don’t cost you extra and they help keep dibi8.com running.

Affiliate Disclosure #

This article contains affiliate links. If you sign up for DigitalOcean using our referral link, we receive a commission at no extra cost to you. We only recommend services we use for our own infrastructure. Lobe Chat is open-source (MIT license) and free to use — no purchase is required.