LobeHub mit Docker Compose einrichten: Nachfolger von Lobe Chat selbst hosten

Aus Lobe Chat ist LobeHub geworden. Mit Version 2 hat das Projekt nicht nur den Namen gewechselt (GitHub: lobehub/lobehub), sondern auch den Aufbau: Es gibt nur noch den Server-Datenbank-Betrieb mit PostgreSQL, die Anmeldung läuft über Better Auth, und ein eigener Gateway-Dienst führt Agenten serverseitig aus. Die alten Images lobehub/lobe-chat und lobehub/lobe-chat-database stehen seit Version 1.143.3 vom 25.01.2026 still. Diese Anleitung richtet LobeHub 2.2.18 mit der offiziellen Docker-Compose-Vorlage ein, sichert die Ports ab, beschränkt die Registrierung und zeigt ein funktionierendes Backup mit Wiederherstellung.

Voraussetzungen

LobeHub selbst rechnet keine Modelle. Die Sprachmodelle laufen bei einem Anbieter wie OpenAI oder Anthropic oder lokal in Ollama. Für den Stack allein genügt deshalb ein kleiner Server.

• CPU: 2 Kerne (Herstellerangabe Minimum), x86_64 oder ARM64. Das Image lobehub/lobehub:2.2.18 gibt es für beide Architekturen.
• RAM: 4 GB. Im Test belegten die sechs laufenden Container zusammen etwa 1,2 GB (LobeHub 447 MB, PostgreSQL 284 MB, RustFS 275 MB, SearXNG 170 MB).
• Speicher: 20 GB laut Hersteller, dazu Platz für hochgeladene Dateien.
• System: Linux mit Docker Engine und Compose-Plugin v2, zum Beispiel Debian 12 oder Ubuntu 24.04. Getestet mit Docker Compose 2.40.
• Für den Produktivbetrieb: Reverse Proxy mit HTTPS und drei Hostnamen (App, S3-Speicher, Gateway).
• Optional: Ollama für lokale Modelle. Dann gelten die Hardwareanforderungen des Modells, nicht die von LobeHub.

Docker noch nicht installiert? Die Grundlagen stehen in Docker und Docker Compose auf Linux installieren.

Schritt 1: Offizielle Vorlage herunterladen

Der Hersteller bietet ein interaktives Skript (setup.sh) an, das Vorlage und Geheimnisse in einem Rutsch erzeugt. Laut Doku ist es nur für die Erstinstallation gedacht. Der manuelle Weg zeigt, was tatsächlich konfiguriert wird, und lässt sich später wiederholen. Laden Sie die Dateien vom Release-Tag statt vom Hauptzweig, damit Vorlage und Image-Version zusammenpassen:

mkdir -p /opt/lobehub && cd /opt/lobehub
B=https://raw.githubusercontent.com/lobehub/lobehub/v2.2.18/docker-compose/deploy
curl -fsSO $B/docker-compose.yml
curl -fsSO $B/bucket.config.json
curl -fsSO $B/searxng-settings.yml
curl -fsS $B/.env.example -o .env

Die Vorlage startet sieben Dienste. Die optionalen Elasticsearch-Dienste sind über Compose-Profile abgeschaltet.

Dienst	Image (Stand 30.09.2026)	Port intern	Aufgabe
lobe	lobehub/lobehub:2.2.18	3210	Weboberfläche und API
gateway	ghcr.io/lobehub/lobehub-gateway:0.3.2	8787, 8788	Agenten-Gateway (WebSocket), Geräte-Gateway
postgresql	paradedb/paradedb:latest-pg17 (= 0.25.11-pg17)	5432	Datenbank mit pg_search
redis	redis:7-alpine	6379	Cache, Sitzungen
rustfs	rustfs/rustfs:latest (= 1.0.0)	9000, 9001	S3-Speicher für Dateien
rustfs-init	rustfs/rc:latest (= v0.1.36)	keiner	legt Bucket, Policy und CORS an, beendet sich
searxng	searxng/searxng	8080	Websuche für Agenten

