Diese Anleitung zeigt, wie Sie LibreChat per Docker Compose selbst betreiben: eine self-hosted Chat-Oberfläche für OpenAI, Anthropic Claude, Google Gemini, Azure OpenAI und lokale Modelle (Ollama, LocalAI), mit Volltextsuche (MeiliSearch) und Datei-Uploads samt Retrieval (RAG-API mit pgvector).

Kurzfassung

Repo klonen, .env aus der Vorlage anlegen, Stack starten:

git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat
cp .env.example .env
docker compose up -d

Danach erreichen Sie die Web-UI unter http://SERVER_IP:3080. Der erste registrierte Account wird automatisch Admin – es gibt keine Default-Zugangsdaten. Für Produktion danach eigene Secrets in der .env setzen, den Port des mitgelieferten Admin-Panels (3000) absichern und HTTPS über einen Reverse-Proxy davorschalten.

Voraussetzungen

Linux-Server mit Debian 12 oder Ubuntu 24.04 LTS und Docker Engine inkl. Docker Compose Plugin (docker compose version muss funktionieren).
RAM: mindestens 512 MB bis 1 GB, empfohlen 2 GB mit RAG und MeiliSearch; 1 vCPU für kleine Instanzen.
Linux-Kernel unter 6.19 oder ab 7.0.14: Die Compose-Datei nutzt mongo:8.0.20. Prüfen Sie mit uname -r die Kernel-Version. Auf Ubuntu zeigt uname -r nur 7.0.0-…, die zugrunde liegende Upstream-Version nennt cat /proc/version_signature. Laut Kompatibilitätstabelle in MongoDB-Ticket SERVER-125742 läuft 8.0.20 unter Kernel 6.19 und ab Kernel 7.0.14 beziehungsweise 7.1 ohne Einschränkung. Mit Kernel 6.19 bis 7.0.13 stürzt MongoDB 8.0.0 bis 8.0.20 nach etwa 60 Sekunden ab, MongoDB warnt dort ausdrücklich vor Datenbeschädigung (Ursache: SERVER-121912). Neuere 8.0-Versionen brechen auf diesen Kerneln den Start ab. Auf einem solchen Host aktualisieren Sie den Kernel auf 7.0.14 oder neuer oder setzen bei einer Neuinstallation mongo:7.0 ein (Support laut MongoDB bis 31.08.2027).
Keine GPU nötig: Eine GPU (mit nvidia-container-toolkit) braucht nur ein Ollama-/LocalAI-Container für selbst bereitgestellte lokale Modelle.
Mindestens ein Provider-Key (z. B. Anthropic sk-ant-..., OpenAI sk-...) oder ein erreichbarer Ollama-Endpoint.
Für produktiven Betrieb: eine Domain plus Reverse-Proxy (Caddy, Nginx Proxy Manager, Traefik) für HTTPS, denn LibreChat bringt kein TLS mit.

Prüfen Sie vorab die Versionen:

docker --version
docker compose version

Schritt 1: Repository klonen und Verzeichnis vorbereiten

LibreChat wird aus dem Git-Repo betrieben (inzwischen LibreChat-AI/LibreChat; danny-avila/LibreChat leitet weiter). Die Images kommen fertig aus der LibreChat-Registry:

git clone https://github.com/danny-avila/LibreChat.git
cd LibreChat

Persistente Daten landen relativ zum Repo (z. B. ./data-node für MongoDB); wählen Sie einen festen, gesicherten Pfad wie /opt/LibreChat.

Verifizieren: ls im Verzeichnis zeigt unter anderem docker-compose.yml, .env.example, librechat.example.yaml und docker-compose.override.yml.example.

Schritt 2: .env anlegen und Secrets setzen

Die .env steuert Ports, Domains, Provider-Keys und Secrets. Die mitgelieferte Vorlage ist für ein Basis-Setup lauffähig:

cp .env.example .env

Leere Secrets ersetzt LibreChat durch temporäre Werte in .env.temp (Volume librechat-data). Für den Produktivbetrieb müssen Sie dauerhafte Zufallswerte setzen, sonst hängen Credentials und Sessions an diesen temporären Werten:

