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

# MetaGPT société logicielle

## Aperçu

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

Contrairement à un agent de codage unique, MetaGPT reflète les flux de travail d'une équipe réelle. Lorsque vous lui donnez une tâche comme « Construire un jeu Snake en Python », il :

1. **Product Manager** — Rédige un document de spécifications produit (PRD)
2. **Architect** — Conçoit l'architecture système et la pile technologique
3. **Project Manager** — Décompose les tâches et les assigne
4. **Engineers** — Écrivent du code fonctionnel pour chaque composant
5. **QA Engineer** — Écrit des tests unitaires et valide l'implémentation

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

**Principales capacité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 avec des responsabilités distinctes
* **Génération de documents** — Produit automatiquement des PRD, des conceptions système, des spécifications d'API
* **Prise en charge multilingue** — Python, Node.js, Go, et plus
* **Interpréteur de données** — Agent autonome d'analyse et de visualisation des données
* **Développement incrémental** — Ajoute des fonctionnalités à des projets existants
* **Mode d'interaction humaine** — Met en pause pour une revue humaine à des étapes clés

**Pourquoi Clore.ai pour MetaGPT ?**

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

* **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 timeouts
* **Backend LLM local** — Utilisez Ollama ou vLLM pour éliminer les coûts API par token pour les grands projets
* **Contrôle 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 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 + OpenAI/Anthropic API** | Aucune    | —     | 4 Go  | 20 Go    | \~0,03–0,08 $/h |
| **+ Ollama (Qwen2.5-Coder 7B)**    | RTX 3090  | 24 Go | 16 Go | 40 Go    | \~0,20 $/h      |
| **+ Ollama (DeepSeek Coder 33B)**  | RTX 4090  | 24 Go | 32 Go | 60 Go    | \~0,35 $/h      |
| **+ vLLM (Qwen2.5-Coder 32B)**     | RTX 4090  | 24 Go | 32 Go | 80 Go    | \~0,35 $/h      |
| **+ vLLM (Llama 3.1 70B)**         | A100 80GB | 80 Go | 64 Go | 100 Go   | \~1,10 $/h      |

> **Recommandation :** MetaGPT dépend fortement de la qualité du modèle pour un raisonnement multi-étapes cohérent. Pour des 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 GPU](/guides/guides_v2-fr/prise-en-main/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 local)
* 20+ Go d'espace disque libre (image MetaGPT + fichiers de projet générés)
* Accès Internet sortant (pour récupérer des images Docker et joindre les API LLM)

***

## Démarrage rapide

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

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

* Pour API uniquement : Tout serveur avec ≥4 Go de RAM
* Pour LLM local : GPU avec ≥24 Go de VRAM

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

### Étape 2 : Récupérez l'image Docker MetaGPT

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

> L'image MetaGPT fait \~3 Go. Cela peut prendre 2–5 minutes au 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 des 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

Éditez 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 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 : Exécutez 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 "Create a snake game with 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. Prévoyez 5–15 minutes selon votre LLM.

### Étape 6 : Consultez 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
# Liste 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 LLM principale
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       # Correction automatique des réponses LLM mal formées
max_auto_summarize_code: 1    # Itérations de résumé de code (0 = désactivé)
max_project_auto_run: 5       # Nombre maximal de cycles d'exécution automatique

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

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

### Exécution en mode interactif

Pour plus de contrôle, exécutez MetaGPT avec des points de contrôle de révision 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 "Build a REST API for a todo list app with FastAPI" \
  --human-review
```

Avec `--human-review`, MetaGPT se met en pause après les étapes PRD et conception système, vous permettant de fournir des retours avant que l'ingénierie ne commence.

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

```bash
# Continuer 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 "Add user authentication to the existing todo API" \
  --project-path /app/metagpt/workspace/my-project \
  --inc
```

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

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

```bash
# Analyse de données interactive 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 \
    "Analyze /data/sales.csv and find top-performing products, create visualization"
```

### 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 "your task"' pour exécuter
    entrypoint: ["bash"]
```

```bash
# Exécuter une tâche via docker-compose
docker compose -f /opt/metagpt/docker-compose.yml \
  run --rm metagpt \
  metagpt "Create a Flask web app with user registration"
```

***

