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

Chef de produit — Rédige un document d'exigences produit (PRD)
Architecte — Conçoit l'architecture du système et la pile technologique
Chef de projet — Décompose les tâches et les attribue
Ingénieurs — Écrivent du code fonctionnel réel pour chaque composant
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

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.

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:

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

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

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

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 :

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

nano /opt/metagpt/config/config2.yaml

Pour OpenAI (GPT-4o) :

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) :

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) :

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

# 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

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

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

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)

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

# 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

# /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"]

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

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

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

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

# 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

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

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

# 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

# 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

# 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

# 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

# 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

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

# 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 — Code source, exemples, feuille de route
Documentation MetaGPT — Documentation officielle, référence de configuration, tutoriels
Discord MetaGPT — Support communautaire, cas d'utilisation, astuces sur les modèles
Docker Hub : metagpt/metagpt — Balises d'image disponibles
Ollama sur Clore.ai — Exécutez des LLM locaux pour alimenter MetaGPT gratuitement
vLLM sur Clore.ai — LLM local à haut débit pour MetaGPT à grande échelle
Guide de comparaison des GPU — Choisissez le bon GPU Clore.ai pour votre charge de travail
Classement SWE-bench — Benchmark des frameworks de codage multi-agents
Article MetaGPT — Recherche originale : « MetaGPT : Métaprogrammation pour un cadre collaboratif multi-agents »

PrécédentConstructeur d'agents IA Flowise

SuivantFramework d'agents SuperAGI

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?