LobeChat KI-Assistent

Setzen Sie LobeChat auf Clore.ai ein — eine beeindruckende, funktionsreiche KI-Chat-Oberfläche mit Multi-Provider-Unterstützung, Wissensdatenbank und Plugins, die auf erschwinglichen GPU-gestützten Cloud-Servern läuft.

Überblick

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

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

Schritt 2: LobeChat herunterladen und starten

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

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:

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

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

-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

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

Schritt 2: Erstellen Sie docker-compose.yml

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

docker compose up -d
docker compose logs -f lobechat

Schritt 4: MinIO-Bucket erstellen

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

-e BING_API_KEY=your-bing-search-key

Text-zu-Sprache aktivieren:

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

Benutzerdefiniertes Systemprompt für den Standardagenten setzen:

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

LobeChat aktualisieren

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

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 für die vollständige Einrichtung. Schnelle Integration:

# 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

# 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

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

# 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

# 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

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

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

# 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

# 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 — offizielle Doku, Plugin-Entwicklung, Deploy-Anleitungen

• LobeChat GitHub — Quellcode, Issues, Diskussionen

• Ollama auf Clore.ai ausführen — lokales LLM-Backend für LobeChat

• vLLM auf Clore.ai ausführen — Hochleistungs-, OpenAI-kompatible Inferenz

• GPU-Vergleichsanleitung — Auswahl der richtigen Clore.ai-GPU

• LobeChat Docker Hub — Image-Tags und Versionen

• LobeChat-Umgebungsvariablen — vollständige Variablenreferenz