# JWT_SECRET und JWT_REFRESH_SECRET (je 32 Hex-Zeichen)
openssl rand -hex 16
openssl rand -hex 16

# CREDS_KEY (64 Hex-Zeichen)
openssl rand -hex 32

# CREDS_IV (32 Hex-Zeichen)
openssl rand -hex 16

# MEILI_MASTER_KEY (starker Zufalls-Key)
openssl rand -hex 32

# ADMIN_PANEL_SESSION_SECRET (mind. 32 Zeichen, fuer das Admin-Panel)
openssl rand -hex 32

Tragen Sie die Werte und Ihre Provider-Keys in die .env ein:

# --- Server ---
PORT=3080
HOST=0.0.0.0

# Bei Reverse-Proxy auf Ihre oeffentliche Domain setzen
DOMAIN_CLIENT=https://chat.IHRE-DOMAIN.de
DOMAIN_SERVER=https://chat.IHRE-DOMAIN.de

# Dateibesitz der Bind-Mounts (Ausgabe von id -u / id -g)
UID=1000
GID=1000

# --- Sicherheits-Secrets (eigene Werte aus openssl eintragen!) ---
JWT_SECRET=IHR-32-HEX-WERT
JWT_REFRESH_SECRET=IHR-32-HEX-WERT
CREDS_KEY=IHR-64-HEX-WERT
CREDS_IV=IHR-32-HEX-WERT
MEILI_MASTER_KEY=IHR-STARKER-KEY
ADMIN_PANEL_SESSION_SECRET=IHR-64-HEX-WERT

# --- Provider-Keys (oder user_provided) ---
OPENAI_API_KEY=sk-IHR-OPENAI-KEY
ANTHROPIC_API_KEY=sk-ant-IHR-KEY

# Embeddings fuer Datei-Uploads (RAG), Standard: OpenAI
RAG_OPENAI_API_KEY=sk-IHR-OPENAI-KEY
GOOGLE_KEY=IHR-GEMINI-KEY

# --- Registrierung und Suche ---
ALLOW_REGISTRATION=true
SEARCH=true

Mit user_provided (Vorlage bei Anthropic und Google) hinterlegt jeder Nutzer seinen Key in der Web-UI. Die Suche braucht SEARCH=true und einen eigenen MEILI_MASTER_KEY.

Verifizieren: grep -E '^(JWT_SECRET|CREDS_KEY|CREDS_IV|MEILI_MASTER_KEY|ADMIN_PANEL_SESSION_SECRET)=' .env zeigt fünf Zeilen, jede mit einem nicht leeren Wert.

Schritt 3: Die compose.yaml verstehen und anpassen

Die mitgelieferte docker-compose.yml startet sechs Container: api, admin-panel, mongodb, meilisearch, rag_api und vectordb (pgvector). Anpassungen gehören laut Projekt in eine Override-Datei. Die relevanten Teile:

