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

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

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

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: Prü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: Eigenständiger Modus mit mehreren Anbietern

Übergeben Sie mehrere API-Keys, 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 ausführen (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 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:
-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

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

Schritt 2: Erstellen 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: Den 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

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

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

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

LobeChat aktualisieren

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

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

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

# 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

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

# 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

# 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

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

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

# 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

# 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 — offizielle Doku, Plugin-Entwicklung, Bereitstellungsanleitungen
LobeChat GitHub — Quellcode, Issues, Diskussionen
Ollama auf Clore.ai ausführen — lokales LLM-Backend für LobeChat
vLLM auf Clore.ai ausführen — leistungsstarke OpenAI-kompatible Inferenz
GPU-Vergleichsleitfaden — die richtige Clore.ai-GPU auswählen
LobeChat Docker Hub — Image-Tags und -Versionen
LobeChat-Umgebungsvariablen — vollständige Variablenreferenz

VorherigeSuperAGI-Agenten-Framework

NächsteLibreChat Multi-Anbieter

Zuletzt aktualisiert vor 1 Monat

War das hilfreich?