---
title: "LobeHub mit Docker Compose einrichten: Nachfolger von Lobe Chat selbst hosten"
date: 2026-06-02T21:04:56+02:00
modified: 2026-11-08T20:07:54+01:00
category: kuenstliche-intelligenz
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/lobehub-docker-compose-selbst-hosten
reading_time: 10
---

# 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.3.0 mit der offiziellen Docker-Compose-Vorlage ein, sichert die Ports ab, beschränkt die Registrierung und zeigt ein funktionierendes Backup mit Wiederherstellung.

**Kurzfassung:** Laden Sie `docker-compose.yml` und `.env.example` aus dem Ordner `docker-compose/deploy` des Release-Tags, erzeugen Sie die Geheimnisse (darunter das JWKS-Schlüsselpaar) und binden Sie alle Ports an `127.0.0.1`. Nach `docker compose up -d` meldet das Log „database migration pass“, die Startseite leitet auf `/signin` um. Die Registrierung ist danach für jede E-Mail-Adresse offen, bis Sie `AUTH_ALLOWED_EMAILS` setzen. Sichern Sie die Datenbank per `pg_dump` und prüfen Sie die Rücksicherung in eine leere Datenbank.

## 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.3.0` gibt es für beide Architekturen.
- [ ] **RAM:** 4 GB. Im Test belegten die sechs laufenden Container im Leerlauf kurz nach dem Start zusammen knapp 1 GiB (LobeHub 522 MiB, PostgreSQL 219 MiB, RustFS 151 MiB, SearXNG 96 MiB).
- [ ] **Speicher:** 20 GB laut Hersteller, dazu Platz für hochgeladene Dateien.
- [ ] **System:** Linux mit Docker Engine und Compose-Plugin (v2 oder neuer), zum Beispiel Debian 12 oder Ubuntu 24.04.
- [ ] **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](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).

## 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:

Datei: `setup.sh`

```bash
mkdir -p /opt/lobehub && cd /opt/lobehub
B=https://raw.githubusercontent.com/lobehub/lobehub/v2.3.0/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 | Port intern | Aufgabe |
| --- | --- | --- | --- |
| lobe | `lobehub/lobehub:2.3.0` | 3210 | Weboberfläche und API |
| gateway | `ghcr.io/lobehub/lobehub-gateway:0.5.0` | 8787, 8788 | Agenten-Gateway (WebSocket), Geräte-Gateway |
| postgresql | `paradedb/paradedb:latest-pg17` (= 0.26.4-pg17) | 5432 | Datenbank mit pg_search |
| redis | `redis:7-alpine` | 6379 | Cache, Sitzungen |
| rustfs | `rustfs/rustfs:latest` (= 1.0.4) | 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 |

> **Prüfen:** `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:

Datei: `compose.override.yaml`

```yaml
services:
  lobe:
    image: lobehub/lobehub:2.3.0
  postgresql:
    image: paradedb/paradedb:0.26.4-pg17
    ports: !reset []
  redis:
    ports: !reset []
  rustfs:
    image: rustfs/rustfs:1.0.4
  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:

```ini
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
```

> **Prüfen:** `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.

```bash
$ 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.3.0 -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).

> **Prüfen:** `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

```bash
$ docker compose pull
$ docker compose up -d
$ docker compose logs -f lobe
```

Im Test waren PostgreSQL, Redis und RustFS nach etwa 30 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.

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

> **Prüfen:** `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`:

Datei: `.env`

```ini
# 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.

> **Prüfen:** 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:

```plaintext
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](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung).

> **Prüfen:** `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](https://s-edv.com/anleitungen/ollama-open-webui-docker-lokales-llm).

> **Prüfen:** 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.

```bash
$ 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:

```bash
$ 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;"
```

Mit ParadeDB 0.26 gibt der Import viele Warnungen aus (`key_field is deprecated`, `JoinScan not used`), im Test 167 je Import. Sie brechen den Import nicht ab.

> **Prüfen:** 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.

### Wie aktualisiere ich LobeHub?

Release Notes lesen, Backup nach Schritt 8, dann `docker-compose.yml`, `bucket.config.json` und `searxng-settings.yml` 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: Beim Sprung von 2.2.18 auf 2.3.0 stieg die Zahl der Migrationen im Test von 167 auf 199, die Konten blieben erhalten und die Anmeldung funktionierte. Überschreiben Sie dabei nicht die `.env`, sonst sind Ihre Geheimnisse weg. Die Compose-Datei von 2.3.0 ändert gegenüber 2.2.18 nur das Gateway-Image auf 0.5.0. Die `.env.example` ergänzt die optionale Variable `DEVICE_GATEWAY_PUBLIC_URL` für Desktop- und CLI-Clients, neue Pflichtwerte gibt es nicht. Laut Release Notes blockiert Migration `0196` während des Indexaufbaus Schreibzugriffe auf die Tabellen `user_memories_*`. Planen Sie das bei großen Tabellen ein.

Heben Sie auch ParadeDB an, bleibt die Erweiterung zunächst auf dem alten Stand: Nach dem Wechsel von 0.25.11 auf 0.26.4 meldete die Datenbank im Test weiter `pg_search` 0.25.11. Erst dieser Befehl hob sie auf 0.26.4 an:

```bash
$ docker compose exec -T postgresql psql -U postgres -d lobechat -c "ALTER EXTENSION pg_search UPDATE;"
```

### 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](https://s-edv.com/anleitungen/librechat-self-hosted-chatgpt-claude-alternative-docker).

## 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 belegte im Test knapp 1 GiB RAM und passt damit auf einen Server mit 2 Kernen und 4 GB RAM. 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](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
- [Ollama und Open WebUI mit Docker](https://s-edv.com/anleitungen/ollama-open-webui-docker-lokales-llm)
- [Caddy als Reverse Proxy einrichten](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung)
- [LibreChat mit Docker](https://s-edv.com/anleitungen/librechat-self-hosted-chatgpt-claude-alternative-docker)
- [LobeHub: Deploying with Docker Compose](https://lobehub.com/docs/self-hosting/platform/docker-compose)
- [LobeHub: Authentication Services](https://lobehub.com/docs/self-hosting/auth)
- [LobeHub 2.0 Breaking Changes](https://lobehub.com/docs/self-hosting/migration/v2/breaking-changes)
- [GitHub: docker-compose/deploy (v2.3.0)](https://github.com/lobehub/lobehub/tree/v2.3.0/docker-compose/deploy)
- [GitHub: Release Notes LobeHub v2.3.0](https://github.com/lobehub/lobehub/releases/tag/v2.3.0)
- [GitHub: LobeHub Releases](https://github.com/lobehub/lobehub/releases)