> 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

## Überblick

[LobeChat](https://github.com/lobehub/lobe-chat) ist ein modernes Open-Source-AI-Chat-Framework mit über 55K GitHub-Sternen, bekannt für seine ausgereifte Benutzeroberfläche und umfangreiche Funktionspalette. Es unterstützt praktisch jeden großen 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 betreiben?**

* **Keine GPU erforderlich** — LobeChat selbst ist eine leichte Web-App. Clore.ai-Instanzen ohne GPU oder mit minimaler GPU sind für die Oberfläche völlig ausreichend.
* **Kombination mit lokalen LLMs** — Starten Sie Ollama oder vLLM auf demselben Clore.ai-Server und konfigurieren Sie LobeChat darauf für vollständig lokale, private Inferenz.
* **Erschwingliches Hosting** — Eine einfache Clore.ai-Instanz kostet einen Bruchteil traditioneller VPS-Anbieter, und Sie können sie abschalten, wenn sie nicht verwendet wird.
* **Volle Datenhoheit** — Der Datenbankmodus speichert alle Gespräche, Dateien und Embeddings in Ihrer eigenen PostgreSQL-Instanz auf dem Server.

LobeChat arbeitet in zwei verschiedenen Modi:

| Modus          | Beschreibung                                                         | Am besten geeignet für                        |
| -------------- | -------------------------------------------------------------------- | --------------------------------------------- |
| **Standalone** | Ein einzelner Docker-Container, Einstellungen im Browser gespeichert | Schnelles Testen, persönlicher Gebrauch       |
| **Datenbank**  | Vollständiger Stack (PostgreSQL + MinIO + Auth + App)                | Teams, persistente Historie, Wissensdatenbank |

***

## Anforderungen

### Server-Spezifikationen

| Komponente   | Minimum            | Empfohlen                                     | Hinweise                                                        |
| ------------ | ------------------ | --------------------------------------------- | --------------------------------------------------------------- |
| **GPU**      | Keine erforderlich | RTX 3090 (falls lokale LLMs betrieben werden) | Nur nötig für Ollama/vLLM-Backend                               |
| **VRAM**     | —                  | 24 GB (RTX 3090)                              | Für lokale Modellausführung                                     |
| **CPU**      | 2 vCPU             | 4+ vCPU                                       | LobeChat selbst ist ressourcenschonend                          |
| **RAM**      | 2 GB               | 8 GB                                          | 4+ GB, wenn der Datenbankmodus verwendet wird                   |
| **Speicher** | 10 GB              | 50+ GB                                        | Mehr, wenn hochgeladene Dateien oder Modelle gespeichert werden |

### Clore.ai Preisinformationen

| Servertyp             | Ungefähre Kosten   | Einsatzgebiet                         |
| --------------------- | ------------------ | ------------------------------------- |
| Nur-CPU-Instanz       | \~0,05–0,10 $/Std. | Nur Standalone LobeChat               |
| RTX 3090 (24 GB VRAM) | \~$0.20/Stunde     | LobeChat + Ollama lokale LLMs         |
| RTX 4090 (24 GB VRAM) | \~$0.35/Stunde     | LobeChat + schnellere lokale Inferenz |
| A100 80 GB            | \~$1.10/Stunde     | LobeChat + große Modelle (70B+)       |

> 💡 **Tipp:** Für API-only Nutzung (Verbindung zu OpenAI, Anthropic usw.) reicht jede kleine Instanz. Ein GPU-Server macht nur Sinn, wenn Sie auch lokale LLMs betreiben möchten. Siehe [GPU-Vergleichsanleitung](/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 bei Verwendung eines lokalen LLM-Backends)
* Mindestens ein API-Schlüssel (OpenAI, Anthropic usw.) **oder** eine lokale Ollama-Instanz

***

## Schnellstart

### Option A: Standalone-Modus (empfohlen zum Einstieg)

Im Standalone-Modus läuft LobeChat als einzelner Container. Einstellungen und Gesprächsverlauf werden im lokalen Speicher des Browsers abgelegt — keine Datenbank erforderlich.

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

```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: Überprü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: Standalone mit mehreren Anbietern

Geben Sie mehrere API-Schlüssel an, 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 betreiben (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 herunterladen
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 persistente Gesprächshistorie, Multi-User-Unterstützung, Datei-Uploads zu S3-kompatiblem Speicher und eine vollständige Wissensdatenbank.

**Schritt 1: Projektverzeichnis anlegen**

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

**Schritt 2: Erstellen Sie `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: 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

**Web-Such-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
```

**Benutzerdefiniertes Systemprompt für den Standardagenten setzen:**

```bash
-e DEFAULT_AGENT_CONFIG='{"systemRole":"You are a helpful assistant."}'
```

### LobeChat aktualisieren

```bash
# Neuestes Image ziehen
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 **unterstützen** benötigt keine GPU. Wenn es jedoch mit einem GPU-beschleunigten Backend auf Clore.ai kombiniert wird, erhalten Sie lokale, private LLM-Inferenz:

### Kombination mit vLLM (Hochleistungsinferenz)

Siehe die [vLLM-Leitfaden](/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
```

### Ressourcenverbrauch

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

***

## Tipps & bewährte Methoden

### Kostenoptimierung

* **Schalten Sie Ihren Server aus, wenn er nicht genutzt wird.** Clore.ai berechnet stundenweise — nutzen Sie das Dashboard, um Instanzen zu pausieren, die Sie nicht aktiv verwenden.
* **Standalone-Modus für den persönlichen Gebrauch.** Sofern Sie keine Multi-User-Unterstützung oder persistente serverseitige Historie benötigen, vermeidet der Standalone-Modus den Overhead von PostgreSQL und MinIO.
* **Verwenden Sie API-Anbieter für große Modelle.** Claude- oder GPT-4-Anfragen über externe APIs zu leiten ist günstiger, als gelegentlich ein H100 anzumieten.

### Sicherheit

```bash
# Setzen Sie stets einen Zugriffscode auf öffentlichen Clore.ai-IP-Adressen
-e ACCESS_CODE=your-strong-password-here

# Auf einen bestimmten Ursprung beschränken (optional)
-e NEXT_PUBLIC_SERVICE_MODE=server
```

* Setzen Sie LobeChat niemals auf einer öffentlichen IP ohne einen `ACCESS_CODE` .
* Erwägen Sie die Verwendung eines Nginx-Reverse-Proxys mit HTTPS bei langfristigem Betrieb.
* Rotieren Sie API-Schlüssel, wenn Sie eine Kompromittierung vermuten.

### Leistung

```bash
# Erhöhen Sie den Node.js-Heap, wenn Sie den Datenbankmodus mit vielen Benutzern ausführen
-e NODE_OPTIONS="--max-old-space-size=4096"
```

* Für den Datenbankmodus mit 10+ gleichzeitigen Benutzern stellen Sie mindestens 8 GB RAM auf dem Host sicher.
* 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
# Erstellen Sie ein Docker-Volume für Standalone-Konversationsexporte
docker run -d \
  --name lobechat \
  -p 3210:3210 \
  -v lobechat_data:/app/data \
  lobehub/lobe-chat
```

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

***

## Fehlerbehebung

### Container startet nicht

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

# Überprüfen, ob der Port in Gebrauch ist
ss -tlnp | grep 3210

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

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

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

# Wenn das fehlschlägt, prüfen Sie, ob Ollama auf allen Schnittstellen hört
docker exec ollama ollama serve --host 0.0.0.0
```

### Datenbankverbindungsfehler (Datenbankmodus)

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

# Überprüfen Sie das FORMAT der DATABASE_URL
# postgresql://user:password@host:port/dbname

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

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

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

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

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

### Speicherplatzfehler

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

# Container-Speicherlimit 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, Deploy-Anleitungen
* [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) — Hochleistungs-, OpenAI-kompatible Inferenz
* [GPU-Vergleichsanleitung](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Auswahl der richtigen Clore.ai-GPU
* [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:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/lobechat.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.