# AnythingLLM RAG-Plattform

## Überblick

[AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) ist ein voll ausgestatteter Open-Source-AI-Arbeitsbereich mit über 40.000 GitHub-Sternen. Er kombiniert dokumentenbasierte RAG (Retrieval-Augmented Generation), KI-Agenten und einen No-Code-Agenten-Baukasten in einer einzigen, selbst gehosteten Anwendung – alles verwaltet über eine saubere, intuitive Benutzeroberfläche, die keine Programmierkenntnisse zur Einrichtung erfordert.

**Warum AnythingLLM auf Clore.ai betreiben?**

* **Vollständige RAG-Pipeline sofort einsatzbereit** — Laden Sie PDFs, Word-Dokumente, Websites und YouTube-Transkripte hoch. AnythingLLM zerlegt, erstellt Einbettungen und speichert sie automatisch für semantische Suche.
* **Keine GPU für die Anwendung erforderlich** — AnythingLLM verwendet standardmäßig CPU-basierte Einbettungen. Kombinieren Sie es mit einem Clore.ai-GPU-Server, der Ollama oder vLLM für lokale Inferenz ausführt.
* **KI-Agenten mit echten Tools** — Eingebaute Agenten können das Web durchsuchen, Code schreiben und ausführen, Dateien verwalten und externe APIs aufrufen – alles über eine GUI orchestriert.
* **MCP-Kompatibilität** — Integriert sich in das Model Context Protocol-Ökosystem für erweiterte Tool-Konnektivität.
* **Workspace-Isolierung** — Erstellen Sie separate Workspaces mit unterschiedlichen Wissensdatenbanken und LLM-Einstellungen für verschiedene Projekte oder Teams.

### Architekturübersicht

```
┌─────────────────────────────────────────────┐
│            AnythingLLM (Port 3001)          │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │  Agents  │  │  Users   │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM Provider Router   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (lokal)
  Claude        Gemini      vLLM (lokal)
```

***

## Anforderungen

### Server-Spezifikationen

| Komponente   | Minimum            | Empfohlen                                     | Hinweise                                       |
| ------------ | ------------------ | --------------------------------------------- | ---------------------------------------------- |
| **GPU**      | Keine erforderlich | RTX 3090 (falls lokale LLMs verwendet werden) | Nur für Ollama/vLLM-Backend                    |
| **VRAM**     | —                  | 24 GB                                         | Für lokale Modellausführung                    |
| **CPU**      | 2 vCPU             | 4 vCPU                                        | Einbettungen laufen auf der CPU                |
| **RAM**      | 4 GB               | 8 GB                                          | Mehr = größeres Dokumenten-Index im Speicher   |
| **Speicher** | 10 GB              | 50+ GB                                        | Dokumentenspeicherung, Vektor-DB, Modell-Cache |

### Clore.ai Preisinformationen

| Servertyp                      | Ungefähre Kosten   | Einsatzgebiet                            |
| ------------------------------ | ------------------ | ---------------------------------------- |
| CPU-Instanz (4 vCPU, 8 GB RAM) | \~0,05–0,10 $/Std. | AnythingLLM + externe API-Anbieter       |
| RTX 3090 (24 GB VRAM)          | \~$0.20/Stunde     | AnythingLLM + Ollama lokale LLMs         |
| RTX 4090 (24 GB VRAM)          | \~$0.35/Stunde     | AnythingLLM + schnellere lokale Inferenz |
| A100 80 GB                     | \~$1.10/Stunde     | AnythingLLM + große Modelle ab 70B+      |

> 💡 **Pro-Tipp:** Die eingebaute Einbettung von AnythingLLM (LanceDB + lokaler CPU-Embedder) funktioniert ohne GPU. Für das LLM-Backend können Sie kostenlose API-Anbieter wie OpenRouter oder Groq nutzen, um die Kosten gering zu halten.

### Voraussetzungen

* Clore.ai-Server mit SSH-Zugang
* 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 Single-Container-Bereitstellung enthält alles: die Web-UI, LanceDB-Vektorspeicher und den Dokumentenprozessor.

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

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

**Schritt 2: Speicherverzeichnis einrichten**

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

**Schritt 3: AnythingLLM starten**

```bash
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 zum Scrapen von Webseiten und Rendern von PDFs, was erhöhte Container-Berechtigungen erfordert.

**Schritt 4: Start überprüfen**

```bash
docker logs anythingllm --tail 30 -f
# Warten auf: "Server listening on port 3001"
```

**Schritt 5: Setup-Assistent abschließen**

Im Browser öffnen:

```
http://<your-clore-server-ip>:3001
```

Der erstmalige Setup-Assistent führt Sie durch:

1. Admin-Konto erstellen
2. LLM-Anbieter wählen
3. Einbettungsmodell wählen
4. Ihren ersten Workspace konfigurieren

***

### Methode 2: Docker Compose (Multi-Service)

Für Produktionsbereitstellungen mit separaten Diensten und leichterer Verwaltung:

**Schritt 1: Projektverzeichnis anlegen**

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

**Schritt 2: Erstellen Sie `docker-compose.yml`**

```bash
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
      # Einbettung
      EMBEDDING_ENGINE: native
      # Vektor-DB
      VECTOR_DB: lancedb
      # Auth
      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**

```bash
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=Ihr-zufälliges-64-Zeichen-Secret-hier
EOF
```

**Schritt 4: Starten**

```bash
docker compose up -d
docker compose logs anythingllm -f
```

***

### Methode 3: Mit vorkonfigurierten Umgebungsvariablen

Für automatisierte Bereitstellung ohne Setup-Assistent:

```bash
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-Anbieter-Optionen

AnythingLLM unterstützt eine große Auswahl an LLM-Backends. Einstellbar in der UI unter **Einstellungen → LLM-Voreinstellungen**, oder über Umgebungsvariablen:

**OpenAI:**

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

**Anthropic Claude:**

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

**Google Gemini:**

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

**Ollama (lokal):**

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

**OpenRouter (Zugriff auf 100+ Modelle):**

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

### Einbettungskonfiguration

| Engine    | Backend         | GPU benötigt | Qualität          |
| --------- | --------------- | ------------ | ----------------- |
| `native`  | CPU (eingebaut) | Nein         | Gut               |
| `openai`  | OpenAI API      | Nein         | Ausgezeichnet     |
| `ollama`  | Lokales Ollama  | Optional     | Gut–Ausgezeichnet |
| `localai` | LocalAI         | Optional     | Variable          |

```bash
# Verwenden Sie OpenAI-Einbettungen für beste Qualität
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# Verwenden Sie Ollama-Einbettungen 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 Vektor-Datenbanken

| DB         | Beschreibung                   | Am besten geeignet für               |
| ---------- | ------------------------------ | ------------------------------------ |
| `lancedb`  | Eingebaut, keine Konfiguration | Standard, kleine–mittlere Datensätze |
| `chroma`   | ChromaDB (extern)              | Mittlere Datensätze, Flexibilität    |
| `pinecone` | Pinecone Cloud                 | Große Datensätze, Produktion         |
| `weaviate` | Weaviate (selbst gehostet)     | Erweiterte Anwendungsfälle           |

### Workspace-Konfiguration

AnythingLLM-Workspaces sind isolierte Umgebungen mit eigenen:

* Dokumenten-Wissensbasis
* LLM-Einstellungen (können global überschreiben)
* Chat-Verlauf
* Agentenkonfigurationen

Erstellen Sie Workspaces über die UI oder API:

```bash
# Workspace über 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}'
```

### Dokumentaufnahme (Ingestion)

Laden Sie Dokumente über UI oder API hoch:

```bash
# 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 Workspace 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. GPU-Beschleunigung gilt für das LLM-Inferenz-Backend.

### Ollama auf demselben Clore.ai-Server ausführen

```bash
# 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 Einbettungen
docker exec ollama ollama pull mxbai-embed-large # bessere Einbettungen

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

### Best Practices für Dokumentenaufnahme

```bash
# Für große Dokumentensätze Node.js-Speicher erhöhen
-e NODE_OPTIONS="--max-old-space-size=4096"

# Empfohlene Chunk-Einstellungen für verschiedene Dokumenttypen
# Technische Dokumentation: Chunk-Größe 1000, Überlappung 200
# Rechtliches/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 die Aufnahme. Verwenden Sie `pdftotext` oder Adobe OCR im Vorfeld.
* **Nach Workspace organisieren** — Erstellen Sie für jedes Projekt/Domain separate Workspaces für bessere Abrufgenauigkeit.
* **Spezifische Abfragen verwenden** — RAG funktioniert am besten mit spezifischen Fragen, nicht mit allgemeinen Anfragen.

### Kostenmanagement auf Clore.ai

```bash
# Sichern Sie Ihren Speicher, bevor Sie eine Clore.ai-Instanz stoppen
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

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

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

* Vektor-Einbettungen (LanceDB)
* Hochgeladene Dokumente
* Chat-Verlauf
* Agentenkonfigurationen

### Multi-Benutzer-Einrichtung

```bash
# 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 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"}'
```

### KI-Agentenkonfiguration

AnythingLLM-Agenten können reale Aufgaben ausführen. Aktivieren Sie Tools in **Einstellungen → Agents**:

* **Web-Browsen** — Ruft Webseiten ab und liest sie
* **Google-Suche** — Durchsucht Google (erfordert API-Schlüssel)
* **Code-Interpreter** — Führt Python in einer Sandbox aus
* **GitHub** — Liest Repositories
* **SQL-Connector** — Fragt Datenbanken ab

```bash
# 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

```bash
# Für schwere 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

```bash
# Neuestes Image ziehen
docker pull mintplexlabs/anythingllm:latest

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

# Alten Container stoppen und entfernen (Daten sind 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

```bash
# Überprüfen, ob Container läuft
docker ps | grep anythingllm

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

# Überprüfen Sie die Portbindung
ss -tlnp | grep 3001

# Prüfen, ob der Clore.ai-Server Port 3001 in der Portzuordnung hat
# (in den Clore.ai-Bereitstellungseinstellungen hinzufügen)
```

### Dokument-Upload schlägt fehl

```bash
# Überprüfen Sie den verfügbaren Festplattenspeicher
df -h

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

# Verifizieren, dass 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 Behebungen:

```bash
# 1. Ändern Sie den Ähnlichkeitsschwellenwert (niedriger = mehr Dokumente werden abgerufen)
# Einstellungen → Workspace → Vektor-Datenbank → Similarity Threshold: 0.5

# 2. Erhöhen Sie die Top-K-Ergebnisse
# Einstellungen → Workspace → Vektor-Datenbank → Max Context Snippets: 10

# 3. Verbessern Sie die Chunk-Größe (Dokumente nach Änderung neu ingestieren)
# Einstellungen → Workspace → Text Splitter → Chunk Size: 1000, Overlap: 200

# 4. Wechseln Sie zu einem besseren Einbettungsmodell
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large
```

### Ollama-Verbindung von AnythingLLM schlägt fehl

```bash
# Im AnythingLLM-Container testen
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# Falls das fehlschlägt, finden Sie die tatsächliche Docker-Bridge-IP
ip route | grep docker
# Verwenden Sie 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
```

### Nicht genügend Speicher / Container-Absturz

```bash
# Speicherverbrauch prüfen
docker stats anythingllm

# Speicher freimachen, indem Sie den LanceDB-Cache reduzieren
# Oder zu einer Clore.ai-Instanz mit mehr RAM wechseln

# Neustart mit Speichergrenzen und Swap
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](https://docs.anythingllm.com) — vollständige Einrichtung und API-Referenz
* [AnythingLLM GitHub](https://github.com/Mintplex-Labs/anything-llm) — Quellcode, Issues, Roadmap
* [AnythingLLM Docker Hub](https://hub.docker.com/r/mintplexlabs/anythingllm) — Image-Tags
* [Ollama auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — lokales LLM-Backend für AnythingLLM
* [vLLM auf Clore.ai ausführen](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Hochleistungs-Inferenz
* [GPU-Vergleichsanleitung](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — Auswahl des richtigen Clore.ai-Tarifs
* [MCP-Dokumentation](https://modelcontextprotocol.io) — Model Context Protocol zum Erweitern von Agenten
* [AnythingLLM API-Referenz](https://docs.anythingllm.com/api-reference) — REST-API für Automatisierung