Verifizieren: ls -A /opt/lobehub zeigt .env, bucket.config.json, docker-compose.yml und searxng-settings.yml. grep -c YOUR_ .env liefert 6: So viele Platzhalter warten auf echte Werte.

Schritt 2: Ports absichern und Versionen festschreiben

Die Vorlage veröffentlicht PostgreSQL (5432) und Redis (6379) auf allen Schnittstellen des Hosts. Beide Dienste braucht nur LobeHub im Compose-Netz. Außerdem verwenden mehrere Dienste latest. Beides korrigieren Sie in einer eigenen compose.override.yaml, die Compose automatisch mitliest. Die Herstellerdatei bleibt unverändert und lässt sich bei Updates ersetzen:

services:
  lobe:
    image: lobehub/lobehub:2.2.18
  postgresql:
    image: paradedb/paradedb:0.25.11-pg17
    ports: !reset []
  redis:
    ports: !reset []
  rustfs:
    image: rustfs/rustfs:1.0.0
  rustfs-init:
    image: rustfs/rc:v0.1.36

Die übrigen Ports steuert die .env. Weil die Vorlage sie als ${LOBE_PORT}:3210 einsetzt, dürfen die Variablen eine IP-Adresse enthalten. Tragen Sie ein:

LOBE_PORT=127.0.0.1:3210
RUSTFS_PORT=127.0.0.1:9000
RUSTFS_ADMIN_PORT=127.0.0.1:9001
AGENT_GATEWAY_PORT=127.0.0.1:8787
DEVICE_GATEWAY_PORT=127.0.0.1:8788

Verifizieren: docker compose config | grep -E 'published|host_ip' zeigt nur noch host_ip: 127.0.0.1 und keine Einträge für 5432 oder 6379.

Schritt 3: Geheimnisse erzeugen

LobeHub 2 braucht mehr Schlüssel als Lobe Chat. KEY_VAULTS_SECRET verschlüsselt die in der Datenbank gespeicherten API-Schlüssel der Nutzer, AUTH_SECRET die Sitzungen. JWKS_KEY ist ein RSA-Schlüsselsatz, mit dem LobeHub interne Tokens signiert. Das Gateway bekommt nur die öffentliche Hälfte JWKS_PUBLIC_KEY. Die Doku warnt ausdrücklich: Wer den Beispielschlüssel aus einer alten .env.example weiterverwendet (kid 6823046760c5d460), erlaubt jedem, gültige Tokens zu fälschen.

openssl rand -base64 32   # KEY_VAULTS_SECRET
openssl rand -base64 32   # AUTH_SECRET
openssl rand -hex 32      # GATEWAY_SERVICE_TOKEN
openssl rand -hex 16      # POSTGRES_PASSWORD
openssl rand -hex 16      # RUSTFS_SECRET_KEY
docker run --rm --entrypoint /bin/node lobehub/lobehub:2.2.18 -e 'const c=require("crypto");const {privateKey,publicKey}=c.generateKeyPairSync("rsa",{modulusLength:2048});const meta={alg:"RS256",kid:c.randomBytes(8).toString("hex"),use:"sig"};console.log("JWKS_KEY="+JSON.stringify({keys:[{...privateKey.export({format:"jwk"}),...meta}]}));console.log("JWKS_PUBLIC_KEY="+JSON.stringify({keys:[{...publicKey.export({format:"jwk"}),...meta}]}))'

Die letzte Zeile ist der Befehl aus der Herstellerdoku, hier mit festgeschriebenem Image. Er gibt zwei fertige Zeilen aus, die Sie unverändert in die .env übernehmen. Ersetzen Sie dort auch das Beispielpasswort bei POSTGRES_PASSWORD: Die Vorlage liefert einen festen Wert mit, der in jeder Installation gleich wäre. APP_URL, S3_ENDPOINT und AGENT_GATEWAY_URL passen Sie in Schritt 6 an Ihre Domains an. Schützen Sie die Datei anschließend mit chmod 600 .env (Docker Compose liest sie auf dem Host ein).

