# 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](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) 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@ -p ``` **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://: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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama)): ```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://:9000 # Auth (NextAuth) NEXTAUTH_SECRET: your-random-32-char-secret-here NEXTAUTH_URL: http://:3210 # LLM-Anbieter OPENAI_API_KEY: sk-your-openai-key ANTHROPIC_API_KEY: sk-ant-your-key # App APP_URL: http://: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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) 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](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — lokales LLM-Backend für LobeChat * [vLLM auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Hochleistungs-, OpenAI-kompatible Inferenz * [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — 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