> 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-fr/plateformes-ia-et-agents/anythingllm.md).

# Plateforme RAG AnythingLLM

Déployez AnythingLLM sur Clore.ai — une application RAG tout-en-un et une plateforme d'agents IA avec chat documentaire intégré, constructeur d'agents no-code et prise en charge MCP, fonctionnant sur des serveurs cloud GPU économiques.

## Aperçu

[AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) est un espace de travail IA open source, complet, avec plus de 40 k étoiles sur GitHub. Il combine le RAG basé sur les documents (Retrieval-Augmented Generation), des agents IA et un générateur d’agents sans code dans une seule application auto-hébergée — le tout géré via une interface utilisateur claire et intuitive qui ne nécessite aucune programmation pour être configurée.

**Pourquoi exécuter AnythingLLM sur Clore.ai ?**

* **Pipeline RAG complet prêt à l’emploi** — Téléversez des PDF, des documents Word, des sites web et des transcriptions YouTube. AnythingLLM les segmente, les vectorise et les stocke automatiquement pour la recherche sémantique.
* **Aucun GPU requis pour l’application** — AnythingLLM utilise par défaut un encodage basé sur le CPU. Associez-le à un serveur GPU Clore.ai exécutant Ollama ou vLLM pour l’inférence locale.
* **Agents IA avec de vrais outils** — Les agents intégrés peuvent naviguer sur le web, écrire et exécuter du code, gérer des fichiers et appeler des API externes — le tout orchestré via une interface graphique.
* **Compatibilité MCP** — S’intègre à l’écosystème du Model Context Protocol pour une connectivité étendue aux outils.
* **Isolation des espaces de travail** — Créez des espaces de travail distincts avec différentes bases de connaissances et paramètres LLM pour différents projets ou équipes.

### Vue d’ensemble de l’architecture

```
┌─────────────────────────────────────────────┐
│            AnythingLLM (Port 3001)          │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │  Agents  │  │  Users   │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    Routeur du fournisseur LLM   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (local)
  Claude        Gemini      vLLM (local)
```

***

## Exigences

### Spécifications du serveur

| Composant    | Minimum      | Recommandé                                 | Remarques                                                              |
| ------------ | ------------ | ------------------------------------------ | ---------------------------------------------------------------------- |
| **GPU**      | Aucun requis | RTX 3090 (si vous utilisez des LLM locaux) | Pour le backend Ollama/vLLM uniquement                                 |
| **VRAM**     | —            | 24 Go                                      | Pour l’inférence de modèles locaux                                     |
| **CPU**      | 2 vCPU       | 4 vCPU                                     | L’encodage s’exécute sur le CPU                                        |
| **RAM**      | 4 Go         | 8 Go                                       | Plus = index de documents plus volumineux en mémoire                   |
| **Stockage** | 10 Go        | 50+ Go                                     | Stockage des documents, base de données vectorielle, cache des modèles |

### Référence tarifaire Clore.ai

