Diese Anleitung zeigt dir Schritt für Schritt, wie du LibreChat per Docker Compose self-hostest – eine quelloffene, self-hosted ChatGPT- und Claude-Alternative. LibreChat (das Projekt danny-avila/LibreChat) ist eine Multi-Provider-Chat-Oberfläche: über eine einzige Web-UI sprichst du wahlweise mit OpenAI (GPT), Anthropic Claude, Google Gemini, Azure OpenAI oder lokalen Modellen via Ollama bzw. LocalAI. Für Admins im Mittelstand und ambitionierte Heimserver-Nutzer heißt das: ein zentraler, datenschutzfreundlicher KI-Zugang auf dem eigenen Server, mit Volltextsuche über alle Chats (MeiliSearch) und Datei-Uploads samt Retrieval (RAG-API mit pgvector). Im Gegensatz zu Open WebUI, das primär auf lokale Modelle zielt, ist LibreChat als Multi-Provider-Hub inklusive Claude gedacht.

Kurzfassung: Repo klonen, .env aus der Vorlage anlegen, Stack hochziehen – das war es im Kern:

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

Danach erreichst du 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 und HTTPS über einen Reverse-Proxy davorschalten.

Voraussetzungen

Linux-Server mit Debian 12 oder Ubuntu 24.04 LTS und installiertem Docker Engine inkl. Docker Compose Plugin (docker compose version muss funktionieren).
RAM: LibreChat selbst ist leichtgewichtig. Minimum rund 512 MB bis 1 GB, empfohlen 2 GB, wenn alle Dienste (RAG, MeiliSearch) aktiv sind. 1 vCPU genügt für kleine Instanzen, Storage je nach Uploads und Datenbankgröße.
Keine GPU nötig für LibreChat: Die App ruft KI-Modelle nur als Endpoint auf. Eine GPU ist erst relevant, wenn du lokale Modelle mit Ollama oder LocalAI selbst servierst – dann brauchst du das nvidia-container-toolkit für GPU-Passthrough im Ollama-/LocalAI-Container, nicht in LibreChat. Cloud-Provider wie OpenAI oder Claude laufen ganz ohne lokale GPU.
Mindestens ein Provider-Key, z. B. ein Anthropic-API-Key für Claude (sk-ant-...) oder ein OpenAI-Key (sk-...). Alternativ ein erreichbarer Ollama-Endpoint für rein lokale Modelle.
Optional, aber für produktiven Betrieb dringend empfohlen: eine Domain plus Reverse-Proxy (Caddy, Nginx Proxy Manager, Traefik) für HTTPS – LibreChat selbst bringt kein TLS mit.

Fehlt Docker noch, hilft dir die verlinkte Grundlagen-Anleitung am Ende. Prüfe vorab kurz die Versionen:

docker --version
docker compose version

Schritt 1: Repository klonen und Verzeichnis vorbereiten

LibreChat wird offiziell aus dem Git-Repo betrieben, weil dort die docker-compose.yml, die Beispiel-Konfigurationen und die Persistenz-Pfade liegen. Du baust dabei kein Image selbst – der Stack zieht fertige Images aus der LibreChat-Registry. Klone das Repo und wechsle hinein:

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

Alle folgenden Befehle führst du aus diesem Verzeichnis aus. Die persistenten Daten landen später relativ zum Repo (z. B. ./data-node für MongoDB), deshalb ist ein fester, gesicherter Pfad wichtig – etwa /opt/LibreChat auf einem Produktivserver.

Schritt 2: .env anlegen und Secrets setzen

Die Datei .env steuert Ports, Domains, Provider-Keys und Sicherheits-Secrets. Kopiere zunächst die mitgelieferte Vorlage – sie ist out-of-the-box lauffähig für ein Basis-Setup:

cp .env.example .env

Für den Produktivbetrieb musst du die kryptografischen Secrets durch eigene Zufallswerte ersetzen, sonst sind gespeicherte Credentials und Sessions unsicher. Erzeuge sie mit openssl:

# 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

Trage die erzeugten Werte sowie deine Provider-Keys in die .env ein. Die wichtigsten Zeilen sehen so aus:

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

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

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

# --- Provider-Keys ---
OPENAI_API_KEY=sk-DEIN-OPENAI-KEY
ANTHROPIC_API_KEY=sk-ant-DEIN-CLAUDE-KEY
GOOGLE_KEY=DEIN-GEMINI-KEY

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