Verifizieren: grep -c YOUR_ .env liefert 0, grep -c uWNZugjBqixf8dxC .env ebenfalls 0. grep '^JWKS_PUBLIC_KEY=' .env | grep -c '"d":' muss 0 ergeben, denn der öffentliche Schlüssel darf kein privates Feld d enthalten.

Schritt 4: Stack starten

docker compose pull
docker compose up -d
docker compose logs -f lobe

Im Test waren PostgreSQL, Redis und RustFS nach etwa 15 Sekunden healthy, rustfs-init hatte Bucket und CORS-Regel angelegt und sich mit Exit 0 beendet. LobeHub führt beim ersten Start die Datenbankmigration aus und antwortete nach rund einer Minute. Das Log enthält dabei Hinweise zu QStash (QSTASH_TOKEN not set); sie betreffen den optionalen Upstash-Workflow-Dienst und verhinderten den Start nicht.

[Database] Start to migration...
✅ database migration pass.
▲ Next.js 16.3.5
- Network:       http://0.0.0.0:3210
✅ Gateway: Started successfully.

Verifizieren: docker compose ps -a zeigt lobe, gateway und searxng als Up, die drei Datendienste als Up (healthy) und rustfs-init als Exited (0). curl -sI http://127.0.0.1:3210/ liefert HTTP/1.1 302 Found mit location: …/signin.

Schritt 5: Erstes Konto anlegen und Registrierung beschränken

Öffnen Sie per SSH-Tunnel (ssh -L 3210:127.0.0.1:3210 user@server) die Adresse http://localhost:3210 und registrieren Sie sich mit E-Mail und Passwort. Wichtig für den Betrieb: Im Test ließ sich direkt danach ein zweites Konto mit einer beliebigen anderen Adresse anlegen, beide mit der Rolle user. Ohne weitere Einstellung kann also jeder, der die Seite erreicht, ein Konto eröffnen. Beschränken Sie die Registrierung deshalb vor dem Veröffentlichen in der .env:

# einzelne Adressen oder ganze Domains, kommagetrennt
AUTH_ALLOWED_EMAILS=admin@firma.de,firma.de

Danach docker compose up -d ausführen, Compose erstellt den Container lobe neu. Die Variable prüft laut Doku nur die Adresse, nicht deren Besitz. Wer zusätzlich eine Bestätigung per E-Mail verlangen will, setzt AUTH_EMAIL_VERIFICATION=1 und konfiguriert SMTP. Für reinen SSO-Betrieb gibt es AUTH_DISABLE_EMAIL_PASSWORD=1, dann muss mindestens ein SSO-Anbieter eingerichtet sein.

Verifizieren: Ein Registrierungsversuch mit einer nicht erlaubten Adresse scheitert. Im Test antwortete die API mit HTTP 403 und {"code":"EMAIL_NOT_ALLOWED"}, die Anmeldung des bestehenden Kontos funktionierte weiter.

Schritt 6: Reverse Proxy und HTTPS

Für den Zugriff im Netz braucht LobeHub drei vom Browser erreichbare Adressen, weil der Browser Dateien direkt in den S3-Speicher hochlädt und Agenten-Läufe per WebSocket vom Gateway empfängt. Die Konsole von RustFS (9001) veröffentlichen Sie nur bei Bedarf.

Hostname (Beispiel)	Ziel	Variable in .env
chat.firma.de	127.0.0.1:3210	APP_URL=https://chat.firma.de
s3.firma.de	127.0.0.1:9000	S3_ENDPOINT=https://s3.firma.de
gateway.firma.de	127.0.0.1:8787 (WebSocket)	AGENT_GATEWAY_URL=https://gateway.firma.de

Mit Caddy genügt je Hostname ein Block, Caddy reicht WebSocket-Verbindungen ohne Zusatzkonfiguration durch:

