# LibreChat Multi-Provider

## Überblick

[LibreChat](https://github.com/danny-avila/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**

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

**Schritt 2: Repository klonen**

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

**Schritt 3: Umgebung konfigurieren**

```bash
cp .env.example .env
nano .env
```

Mindestens festlegen:

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

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

**Schritt 4: Stack starten**

```bash
docker compose up -d
```

Dies startet:

* `LibreChat` — Hauptanwendung auf Port 3080
* `MongoDB` — Konversations- und Benutzerspeicherung
* `MeiliSearch` — schnelle Konversationssuche

**Schritt 5: Überprüfen und zugreifen**

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

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

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

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

```yaml
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:

```bash
# In .env
ALLOW_REGISTRATION=false
```

Starten Sie dann neu: `docker compose restart LibreChat`

### Code Interpreter aktivieren

```bash
# 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

```bash
# 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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama)):

```bash
# 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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm)):

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

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

```bash
# 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

```bash
# 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

```bash
# 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)

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

```bash
# Ü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

```bash
# Ü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

```bash
# 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

```bash
# 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

```bash
# 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

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

***

## Weiterführende Lektüre

* [LibreChat Dokumentation](https://docs.librechat.ai) — vollständige Konfigurationsreferenz
* [LibreChat GitHub](https://github.com/danny-avila/LibreChat) — Quellcode, Issues, Changelog
* [LibreChat Docker Hub](https://ghcr.io/danny-avila/librechat-dev) — Image-Tags
* [Ollama auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — lokales LLM-Backend
* [vLLM auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Inferenz mit hohem Durchsatz
* [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — die richtige GPU-Klasse wählen
* [LibreChat Konfigurationsdatei Referenz](https://docs.librechat.ai/install/configuration/librechat_yaml.html) — `librechat.yaml` schema