## 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émarrer 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 : Récupérer un modèle de codage de haute qualité
# Pour RTX 3090/4090 (24 Go 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 GPUs plus petits (8–16 Go VRAM) :
docker exec ollama ollama pull qwen2.5-coder:7b
docker exec ollama ollama pull codellama:13b

# Étape 3 : Configurer 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 : Exécuter 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 "Create a Python CLI tool for file organization"
```

> Voir le complet [guide 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 tokens sur des projets larges et complexes :

```bash
# Étape 1 : Démarrer 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

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

# Étape 2 : Configurer 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 : Exécuter 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 "Build a complete e-commerce backend with FastAPI and 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 min | Remarques                             |
| --------------------- | ------------------------------ | -------- | ------------------------------------- |
| Scripts simples       | `qwen2.5-coder:7b`             | 8 Go     | Rapide, adapté aux outils CLI         |
| Projets moyens        | `qwen2.5-coder:14b`            | 12 Go    | Bon équilibre                         |
| Systèmes complexes    | `qwen2.5-coder:32b`            | 24 Go    | Meilleure option locale               |
| Grosses bases de code | `gpt-4o` / `claude-3-5-sonnet` | API      | Le plus fiable pour des PRD complexes |

> **Conseil :** Les modèles locaux fonctionnent bien pour la génération de code mais ont parfois des difficultés avec le 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 de code.

***

## Conseils et bonnes pratiques

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

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

```
✅ Bons prompts :
"Create a Python REST API using FastAPI that manages a library catalog.
Fonctionnalités : ajouter/rechercher/supprimer des livres, authentification utilisateur avec JWT, 
Base de données SQLite, docs OpenAPI. Objectif : prêt pour la production avec tests."

"Build a CLI data pipeline tool in Python that reads CSV files,
effectue des analyses statistiques et génère des graphiques avec matplotlib."

❌ Prompts vagues :
"Make a web app"
"Build something with Python"
```

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

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

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

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

Utilisez `--human-review` pour les projets importants. L'étape PRD est celle où les exigences sont verrouillées — détecter les problèmes à ce stade économise un coût significatif en tokens comparé à la révision après génération de code.

### 4. Tester 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. Utiliser le contrôle de version

```bash
# Initialiser 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: Added authentication feature"
```

### 6. Lancer plusieurs projets en lot

Exécutez plusieurs projets pendant la nuit sur Clore.ai pour une valeur maximale :

```bash
#!/bin/bash
# /opt/metagpt/batch-run.sh
PROJECTS=(
  "Create a URL shortener service with Python and Redis"
  "Build a Markdown to PDF converter CLI tool"
  "Create a REST API for a blog with comments and tags"
)

for project in "${PROJECTS[@]}"; do
  echo "Starting: $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 "Completed: $project"
done
```

***

## Dépannage

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

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

# Vérifier l'espace disque disponible
df -h
# L'image MetaGPT fait ~3 Go ; l'espace de travail peut croître de 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 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 en trop
# - Clé expirée ou quota dépassé
# - Mauvais api_type dans la configuration (ex. "openai" vs "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 l'échec persiste, vérifiez les logs 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 logs de debug 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 "Simple task" 2>&1 | tee /opt/metagpt/logs/debug.log

# Causes courantes :
# - Modèle local trop lent (essayez un modèle quantifié plus petit)
# - Limitation de débit 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)
```

### Espace disque insuffisant

```bash
# Les projets générés peuvent être volumineux ; supprimez 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 « Repair LLM Output »

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

***

## Lectures complémentaires

* [Répertoire GitHub MetaGPT](https://github.com/geekan/MetaGPT) — Code source, exemples, feuille de route
* [Documentation MetaGPT](https://docs.deepwisdom.ai/main/en/) — Docs officielles, référence de configuration, tutoriels
* [Discord MetaGPT](https://discord.gg/DYn29wFk9z) — Support communautaire, cas d'utilisation, conseils sur les modèles
* [Docker Hub : metagpt/metagpt](https://hub.docker.com/r/metagpt/metagpt) — Tags d'image disponibles
* [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Exécutez des LLMs 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 GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — Choisissez le GPU Clore.ai adapté à votre charge de travail
* [Leaderboard SWE-bench](https://www.swebench.com) — Benchmark des cadres de codage multi-agents
* [Article MetaGPT](https://arxiv.org/abs/2308.00352) — Recherche originale : « MetaGPT: Meta Programming for a Multi-Agent Collaborative Framework »


---

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