chat.firma.de {
    reverse_proxy 127.0.0.1:3210
}
s3.firma.de {
    reverse_proxy 127.0.0.1:9000
}
gateway.firma.de {
    reverse_proxy 127.0.0.1:8787
}

INTERNAL_APP_URL bleibt auf http://localhost:3210: Darüber ruft sich der Container für asynchrone Funktionen wie die Bildgenerierung selbst auf. Eine Einführung in Caddy gibt Caddy als Reverse Proxy einrichten.

Verifizieren: curl -sI https://chat.firma.de/ liefert 302 auf /signin, curl -s https://s3.firma.de/health antwortet ohne Zertifikatsfehler. Nach dem Hochladen eines Bildes in einem Chat erscheint es in der Konsole von RustFS im Bucket lobe.

Schritt 7: Modelle anbinden

API-Schlüssel für OpenAI, Anthropic und andere Anbieter trägt jeder Nutzer in den Einstellungen ein. LobeHub speichert sie mit KEY_VAULTS_SECRET verschlüsselt. Alternativ hinterlegen Sie serverweite Schlüssel als Umgebungsvariablen in der .env, die Namen stehen in der Hersteller-Referenz „Model Provider“. Für Ollama nennt die Doku OLLAMA_PROXY_URL mit der Adresse des Ollama-Servers; Ollama selbst muss dafür mit OLLAMA_HOST=0.0.0.0 und OLLAMA_ORIGINS=* laufen und darf dann nur im internen Netz erreichbar sein. Wie Sie Ollama mit Docker betreiben, zeigt Ollama und Open WebUI mit Docker.

Verifizieren: In einem neuen Chat erscheint das gewählte Modell in der Modellauswahl und beantwortet eine kurze Testfrage.

Schritt 8: Backup und Wiederherstellung

Zu sichern sind drei Dinge: die Datenbank, der S3-Speicher und die Dateien im Projektordner, allen voran die .env. Ohne den dort gespeicherten KEY_VAULTS_SECRET lassen sich die gespeicherten API-Schlüssel nicht mehr entschlüsseln.

docker compose exec -T postgresql pg_dump -U postgres lobechat > lobechat.sql
docker compose exec rustfs tar czf /tmp/rustfs.tar.gz /data
docker cp lobe-rustfs:/tmp/rustfs.tar.gz ./rustfs-backup.tar.gz
cp .env docker-compose.yml compose.override.yaml bucket.config.json searxng-settings.yml /pfad/zum/backup/

Beim Test der Rücksicherung zeigte sich eine Besonderheit des ParadeDB-Images: Eine mit CREATE DATABASE neu angelegte Datenbank enthält bereits das Schema paradedb, und der Import bricht mit ERROR: schema "paradedb" already exists ab. Legen Sie die Zieldatenbank deshalb aus template0 an:

docker compose exec -T postgresql psql -U postgres -c "CREATE DATABASE restoretest TEMPLATE template0;"
docker compose exec -T postgresql psql -U postgres -v ON_ERROR_STOP=1 -q restoretest < lobechat.sql
docker compose exec -T postgresql psql -U postgres -d restoretest -tAc "SELECT count(*) FROM users;"

Verifizieren: Der Import endet mit Exit-Code 0, die Abfrage liefert die Zahl der angelegten Konten (im Test 2). Löschen Sie die Testdatenbank danach mit DROP DATABASE restoretest;.

Typische Fehler

• „ACTION REQUIRED: Gateway Mode configuration needs attention“ im Log: In der .env fehlt eine Gateway-Variable. Im Test mit leerem JWKS_PUBLIC_KEY nannte das Log genau diese Variable. Folge laut Doku: Agenten-Läufe fallen auf den Browser zurück. Werte aus Schritt 3 eintragen, docker compose up -d --force-recreate.
• Startseite liefert 000 oder „Connection refused“: Die Migration läuft noch. docker compose logs lobe abwarten, bis „database migration pass“ erscheint.
• Bild-Upload im Chat scheitert, Avatar-Upload funktioniert: S3_ENDPOINT ist für den Browser nicht erreichbar, etwa weil dort http://rustfs:9000 steht. Öffentliche S3-Adresse eintragen; fehlt die CORS-Regel, docker compose up -d --force-recreate rustfs-init.
• Import bricht mit schema "paradedb" already exists ab: Zieldatenbank aus template0 anlegen (Schritt 8).
• Fremde Konten in der Nutzerliste: Registrierung war offen. AUTH_ALLOWED_EMAILS setzen und unbekannte Konten entfernen.

