> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/librechat.md).

# 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](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 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](https://clore.ai/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**

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

```bash
# Zufällige Geheimnisse erzeugen
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` — Speicher für Unterhaltungen und Benutzer
* `MeiliSearch` — schnelle Unterhaltungssuche

**Schritt 5: Prüfen und aufrufen**

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

***

### Methode 2: Vorgefertigtes Docker-Image (am schnellsten)

Wenn Sie den Build 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: Schneller Einzelcontainer-Test

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=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:

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

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

Dann neu starten: `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 der Docker-Socket zugänglich ist.

### Konfiguration für Datei-Uploads

```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 **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](/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 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](/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: "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](https://clore.ai/bare-metal) |

***

## Tipps & bewährte Praktiken

### Kostenmanagement auf Clore.ai

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

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

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

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

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

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

# 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

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

```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 Referenz zur Konfiguration
* [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-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — die richtige GPU-Stufe auswählen
* [Referenz für die LibreChat-Konfigurationsdatei](https://docs.librechat.ai/install/configuration/librechat_yaml.html) — `librechat.yaml` Schema


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.