Statt eines festen Keys kannst du auch user_provided eintragen – dann tragen die Nutzer ihren eigenen API-Key in der Web-UI ein, was für Mehrbenutzer-Instanzen praktisch ist. SEARCH=true aktiviert die MeiliSearch-Volltextsuche über deine Chats.

Schritt 3: Die compose.yaml verstehen und anpassen

Das Repo bringt eine vollständige docker-compose.yml mit, die fünf Container startet: api (LibreChat selbst), mongodb, meilisearch, rag_api und vectordb (pgvector). Du musst diese Datei nicht neu schreiben – sie ist sofort lauffähig. Zur Orientierung und für eigene Anpassungen hier eine vollständige, lauffähige Variante, die exakt den offiziellen Images, Ports und Volumes entspricht:

services:
  api:
    # Stabile Releases: registry.librechat.ai/danny-avila/librechat:latest
    image: registry.librechat.ai/danny-avila/librechat-dev:latest
    container_name: LibreChat
    ports:
      - "${PORT}:${PORT}"
    depends_on:
      - mongodb
      - rag_api
    restart: always
    environment:
      - HOST=0.0.0.0
      - MONGO_URI=mongodb://mongodb:27017/LibreChat
      - MEILI_HOST=http://meilisearch:7700
      - 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/api/logs

  mongodb:
    image: mongo:8.0.20
    container_name: chat-mongodb
    restart: always
    volumes:
      - ./data-node:/data/db
    command: mongod --noauth

  meilisearch:
    image: getmeili/meilisearch:v1.35.1
    container_name: chat-meilisearch
    restart: always
    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:
    image: pgvector/pgvector:0.8.0-pg15-trixie
    container_name: vectordb
    restart: always
    environment:
      - POSTGRES_DB=mydatabase
      - POSTGRES_USER=myuser
      - POSTGRES_PASSWORD=mypassword
    volumes:
      - pgdata2:/var/lib/postgresql/data

  rag_api:
    image: registry.librechat.ai/danny-avila/librechat-rag-api-dev-lite:latest
    container_name: rag_api
    restart: always
    depends_on:
      - vectordb
    environment:
      - DB_HOST=vectordb
      - RAG_PORT=${RAG_PORT:-8000}

volumes:
  pgdata2:

Wichtig zu den Ports: Nur die Web-UI und API liegen auf 3080 (Mapping ${PORT}:${PORT}, Default 3080). MeiliSearch (7700), RAG-API (8000), MongoDB (27017) und pgvector (5432) sind ausschließlich im internen Compose-Netz erreichbar und werden nicht nach außen gemappt. Das ist auch der Grund, warum MongoDB gefahrlos mit --noauth laufen kann – die Ports dürfen niemals öffentlich exponiert werden.

Brauchst du einen anderen Port (z. B. weil 3080 belegt ist), erledigst du das sauber über eine Override-Datei statt durch Änderung der Originaldatei. Mehr dazu im nächsten Schritt.

Schritt 4: Stack starten und Web-UI-Ersteinrichtung

Jetzt ziehst du die fertigen Images und startest den Stack. Es wird nichts lokal gebaut – das spart RAM und Zeit (ein lokaler Build scheitert bei zu wenig Arbeitsspeicher ohnehin):

docker compose up -d

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

Sobald im Log der API-Container läuft, rufst du die Oberfläche im Browser auf:

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

Lege jetzt den ersten Account an. Dieser erste registrierte Benutzer wird automatisch zum Admin – es gibt keine vorgegebenen Login-Daten. Danach kannst du dich anmelden und sofort einen Provider wählen (z. B. Claude), sofern du den passenden Key in der .env hinterlegt hast.

Für eine geschlossene Instanz setzt du nach dem Anlegen des Admin-Accounts die Registrierung ab und startest neu:

ALLOW_REGISTRATION=false

docker compose up -d

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

Cloud-Provider wie OpenAI und Claude konfigurierst du komplett über die .env. Lokale Modelle dagegen werden nicht über Env-Vars eingebunden, sondern über die Datei librechat.yaml im Abschnitt endpoints.custom. Diese Datei muss zusätzlich über eine Override-Datei in den Container gemountet werden. Aktiviere zuerst die Override:

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

In der docker-compose.override.yml kommentierst du unter services.api.volumes den Mount der Config ein:

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

Compose merged die Override automatisch mit der Hauptdatei. Der große Vorteil: Deine Anpassungen überleben Updates, weil du die Original-docker-compose.yml nie anfasst. Lege nun die librechat.yaml an – das version-Feld ist Pflicht, sonst erscheint der Endpoint nicht:

version: 1.2.8

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

