LibreChat Multi-Anbieter

Deploye LibreChat auf Clore.ai — eine leistungsstarke, selbst gehostete ChatGPT-Alternative mit KI-Unterstützung für mehrere Anbieter, Gesprächsverzweigung und Plugin-Ökosystem auf günstiger GPU-Cloud-Infrastruktur.

Überblick

LibreChat ist eine erweiterte, quelloffene, ChatGPT-ähnliche Oberfläche mit über 22.000 GitHub-Sternen. Sie stellt das ChatGPT-Erlebnis originalgetreu neu dar und fügt gleichzeitig Funktionen hinzu, die dem Original fehlen — Wechsel zwischen mehreren Anbietern innerhalb derselben Unterhaltung, Verzweigung/Abspaltung von Unterhaltungen, ein umfangreiches Plugin-System, Datei-Uploads mit Vision und eine vollständige Sandbox für den Code-Interpreter.

Warum LibreChat auf Clore.ai ausführen?

• Echte Multi-Provider-Unterstützung in einer UI — Wechseln Sie mitten in einer Sitzung zwischen GPT-4, Claude 3.5, Gemini Pro, Mistral und lokalen Ollama-Modellen.

• Für die App wird keine GPU benötigt — LibreChat ist eine Node.js-Anwendung; es benötigt nur dann Rechenleistung für Inferenz, wenn Sie ein lokales LLM-Backend anbinden.

• Kostengünstiges Self-Hosting — Die Preise bei Clore.ai beginnen bei Bruchteilen eines Cents pro Minute, ideal für den Betrieb einer persönlichen KI-Zentrale.

• Persistente Unterhaltungen — MongoDB speichert Ihren gesamten Chatverlauf serverseitig, anders als browserlokale Lösungen.

• Teamfreundlich — Unterstützung für mehrere Benutzer mit individueller Verwaltung von API-Schlüsseln.

Hauptfunktionen

Funktion	Beschreibung
Mehrere Anbieter	OpenAI, Anthropic, Google, Azure, Mistral, Ollama, OpenRouter
Unterhaltungs-Verzweigung	Abzweigen und alternative Antworten erkunden
Plugins	Bing-Suche, Zapier, WolframAlpha, benutzerdefinierte Tools
Datei-Uploads	Bilder, PDFs, Dokumente mit Vision-Analyse
Code-Interpreter	Python in einer isolierten Sandbox ausführen
Artefakte	HTML-, React- und Markdown-Ausgaben rendern
Presets	Benutzerdefinierte Modellkonfigurationen speichern und teilen

---

Anforderungen

Serverspezifikationen

Komponente	Minimum	Empfohlen	Hinweise
GPU	Nicht erforderlich	RTX 3090 (falls Ollama hinzugefügt wird)	Nur für lokale LLM-Inferenz
VRAM	—	24 GB	Für lokale Modelle über Ollama
CPU	2 vCPU	4 vCPU	Node.js + MongoDB
RAM	4 GB	8 GB	MongoDB profitiert von mehr RAM
Speicher	20 GB	50+ GB	Datei-Uploads, Modell-Cache falls lokal

Clore.ai-Preisreferenz

Servertyp	Ca. Kosten	Anwendungsfall
CPU-fokussiert (4 vCPU, 8 GB RAM)	ca. 0,05–0,10 $/Std.	LibreChat + externe API-Anbieter
RTX 3090 (24 GB VRAM)	ca. 0,07–0,21 $/h	LibreChat + lokale Ollama-Inferenz
RTX 4090 (24 GB VRAM)	ca. 0,14–0,42 $/h	LibreChat + schnelleres Ollama/vLLM
A100 80 GB	Bare Metal	LibreChat + große 70B+-Modelle

💡 Kostentipp: Wenn Sie LibreChat nur verwenden, um API-Aufrufe an OpenAI/Anthropic/Google weiterzuleiten, zahlen Sie nur für die Server-Compute-Ressourcen von Clore.ai (günstig), nicht für die Inferenz-Hardware. Planen Sie etwa 0,05–0,15 $/Std. für einen zuverlässigen LibreChat-Host ein.

Voraussetzungen

• Clore.ai-Server mit SSH-Zugriff

• Docker + Docker Compose (vorinstalliert auf Clore.ai)

• Git (vorinstalliert auf Clore.ai)

• Mindestens ein LLM-API-Schlüssel oder ein lokales Ollama/vLLM-Backend

---

Schnellstart

Methode 1: Docker Compose (offiziell — empfohlen)

Die offizielle Bereitstellung von LibreChat verwendet Docker Compose mit MongoDB und MeiliSearch für die volle Funktionalität.

Schritt 1: Mit Ihrem Clore.ai-Server verbinden

ssh root@<your-clore-server-ip> -p <ssh-port>

Schritt 2: Repository klonen

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

Schritt 3: Umgebung konfigurieren

cp .env.example .env
nano .env

Mindestens festlegen:

# In .env — kritische Einstellungen
MONGO_URI=mongodb://mongodb:27017/LibreChat
JWT_SECRET=hier-ihr-zufälliges-64-stelliges-geheimnis
JWT_REFRESH_SECRET=hier-ein-anderes-zufälliges-64-stelliges-geheimnis
CREDS_KEY=hier-ihr-zufälliger-32-stelliger-schlüssel
CREDS_IV=hier-ihr-zufälliger-16-stelliger-iv

# API-Schlüssel (fügen Sie die hinzu, die Sie verwenden)
OPENAI_API_KEY=sk-ihr-openai-schlüssel
ANTHROPIC_API_KEY=sk-ant-ihr-anthropic-schlüssel
GOOGLE_KEY=ihr-google-gemini-schlüssel

Geheimnisse schnell erzeugen:

# Zufällige Geheimnisse erzeugen
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

Schritt 4: Stack starten

docker compose up -d

Dies startet:

• LibreChat — Hauptanwendung auf Port 3080

• MongoDB — Speicher für Unterhaltungen und Benutzer

• MeiliSearch — schnelle Unterhaltungssuche

Schritt 5: Prüfen und aufrufen

docker compose ps
docker compose logs librechat --tail 30

Im Browser öffnen:

http://<ihre-clore-server-ip>:3080

Registrieren Sie ein neues Konto auf der Anmeldeseite.

---

Methode 2: Vorgefertigtes Docker-Image (am schnellsten)

Wenn Sie den Build aus dem Quellcode überspringen möchten:

mkdir -p ~/librechat && cd ~/librechat

# Nur die docker-compose-Dateien herunterladen
curl -o docker-compose.yml https://raw.githubusercontent.com/danny-avila/LibreChat/main/docker-compose.yml
curl -o .env https://raw.githubusercontent.com/danny-avila/LibreChat/main/.env.example

# Konfiguration bearbeiten
nano .env

# Starten
docker compose up -d

---

Methode 3: Schneller Einzelcontainer-Test

Für einen schnellen Proof of Concept ohne MongoDB (eingeschränkte Funktionalität):

docker run -d \
  --name librechat \
  --restart unless-stopped \\
  -p 3080:3080 \
  -e OPENAI_API_KEY=sk-your-key \\
  -e JWT_SECRET=hier-ihr-jwt-geheimnis \
  -e MONGO_URI=mongodb://host-gateway:27017/LibreChat \
  --add-host=host-gateway:host-gateway \\
  ghcr.io/danny-avila/librechat-dev:latest

⚠️ Diese Methode erfordert eine separate MongoDB-Instanz. Verwenden Sie Methode 1 für eine vollständige Einrichtung.

---

Konfiguration

KI-Anbieter hinzufügen

Bearbeiten Sie librechat.yaml (erstellen Sie sie im Projektstamm) für erweiterte Anbieter-Konfiguration:

cat > librechat.yaml << 'EOF'
version: 1.1.5
cache: true

endpoints:
  openAI:
    models:
      default: ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-3.5-turbo"]
      fetch: true

  anthropic:
    models:
      default: ["claude-opus-4-5", "claude-sonnet-4-5", "claude-3-haiku-20240307"]
      fetch: false

  google:
    models:
      default: ["gemini-1.5-pro", "gemini-1.5-flash", "gemini-pro"]
      fetch: false

  ollama:
    # Verweist auf Ollama, das auf demselben Clore.ai-Server läuft
    baseURL: http://host-gateway:11434/v1
    apiKey: ollama
    models:
      default: ["llama3.2", "mistral", "codellama"]
      fetch: true

  custom:
    - name: "OpenRouter"
      apiKey: "${OPENROUTER_API_KEY}"
      baseURL: "https://openrouter.ai/api/v1"
      models:
        default: ["meta-llama/llama-3.1-8b-instruct:free"]
        fetch: true
      titleConvo: true
      titleModel: "meta-llama/llama-3.1-8b-instruct:free"
EOF

Mounten Sie diese Datei in Ihrem docker-compose.yml:

services:
  LibreChat:
    volumes:
      - ./librechat.yaml:/app/librechat.yaml

Referenz der Umgebungsvariablen

Variable	Beschreibung	Beispiel
MONGO_URI	MongoDB-Verbindungszeichenfolge	mongodb://mongodb:27017/LibreChat
JWT_SECRET	JWT-Signaturgeheimnis (64+ Zeichen)	Zufällige Hex-Zeichenfolge
OPENAI_API_KEY	OpenAI-Schlüssel	sk-...
ANTHROPIC_API_KEY	Anthropic-Schlüssel	sk-ant-...
GOOGLE_KEY	Google-Gemini-Schlüssel	KI...
ALLOW_REGISTRATION	Öffentliche Registrierung aktivieren	true / false
ALLOW_EMAIL_LOGIN	Anmeldung mit E-Mail/Passwort aktivieren	true
DEBUG_LOGGING	Ausführliche Protokolle	true
SEARCH	MeiliSearch aktivieren	true
MEILI_MASTER_KEY	MeiliSearch-API-Schlüssel	Zufällige Zeichenfolge

Registrierung einschränken

Für die private Nutzung deaktivieren Sie die öffentliche Registrierung, nachdem Sie Ihr Konto erstellt haben:

# In .env
ALLOW_REGISTRATION=false

Dann neu starten: docker compose restart LibreChat

Code-Interpreter aktivieren

# In .env
CODE_INTERPRETER_ENABLED=true

Der Code-Interpreter führt Python in einem isolierten Docker-Container aus. Stellen Sie sicher, dass der Docker-Socket zugänglich ist.

Konfiguration für Datei-Uploads

# In .env
# Maximale Dateigröße in MB
FILE_UPLOAD_SIZE_LIMIT=100

# Bild-Uploads für Vision-Modelle aktivieren
VISION_ENABLED=true

---

GPU-Beschleunigung

LibreChat nicht nutzt die GPU nicht direkt — es ist eine Routing-Schicht. GPU-Beschleunigung gilt für jedes lokale Inferenz-Backend, das Sie damit verbinden.

Verbindung zu Ollama herstellen (derselbe Server)

Wenn Ollama auf demselben Clore.ai-Server läuft (siehe Ollama-Anleitung):

# Ollama mit GPU-Unterstützung starten
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama_models:/root/.ollama \
  ollama/ollama

# Modelle abrufen
docker exec ollama ollama pull llama3.2
docker exec ollama ollama pull codellama:13b

# In librechat.yaml setzen Sie:
# baseURL: http://172.17.0.1:11434/v1

Verbindung zu vLLM herstellen (hoher Durchsatz)

Für Bereitstellungen mit hoher Parallelität (siehe vLLM-Anleitung):

# vLLM auf einer A100-Clore.ai-Instanz starten
docker run -d \
  --name vllm \\
  --gpus all \
  --restart unless-stopped \\
  -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \
  -e HF_TOKEN=ihr-hf-token \
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-3.1-70B-Instruct \
  --tensor-parallel-size 2 \
  --max-model-len 8192

In librechat.yaml:

  custom:
    - name: "Lokales vLLM"
      apiKey: "nicht-benoetigt"
      baseURL: "http://172.17.0.1:8000/v1"
      models:
        default: ["meta-llama/Llama-3.1-70B-Instruct"]
        fetch: true

GPU-Dimensionierung für lokale Modelle

Modellgröße	Min. VRAM	Empfohlene Clore-GPU	Ca. Kosten
7–8B (Q4)	6 GB	RTX 3090	ca. 0,07–0,21 $/h
13B (Q4)	10 GB	RTX 3090	ca. 0,07–0,21 $/h
34B (Q4)	24 GB	RTX 4090	ca. 0,14–0,42 $/h
70B (Q4)	48 GB	2× RTX 3090	ca. 0,14–0,42 $/h
70B (FP16)	80 GB	A100 80GB	Bare Metal

---

Tipps & bewährte Praktiken

Kostenmanagement auf Clore.ai

# Sichern Sie Ihre Konfiguration per Snapshot, bevor Sie den Server stoppen
docker compose exec mongodb mongodump --out /tmp/backup
docker cp librechat-mongodb-1:/tmp/backup ./mongo-backup-$(date +%Y%m%d)

# Stoppen Sie alle Container, wenn sie nicht benutzt werden
docker compose stop

# Oder reduzieren Sie die Kosten auf null, indem Sie die Clore.ai-Instanz im Dashboard pausieren

Backup-Strategie

# Skript für automatisierte tägliche Backups
cat > /root/backup-librechat.sh << 'EOF'
#!/bin/bash
cd ~/LibreChat
docker compose exec -T mongodb mongodump --archive | \
  gzip > ~/backups/librechat-$(date +%Y%m%d-%H%M).mongo.gz
# Nur die letzten 7 Tage behalten
find ~/backups -name "*.mongo.gz" -mtime +7 -delete
EOF

chmod +x /root/backup-librechat.sh
# In crontab eintragen: 0 2 * * * /root/backup-librechat.sh

Wiederherstellen aus einem Backup

# MongoDB-Dump wiederherstellen
gunzip < ~/backups/librechat-20240101-0200.mongo.gz | \
  docker compose exec -T mongodb mongorestore --archive

LibreChat absichern

• Verwenden Sie immer starke, eindeutige Werte für JWT_SECRET und CREDS_KEY

• Deaktivieren Sie die Registrierung nach der ersten Benutzererstellung: ALLOW_REGISTRATION=false

• Verwenden Sie für die Produktion einen Reverse Proxy (nginx/Caddy) mit HTTPS

• Aktualisieren Sie das Docker-Image regelmäßig: docker compose pull && docker compose up -d

Nginx Reverse Proxy (optional)

cat > /etc/nginx/sites-available/librechat << 'EOF'
server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://localhost:3080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        client_max_body_size 100M;
    }
}
EOF
ln -s /etc/nginx/sites-available/librechat /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx

---

Fehlerbehebung

Port 3080 nicht erreichbar

# Prüfen Sie, ob der Container läuft
docker compose ps

# Port-Zuordnung prüfen
ss -tlnp | grep 3080

# Anwendungsprotokolle anzeigen
docker compose logs librechat --tail 50 -f

# Clore.ai-Firewall prüfen — stellen Sie sicher, dass Port 3080 in Ihrer Portzuordnung enthalten ist

MongoDB-Verbindung verweigert

# MongoDB-Status prüfen
docker compose ps mongodb
docker compose logs mongodb --tail 20

# Prüfen Sie, ob MONGO_URI in .env mit dem Servicenamen übereinstimmt
# Sollte sein: mongodb://mongodb:27017/LibreChat (nicht localhost)

# Verbindung manuell testen
docker compose exec LibreChat node -e "
const mongoose = require('mongoose');
mongoose.connect(process.env.MONGO_URI)
  .then(() => console.log('Verbunden!'))
  .catch(e => console.error(e));
"

JWT-/Authentifizierungsfehler

# Geheimnisse in .env neu generieren
node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

# JWT_SECRET und JWT_REFRESH_SECRET aktualisieren
# Dann neu starten: docker compose restart LibreChat

Ollama-Modelle werden nicht angezeigt

# Ollama-API aus dem LibreChat-Container testen
docker compose exec LibreChat \
  curl -s http://172.17.0.1:11434/v1/models | python3 -m json.tool

# Sicherstellen, dass Ollama auf 0.0.0.0 lauscht und nicht nur auf localhost
docker exec ollama ollama serve  # Startprotokolle auf Bind-Adresse prüfen

Kein Speicherplatz mehr

# Festplattenbelegung prüfen
df -h
docker system df

# Docker-Ressourcen bereinigen
docker system prune -f
docker volume prune -f  # WARNUNG: entfernt ungenutzte Volumes

# LibreChat-Upload-Verzeichnis prüfen
du -sh ~/LibreChat/client/public/uploads

Auf die neueste Version aktualisieren

cd ~/LibreChat
git pull origin main
docker compose pull
docker compose up -d --build

---

Weiterführende Lektüre

• LibreChat-Dokumentation — vollständige Referenz zur Konfiguration

• LibreChat GitHub — Quellcode, Issues, Changelog

• LibreChat Docker Hub — Image-Tags

• Ollama auf Clore.ai ausführen — lokales LLM-Backend

• vLLM auf Clore.ai ausführen — Inferenz mit hohem Durchsatz

• GPU-Vergleichsleitfaden — die richtige GPU-Stufe auswählen

• Referenz für die LibreChat-Konfigurationsdatei — librechat.yaml Schema