# How to Run Lobe Chat in Production Mode: Docker, Vercel, and Self-Hosting Guide

> Deploy Lobe Chat in production using Docker Compose with PostgreSQL and Redis or host on Vercel. Learn how to run Lobe Chat efficiently and securely.

- Repository: [LobeHub/lobe-chat](https://github.com/lobehub/lobe-chat)
- Tags: how-to-guide
- Published: 2026-03-03

---

**To run Lobe Chat in production mode, deploy the pre-built Docker image `lobehub/lobehub:latest` using Docker Compose with the full service stack (PostgreSQL, Redis, RustFS), or host the compiled Next.js application on Vercel with production environment variables configured.**

Lobe Chat is a modern AI-agent workspace built on **Next.js 16** (App Router) that requires specific backend services to function in production. According to the `lobehub/lobe-chat` source code, production deployments execute the compiled application via `next start -p 3210` rather than the development server, typically within containerized environments or serverless platforms.

## Production Architecture Overview

A production-ready Lobe Chat instance consists of the Next.js application serving as both the frontend and API gateway, backed by several persistent services:

- **Next.js Application**: The compiled SSR application and API routes exposed on port 3210 (`next build && next start -p 3210`), as defined in [[`package.json`](https://github.com/lobehub/lobe-chat/blob/main/package.json)](https://github.com/lobehub/lobe-chat/blob/canary/package.json#L97)
- **PostgreSQL**: Primary database for application state (using `postgres:15` or `paradedb/paradedb:latest-pg17` for vector search)
- **Redis**: Session store and short-term caching (`redis:7-alpine`)
- **RustFS**: Object storage for file uploads (`rustfs/rustfs:latest`)
- **SearXNG**: Optional web-search proxy (`searxng/searxng:latest`)

These services are orchestrated via the official [`docker-compose/deploy/docker-compose.yml`](https://github.com/lobehub/lobe-chat/blob/main/docker-compose/deploy/docker-compose.yml) file, which creates an isolated Docker network named `lobe` for internal service communication.

## Production Deployment Options

### Docker Compose (Recommended)

The recommended method for self-hosting uses the official Docker Compose configuration to launch the complete service stack.

**1. Pull the pre-built image:**

```bash
docker pull lobehub/lobehub:latest

```

**2. Configure environment variables:**

Copy the example environment file and populate it with production secrets:

```bash
cp .env.example .env

```

Edit `.env` to include `DATABASE_URL`, `REDIS_URL`, and your LLM provider API keys (OpenAI, Anthropic, etc.). The full reference is available at [`.env.example`](https://github.com/lobehub/lobe-chat/blob/canary/.env.example).

**3. Launch the full stack:**

```bash
docker compose -f docker-compose/deploy/docker-compose.yml up -d

```

The compose file defines the Lobe Chat service as follows:

```yaml
services:
  lobe:
    image: lobehub/lobehub:latest
    container_name: lobehub
    env_file: .env
    ports:
      - "3210:3210"
    restart: always
    depends_on:
      - postgres
      - redis
      - rustfs

```

**4. Verify the deployment:**

Access the application at `http://localhost:3210`. The container runs `next start` internally, serving the optimized production build.

### Single Container (Quick Test)

For testing without auxiliary services, run the container standalone with external services configured via environment variables:

```bash
docker run -it -d \
  --name lobehub \
  -p 3210:3210 \
  --env-file lobe-chat.env \
  --network host \
  lobehub/lobehub:latest

```

Required minimum environment variables in `lobe-chat.env`:

```dotenv
DATABASE_URL=postgresql://user:pass@host:5432/lobe
REDIS_URL=redis://host:6379
OPENAI_API_KEY=sk-xxxx

```

### Vercel (Serverless)

Deploy to Vercel's edge network for a managed serverless architecture:

**1.** Push the repository to GitHub and import the project into Vercel.
**2.** Add environment variables from `.env.example` to the Vercel dashboard under Production settings.
**3.** Deploy. Vercel automatically runs `next build` and serves the application globally.

The runtime detects Vercel via `process.env.VERCEL` in [[`src/envs/app.ts`](https://github.com/lobehub/lobe-chat/blob/main/src/envs/app.ts)](https://github.com/lobehub/lobe-chat/blob/canary/src/envs/app.ts):

```typescript
const isInVercel = process.env.VERCEL === '1';
if (isInVercel) {
  // Vercel URL fallback logic
}

```

## Environment Configuration

Production deployments require specific environment variables defined in the application configuration. Key variables include:

```dotenv

# Core Services

DATABASE_URL=postgresql://postgres:mysecretpassword@postgres:5432/lobe
REDIS_URL=redis://redis:6379

# LLM Providers

OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxx
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxx

# Application Settings

NEXT_PUBLIC_BASE_URL=https://my-lobe-chat.example.com
NEXT_PUBLIC_HTTPS=true

```

The production build process is defined in the [`Dockerfile`](https://github.com/lobehub/lobe-chat/blob/canary/Dockerfile), which uses Node 18, executes `next build`, and starts the server with the command specified in [[`package.json`](https://github.com/lobehub/lobe-chat/blob/main/package.json)](https://github.com/lobehub/lobe-chat/blob/canary/package.json#L97):

```json
{
  "scripts": {
    "start": "next start -p 3210"
  }
}

```

## Key Production Files

Understanding these source files ensures proper customization of your production deployment:

- **[`Dockerfile`](https://github.com/lobehub/lobe-chat/blob/canary/Dockerfile)**: Defines the multi-stage build process (Node 18 → `next build` → `next start`)
- **[[`docker-compose/deploy/docker-compose.yml`](https://github.com/lobehub/lobe-chat/blob/main/docker-compose/deploy/docker-compose.yml)](https://github.com/lobehub/lobe-chat/blob/canary/docker-compose/deploy/docker-compose.yml)**: Orchestrates the complete production stack including PostgreSQL, Redis, RustFS, and SearXNG
- **[`.env.example`](https://github.com/lobehub/lobe-chat/blob/canary/.env.example)**: Comprehensive list of all environment variables required for production
- **[[`src/envs/app.ts`](https://github.com/lobehub/lobe-chat/blob/main/src/envs/app.ts)](https://github.com/lobehub/lobe-chat/blob/canary/src/envs/app.ts)**: Runtime environment detection (Vercel vs. self-hosted) and URL resolution logic
- **[[`src/server/utils/url.ts`](https://github.com/lobehub/lobe-chat/blob/main/src/server/utils/url.ts)](https://github.com/lobehub/lobe-chat/blob/canary/src/server/utils/url.ts)**: URL generation utilities for production and preview environments

## Summary

- **Run Lobe Chat in production mode** using the `lobehub/lobehub:latest` Docker image with `next start -p 3210` as the entry point
- **Use Docker Compose** with [`docker-compose/deploy/docker-compose.yml`](https://github.com/lobehub/lobe-chat/blob/main/docker-compose/deploy/docker-compose.yml) for the complete self-hosted stack (PostgreSQL, Redis, RustFS)
- **Configure environment variables** via `.env` file based on `.env.example` before starting the container
- **Deploy to Vercel** by pushing the repository and setting production environment variables in the dashboard
- **Verify port 3210** is exposed and accessible for the Next.js server traffic

## Frequently Asked Questions

### What is the default port for Lobe Chat in production mode?

The production server runs on **port 3210** by default. This is hardcoded in the start script within [[`package.json`](https://github.com/lobehub/lobe-chat/blob/main/package.json)](https://github.com/lobehub/lobe-chat/blob/canary/package.json#L97) as `"start": "next start -p 3210"`. When using Docker, map this port to your host (e.g., `"3210:3210"`) to access the application.

### Can I run Lobe Chat without Docker?

Yes, you can run Lobe Chat without Docker by executing `next start -p 3210` directly on a Node.js 18+ server, but you must manually configure and connect PostgreSQL, Redis, and RustFS services. Alternatively, deploy to **Vercel** for a fully managed serverless environment without container management.

### What database does Lobe Chat require for production?

Lobe Chat requires **PostgreSQL** (version 15 or higher, or ParadeDB with pg17 for vector search capabilities) as its primary database. The application uses Redis for session storage and caching, and RustFS for object storage of uploaded files. These dependencies are defined in the official [[`docker-compose/deploy/docker-compose.yml`](https://github.com/lobehub/lobe-chat/blob/main/docker-compose/deploy/docker-compose.yml)](https://github.com/lobehub/lobe-chat/blob/canary/docker-compose/deploy/docker-compose.yml).

### How does Lobe Chat detect if it is running on Vercel?

The application checks `process.env.VERCEL === '1'` in [[`src/envs/app.ts`](https://github.com/lobehub/lobe-chat/blob/main/src/envs/app.ts)](https://github.com/lobehub/lobe-chat/blob/canary/src/envs/app.ts) to determine if it is operating within the Vercel serverless environment. This detection affects URL resolution logic, specifically how the base URL is constructed for preview deployments versus production domains.