Achtung auf Linux: host.docker.internal funktioniert dort nicht automatisch. Läuft dein Ollama auf dem Host, ergänzt du im api-Service der Override entweder einen extra_hosts-Eintrag oder nutzt die Host-IP bzw. den Ollama-Containernamen im selben Docker-Netz:

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

Anschließend übernimmst du alles mit einem erneuten Start:

docker compose up -d

Wenn du komplett lokale Modelle bevorzugst, lies ergänzend unsere Anleitung zu Ollama und Open WebUI – LibreChat ruft den Ollama-Endpoint lediglich auf, das Modell-Serving übernimmt Ollama selbst (dort ist auch die GPU relevant).

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

Zwei Komfortfunktionen sind im Stack bereits enthalten und nur kurz zu aktivieren bzw. zu verstehen:

Volltextsuche über Chats: Mit SEARCH=true in der .env indiziert MeiliSearch deine Unterhaltungen. Du findest später über das Suchfeld der UI jede vergangene Konversation.
Datei-Uploads mit Retrieval (RAG): Die rag_api verarbeitet hochgeladene Dateien und legt Embeddings in pgvector (vectordb) ab. Der api-Container findet die RAG-API über RAG_API_URL=http://rag_api:8000. So kannst du in einem Chat ein Dokument hochladen und Fragen dazu stellen – das Modell bekommt die relevanten Passagen als Kontext.

Beide Dienste laufen ohne Zusatzkonfiguration, sobald der Stack vollständig hochgefahren ist. Plane für aktiven RAG-Betrieb eher 2 GB RAM ein.

Schritt 7: HTTPS per Reverse-Proxy

LibreChat lauscht ausschließlich per HTTP auf Port 3080 und bringt kein eingebautes TLS mit. Für den öffentlichen Betrieb terminierst du HTTPS über einen vorgeschalteten Reverse-Proxy (Caddy, Nginx Proxy Manager oder Traefik), der auf localhost:3080 weiterleitet. Wichtig: Setze in der .env DOMAIN_CLIENT und DOMAIN_SERVER auf deine öffentliche https://-Domain, sonst funktionieren Links und Sessions nicht korrekt.

Ein minimales Beispiel mit Caddy (automatisches Zertifikat) als Caddyfile:

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

Die Einrichtung des Proxys selbst (Zertifikate, weitere Header) ist ein eigenes Thema – entscheidend ist hier nur: Port 3080 bleibt intern, nach außen geht ausschließlich Port 443 über den Proxy.

Schritt 8: Update- und Backup-Workflow

Updates erfolgen ohne lokalen Build über die vorgefertigten Images. Der offizielle Ablauf:

docker compose down
git pull
docker compose pull
docker compose up -d

Vergiss nach dem git pull niemals docker compose pull und up -d – sonst läuft eventuell noch ein altes Image. Die Override-Datei und damit deine librechat.yaml bleiben dabei erhalten. Niemals die Persistenz-Verzeichnisse (data-node, meili_data..., pgdata2, uploads) löschen – sonst sind Chats, Dateien und Embeddings weg.

Für ein konsistentes Backup stoppst du den Stack kurz (sauberer Mongo-Dump) und sicherst 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

Beachte, dass der MeiliSearch-Pfad die Versionsnummer enthält (z. B. meili_data_v1.35.1). Bei einem MeiliSearch-Versionssprung entsteht ein neuer Pfad und ein Reindex – passe das Backup-Kommando dann entsprechend an.

Troubleshooting

Web-UI nicht erreichbar: Prüfe mit docker compose ps, ob der api-Container läuft, und sieh in docker compose logs -f api nach. Häufige Ursache ist eine fehlerhafte librechat.yaml (z. B. fehlendes version-Feld).
Lokaler Ollama-Endpoint erscheint nicht: Entweder fehlt der Mount via docker-compose.override.yml, das version-Feld in der librechat.yaml oder – unter Linux – die Auflösung von host.docker.internal. Lösung: extra_hosts: host.docker.internal:host-gateway ergänzen oder den Container-/Host-Namen nutzen.
Verschlüsselte Credentials/Sessions unsicher oder Login bricht ab: Du hast die Default-Secrets nicht ersetzt. Setze eigene Werte für JWT_SECRET, JWT_REFRESH_SECRET, CREDS_KEY, CREDS_IV und MEILI_MASTER_KEY und starte neu.
Container startet nicht / OOM-Kills: Zu wenig RAM. Bei unter rund 2 GB mit aktivem RAG und MeiliSearch wird es eng. Nutze die vorgefertigten Images (docker compose pull) statt eines lokalen Builds, der bei wenig RAM komplett scheitert.
Falsche Image-Version in Produktion: Die docker-compose.yml aus dem main-Branch referenziert oft *-dev:latest (Development-Builds). Für stabile Instanzen stellst du auf registry.librechat.ai/danny-avila/librechat:latest bzw. eine getaggte Release-Version um.
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 versehentlich offen: MongoDB läuft mit --noauth und ist nur sicher, weil 27017/5432/7700/8000 nicht nach außen gemappt sind. Exponiere diese Ports niemals öffentlich.

