LibreChat Multi-Provider

Setzen Sie LibreChat auf Clore.ai ein — eine leistungsstarke, selbst gehostete ChatGPT-Alternative mit Multi-Provider-KI-Unterstützung, Gesprächsverzweigungen und Plugin-Ökosystem auf erschwinglicher GPU-Cloud-Infrastruktur.

Überblick

LibreChat ist eine erweiterte, quelloffene ChatGPT-ähnliche Oberfläche mit über 22.000 GitHub-Sternen. Sie stellt das ChatGPT-Erlebnis getreu neu dar und fügt Funktionen hinzu, die dem Original fehlen — wechselnde Anbieter innerhalb derselben Konversation, Verzweigungen/Forks von Konversationen, ein umfangreiches Plugin-System, Datei-Uploads mit Vision und eine vollständige Code-Interpreter-Sandbox.

Warum LibreChat auf Clore.ai betreiben?

• Echter Multi-Provider in einer UI — Wechseln Sie während einer Sitzung zwischen GPT-4, Claude 3.5, Gemini Pro, Mistral und lokalen Ollama-Modellen.

• Keine GPU für die App erforderlich — LibreChat ist eine Node.js-Anwendung; es wird nur Rechenleistung für Inferenz benötigt, wenn Sie ein lokales LLM-Backend anschließen.

• Kosteneffizientes Self-Hosting — Die Preise von Clore.ai beginnen bei Bruchteilen eines Cents pro Minute, ideal zum Betreiben eines persönlichen KI-Hubs.

• Persistente Konversationen — MongoDB speichert Ihren gesamten Chatverlauf serverseitig, im Gegensatz zu browserlokalen Lösungen.

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

Hauptmerkmale

Funktion	Beschreibung
Multi-Provider	OpenAI, Anthropic, Google, Azure, Mistral, Ollama, OpenRouter
Konversationsverzweigung	Forken 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
Voreinstellungen	Benutzerdefinierte Modellkonfigurationen speichern und teilen

---

Anforderungen

Server-Spezifikationen

Komponente	Minimum	Empfohlen	Hinweise
GPU	Keine 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 wenn lokal

Clore.ai Preisinformationen

Servertyp	Ungefähre Kosten	Einsatzgebiet
CPU-fokussiert (4 vCPU, 8 GB RAM)	~0,05–0,10 $/Std.	LibreChat + externe API-Anbieter
RTX 3090 (24 GB VRAM)	~$0.20/Stunde	LibreChat + Ollama lokale Inferenz
RTX 4090 (24 GB VRAM)	~$0.35/Stunde	LibreChat + schnellere Ollama/vLLM
A100 80 GB	~$1.10/Stunde	LibreChat + große 70B+-Modelle

💡 Kosten-Tipp: Wenn Sie LibreChat nur verwenden, um API-Aufrufe an OpenAI/Anthropic/Google zu routen, zahlen Sie nur für die Clore.ai-Server-Rechenzeit (günstig), nicht für die Inferenz-Hardware. Budgetieren Sie etwa ~$0.05–0.15/Stunde für einen zuverlässigen LibreChat-Host.

Voraussetzungen

• Clore.ai-Server mit SSH-Zugang

• 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 volle Funktionalität.

Schritt 1: Verbinden Sie sich mit Ihrem Clore.ai-Server

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=Ihr-zufälliges-64-Zeichen-Secret-hier
JWT_REFRESH_SECRET=ein-anderes-zufälliges-64-Zeichen-Secret-hier
CREDS_KEY=Ihr-zufälliger-32-Zeichen-Schlüssel-hier
CREDS_IV=Ihr-zufälliges-16-Zeichen-IV-hier

# API-Schlüssel (fügen Sie diejenigen 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 generieren:

# Zufällige Geheimnisse generieren
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 — Konversations- und Benutzerspeicherung

• MeiliSearch — schnelle Konversationssuche

Schritt 5: Überprüfen und zugreifen

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 Login-Seite.

---

Methode 2: Vorgefertigtes Docker-Image (Am schnellsten)

Wenn Sie das Bauen 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: Einzelcontainer Schnelltest

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=Ihr-JWT-Secret-hier \
  -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 Installation.

---

Konfiguration

AI-Anbieter hinzufügen

Bearbeiten librechat.yaml (erstelle 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-Verbindungsstring	mongodb://mongodb:27017/LibreChat
JWT_SECRET	JWT-Signatur-Secret (64+ Zeichen)	Zufälliger Hex-String
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	E-Mail/Passwort-Login aktivieren	true
DEBUG_LOGGING	Ausführliche Protokollierung	true
SEARCH	MeiliSearch aktivieren	true
MEILI_MASTER_KEY	MeiliSearch API-Schlüssel	Zufälliger String

Registrierung einschränken

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

# In .env
ALLOW_REGISTRATION=false

Starten Sie dann neu: 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 auf den Docker-Socket zugegriffen werden kann.

Datei-Upload-Konfiguration

# 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 verwendet unterstützen nicht direkt GPU — es ist eine Routing-Schicht. GPU-Beschleunigung gilt für jedes lokale Inferenz-Backend, das Sie anschließen.

Verbindung zu Ollama (gleicher 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 herunterladen
docker exec ollama ollama pull llama3.2
docker exec ollama ollama pull codellama:13b

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

Verbindung zu vLLM (Hohe Durchsatzleistung)

Für hochkonkurrierende Deployments (siehe vLLM-Leitfaden):

# 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: "Local vLLM"
      apiKey: "nicht-erforderlich"
      baseURL: "http://172.17.0.1:8000/v1"
      models:
        default: ["meta-llama/Llama-3.1-70B-Instruct"]
        fetch: true

GPU-Größen für lokale Modelle

Modellgröße	Min. VRAM	Empfohlene Clore-GPU	Ungefähre Kosten
7–8B (Q4)	6 GB	RTX 3090	~$0.20/Stunde
13B (Q4)	10 GB	RTX 3090	~$0.20/Stunde
34B (Q4)	24 GB	RTX 4090	~$0.35/Stunde
70B (Q4)	48 GB	2× RTX 3090	~$0.40/Stunde
70B (FP16)	80 GB	A100 80GB	~$1.10/Stunde

---

Tipps & bewährte Methoden

Kostenmanagement auf Clore.ai

# Snapshot Ihrer Konfiguration erstellen, 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 verwendet werden
docker compose stop

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

Backup-Strategie

# Automatisiertes tägliches Backup-Skript
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 aufbewahren
find ~/backups -name "*.mongo.gz" -mtime +7 -delete
EOF

chmod +x /root/backup-librechat.sh
# Zum Crontab hinzufügen: 0 2 * * * /root/backup-librechat.sh

Wiederherstellung aus Backup

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

LibreChat sichern

• Setzen Sie immer starke, einzigartige Werte für JWT_SECRET und CREDS_KEY

• Deaktivieren Sie die Registrierung nach der Erstellung des ersten Benutzers: ALLOW_REGISTRATION=false

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

• Aktualisieren Sie regelmäßig das Docker-Image: 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

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

# Überprüfen Sie die Portbindung
ss -tlnp | grep 3080

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

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

MongoDB-Verbindung verweigert

# Überprüfen Sie den MongoDB-Status
docker compose ps mongodb
docker compose logs mongodb --tail 20

# Überprüfen Sie, ob MONGO_URI in .env mit dem Dienstnamen ü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('Connected!'))
  .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

# Stellen Sie sicher, dass Ollama auf 0.0.0.0 lauscht, nicht nur auf localhost
docker exec ollama ollama serve  # Startprotokolle auf Bind-Adresse überprüfen

Festplattenspeicher voll

# Festplattennutzung prüfen
df -h
docker system df

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

# Überprüfen Sie das LibreChat Uploads-Verzeichnis
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 Konfigurationsreferenz

• 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-Vergleichsanleitung — die richtige GPU-Klasse wählen

• LibreChat Konfigurationsdatei Referenz — librechat.yaml schema