| Type de serveur                    | Coût approx.                              | Cas d’utilisation                          |
| ---------------------------------- | ----------------------------------------- | ------------------------------------------ |
| Instance CPU (4 vCPU, 8 Go de RAM) | \~0,05–0,10 $/h                           | AnythingLLM + fournisseurs d’API externes  |
| RTX 3090 (24 Go de VRAM)           | 0,07–0,21 $/h                             | AnythingLLM + LLM locaux Ollama            |
| RTX 4090 (24 Go de VRAM)           | 0,14–0,42 $/h                             | AnythingLLM + inférence locale plus rapide |
| A100 80 Go                         | [bare metal](https://clore.ai/bare-metal) | AnythingLLM + grands modèles 70B+          |

> 💡 **Conseil de pro :** L’encodage intégré d’AnythingLLM (LanceDB + encodeur local sur CPU) fonctionne sans GPU. Pour le backend LLM, vous pouvez utiliser des fournisseurs d’API gratuits comme OpenRouter ou Groq afin de réduire au minimum les coûts.

### Prérequis

* Serveur Clore.ai avec accès SSH
* Docker (préinstallé sur les serveurs Clore.ai)
* Au moins une clé API LLM **ou** backend local Ollama/vLLM

***

## Démarrage rapide

### Méthode 1 : Conteneur Docker unique (recommandé)

Le déploiement officiel en conteneur unique inclut tout : l’interface web, le magasin vectoriel LanceDB et le processeur de documents.

**Étape 1 : connectez-vous à votre serveur Clore.ai**

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

**Étape 2 : Configurer le répertoire de stockage**

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

**Étape 3 : Exécuter AnythingLLM**

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

> **Pourquoi `--cap-add SYS_ADMIN`?** AnythingLLM utilise Chromium pour le scraping des pages web et le rendu des PDF, ce qui nécessite des capacités de conteneur élevées.

**Étape 4 : Vérifier le démarrage**

```bash
docker logs anythingllm --tail 30 -f
# Attendez : "Serveur à l’écoute sur le port 3001"
```

**Étape 5 : Terminer l’assistant de configuration**

Ouvrez dans le navigateur :

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

L’assistant de configuration initial vous guide à travers :

1. Créer un compte administrateur
2. Choisir le fournisseur LLM
3. Choisir le modèle d’embedding
4. Configurer votre premier espace de travail

***

### Méthode 2 : Docker Compose (multiservice)

Pour des déploiements de production avec des services séparés et une gestion plus simple :

**Étape 1 : créez le répertoire du projet**

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

**Étape 2 : créez `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"
      # Fournisseur LLM (configurer un seul)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # Intégration
      EMBEDDING_ENGINE: native
      # Base de données vectorielle
      VECTOR_DB: lancedb
      # Authentification
      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
```

**Étape 3 : Créer `.env` fichier**

```bash
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=votre-secret-aléatoire-de-64-caractères-ici
EOF
```

**Étape 4 : Démarrer**

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

***

### Méthode 3 : Avec des variables d’environnement préconfigurées

Pour un déploiement automatisé sans l’assistant de configuration :

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

***

## Configuration

### Options du fournisseur LLM

AnythingLLM prend en charge un large éventail de backends LLM. À définir dans l’interface utilisateur sous **Paramètres → Préférence LLM**, ou via des variables d’environnement :

**OpenAI :**

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

**Claude d’Anthropic :**

```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 (local) :**

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

**OpenRouter (accès à plus de 100 modèles) :**

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

### Configuration de l’intégration

| Moteur    | Backend       | GPU requis | Qualité         |
| --------- | ------------- | ---------- | --------------- |
| `native`  | CPU (intégré) | Non        | Bon             |
| `openai`  | API OpenAI    | Non        | Excellente      |
| `ollama`  | Ollama local  | Facultatif | Bon à excellent |
| `localai` | LocalAI       | Facultatif | Variable        |

```bash
# Utilisez les embeddings OpenAI pour la meilleure qualité
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# Utilisez les embeddings Ollama pour un pipeline entièrement local
-e EMBEDDING_ENGINE=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e EMBEDDING_MODEL_PREF=nomic-embed-text
```

### Options de base de données vectorielle

| BD         | Description                 | Idéal pour                                       |
| ---------- | --------------------------- | ------------------------------------------------ |
| `lancedb`  | Intégré, sans configuration | Par défaut, ensembles de données petits à moyens |
| `chroma`   | ChromaDB (externe)          | Ensembles de données moyens, flexibilité         |
| `pinecone` | Pinecone cloud              | Ensembles de données volumineux, production      |
| `weaviate` | Weaviate (auto-hébergé)     | Cas d’usage avancés                              |

### Configuration des espaces de travail

Les espaces de travail AnythingLLM sont des environnements isolés avec leurs propres :

* Base de connaissances documentaire
* Paramètres LLM (peuvent remplacer les paramètres globaux)
* Historique des conversations
* Configurations des agents

Créez des espaces de travail via l’interface ou l’API :

```bash
# Créer un espace de travail via l’API
curl -X POST http://localhost:3001/api/v1/workspace/new \\
  -H "Authorization: Bearer your-api-key" \\
  -H "Content-Type: application/json" \
  -d '{"name": "Mon projet", "similarityThreshold": 0.7}'
```

### Ingestion de documents

Téléversez des documents via l’interface ou l’API :

```bash
# Téléverser un document via l’API
curl -X POST http://localhost:3001/api/v1/document/upload \\
  -H "Authorization: Bearer your-api-key" \\
  -F "file=@/path/to/document.pdf"

# Déplacer le document vers l’espace de travail
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"]}'
```

***

## Accélération GPU

AnythingLLM s’exécute lui-même sur le CPU. L’accélération GPU s’applique au backend d’inférence LLM.

### Exécution d’Ollama sur le même serveur Clore.ai

```bash
# Démarrer Ollama avec prise en charge GPU
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \\
  ollama/ollama

# Télécharger les modèles pour AnythingLLM
docker exec ollama ollama pull llama3.2          # 2B, rapide
docker exec ollama ollama pull llama3.1:8b       # 8B, équilibré
docker exec ollama ollama pull nomic-embed-text  # pour les embeddings
docker exec ollama ollama pull mxbai-embed-large # meilleurs embeddings

# Redémarrer AnythingLLM avec la configuration Ollama
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
```

### Performances du modèle GPU sur Clore.ai

| Modèle        | GPU        | VRAM  | Vitesse d’encodage | Vitesse d’inférence | Coût/heure |
| ------------- | ---------- | ----- | ------------------ | ------------------- | ---------- |
| Llama 3.2 3B  | RTX 3090   | 2 Go  | Rapide             | 60–80 tok/s         | \~$0.20    |
| Llama 3.1 8B  | RTX 3090   | 6 Go  | Rapide             | 40–60 tok/s         | \~$0.20    |
| Mistral 7B    | RTX 3090   | 5 Go  | Rapide             | 45–65 tok/s         | \~$0.20    |
| Llama 3.1 70B | A100 80 Go | 40 Go | Moyen              | 20–35 tok/s         | \~$1.10    |

***

## Conseils et bonnes pratiques

### Bonnes pratiques pour l’ingestion de documents

```bash
# Pour les grands ensembles de documents, augmentez la mémoire de Node.js
-e NODE_OPTIONS="--max-old-space-size=4096"

# Paramètres de découpage recommandés pour différents types de documents
# Docs techniques : taille de segment 1000, chevauchement 200
# Contrats/juridique : taille de segment 500, chevauchement 100
# Livres/articles : taille de segment 1500, chevauchement 300
```

* **Prétraiter les gros PDF** — Les scans avec beaucoup d’OCR ralentissent l’ingestion. Utilisez `pdftotext` ou Adobe OCR au préalable.
* **Organiser par espace de travail** — Créez des espaces de travail distincts par projet/domaine pour une meilleure précision de récupération.
* **Utilisez des requêtes spécifiques** — Le RAG fonctionne mieux avec des questions précises, pas avec des demandes générales.

### Gestion des coûts sur Clore.ai

```bash
# Sauvegardez votre stockage avant d’arrêter une instance Clore.ai
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

# Pour reprendre sur une nouvelle instance Clore.ai, restaurez la sauvegarde
tar -xzf anythingllm-backup-20240101.tar.gz -C ~/
```

Comme les instances Clore.ai sont éphémères, sauvegardez toujours le répertoire de stockage. Il contient :

* Embeddings vectoriels (LanceDB)
* Documents téléversés
* Historique des conversations
* Configurations des agents

### Configuration multi-utilisateur

```bash
# Activer le mode multi-utilisateur dans l’interface :
# Paramètres → Sécurité → Activer le mode multi-utilisateur

# Ou via l’environnement :
-e MULTI_USER_MODE=true

# Créer un utilisateur via l’API après avoir activé le mode multi-utilisateur
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"}'
```

### Configuration de l’agent IA

Les agents AnythingLLM peuvent effectuer des tâches du monde réel. Activez les outils dans **Paramètres → Agents**:

* **Navigation web** — Récupère et lit les pages web
* **Recherche Google** — Recherche sur Google (clé API requise)
* **Interpréteur de code** — Exécute du Python dans un bac à sable
* **GitHub** — Lit des dépôts
* **Connecteur SQL** — Interroge des bases de données

```bash
# Activer les capacités des agents via l’environnement
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=your-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=your-api-key
```

### Réglage des performances

```bash
# Pour les charges de travail lourdes de traitement de documents
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
```

### Mise à jour d’AnythingLLM

```bash
# Récupérez la dernière image
docker pull mintplexlabs/anythingllm:latest

# Sauvegarde d’abord
cp -r $HOME/anythingllm $HOME/anythingllm-backup-$(date +%Y%m%d)

# Arrêter et supprimer l’ancien conteneur (les données sont dans le volume, sans risque)
docker stop anythingllm && docker rm anythingllm

# Redémarrer avec la même commande
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
```

***

## Dépannage

### Le conteneur démarre, mais l’interface n’est pas accessible

```bash
# Vérifier que le conteneur est en cours d'exécution
docker ps | grep anythingllm

# Vérifier les logs pour les erreurs de démarrage
docker logs anythingllm --tail 50

# Vérifiez la liaison du port
ss -tlnp | grep 3001

# Vérifiez si le serveur Clore.ai a le port 3001 dans le mappage des ports
# (ajoutez-le dans les paramètres de déploiement Clore.ai)
```

### Échec du téléversement du document

```bash
# Vérifiez l'espace disque disponible
df -h

# Inspecter les logs du processeur de documents
docker logs anythingllm 2>&1 | grep -i "error\|fail\|upload"

# Vérifier que la capacité SYS_ADMIN est définie (requise pour Chromium)
docker inspect anythingllm | grep -A5 CapAdd
```

### Les réponses RAG sont de mauvaise qualité / hallucinent

Causes courantes et correctifs :

```bash
# 1. Ajuster le seuil de similarité (plus bas = plus de documents récupérés)
# Paramètres → Espace de travail → Base de données vectorielle → Seuil de similarité : 0.5

# 2. Augmenter le nombre de résultats top-K
# Paramètres → Espace de travail → Base de données vectorielle → Nombre maximal d’extraits de contexte : 10

# 3. Améliorer la taille des segments (réingérez les documents après modification)
# Paramètres → Espace de travail → Séparateur de texte → Taille de segment : 1000, chevauchement : 200

# 4. Passer à un meilleur modèle d’embeddings
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large
```

### Échec de la connexion à Ollama depuis AnythingLLM

```bash
# Tester depuis le conteneur AnythingLLM
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# Si cela échoue, trouvez l’adresse IP réelle du pont Docker
ip route | grep docker
# Utilisez cette IP dans OLLAMA_BASE_PATH

# Alternative : utiliser le réseau de l’hôte
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
```

### Manque de mémoire / crash du conteneur

```bash
# Vérifier l'utilisation de la mémoire
docker stats anythingllm

# Libérer de la mémoire en réduisant le cache LanceDB
# Ou passez à une instance Clore.ai avec plus de RAM

# Redémarrer avec des limites de mémoire et un 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
```

***

## Pour aller plus loin

* [Documentation AnythingLLM](https://docs.anythingllm.com) — configuration complète et référence de l’API
* [AnythingLLM GitHub](https://github.com/Mintplex-Labs/anything-llm) — code source, problèmes, feuille de route
* [AnythingLLM Docker Hub](https://hub.docker.com/r/mintplexlabs/anythingllm) — tags d'image
* [Exécuter Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — backend LLM local pour AnythingLLM
* [Exécuter vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — inférence haute performance
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — choisir le bon niveau Clore.ai
* [Documentation MCP](https://modelcontextprotocol.io) — protocole de contexte du modèle pour étendre les agents
* [Référence de l’API AnythingLLM](https://docs.anythingllm.com/api-reference) — API REST pour l’automatisation


---

# 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-fr/plateformes-ia-et-agents/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.