> 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

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](https://github.com/Mintplex-Labs/anything-llm) 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](https://clore.ai/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**

```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 für das Scraping von Webseiten und das Rendern von PDFs, was erhöhte Container-Berechtigungen erfordert.

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

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

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

**Schritt 2: Erstellen `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
      # 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**

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

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

***

### Methode 3: Mit vorkonfigurierten Umgebungsvariablen

Für die automatisierte Bereitstellung ohne den Einrichtungsassistenten:

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

AnythingLLM unterstützt eine breite Palette von LLM-Backends. In der UI unter **Einstellungen → LLM-Präferenz** 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 über 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
```

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

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

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

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

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

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

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

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

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

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

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

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

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

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

```bash
# 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](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) — hochleistungsfähige Inferenz
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — die richtige Clore.ai-Stufe auswählen
* [MCP-Dokumentation](https://modelcontextprotocol.io) — Model Context Protocol zur Erweiterung von Agents
* [AnythingLLM API-Referenz](https://docs.anythingllm.com/api-reference) — REST-API zur 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.