Häufige Fragen

Brauche ich eine GPU, um LibreChat zu betreiben?

Nein. LibreChat selbst ruft KI-Modelle nur als Endpoint auf und braucht keine GPU. Eine GPU ist erst nötig, wenn du lokale Modelle mit Ollama oder LocalAI selbst servierst – dann konfigurierst du das nvidia-container-toolkit im jeweiligen Modell-Container, nicht in LibreChat. Mit Cloud-Providern wie Claude oder OpenAI genügt ein kleiner CPU-Server.

Wie binde ich Anthropic Claude ein?

Trage deinen Anthropic-API-Key als ANTHROPIC_API_KEY=sk-ant-... in die .env ein und starte den Stack neu. Danach taucht Claude als Endpoint in der Web-UI auf. Alternativ setzt du den Wert auf user_provided, dann hinterlegt jeder Nutzer seinen eigenen Key in der Oberfläche.

Was unterscheidet LibreChat von Open WebUI?

Open WebUI ist primär auf lokale Modelle (Ollama) ausgerichtet. LibreChat ist als Multi-Provider-Hub konzipiert: Du sprichst aus einer Oberfläche mit OpenAI, Anthropic Claude, Google Gemini, Azure und lokalen Modellen. Wer mehrere kommerzielle Provider inklusive Claude zentral bündeln will, ist mit LibreChat besser bedient.

Wer wird Administrator und gibt es Default-Zugangsdaten?

Es gibt keine Default-Zugangsdaten. Der erste über die Web-UI registrierte Account wird automatisch Admin. Danach solltest du für geschlossene Instanzen ALLOW_REGISTRATION=false setzen, damit sich nicht jeder anmelden kann.

Kann ich Dateien hochladen und das Modell darauf antworten lassen?

Ja. Die mitgelieferte rag_api mit pgvector (vectordb) verarbeitet Uploads, erzeugt Embeddings und liefert die relevanten Passagen als Kontext an das Modell. Die Verbindung läuft über RAG_API_URL und funktioniert mit dem Standard-Stack ohne Zusatzkonfiguration.

Wie aktualisiere ich, ohne Daten zu verlieren?

Mit docker compose down, git pull, docker compose pull und docker compose up -d. Die Persistenz-Verzeichnisse (data-node, meili_data..., pgdata2, uploads) bleiben dabei unangetastet – lösche sie niemals, sonst sind Chats, Dateien und Embeddings verloren.

Fazit

Mit git clone, einer angepassten .env und docker compose up -d hast du LibreChat in wenigen Minuten als self-hosted ChatGPT- und Claude-Alternative laufen. Der mitgelieferte Fünf-Container-Stack ist out-of-the-box funktionsfähig; für Produktion ersetzt du die Secrets, schaltest die Registrierung nach dem Admin-Account ab und stellst HTTPS über einen Reverse-Proxy davor. Lokale Modelle bindest du sauber über librechat.yaml und die Override-Datei ein, sodass deine Konfiguration Updates überlebt. Updates und Backups sind dank fertiger Images und klarer Persistenz-Pfade unkompliziert. Damit bekommst du einen zentralen, datenschutzfreundlichen KI-Zugang für dein Team – mit Claude, OpenAI und lokalen Modellen unter einem Dach.

Weiterführende Anleitungen und Quellen

Diese Anleitungen bauen die Basis rund um LibreChat aus und zeigen verwandte Setups:

Docker Compose Grundlagen: Stacks aufbauen und verwalten – die Basis für alle hier gezeigten compose.yaml-Befehle.
Ollama und Open WebUI mit Docker: lokales LLM betreiben – für das GPU-gestützte Serving lokaler Modelle, die du als Endpoint in LibreChat einbindest.
Lobe Chat als KI-Chat-Plattform mit Docker einrichten – eine weitere self-hosted Chat-Oberfläche zum Vergleich.
Alle Anleitungen der Kategorie Künstliche Intelligenz für weitere KI-Themen.

Quellen: