# 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](/guides/guides_v2-de/sprachmodelle/ollama.md)):

```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](/guides/guides_v2-de/sprachmodelle/vllm.md)):

```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](/guides/guides_v2-de/sprachmodelle/ollama.md) — lokales LLM-Backend
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md) — Inferenz mit hohem Durchsatz
* [GPU-Vergleichsanleitung](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — die richtige GPU-Klasse wählen
* [LibreChat Konfigurationsdatei Referenz](https://docs.librechat.ai/install/configuration/librechat_yaml.html) — `librechat.yaml` schema


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/librechat.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.