> 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/lobechat.md).

# LobeChat-KI-Assistent

Deploye LobeChat auf Clore.ai — eine beeindruckende, funktionsreiche KI-Chat-Oberfläche mit Unterstützung für mehrere Anbieter, Wissensdatenbank und Plugins auf günstigen GPU-basierten Cloud-Servern.

## Überblick

[LobeChat](https://github.com/lobehub/lobe-chat) ist ein modernes, Open-Source-KI-Chat-Framework mit über 55.000 GitHub-Sternen, bekannt für seine ausgereifte Benutzeroberfläche und seinen umfangreichen Funktionsumfang. Es unterstützt praktisch jeden wichtigen LLM-Anbieter — OpenAI, Anthropic Claude, Google Gemini, Mistral und lokale Modelle über Ollama — alles über eine einzige, selbst gehostete Oberfläche.

**Warum LobeChat auf Clore.ai ausführen?**

* **Keine GPU erforderlich** — LobeChat selbst ist eine leichte Web-App. Clore.ai-Instanzen nur mit CPU oder mit minimaler GPU sind für die Oberfläche völlig ausreichend.
* **Mit lokalen LLMs kombinieren** — Starten Sie Ollama oder vLLM auf demselben Clore.ai-Server und verbinden Sie LobeChat damit für vollständig lokale, private Inferenz.
* **Erschwingliches Hosting** — Eine einfache Clore.ai-Instanz kostet nur einen Bruchteil traditioneller VPS-Anbieter, und Sie können sie bei Nichtgebrauch herunterfahren.
* **Vollständige Datenhoheit** — Im Datenbankmodus werden alle Unterhaltungen, Dateien und Embeddings in Ihrer eigenen PostgreSQL-Instanz auf dem Server gespeichert.

LobeChat arbeitet in zwei unterschiedlichen Modi:

| Modus            | Beschreibung                                                     | Am besten geeignet für                        |
| ---------------- | ---------------------------------------------------------------- | --------------------------------------------- |
| **Eigenständig** | Einzelner Docker-Container, Einstellungen im Browser gespeichert | Schnelle Tests, persönliche Nutzung           |
| **Datenbank**    | Vollständiger Stack (PostgreSQL + MinIO + Auth + App)            | Teams, persistenter Verlauf, Wissensdatenbank |

***

## Anforderungen

### Serverspezifikationen

| Komponente   | Minimum            | Empfohlen                                     | Hinweise                                                        |
| ------------ | ------------------ | --------------------------------------------- | --------------------------------------------------------------- |
| **GPU**      | Nicht erforderlich | RTX 3090 (wenn lokale LLMs ausgeführt werden) | Nur für das Ollama/vLLM-Backend erforderlich                    |
| **VRAM**     | —                  | 24 GB (RTX 3090)                              | Für lokale Modell-Inferenz                                      |
| **CPU**      | 2 vCPU             | 4+ vCPU                                       | LobeChat selbst ist leichtgewichtig                             |
| **RAM**      | 2 GB               | 8 GB                                          | 4+ GB bei Nutzung des Datenbankmodus                            |
| **Speicher** | 10 GB              | 50+ GB                                        | Mehr, wenn hochgeladene Dateien oder Modelle gespeichert werden |

### Clore.ai-Preisreferenz

| Servertyp             | Ca. Kosten                                | Anwendungsfall                        |
| --------------------- | ----------------------------------------- | ------------------------------------- |
| Nur-CPU-Instanz       | ca. 0,05–0,10 $/Std.                      | Nur eigenständiges LobeChat           |
| RTX 3090 (24 GB VRAM) | ca. 0,07–0,21 $/h                         | LobeChat + lokale Ollama-LLMs         |
| RTX 4090 (24 GB VRAM) | ca. 0,14–0,42 $/h                         | LobeChat + schnellere lokale Inferenz |
| A100 80 GB            | [Bare Metal](https://clore.ai/bare-metal) | LobeChat + große Modelle (70B+)       |

> 💡 **Tipp:** Für die Nutzung nur über APIs (Verbindung zu OpenAI, Anthropic usw.) reicht jede kleine Instanz aus. Ein GPU-Server ist nur sinnvoll, wenn Sie auch lokale LLMs ausführen möchten. Siehe [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) für Details.

### Voraussetzungen

* Clore.ai-Konto mit einem bereitgestellten Server
* SSH-Zugriff auf Ihren Server
* Docker und Docker Compose (auf Clore.ai-Servern vorinstalliert)
* NVIDIA-Treiber (vorinstalliert; nur relevant, wenn das lokale LLM-Backend verwendet wird)
* Mindestens ein API-Key (OpenAI, Anthropic usw.) **oder** eine lokale Ollama-Instanz

***

## Schnellstart

### Option A: Eigenständiger Modus (empfohlen für den Einstieg)

Der eigenständige Modus führt LobeChat als einzelnen Container aus. Einstellungen und Gesprächsverlauf werden im lokalen Speicher des Browsers gespeichert — keine Datenbank erforderlich.

**Schritt 1: Mit Ihrem Clore.ai-Server verbinden**

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

**Schritt 2: LobeChat herunterladen und starten**

```bash
docker run -d \
  --name lobechat \\
  --restart unless-stopped \\
  -p 3210:3210 \\
  -e OPENAI_API_KEY=sk-your-openai-key-here \\
  -e OPENAI_PROXY_URL=https://api.openai.com/v1 \\
  lobehub/lobe-chat
```

**Schritt 3: Prüfen, ob es läuft**

```bash
docker ps
docker logs lobechat --tail 20
```

**Schritt 4: Auf die Oberfläche zugreifen**

Öffnen Sie Ihren Browser und navigieren Sie zu:

```
http://<your-clore-server-ip>:3210
```

> ⚠️ **Sicherheitshinweis:** Clore.ai-Server sind öffentlich zugänglich. Erwägen Sie, `ACCESS_CODE` zu setzen, um Ihre Instanz mit einem Passwort zu schützen (siehe Konfigurationsabschnitt unten).

***

### Option B: Eigenständiger Modus mit mehreren Anbietern

Übergeben Sie mehrere API-Keys, um verschiedene Anbieter gleichzeitig zu unterstützen:

```bash
docker run -d \
  --name lobechat \\
  --restart unless-stopped \\
  -p 3210:3210 \\
  -e OPENAI_API_KEY=sk-your-openai-key \\
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \\
  -e GOOGLE_API_KEY=your-google-gemini-key \\
  -e MISTRAL_API_KEY=your-mistral-key \\
  -e ACCESS_CODE=your-secret-password \\
  lobehub/lobe-chat
```

***

### Option C: Mit lokalem Ollama-Backend

Wenn Sie Ollama auf demselben Clore.ai-Server ausführen (siehe [Ollama-Anleitung](/guides/guides_v2-de/sprachmodelle/ollama.md)):

```bash
Zuerst Ollama starten
docker run -d \
  --name ollama \\
  --restart unless-stopped \\
  --gpus all \
  -p 11434:11434 \
  -v ollama:/root/.ollama \\
  ollama/ollama

# Ein Modell abrufen
docker exec ollama ollama pull llama3.2

# LobeChat starten und auf Ollama verweisen
docker run -d \
  --name lobechat \\
  --restart unless-stopped \\
  -p 3210:3210 \\
  -e OLLAMA_PROXY_URL=http://host-gateway:11434 \\
  --add-host=host-gateway:host-gateway \\
  lobehub/lobe-chat
```

> Unter Linux ersetzen Sie `host-gateway` durch die tatsächliche Docker-Bridge-IP, typischerweise `172.17.0.1`:
>
> ```bash
> -e OLLAMA_PROXY_URL=http://172.17.0.1:11434
> ```

***

### Option D: Datenbankmodus (Docker Compose)

Der Datenbankmodus ermöglicht einen persistenten Gesprächsverlauf, Unterstützung für mehrere Benutzer, Datei-Uploads in S3-kompatiblen Speicher und eine vollständige Wissensdatenbank.

**Schritt 1: Projektverzeichnis erstellen**

```bash
mkdir -p ~/lobechat && cd ~/lobechat
```

**Schritt 2: Erstellen `docker-compose.yml`**

```bash
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  postgresql:
    image: pgvector/pgvector:pg16
    container_name: lobe-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: lobechat
      POSTGRES_USER: lobechat
      POSTGRES_PASSWORD: changeme_strong_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U lobechat -d lobechat"]
      interval: 10s
      timeout: 5s
      retries: 5

  minio:
    image: minio/minio
    container_name: lobe-minio
    restart: unless-stopped
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: changeme_minio_password
    command: server /data --console-address ":9001"
    volumes:
      - minio_data:/data
    ports:
      - "9000:9000"
      - "9001:9001"

  lobechat:
    image: lobehub/lobe-chat-database
    container_name: lobe-chat
    restart: unless-stopped
    depends_on:
      postgresql:
        condition: service_healthy
    ports:
      - "3210:3210"
    environment:
      # Datenbank
      DATABASE_URL: postgresql://lobechat:changeme_strong_password@postgresql:5432/lobechat
      # S3-Speicher (MinIO)
      S3_ENDPOINT: http://minio:9000
      S3_BUCKET: lobechat
      S3_ACCESS_KEY_ID: minioadmin
      S3_SECRET_ACCESS_KEY: changeme_minio_password
      S3_PUBLIC_DOMAIN: http://<your-server-ip>:9000
      # Auth (NextAuth)
      NEXTAUTH_SECRET: your-random-32-char-secret-here
      NEXTAUTH_URL: http://<your-server-ip>:3210
      # LLM-Anbieter
      OPENAI_API_KEY: sk-your-openai-key
      ANTHROPIC_API_KEY: sk-ant-your-key
      # App
      APP_URL: http://<your-server-ip>:3210

volumes:
  postgres_data:
  minio_data:
EOF
```

**Schritt 3: Den Stack starten**

```bash
docker compose up -d
docker compose logs -f lobechat
```

**Schritt 4: MinIO-Bucket erstellen**

```bash
# MinIO-Client installieren
docker exec lobe-minio mc alias set local http://localhost:9000 minioadmin changeme_minio_password
docker exec lobe-minio mc mb local/lobechat
docker exec lobe-minio mc anonymous set download local/lobechat
```

***

## Konfiguration

### Referenz der Umgebungsvariablen

| Variable               | Beschreibung                                                 | Standard                    |
| ---------------------- | ------------------------------------------------------------ | --------------------------- |
| `OPENAI_API_KEY`       | OpenAI-API-Schlüssel                                         | —                           |
| `OPENAI_PROXY_URL`     | Benutzerdefinierter OpenAI-kompatibler Endpunkt              | `https://api.openai.com/v1` |
| `ANTHROPIC_API_KEY`    | Anthropic Claude API-Schlüssel                               | —                           |
| `GOOGLE_API_KEY`       | Google Gemini API-Schlüssel                                  | —                           |
| `MISTRAL_API_KEY`      | Mistral AI API-Schlüssel                                     | —                           |
| `OLLAMA_PROXY_URL`     | URL zur lokalen Ollama-Instanz                               | —                           |
| `ACCESS_CODE`          | Passwort zum Schutz der Oberfläche                           | —                           |
| `DEFAULT_AGENT_CONFIG` | JSON-Konfiguration für das Standardverhalten des Assistenten | —                           |
| `FEATURE_FLAGS`        | Bestimmte Funktionen aktivieren/deaktivieren                 | —                           |

### Bestimmte Funktionen aktivieren

**Websuch-Plugin aktivieren:**

```bash
-e BING_API_KEY=your-bing-search-key
```

**Text-zu-Sprache aktivieren:**

```bash
-e AZURE_TTS_API_KEY=your-azure-key \\
-e AZURE_TTS_REGION=eastus
```

**Benutzerdefinierten System-Prompt für den Standard-Agenten festlegen:**

```bash
-e DEFAULT_AGENT_CONFIG='{"systemRole":"Sie sind ein hilfreicher Assistent."}'
```

### LobeChat aktualisieren

```bash
# Neuestes Image abrufen
docker pull lobehub/lobe-chat

# Alten Container stoppen und entfernen
docker stop lobechat && docker rm lobechat

# Neuen Container mit denselben Parametern starten
docker run -d \
  --name lobechat \\
  --restart unless-stopped \\
  -p 3210:3210 \\
  -e OPENAI_API_KEY=sk-your-key \\
  lobehub/lobe-chat
```

Für Docker Compose:

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

***

## GPU-Beschleunigung

LobeChat selbst **nicht** benötigt keine GPU. In Kombination mit einem GPU-beschleunigten Backend auf Clore.ai erhalten Sie jedoch lokale, private LLM-Inferenz:

### Kombination mit vLLM (Hochleistungs-Inferenz)

Siehe die [vLLM-Anleitung](/guides/guides_v2-de/sprachmodelle/vllm.md) für die vollständige Einrichtung. Schnelle Integration:

```bash
# vLLM-Server starten (auf demselben Host)
docker run -d \
  --name vllm \\
  --gpus all \
  --restart unless-stopped \\
  -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  vllm/vllm-openai:latest \
  --model meta-llama/Llama-3.1-8B-Instruct \\
  --served-model-name llama3.1-8b

# LobeChat starten und auf vLLM verweisen (OpenAI-kompatible API)
docker run -d \
  --name lobechat \\
  --restart unless-stopped \\
  -p 3210:3210 \\
  -e OPENAI_API_KEY=not-needed \\
  -e OPENAI_PROXY_URL=http://172.17.0.1:8000/v1 \\
  lobehub/lobe-chat
```

### Ressourcennutzung

| Backend               | Verwendeter GPU-VRAM | Ungefähre Durchsatzrate        |
| --------------------- | -------------------- | ------------------------------ |
| Ollama (Llama 3.2 3B) | \~2 GB               | 50–80 Token/Sek. auf 3090      |
| Ollama (Llama 3.1 8B) | \~6 GB               | 40–60 Token/Sek. auf 3090      |
| vLLM (Llama 3.1 8B)   | \~16 GB              | 80–150 Token/Sek. auf 3090     |
| vLLM (Llama 3.1 70B)  | \~80 GB              | 20–40 Token/Sek. auf A100 80GB |

***

## Tipps & bewährte Praktiken

### Kostenoptimierung

* **Stoppen Sie Ihren Server, wenn er im Leerlauf ist.** Clore.ai berechnet stundenweise — verwenden Sie das Dashboard, um Instanzen anzuhalten, die Sie gerade nicht aktiv nutzen.
* **Eigenständiger Modus für die persönliche Nutzung.** Sofern Sie keine Unterstützung für mehrere Benutzer oder einen persistenten serverseitigen Verlauf benötigen, vermeidet der eigenständige Modus den Mehraufwand von PostgreSQL und MinIO.
* **Nutzen Sie API-Anbieter für große Modelle.** Claude- oder GPT-4-Anfragen über externe APIs weiterzuleiten ist günstiger, als für gelegentliche Abfragen eine H100 zu mieten.

### Sicherheit

```bash
# Auf öffentlichen Clore.ai-IPs immer einen Zugriffscode festlegen
-e ACCESS_CODE=your-strong-password-here

# Auf bestimmte Ursprünge beschränken (optional)
-e NEXT_PUBLIC_SERVICE_MODE=server
```

* LobeChat niemals ohne einen `ACCESS_CODE` auf einer öffentlichen IP.
* Erwägen Sie, bei längerem Betrieb einen Nginx-Reverse-Proxy mit HTTPS zu verwenden.
* Rotieren Sie API-Keys, wenn Sie eine Offenlegung vermuten.

### Leistung

```bash
# Node.js-Heap erhöhen, wenn der Datenbankmodus mit vielen Benutzern läuft
-e NODE_OPTIONS="--max-old-space-size=4096"
```

* Für den Datenbankmodus mit 10+ gleichzeitigen Benutzern sollten auf dem Host mindestens 8 GB RAM vorhanden sein.
* MinIO arbeitet besser mit SSD-gestütztem Speicher (Clore.ai-NVMe-Instanzen).

### Persistenz zwischen Clore.ai-Sitzungen

Da Clore.ai-Server beendet werden können:

```bash
# Docker-Volume für eigenständige Gesprächsexporte erstellen
docker run -d \
  --name lobechat \\
  -p 3210:3210 \\
  -v lobechat_data:/app/data \\
  lobehub/lobe-chat
```

Exportieren Sie Gespräche regelmäßig in der UI über Einstellungen → Datenexport.

***

## Fehlerbehebung

### Container startet nicht

```bash
# Protokolle prüfen
docker logs lobechat --tail 50

# Prüfen, ob der Port nicht belegt ist
ss -tlnp | grep 3210

# Prüfen, ob der Docker-Daemon läuft
systemctl status docker
```

### Keine Verbindung zu Ollama von LobeChat aus möglich

```bash
# Verbindung aus dem LobeChat-Container testen
docker exec lobechat curl -s http://172.17.0.1:11434/api/tags

# Falls das fehlschlägt, prüfen, ob Ollama auf allen Schnittstellen lauscht
docker exec ollama ollama serve --host 0.0.0.0
```

### Datenbankverbindungsfehler (Datenbankmodus)

```bash
# PostgreSQL-Status prüfen
docker exec lobe-postgres pg_isready -U lobechat

# DATABASE_URL-Format prüfen
# postgresql://user:password@host:port/dbname

# Migrationen bei Bedarf manuell ausführen
docker exec lobe-chat npx prisma migrate deploy
```

### Bilder/Dateien werden nicht hochgeladen (Datenbankmodus)

```bash
# Prüfen, ob MinIO erreichbar ist
curl -s http://localhost:9000/minio/health/live

# Prüfen, ob der Bucket existiert
docker exec lobe-minio mc ls local/

# Prüfen, ob S3_PUBLIC_DOMAIN auf die richtige Server-IP gesetzt ist
```

### Speicherfehler wegen unzureichendem Arbeitsspeicher

```bash
# Aktuelle Speichernutzung prüfen
docker stats lobechat

# Speicherlimit des Containers erhöhen
docker run -d \
  --name lobechat \\
  --memory=2g \\
  -p 3210:3210 \\
  lobehub/lobe-chat
```

***

## Weiterführende Lektüre

* [LobeChat-Dokumentation](https://lobehub.com/docs) — offizielle Doku, Plugin-Entwicklung, Bereitstellungsanleitungen
* [LobeChat GitHub](https://github.com/lobehub/lobe-chat) — Quellcode, Issues, Diskussionen
* [Ollama auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/ollama.md) — lokales LLM-Backend für LobeChat
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md) — leistungsstarke OpenAI-kompatible Inferenz
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — die richtige Clore.ai-GPU auswählen
* [LobeChat Docker Hub](https://hub.docker.com/r/lobehub/lobe-chat) — Image-Tags und -Versionen
* [LobeChat-Umgebungsvariablen](https://lobehub.com/docs/self-hosting/environment-variables) — vollständige Variablenreferenz


---

# 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/lobechat.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.