AnythingLLM RAG-Plattform

Deploye AnythingLLM auf Clore.ai — eine All-in-one-RAG-Anwendung und KI-Agenten-Plattform mit integriertem Dokumenten-Chat, No-Code-Agenten-Builder und MCP-Unterstützung auf kosteneffizienten GPU-Cloud-Servern.

Überblick

AnythingLLM ist ein voll ausgestatteter, quelloffener KI-Arbeitsbereich mit über 40.000 GitHub-Sternen. Er vereint dokumentbasiertes RAG (Retrieval-Augmented Generation), KI-Agenten und einen No-Code-Agent-Builder in einer einzigen, selbst gehosteten Anwendung — alles verwaltet über eine saubere, intuitive UI, die für die Einrichtung keine Programmierung erfordert.

Warum AnythingLLM auf Clore.ai betreiben?

• Vollständige RAG-Pipeline direkt einsatzbereit — Lade PDFs, Word-Dokumente, Websites und YouTube-Transkripte hoch. AnythingLLM zerlegt sie automatisch in Chunks, erstellt Embeddings und speichert sie für die semantische Suche.

• Keine GPU für die Anwendung erforderlich — AnythingLLM verwendet standardmäßig CPU-basiertes Embedding. Kombiniere es mit einem Clore.ai-GPU-Server, auf dem Ollama oder vLLM für lokale Inferenz läuft.

• KI-Agenten mit echten Werkzeugen — Eingebaute Agenten können im Web surfen, Code schreiben und ausführen, Dateien verwalten und externe APIs aufrufen — alles orchestriert über eine GUI.

• MCP-Kompatibilität — Integriert sich in das Model-Context-Protocol-Ökosystem für erweiterte Werkzeuganbindung.

• Isolierung von Arbeitsbereichen — Erstelle separate Arbeitsbereiche mit unterschiedlichen Wissensdatenbanken und LLM-Einstellungen für verschiedene Projekte oder Teams.

Architekturübersicht

┌─────────────────────────────────────────────┐
│            AnythingLLM (Port 3001)          │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Dokumente │  │ Agenten  │  │  Benutzer │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM-Anbieter-Router   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (lokal)
  Claude        Gemini      vLLM (lokal)

---

Anforderungen

Serverspezifikationen

Komponente	Minimum	Empfohlen	Hinweise
GPU	Nicht erforderlich	RTX 3090 (wenn lokale LLMs verwendet werden)	Nur für das Ollama/vLLM-Backend
VRAM	—	24 GB	Für lokale Modell-Inferenz
CPU	2 vCPU	4 vCPU	Embedding läuft auf der CPU
RAM	4 GB	8 GB	Mehr = größerer Dokumentenindex im Speicher
Speicher	10 GB	50+ GB	Dokumentspeicher, Vektordatenbank, Modellcache

Clore.ai-Preisreferenz

Servertyp	Ca. Kosten	Anwendungsfall
CPU-Instanz (4 vCPU, 8 GB RAM)	ca. 0,05–0,10 $/Std.	AnythingLLM + externe API-Anbieter
RTX 3090 (24 GB VRAM)	ca. 0,07–0,21 $/h	AnythingLLM + lokale Ollama-LLMs
RTX 4090 (24 GB VRAM)	ca. 0,14–0,42 $/h	AnythingLLM + schnellere lokale Inferenz
A100 80 GB	Bare Metal	AnythingLLM + große 70B+-Modelle

💡 Profi-Tipp: Das integrierte Embedding von AnythingLLM (LanceDB + lokaler CPU-Embedder) funktioniert ohne GPU. Für das LLM-Backend kannst du kostenlose API-Anbieter wie OpenRouter oder Groq verwenden, um die Kosten minimal zu halten.

Voraussetzungen

• Clore.ai-Server mit SSH-Zugriff

• Docker (vorinstalliert auf Clore.ai-Servern)

• Mindestens ein LLM-API-Schlüssel oder lokales Ollama/vLLM-Backend

---

Schnellstart

Methode 1: Einzelner Docker-Container (empfohlen)

Die offizielle Bereitstellung mit einem einzigen Container enthält alles: die Web-UI, den LanceDB-Vektorspeicher und den Dokumentenprozessor.

Schritt 1: Mit Ihrem Clore.ai-Server verbinden

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

Schritt 2: Speicherverzeichnis einrichten

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"

Schritt 3: AnythingLLM starten

docker run -d \
  --name anythingllm \
  --restart unless-stopped \\
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

Warum --cap-add SYS_ADMIN? AnythingLLM verwendet Chromium für das Scraping von Webseiten und das Rendern von PDFs, was erhöhte Container-Berechtigungen erfordert.

Schritt 4: Start überprüfen

docker logs anythingllm --tail 30 -f
# Warten auf: "Server lauscht auf Port 3001"

Schritt 5: Einrichtungsassistent abschließen

Im Browser öffnen:

http://<deine-clore-server-ip>:3001

Der Einrichtungsassistent für die erstmalige Nutzung führt dich durch:

1. Admin-Konto erstellen

2. LLM-Anbieter auswählen

3. Embedding-Modell auswählen

4. Ersten Arbeitsbereich konfigurieren

---

Methode 2: Docker Compose (Multi-Service)

Für produktive Bereitstellungen mit getrennten Diensten und einfacher Verwaltung:

Schritt 1: Projektverzeichnis erstellen

mkdir -p ~/anythingllm && cd ~/anythingllm
mkdir -p storage
touch storage/.env

Schritt 2: Erstellen docker-compose.yml

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

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest
    container_name: anythingllm
    restart: unless-stopped
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN
    environment:
      STORAGE_DIR: "/app/server/storage"
      # LLM-Anbieter (einen konfigurieren)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # Embedding
      EMBEDDING_ENGINE: native
      # Vektor-DB
      VECTOR_DB: lancedb
      # Authentifizierung
      AUTH_TOKEN: ${ANYTHINGLLM_AUTH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
    volumes:
      - ./storage:/app/server/storage
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/api/ping"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  anythingllm_storage:
EOF

Schritt 3: Erstellen .env Datei

cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=hier-ihr-zufälliges-64-stelliges-geheimnis
EOF

Schritt 4: Starten

docker compose up -d
docker compose logs anythingllm -f

---

Methode 3: Mit vorkonfigurierten Umgebungsvariablen

Für die automatisierte Bereitstellung ohne den Einrichtungsassistenten:

export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION && touch "$STORAGE_LOCATION/.env"

docker run -d \
  --name anythingllm \
  --restart unless-stopped \\
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v ${STORAGE_LOCATION}:/app/server/storage \
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e LLM_PROVIDER=openai \
  -e OPEN_AI_KEY=sk-your-key \
  -e OPEN_MODEL_PREF=gpt-4o-mini \
  -e EMBEDDING_ENGINE=native \
  -e VECTOR_DB=lancedb \
  -e AUTH_TOKEN=your-password \
  -e JWT_SECRET=$(openssl rand -hex 32) \
  mintplexlabs/anythingllm

---

Konfiguration

LLM-Anbieteroptionen

AnythingLLM unterstützt eine breite Palette von LLM-Backends. In der UI unter Einstellungen → LLM-Präferenz oder über Umgebungsvariablen:

OpenAI:

-e LLM_PROVIDER=openai
-e OPEN_AI_KEY=sk-your-key
-e OPEN_MODEL_PREF=gpt-4o

Anthropic Claude:

-e LLM_PROVIDER=anthropic
-e ANTHROPIC_API_KEY=sk-ant-your-key
-e ANTHROPIC_MODEL_PREF=claude-sonnet-4-5

Google Gemini:

-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=your-key
-e GEMINI_LLM_MODEL_PREF=gemini-1.5-pro

Ollama (lokal):

-e LLM_PROVIDER=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e OLLAMA_MODEL_PREF=llama3.2

OpenRouter (Zugriff auf über 100 Modelle):

-e LLM_PROVIDER=openrouter
-e OPENROUTER_API_KEY=sk-or-your-key
-e OPENROUTER_MODEL_PREF=meta-llama/llama-3.1-8b-instruct:free

Konfiguration der Einbettung

Engine	Backend	GPU erforderlich	Qualität
nativ	CPU (integriert)	Nein	Gut
openai	OpenAI-API	Nein	Hervorragend
ollama	Lokales Ollama	Optional	Gut–Exzellent
localai	LocalAI	Optional	Variable

# Verwende OpenAI-Embeddings für die beste Qualität
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# Verwende Ollama-Embeddings für eine vollständig lokale Pipeline
-e EMBEDDING_ENGINE=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e EMBEDDING_MODEL_PREF=nomic-embed-text

Optionen für die Vektordatenbank

DB	Beschreibung	Am besten geeignet für
lancedb	Integriert, keine Konfiguration	Standard, kleine bis mittelgroße Datensätze
chroma	ChromaDB (extern)	Mittelgroße Datensätze, flexibel
pinecone	Pinecone-Cloud	Große Datensätze, Produktion
weaviate	Weaviate (selbst gehostet)	Fortgeschrittene Anwendungsfälle

Arbeitsbereichs-Konfiguration

Arbeitsbereiche von AnythingLLM sind isolierte Umgebungen mit jeweils eigenen:

• Wissensdatenbank für Dokumente

• LLM-Einstellungen (können global überschrieben werden)

• Chatverlauf

• Agentenkonfigurationen

Arbeitsbereiche über die UI oder API erstellen:

# Arbeitsbereich über die API erstellen
curl -X POST http://localhost:3001/api/v1/workspace/new \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \\
  -d '{"name": "My Project", "similarityThreshold": 0.7}'

Dokumentenimport

Dokumente über UI oder API hochladen:

# Ein Dokument über die API hochladen
curl -X POST http://localhost:3001/api/v1/document/upload \
  -H "Authorization: Bearer your-api-key" \
  -F "file=@/path/to/document.pdf"

# Dokument in den Arbeitsbereich verschieben
curl -X POST http://localhost:3001/api/v1/workspace/my-project/update-embeddings \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \\
  -d '{"adds": ["custom-documents/document.pdf-chunk-1.json"]}'

---

GPU-Beschleunigung

AnythingLLM selbst läuft auf der CPU. Die GPU-Beschleunigung gilt für das LLM-Inferenz-Backend.

Ollama auf demselben Clore.ai-Server ausführen

# Ollama mit GPU-Unterstützung starten
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  ollama/ollama

# Modelle für AnythingLLM herunterladen
docker exec ollama ollama pull llama3.2          # 2B, schnell
docker exec ollama ollama pull llama3.1:8b       # 8B, ausgewogen
docker exec ollama ollama pull nomic-embed-text  # für Embeddings
docker exec ollama ollama pull mxbai-embed-large # bessere Embeddings

# AnythingLLM mit Ollama-Konfiguration neu starten
docker stop anythingllm && docker rm anythingllm

docker run -d \
  --name anythingllm \
  --restart unless-stopped \\
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e LLM_PROVIDER=ollama \
  -e OLLAMA_BASE_PATH=http://172.17.0.1:11434 \
  -e OLLAMA_MODEL_PREF=llama3.1:8b \
  -e EMBEDDING_ENGINE=ollama \
  -e EMBEDDING_MODEL_PREF=nomic-embed-text \
  mintplexlabs/anythingllm

GPU-Modellleistung auf Clore.ai

Modell	GPU	VRAM	Einbettungsgeschwindigkeit	Inferenzgeschwindigkeit	Kosten/Stunde
Llama 3.2 3B	RTX 3090	2 GB	Schnell	60–80 tok/s	~$0.20
Llama 3.1 8B	RTX 3090	6 GB	Schnell	40–60 tok/s	~$0.20
Mistral 7B	RTX 3090	5 GB	Schnell	45–65 tok/s	~$0.20
Llama 3.1 70B	A100 80GB	40 GB	Mittel	20–35 tok/s	~$1.10

---

Tipps & bewährte Praktiken

Best Practices für den Dokumentenimport

# Für große Dokumentensammlungen den Node.js-Speicher erhöhen
-e NODE_OPTIONS="--max-old-space-size=4096"

# Empfohlene Chunk-Einstellungen für verschiedene Dokumenttypen
# Technische Dokumente: Chunk-Größe 1000, Überlappung 200
# Rechtstexte/Verträge: Chunk-Größe 500, Überlappung 100
# Bücher/Artikel: Chunk-Größe 1500, Überlappung 300

• Große PDFs vorverarbeiten — OCR-lastige Scans verlangsamen den Import. Verwende pdftotext oder im Vorfeld Adobe OCR.

• Nach Arbeitsbereich organisieren — Erstelle separate Arbeitsbereiche pro Projekt/Domain für eine höhere Abrufgenauigkeit.

• Spezifische Abfragen verwenden — RAG funktioniert am besten mit konkreten Fragen, nicht mit allgemeinen Anfragen.

Kostenmanagement auf Clore.ai

# Sichere deinen Speicher, bevor du eine Clore.ai-Instanz stoppst
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

# Um auf einer neuen Clore.ai-Instanz fortzufahren, stelle das Backup wieder her
tar -xzf anythingllm-backup-20240101.tar.gz -C ~/

Da Clore.ai-Instanzen flüchtig sind, sichere das Speicherverzeichnis immer. Es enthält:

• Vektor-Embeddings (LanceDB)

• Hochgeladene Dokumente

• Chatverlauf

• Agentenkonfigurationen

Multi-User-Einrichtung

# Multi-User-Modus in der UI aktivieren:
# Einstellungen → Sicherheit → Multi-User-Modus aktivieren

# Oder über die Umgebung:
-e MULTI_USER_MODE=true

# Benutzer nach Aktivierung des Multi-User-Modus über die API erstellen
curl -X POST http://localhost:3001/api/v1/admin/users/new \
  -H "Authorization: Bearer admin-api-key" \
  -H "Content-Type: application/json" \\
  -d '{"username": "alice", "password": "securepass", "role": "default"}'

Konfiguration des KI-Agenten

AnythingLLM-Agenten können Aufgaben in der realen Welt ausführen. Aktiviere Werkzeuge in Einstellungen → Agenten:

• Web durchsuchen — Ruft Webseiten ab und liest sie

• Google-Suche — Sucht bei Google (API-Schlüssel erforderlich)

• Code-Interpreter — Führt Python in einer Sandbox aus

• GitHub — Liest Repositories

• SQL-Connector — Fragt Datenbanken ab

# Agentenfähigkeiten über die Umgebung aktivieren
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=your-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=your-api-key

Leistungsoptimierung

# Für umfangreiche Dokumentenverarbeitungs-Workloads
docker run -d \
  --name anythingllm \
  --restart unless-stopped \\
  --cpus="4" \
  --memory="8g" \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

AnythingLLM aktualisieren

# Neuestes Image abrufen
docker pull mintplexlabs/anythingllm:latest

# Zuerst sichern
cp -r $HOME/anythingllm $HOME/anythingllm-backup-$(date +%Y%m%d)

# Alten Container stoppen und entfernen (Daten liegen im Volume, sicher)
docker stop anythingllm && docker rm anythingllm

# Mit demselben Befehl neu starten
docker run -d \
  --name anythingllm \
  --restart unless-stopped \\
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

---

Fehlerbehebung

Container startet, aber UI nicht erreichbar

# Prüfen, ob der Container läuft
docker ps | grep anythingllm

# Protokolle auf Startfehler prüfen
docker logs anythingllm --tail 50

# Port-Bindung überprüfen
ss -tlnp | grep 3001

# Prüfe, ob der Clore.ai-Server Port 3001 im Port-Mapping hat
# (füge ihn in den Clore.ai-Deployment-Einstellungen hinzu)

Dokument-Upload schlägt fehl

# Verfügbaren Speicherplatz prüfen
df -h

# Protokolle des Dokumentenprozessors prüfen
docker logs anythingllm 2>&1 | grep -i "error\|fail\|upload"

# Prüfe, ob die SYS_ADMIN-Fähigkeit gesetzt ist (erforderlich für Chromium)
docker inspect anythingllm | grep -A5 CapAdd

RAG-Antworten sind von schlechter Qualität / halluzinieren

Häufige Ursachen und Lösungen:

# 1. Ähnlichkeitsschwelle anpassen (niedriger = mehr Dokumente werden abgerufen)
# Einstellungen → Arbeitsbereich → Vektordatenbank → Ähnlichkeitsschwelle: 0,5

# 2. Top-K-Ergebnisse erhöhen
# Einstellungen → Arbeitsbereich → Vektordatenbank → Maximale Kontext-Snippets: 10

# 3. Chunk-Größe verbessern (Dokumente nach der Änderung erneut importieren)
# Einstellungen → Arbeitsbereich → Text-Splitter → Chunk-Größe: 1000, Überlappung: 200

# 4. Zu einem besseren Embedding-Modell wechseln
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large

Ollama-Verbindung von AnythingLLM aus schlägt fehl

# Vom AnythingLLM-Container aus testen
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# Falls das fehlschlägt, ermittle die tatsächliche Docker-Bridge-IP
ip route | grep docker
# Verwende diese IP in OLLAMA_BASE_PATH

# Alternative: Host-Netzwerk verwenden
docker run -d \
  --name anythingllm \
  --network host \\
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  -e OLLAMA_BASE_PATH=http://localhost:11434 \
  mintplexlabs/anythingllm

Speicher erschöpft / Container-Absturz

# Speichernutzung prüfen
docker stats anythingllm

# Speicher freigeben, indem der LanceDB-Cache reduziert wird
# Oder auf eine Clore.ai-Instanz mit mehr RAM wechseln

# Mit Speicherlimits und Swap neu starten
docker run -d \
  --name anythingllm \
  --memory=6g \
  --memory-swap=8g \
  -p 3001:3001 \
  --cap-add SYS_ADMIN \
  -v $HOME/anythingllm:/app/server/storage \
  -v $HOME/anythingllm/.env:/app/server/.env \
  -e STORAGE_DIR="/app/server/storage" \
  mintplexlabs/anythingllm

---

Weiterführende Lektüre

• AnythingLLM-Dokumentation — vollständige Einrichtung und API-Referenz

• AnythingLLM GitHub — Quellcode, Issues, Roadmap

• AnythingLLM Docker Hub — Image-Tags

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

• vLLM auf Clore.ai ausführen — hochleistungsfähige Inferenz

• GPU-Vergleichsleitfaden — die richtige Clore.ai-Stufe auswählen

• MCP-Dokumentation — Model Context Protocol zur Erweiterung von Agents

• AnythingLLM API-Referenz — REST-API zur Automatisierung