> 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/metagpt.md).

# Entreprise logicielle MetaGPT

Déployez MetaGPT sur Clore.ai — exécutez une entreprise logicielle IA multi-agents entièrement autonome sur des serveurs cloud GPU abordables pour générer des codebases complètes, des PRD, des conceptions d'architecture et des tests QA à partir d'un sing

## Aperçu

[MetaGPT](https://github.com/geekan/MetaGPT) est un framework d'IA multi-agents qui simule une **entreprise logicielle** — avec des agents Product Manager, Architecte, Ingénieur et Ingénieur QA — tous collaborant pour transformer une idée en une phrase en un projet logiciel pleinement fonctionnel. Avec plus de 45 k étoiles sur GitHub, MetaGPT est l'une des approches les plus innovantes du développement logiciel piloté par l'IA.

Contrairement à un seul agent de codage, MetaGPT reproduit les flux de travail d'une véritable équipe. Lorsque vous lui donnez une tâche comme « Créez un jeu Snake en Python », il :

1. **Chef de produit** — Rédige un document d'exigences produit (PRD)
2. **Architecte** — Conçoit l'architecture du système et la pile technologique
3. **Chef de projet** — Décompose les tâches et les attribue
4. **Ingénieurs** — Écrivent du code fonctionnel réel pour chaque composant
5. **Ingénieur QA** — Rédige des tests unitaires et valide l'implémentation

Le résultat est un répertoire de projet complet avec du code, de la documentation et des tests — généré de manière autonome.

**Fonctionnalités clés :**

* **Cycle de vie logiciel complet** — Des exigences au code fonctionnel en une seule commande
* **Agents basés sur les rôles** — Agents spécialisés aux responsabilités distinctes
* **Génération de documents** — Génère automatiquement des PRD, des conceptions système et des spécifications d'API
* **Prise en charge multilingue** — Python, Node.js, Go, et plus encore
* **Interpréteur de données** — Agent autonome d'analyse et de visualisation de données
* **Développement incrémental** — Ajoutez des fonctionnalités à des projets existants
* **Mode d'interaction humaine** — Pause pour validation humaine aux étapes clés

**Pourquoi Clore.ai pour MetaGPT ?**

MetaGPT lui-même est basé sur le CPU, mais Clore.ai offre des avantages décisifs :

* **Tâches de longue durée** — La génération MetaGPT peut prendre 10 à 60 minutes ; des serveurs dédiés gèrent cela sans expiration de délai
* **Backend LLM local** — Utilisez Ollama ou vLLM pour éliminer les coûts API par jeton sur les grands projets
* **Maîtrise des coûts** — À 0,20–0,35 $/h, exécutez de longues sessions MetaGPT moins cher que des appels API GPT-4o
* **Environnement isolé** — Le code généré s'exécute dans un environnement serveur contrôlé
* **Collaboration d'équipe** — Partagez un point de terminaison de serveur MetaGPT au sein d'une équipe de développement

***

## Exigences

MetaGPT orchestre les appels API LLM — le GPU n'est nécessaire que si vous exécutez un backend LLM local.

| Configuration                      | GPU        | VRAM  | RAM   | Stockage | Prix estimé                               |
| ---------------------------------- | ---------- | ----- | ----- | -------- | ----------------------------------------- |
| **MetaGPT + API OpenAI/Anthropic** | Aucune     | —     | 4 Go  | 20 Go    | \~0,03–0,08 $/h                           |
| **+ Ollama (Qwen2.5-Coder 7B)**    | RTX 3090   | 24 Go | 16 Go | 40 Go    | 0,07–0,21 $/h                             |
| **+ Ollama (DeepSeek Coder 33B)**  | RTX 4090   | 24 Go | 32 Go | 60 Go    | 0,14–0,42 $/h                             |
| **+ vLLM (Qwen2.5-Coder 32B)**     | RTX 4090   | 24 Go | 32 Go | 80 Go    | 0,14–0,42 $/h                             |
| **+ vLLM (Llama 3.1 70B)**         | A100 80 Go | 80 Go | 64 Go | 100 Go   | [bare metal](https://clore.ai/bare-metal) |

> **Recommandation :** MetaGPT dépend fortement de la qualité du modèle pour un raisonnement cohérent en plusieurs étapes. Pour les projets complexes, utilisez les API GPT-4o ou Claude Sonnet 3.5, ou localement Qwen2.5-Coder-32B / DeepSeek-Coder-V2. Voir le [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md).

**Exigences logicielles sur le serveur Clore.ai :**

* Docker Engine (préinstallé sur toutes les images Clore.ai)
* NVIDIA Container Toolkit (uniquement pour l'option LLM locale)
* 20 Go+ d'espace disque libre (image MetaGPT + fichiers du projet générés)
* Accès Internet sortant (pour télécharger les images Docker et accéder aux API LLM)

***

## Démarrage rapide

### Étape 1 : Connectez-vous à votre serveur Clore.ai

Réservez un serveur sur [Place de marché Clore.ai](https://clore.ai):

* Pour l'API uniquement : tout serveur avec ≥4 Go de RAM
* Pour un LLM local : GPU avec ≥24 Go de VRAM

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

### Étape 2 : Téléchargez l'image Docker de MetaGPT

```bash
docker pull metagpt/metagpt:latest
```

> L'image MetaGPT fait environ 3 Go. Cela peut prendre 2 à 5 minutes lors du premier téléchargement.

### Étape 3 : Configurez la configuration

MetaGPT nécessite un fichier de configuration YAML avec vos identifiants API LLM :

```bash
# Créer les répertoires
mkdir -p /opt/metagpt/{config,workspace}

# Extraire le modèle de configuration par défaut depuis l'image
docker run --rm metagpt/metagpt:latest \\
  cat /app/metagpt/config/config2.yaml \\
  > /opt/metagpt/config/config2.yaml

# Afficher la configuration
cat /opt/metagpt/config/config2.yaml
```

### Étape 4 : Configurez votre fournisseur LLM

Modifiez le fichier de configuration :

```bash
nano /opt/metagpt/config/config2.yaml
```

**Pour OpenAI (GPT-4o) :**

```yaml
llm:
  api_type: "openai"
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "sk-your-openai-key-here"

repair_llm_output: true
max_auto_summarize_code: 1
```

**Pour Anthropic (Claude) :**

```yaml
llm:
  api_type: "anthropic"
  model: "claude-3-5-sonnet-20241022"
  api_key: "sk-ant-your-key-here"

repair_llm_output: true
```

**Pour Ollama local (voir la section GPU) :**

```yaml
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"

repair_llm_output: true
```

### Étape 5 : Lancez votre premier projet MetaGPT

```bash
# Générer un jeu Snake (démo classique)
docker run --rm --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Créez un jeu Snake avec Python"
```

Regardez les agents travailler : vous verrez la génération du PRD, la conception du système, l'écriture du code et les tests en séquence. Comptez 5 à 15 minutes selon votre LLM.

### Étape 6 : Affichez la sortie

```bash
ls -la /opt/metagpt/workspace/
# Vous verrez un répertoire nommé d'après votre projet

find /opt/metagpt/workspace -type f | head -30
# Répertorie tous les fichiers générés : .py, .md, requirements.txt, tests/
```

***

## Configuration

### Référence complète de configuration

```yaml
# /opt/metagpt/config/config2.yaml

# Configuration principale du LLM
llm:
  api_type: "openai"          # openai | anthropic | ollama | azure | gemini
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "your-api-key"
  temperature: 0.0            # Plus bas = génération de code plus déterministe
  max_token: 4096

# Paramètres de comportement de MetaGPT
repair_llm_output: true       # Corrige automatiquement les réponses LLM mal formées
max_auto_summarize_code: 1    # Itérations de résumé du code (0 = désactivé)
max_project_auto_run: 5       # Nombre maximal de cycles d'exécution automatique

# Paramètres du projet
project_name: ""              # Facultatif : remplacer le nom du projet généré
inc: false                    # Mode incrémental (ajouter à un projet existant)
reqa_file: ""                 # Lancer le QA sur un fichier spécifique

# Suivi des coûts
max_budget: 10.0              # Montant max en $ à dépenser (appels API uniquement)
```

### Exécution en mode interactif

Pour plus de contrôle, exécutez MetaGPT avec des points de validation humaine :

```bash
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Créez une API REST pour une application de liste de tâches avec FastAPI" \\
  --human-review
```

Avec `--human-review`, MetaGPT s'interrompt après les étapes du PRD et de la conception du système, vous permettant de fournir des retours avant le début du développement.

### Développement incrémental (ajouter à un projet existant)

```bash
# Poursuivre le développement sur un projet existant
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  -v /opt/metagpt/workspace/my-project:/app/metagpt/workspace/my-project \\
  metagpt/metagpt:latest \\
  metagpt "Ajoutez l'authentification utilisateur à l'API todo existante" \\
  --project-path /app/metagpt/workspace/my-project \\
  --inc
```

### Exécution de l'interpréteur de données

MetaGPT inclut un agent Data Interpreter spécialisé pour l'analyse de données :

```bash
# Analyse interactive de données en Python
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  -v /path/to/your/data:/data:ro \\
  metagpt/metagpt:latest \\
  python -m metagpt.roles.di.data_interpreter \\
    "Analysez /data/sales.csv et trouvez les produits les plus performants, créez une visualisation"
```

### Docker Compose pour une configuration persistante

```yaml
# /opt/metagpt/docker-compose.yml
version: "3.9"

services:
  metagpt:
    image: metagpt/metagpt:latest
    privileged: true
    volumes:
      - /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml:ro
      - /opt/metagpt/workspace:/app/metagpt/workspace
      - /opt/metagpt/logs:/app/metagpt/logs
    environment :
      - PYTHONUNBUFFERED=1
    stdin_open: true
    tty: true
    # Remarque : MetaGPT est basé sur des tâches, ce n'est pas un service persistant.
    # Utilisez 'docker compose run metagpt metagpt "votre tâche"' pour exécuter
    entrypoint: ["bash"]
```

```bash
# Exécutez une tâche via docker-compose
docker compose -f /opt/metagpt/docker-compose.yml \\
  run --rm metagpt \\
  metagpt "Créez une application web Flask avec inscription des utilisateurs"
```

***

## Accélération GPU (intégration LLM locale)

### MetaGPT + Ollama

Exécutez MetaGPT entièrement gratuitement (sans coûts d'API) en utilisant un modèle de codage local :

```bash
# Étape 1 : Démarrez Ollama avec GPU
docker run -d \
  --name ollama \\
  --gpus all \
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# Étape 2 : Téléchargez un modèle de codage de haute qualité
# Pour RTX 3090/4090 (24 Go de VRAM) :
docker exec ollama ollama pull qwen2.5-coder:32b      # Meilleur pour le code
docker exec ollama ollama pull deepseek-coder-v2:16b  # Alternative
# Pour les GPU plus petits (8–16 Go de VRAM) :
docker exec ollama ollama pull qwen2.5-coder:7b
docker exec ollama ollama pull codellama:13b

# Étape 3 : Configurez MetaGPT pour Ollama
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"
  temperature: 0.0
  max_token: 4096

repair_llm_output: true
max_auto_summarize_code: 0
EOF

# Étape 4 : Lancez MetaGPT avec le réseau hôte pour l'accès à Ollama
docker run --rm --privileged \\
  --add-host host.docker.internal:host-gateway \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Créez un outil CLI Python pour l'organisation de fichiers"
```

> Voir le guide complet [d’Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) pour la configuration du modèle et l'optimisation GPU.

### MetaGPT + vLLM (haut débit)

Pour un débit maximal de jetons sur de grands projets complexes :

```bash
# Étape 1 : Démarrez vLLM avec un modèle de codage
docker run -d \
  --name vllm \\
  --gpus all \
  --restart unless-stopped \\
  -p 8000:8000 \
  --ipc=host \
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \\
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90

# Attendez le chargement du modèle
until curl -s http://localhost:8000/health | grep -q ok; do
  echo "Attente de vLLM..."; sleep 10
done

# Étape 2 : Configurez MetaGPT pour vLLM
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "openai"
  model: "Qwen/Qwen2.5-Coder-32B-Instruct"
  base_url: "http://host.docker.internal:8000/v1"
  api_key: "none"
  temperature: 0.0
  max_token: 8192

repair_llm_output: true
EOF

# Étape 3 : Lancez MetaGPT
docker run --rm --privileged \\
  --add-host host.docker.internal:host-gateway \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Créez un backend e-commerce complet avec FastAPI et PostgreSQL"
```

> Voir le [guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) pour les options de quantification et les configurations multi-GPU.

### Modèles recommandés par tâche

| Type de tâche          | Modèle                         | VRAM minimale | Remarques                             |
| ---------------------- | ------------------------------ | ------------- | ------------------------------------- |
| Scripts simples        | `qwen2.5-coder:7b`             | 8 Go          | Rapide, adapté aux outils CLI         |
| Projets intermédiaires | `qwen2.5-coder:14b`            | 12 Go         | Bon équilibre                         |
| Systèmes complexes     | `qwen2.5-coder:32b`            | 24 Go         | Meilleure option locale               |
| Grandes bases de code  | `gpt-4o` / `claude-3-5-sonnet` | API           | Le plus fiable pour les PRD complexes |

> **Astuce :** Les modèles locaux fonctionnent bien pour la génération de code, mais ont parfois du mal avec un raisonnement architectural complexe. Pour des PRD et des conceptions système de qualité production, envisagez d'utiliser GPT-4o ou Claude pour la phase de planification et un modèle local pour la génération du code.

***

## Conseils et bonnes pratiques

### 1. Rédigez des prompts de tâche efficaces

Les performances de MetaGPT dépendent fortement de la qualité de votre prompt initial :

```
✅ Bons prompts :
« Créez une API REST Python utilisant FastAPI qui gère un catalogue de bibliothèque.
Fonctionnalités : ajouter/rechercher/supprimer des livres, authentification utilisateur avec JWT, 
base de données SQLite, documentation OpenAPI. Cible : prête pour la production avec des tests. »

« Créez un outil CLI de pipeline de données en Python qui lit des fichiers CSV,
effectue une analyse statistique et génère des graphiques avec matplotlib. »

❌ Prompts vagues :
« Faites une application web »
« Créez quelque chose avec Python »
```

### 2. Estimez les coûts d'API avant l'exécution

```bash
# MetaGPT traite beaucoup de jetons par projet :
# - Script simple : ~50 k jetons (~0,25 $ avec GPT-4o)
# - Application web moyenne : ~200 k jetons (~1,00 $ avec GPT-4o)
# - Système complexe : ~500 k+ jetons (~2,50 $+ avec GPT-4o)

# Définissez une limite de budget dans la configuration :
# max_budget: 2.0  # Arrêter après 2 $ dépensés
```

### 3. Examinez d'abord le PRD généré

Utilisez `--human-review` pour les projets importants. L'étape du PRD est celle où les exigences sont figées — détecter les problèmes ici permet d'économiser beaucoup de jetons par rapport à une révision après génération du code.

### 4. Testez le code généré

MetaGPT génère des tests unitaires, mais vérifiez toujours :

```bash
# Accédez au projet généré
cd /opt/metagpt/workspace/<your-project>

# Installer les dépendances
pip install -r requirements.txt

# Exécutez les tests générés
pytest tests/ -v

# Essayez d'exécuter l'application principale
python main.py
```

### 5. Utilisez le contrôle de version

```bash
# Initialisez git dans l'espace de travail
cd /opt/metagpt/workspace
git init
git add .
git commit -m "Initial MetaGPT generation"

# Après chaque itération
git add .
git commit -m "MetaGPT: Ajout de la fonctionnalité d'authentification"
```

### 6. Regroupez plusieurs projets

Lancez plusieurs projets pendant la nuit sur Clore.ai pour un maximum de valeur :

```bash
#!/bin/bash
# /opt/metagpt/batch-run.sh
PROJECTS=(
  "Créez un service de raccourcisseur d'URL avec Python et Redis"
  "Créez un outil CLI de conversion Markdown vers PDF"
  "Créez une API REST pour un blog avec commentaires et tags"
)

for project in "${PROJECTS[@]}"; do
  echo "Démarrage : $project"
  docker run --rm --privileged \\
    -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
    -v /opt/metagpt/workspace:/app/metagpt/workspace \\
    metagpt/metagpt:latest \\
    metagpt "$project"
  echo "Terminé : $project"
done
```

***

## Dépannage

### Échec du téléchargement de l'image

```bash
# Si la limite de débit de Docker Hub est atteinte
docker login  # Connectez-vous avec votre compte Docker Hub
docker pull metagpt/metagpt:latest

# Vérifiez l'espace disque disponible
df -h
# L'image MetaGPT fait environ 3 Go ; l'espace de travail peut croître jusqu'à plusieurs Go
```

### Fichier de configuration introuvable

```bash
# Vérifiez que le mappage de chemin est correct
docker run --rm \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  metagpt/metagpt:latest \\
  ls -la /app/metagpt/config/

# Vérifiez également que votre YAML est valide
python3 -c "import yaml; yaml.safe_load(open('/opt/metagpt/config/config2.yaml'))"
```

### Erreur d'authentification de l'API LLM

```bash
# Testez votre clé API indépendamment
curl https://api.openai.com/v1/models \\
  -H "Authorization: Bearer sk-your-key"

# Pour Anthropic :
curl https://api.anthropic.com/v1/models \\
  -H "x-api-key: sk-ant-your-key" \\
  -H "anthropic-version: 2023-06-01"

# Problèmes courants :
# - Clé copiée avec des espaces supplémentaires
# - Clé expirée ou quota dépassé
# - Mauvais api_type dans la configuration (par ex. "openai" au lieu de "anthropic")
```

### Connexion Ollama refusée depuis le conteneur

```bash
# Vérifiez qu'Ollama est en cours d'exécution
docker ps | grep ollama
curl http://localhost:11434/api/tags

# Testez du point de vue du conteneur MetaGPT
docker run --rm \
  --add-host host.docker.internal:host-gateway \
  metagpt/metagpt:latest \\
  curl http://host.docker.internal:11434/api/tags

# Si cela échoue encore, consultez les journaux d'Ollama
docker logs ollama --tail 20
```

### La génération se bloque ou expire

```bash
# Vérifiez si le LLM répond réellement
# Ajoutez des journaux de débogage pour voir quel agent est bloqué
docker run --rm --privileged \\
  -e PYTHONUNBUFFERED=1 \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Tâche simple" 2>&1 | tee /opt/metagpt/logs/debug.log

# Causes courantes :
# - Modèle local trop lent (essayez un modèle quantifié plus petit)
# - Limitation du débit de l'API (ajoutez des délais ou changez de niveau)
# - Fenêtre de contexte du modèle dépassée (réduisez max_auto_summarize_code)
```

### Plus d'espace disque

```bash
# Les projets générés peuvent être volumineux ; nettoyez les anciens
du -sh /opt/metagpt/workspace/*
rm -rf /opt/metagpt/workspace/old-project/

# Nettoyez aussi le cache de build Docker
docker system prune -f

# Vérifiez l'utilisation totale
df -h /opt/metagpt/
```

### Boucles « réparer la sortie du LLM »

```bash
# Si MetaGPT continue de réessayer en raison d'une sortie LLM mal formée :
# 1. Essayez un modèle plus performant (GPT-4o, Claude Sonnet)
# 2. Réduisez la température (réglez à 0.0 pour la déterminisme)
# 3. Désactivez la réparation (si vous utilisez un modèle performant) :
#    repair_llm_output: false
```

***

## Pour aller plus loin

* [Dépôt GitHub de MetaGPT](https://github.com/geekan/MetaGPT) — Code source, exemples, feuille de route
* [Documentation MetaGPT](https://docs.deepwisdom.ai/main/en/) — Documentation officielle, référence de configuration, tutoriels
* [Discord MetaGPT](https://discord.gg/DYn29wFk9z) — Support communautaire, cas d'utilisation, astuces sur les modèles
* [Docker Hub : metagpt/metagpt](https://hub.docker.com/r/metagpt/metagpt) — Balises d'image disponibles
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Exécutez des LLM locaux pour alimenter MetaGPT gratuitement
* [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — LLM local à haut débit pour MetaGPT à grande échelle
* [Guide de comparaison des GPU](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — Choisissez le bon GPU Clore.ai pour votre charge de travail
* [Classement SWE-bench](https://www.swebench.com) — Benchmark des frameworks de codage multi-agents
* [Article MetaGPT](https://arxiv.org/abs/2308.00352) — Recherche originale : « MetaGPT : Métaprogrammation pour un cadre collaboratif multi-agents »


---

# 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/metagpt.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.