Häufige Fragen

Kann ich eine Lobe-Chat-1.x-Installation weiterbetreiben?

Die Images lobe-chat und lobe-chat-database erhalten seit Januar 2026 keine Updates mehr. Für den Umstieg nennt der Hersteller die Änderungen in „LobeHub 2.0 Breaking Changes“: ACCESS_CODE, NextAuth, Clerk und der reine Browser-Datenbank-Modus entfallen, AUTH_SECRET und JWKS_KEY sind Pflicht, PostgreSQL 17 wird empfohlen. Für NextAuth und Clerk gibt es eigene Migrationsanleitungen.

Brauche ich SearXNG und RustFS?

Ein S3-kompatibler Speicher ist laut Doku Teil der Mindestausstattung. RustFS lässt sich durch einen externen S3-Dienst ersetzen. SearXNG liefert die Websuche für Agenten und ist in der Vorlage fest mit SEARXNG_URL verdrahtet; ein Betrieb ohne diesen Dienst wurde nicht getestet.

Wie aktualisiere ich LobeHub?

Release Notes lesen, Backup nach Schritt 8, dann die Vorlage des neuen Tags herunterladen, das Tag in compose.override.yaml anheben und docker compose pull && docker compose up -d ausführen. Die Migration läuft beim Start automatisch.

Worin unterscheidet sich LobeHub von LibreChat?

Beide bündeln mehrere Modellanbieter hinter einer Oberfläche. LobeHub setzt auf Agenten, Plugins und serverseitige Agenten-Läufe mit eigenem Gateway, LibreChat auf MongoDB und eine an ChatGPT angelehnte Oberfläche. Einen Vergleichspunkt bietet LibreChat mit Docker.

Testumfang

Getestet am 30.09.2026 mit LobeHub 2.2.18 und der offiziellen Vorlage des Tags v2.2.18 auf einem Linux-Host mit Docker Compose 2.40: Start aller Dienste, Migration, Registrierung und Beschränkung per AUTH_ALLOWED_EMAILS, fehlende Gateway-Variable, Datenbank-Backup und Rücksicherung. Reverse Proxy mit HTTPS, Datei-Upload im Browser und die Anbindung von Modellen einschließlich Ollama sind nach Herstellerdoku beschrieben und nicht getestet.

Fazit

LobeHub 2 ist mehr als ein umbenanntes Lobe Chat: Datenbank, S3-Speicher und Gateway sind jetzt Pflicht, und mit dem JWKS-Schlüsselpaar kommt ein weiteres Geheimnis hinzu, das zu jeder Installation gehört. Die offizielle Vorlage läuft auf einem Server mit 2 Kernen und 4 GB RAM zuverlässig an. Vor dem Veröffentlichen sollten Sie jedoch die offenen Ports von PostgreSQL und Redis schließen, Versionen festschreiben und die Registrierung beschränken. Wer das Backup samt Rücksicherung einmal durchgespielt hat, kann Updates gelassen einspielen.

Weiterführende Anleitungen und Quellen

• Docker und Docker Compose auf Linux installieren
• Ollama und Open WebUI mit Docker
• Caddy als Reverse Proxy einrichten
• LibreChat mit Docker
• LobeHub: Deploying with Docker Compose
• LobeHub: Authentication Services
• LobeHub 2.0 Breaking Changes
• GitHub: docker-compose/deploy (v2.2.18)
• GitHub: LobeHub Releases