# Auszug aus docker-compose.yml (main-Branch, Stand September 2026)
# Proxy-Variablen im api-Service hier weggelassen, massgeblich ist die Datei im Repo
services:
  api:
    container_name: LibreChat
    ports:
      - "${PORT}:${PORT}"
    depends_on:
      - mongodb
      - rag_api
    image: registry.librechat.ai/librechat-ai/librechat-dev:latest
    restart: always
    user: "${UID}:${GID}"
    extra_hosts:
      - "host.docker.internal:host-gateway"
    environment:
      - HOST=0.0.0.0
      - MONGO_URI=mongodb://mongodb:27017/LibreChat
      - MEILI_HOST=http://meilisearch:7700
      - LIBRECHAT_TEMP_CREDENTIALS_PATH=/app/data/.env.temp
      - RAG_PORT=${RAG_PORT:-8000}
      - RAG_API_URL=http://rag_api:${RAG_PORT:-8000}
    volumes:
      - type: bind
        source: ./.env
        target: /app/.env
      - ./images:/app/client/public/images
      - ./uploads:/app/uploads
      - ./logs:/app/logs
      - ./skill:/app/skill
      - librechat-data:/app/data
  admin-panel:
    container_name: admin-panel
    image: registry.librechat.ai/clickhouse/librechat-admin-panel:latest
    ports:
      - "${ADMIN_PANEL_PORT:-3000}:3000"
    depends_on:
      - api
    restart: always
    environment:
      - PORT=3000
      - SESSION_SECRET=${ADMIN_PANEL_SESSION_SECRET}
      - API_SERVER_URL=http://api:${PORT:-3080}
      - VITE_API_BASE_URL=${DOMAIN_CLIENT:-http://localhost:3080}
      - SESSION_COOKIE_SECURE=${ADMIN_PANEL_SESSION_COOKIE_SECURE:-false}
  mongodb:
    container_name: chat-mongodb
    image: mongo:8.0.20
    restart: always
    user: "${UID}:${GID}"
    volumes:
      - ./data-node:/data/db
    command: mongod --noauth
  meilisearch:
    container_name: chat-meilisearch
    image: getmeili/meilisearch:v1.35.1
    restart: always
    user: "${UID}:${GID}"
    environment:
      - MEILI_HOST=http://meilisearch:7700
      - MEILI_NO_ANALYTICS=true
      - MEILI_MASTER_KEY=${MEILI_MASTER_KEY}
    volumes:
      - ./meili_data_v1.35.1:/meili_data
  vectordb:
    container_name: vectordb
    image: pgvector/pgvector:0.8.0-pg15-trixie
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    restart: always
    volumes:
      - pgdata2:/var/lib/postgresql/data
  rag_api:
    container_name: rag_api
    image: registry.librechat.ai/librechat-ai/librechat-rag-api-dev-lite:latest
    environment:
      - DB_HOST=vectordb
      - RAG_PORT=${RAG_PORT:-8000}
    restart: always
    depends_on:
      - vectordb
    env_file:
      - .env

volumes:
  pgdata2:
  librechat-data:

Ports: Web-UI und API auf 3080. Das Admin-Panel veröffentlicht Port 3000; sperren Sie ihn per Firewall oder binden Sie ihn per Override an 127.0.0.1. MeiliSearch (7700), RAG-API (8000), MongoDB (27017) und pgvector (5432) bleiben im internen Netz. Nur deshalb darf MongoDB mit --noauth laufen: Diese Ports niemals öffentlich freigeben.

Einen anderen Port setzen Sie ebenfalls per Override (Schritt 5).

Verifizieren: docker compose config --services listet api, admin-panel, mongodb, meilisearch, vectordb und rag_api, ohne Fehler oder Warnungen zu fehlenden Variablen.

Schritt 4: Stack starten und Web-UI-Ersteinrichtung

Ziehen Sie die fertigen Images und starten Sie den Stack (kein lokaler Build, der bei wenig RAM scheitert):

docker compose up -d

# Status pruefen und Logs verfolgen
docker compose ps
docker compose logs -f api

Sobald der API-Container läuft, öffnen Sie die Oberfläche:

http://SERVER_IP:3080      (lokal: http://localhost:3080)

Der erste registrierte Account wird automatisch Admin. Steht der Key auf user_provided, hinterlegen Sie ihn nach der Anmeldung in der Oberfläche.

Für eine geschlossene Instanz schalten Sie danach die Registrierung ab und starten neu:

ALLOW_REGISTRATION=false

docker compose up -d --force-recreate api

Verifizieren: docker compose ps zeigt alle sechs Container im Status running bzw. Up, und curl -sI http://localhost:3080 antwortet mit HTTP/1.1 200 OK. Nach dem Abschalten der Registrierung fehlt auf der Login-Seite der Link zum Registrieren.

Schritt 5: Lokale Modelle (Ollama/LocalAI) per librechat.yaml einbinden

Lokale Modelle binden Sie über librechat.yaml (Abschnitt endpoints.custom) ein, die per Override in den Container gemountet wird:

cp docker-compose.override.yml.example docker-compose.override.yml

In der docker-compose.override.yml kommentieren Sie die Zeile services: und unter api.volumes den Mount der Config ein:

services:
  api:
    volumes:
      - type: bind
        source: ./librechat.yaml
        target: /app/librechat.yaml

Die Override überlebt Updates. Legen Sie nun die librechat.yaml an; das Pflichtfeld version übernehmen Sie aus librechat.example.yaml (grep ^version librechat.example.yaml, September 2026: 1.3.17):

version: 1.3.17

endpoints:
  custom:
    - name: "Ollama"
      apiKey: "ollama"
      baseURL: "http://host.docker.internal:11434/v1"
      models:
        default: ["llama3", "mistral"]
        fetch: true

Linux: host.docker.internal funktioniert nur mit extra_hosts-Eintrag; die aktuelle docker-compose.yml bringt ihn mit, bei älteren Ständen ergänzen Sie ihn in der Override. Ollama auf dem Host muss auf der Docker-Bridge lauschen (z. B. OLLAMA_HOST=0.0.0.0):

services:
  api:
    extra_hosts:
      - "host.docker.internal:host-gateway"

Übernehmen Sie alles mit einem Neustart:

docker compose down && docker compose up -d

Verifizieren: docker compose exec api ls /app/librechat.yaml findet die Datei, docker compose logs api | grep -i -E 'custom config|librechat.yaml' zeigt, dass sie geladen wurde, und im Modell-Menü der Web-UI erscheint der Endpoint „Ollama“ mit Ihren Modellen.

Schritt 6: Suche und Datei-Uploads (MeiliSearch und RAG) nutzen

Beide Funktionen sind im Stack enthalten:

Volltextsuche über Chats: Mit SEARCH=true und gesetztem MEILI_MASTER_KEY indiziert MeiliSearch Ihre Unterhaltungen; das Suchfeld der UI findet sie.
Datei-Uploads mit Retrieval (RAG): Die rag_api legt Embeddings in pgvector (vectordb) ab, erreichbar über RAG_API_URL=http://rag_api:8000; das Modell erhält relevante Passagen hochgeladener Dokumente als Kontext.

Embeddings erzeugt die RAG-API standardmäßig über OpenAI (EMBEDDINGS_PROVIDER=openai). Da die Vorlage OPENAI_API_KEY=user_provided setzt, tragen Sie einen echten Key als RAG_OPENAI_API_KEY in die .env ein. Andere Anbieter wählen Sie über EMBEDDINGS_PROVIDER.

Verifizieren: Nach einer neuen Unterhaltung findet das Suchfeld sie über ein Stichwort. Laden Sie in einem Chat eine kleine Textdatei hoch und fragen Sie nach einem Detail daraus; docker compose logs rag_api zeigt dabei keine Fehler zum Embedding.

Schritt 7: HTTPS per Reverse-Proxy

LibreChat spricht nur HTTP auf Port 3080; HTTPS übernimmt ein Reverse-Proxy (Caddy, Nginx Proxy Manager, Traefik) mit Ziel localhost:3080. Setzen Sie DOMAIN_CLIENT und DOMAIN_SERVER in der .env auf Ihre https://-Domain, sonst funktionieren Links und Sessions nicht.

Minimales Beispiel mit Caddy (automatisches Zertifikat) als Caddyfile:

chat.IHRE-DOMAIN.de {
    reverse_proxy localhost:3080
}

Entscheidend: Die Ports 3080 und 3000 bleiben intern, nach außen geht nur Port 443 über den Proxy.

Verifizieren: curl -sI https://chat.IHRE-DOMAIN.de liefert HTTP/2 200 mit gültigem Zertifikat, und von einem fremden Rechner aus ist http://SERVER_IP:3080 nicht erreichbar.

Schritt 8: Update- und Backup-Workflow

Updates laufen über die fertigen Images; der offizielle Ablauf entfernt zusätzlich die alten LibreChat-Images:

docker compose down
docker images -a | grep "librechat" | awk '{print $3}' | xargs docker rmi
git pull
docker compose pull
docker compose up -d

Ohne docker compose pull nach dem git pull läuft eventuell das alte Image. Prüfen Sie danach, ob die version in librechat.example.yaml gestiegen ist. Niemals data-node, meili_data..., pgdata2, librechat-data oder uploads löschen, sonst sind Chats, Dateien und Embeddings weg.

Für ein konsistentes Backup stoppen Sie den Stack (MongoDB und pgvector sauber geschlossen) und sichern die Datenpfade:

docker compose down

# Bind-Mounts und Konfiguration sichern
tar czf librechat-backup-$(date +%F).tar.gz .env data-node meili_data_v1.35.1 images uploads librechat.yaml

# pgvector liegt im named volume 'pgdata2' -> separat sichern
docker run --rm -v librechat_pgdata2:/data -v $(pwd):/backup alpine \
  tar czf /backup/pgdata2.tgz -C /data .

docker compose up -d

Verifizieren: docker compose ps zeigt nach dem Update alle Container als Up, die bisherigen Chats sind in der Web-UI vorhanden, und tar tzf librechat-backup-$(date +%F).tar.gz | head listet .env und data-node/.

Der MeiliSearch-Pfad enthält die Versionsnummer (z. B. meili_data_v1.35.1). Ein Versionssprung erzeugt einen neuen Pfad und einen Reindex; passen Sie dann das Backup-Kommando an.

Troubleshooting

Web-UI nicht erreichbar: docker compose ps und docker compose logs -f api prüfen. Häufige Ursache: fehlerhafte librechat.yaml (z. B. fehlendes version-Feld).
Lokaler Ollama-Endpoint fehlt: Mount in der Override, version-Feld, unter Linux extra_hosts: host.docker.internal:host-gateway und Ollama-Bind-Adresse prüfen.
Admin-Panel-Container startet immer wieder neu: ADMIN_PANEL_SESSION_SECRET fehlt in der .env; ohne diesen Wert verweigert das Panel den Start.
Nach Neuaufbau Keys unlesbar oder Sitzungen weg: Die temporären Secrets sind verloren (z. B. Volume librechat-data gelöscht). Dauerhafte Werte setzen (Schritt 2) und neu starten.
Container startet nicht / OOM-Kills: Zu wenig RAM (unter rund 2 GB mit RAG und MeiliSearch); fertige Images statt lokalem Build nutzen.
Dev-Image in Produktion: Die docker-compose.yml aus main nutzt oft *-dev:latest. Stellen Sie in der Override auf registry.librechat.ai/librechat-ai/librechat:latest (letzte nummerierte Version) um, wie in docker-compose.override.yml.example.
Links zeigen auf localhost statt Domain: DOMAIN_CLIENT und DOMAIN_SERVER in der .env auf die öffentliche https://-Domain setzen und neu starten.
Datenbank-Ports offen: MongoDB läuft mit --noauth; 27017/5432/7700/8000 und 3000 niemals veröffentlichen.

Häufige Fragen

Brauchen Sie eine GPU, um LibreChat zu betreiben?

Nein, die GPU braucht nur ein lokaler Ollama-/LocalAI-Container.

Wie binden Sie Anthropic Claude ein?

Als ANTHROPIC_API_KEY=sk-ant-... in der .env und Neustart. Mit dem Vorlagenwert user_provided hinterlegt jeder Nutzer seinen Key in der Oberfläche.

Was unterscheidet LibreChat von Open WebUI?

Open WebUI zielt primär auf lokale Modelle (Ollama), LibreChat bündelt als Multi-Provider-Hub Cloud-Provider und lokale Modelle.

Wer wird Administrator und gibt es Default-Zugangsdaten?

Keine Default-Zugangsdaten: Der erste registrierte Account wird Admin. Danach ALLOW_REGISTRATION=false setzen (Schritt 4).

Können Sie Dateien hochladen und das Modell darauf antworten lassen?

Ja, über rag_api und pgvector; die Embeddings brauchen einen Provider-Key (Schritt 6).

Wie aktualisieren Sie, ohne Daten zu verlieren?

Mit dem Ablauf aus Schritt 8. Die Persistenz-Verzeichnisse und -Volumes niemals löschen.

Fazit

Für Produktion zählen dauerhafte Secrets, abgeschaltete Registrierung, geschützter Admin-Panel-Port und HTTPS per Reverse-Proxy.

Weiterführende Anleitungen und Quellen

Verwandte Anleitungen:

Quellen: