> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/anythingllm.md).

# 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](/guides/guides_v2-de/sprachmodelle/ollama.md) — lokales LLM-Backend für AnythingLLM
* [vLLM auf Clore.ai ausführen](/guides/guides_v2-de/sprachmodelle/vllm.md) — Hochleistungs-Inferenz
* [GPU-Vergleichsanleitung](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — 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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/anythingllm.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.