Ce que vous saurez faire à la fin
- Installer Microsoft AutoGen et configurer Claude comme moteur LLM principal
- Créer un GroupChat orchestré avec 4 AssistantAgent et un UserProxyAgent
- Bâtir un workflow d’analyse stratégique pour un cabinet de conseil basé à Dakar
- Gérer la terminaison automatique d’une conversation multi-agents (max_round, termination_msg)
- Estimer et maîtriser le coût d’un GroupChat (8 000 à 25 000 FCFA selon profondeur)
Durée : 4h. Pré-requis : Python 3.10+, clé API Anthropic, 10 000 FCFA de crédit pour les premiers tests, Docker (optionnel pour code execution), VS Code.
Étape 1 — AutoGen : la philosophie multi-agents conversationnel
AutoGen, développé par Microsoft Research, repose sur l’idée que des agents spécialisés peuvent résoudre des problèmes complexes en discutant entre eux comme dans une réunion d’équipe. Contrairement à CrewAI qui impose une séquence figée, AutoGen permet une conversation libre où le manager (GroupChatManager) choisit dynamiquement le prochain intervenant. Pour un cabinet de conseil sénégalais qui produit des recommandations stratégiques, c’est un outil de productivité considérable : un livrable de 15 pages produit en 12 minutes contre 2 jours de travail humain.
Étape 2 — Installation et environnement
python -m venv autogen-env
source autogen-env/bin/activate
# autogen-env\Scripts\activate sur Windows
pip install pyautogen==0.3.2 anthropic python-dotenv
pip install matplotlib pandas openpyxl # pour génération de livrables
# Vérification
python -c "import autogen; print(autogen.__version__)"Créez un .env et un fichier OAI_CONFIG_LIST.json qui décrit vos modèles disponibles :
ANTHROPIC_API_KEY=sk-ant-api03-VOTRE_CLEÉtape 3 — Configurer Claude dans AutoGen
AutoGen 0.3+ supporte Anthropic nativement via le paramètre api_type= »anthropic ». Voici la configuration recommandée pour un cabinet sénégalais.
import os
from dotenv import load_dotenv
import autogen
load_dotenv()
config_claude_sonnet = {
"config_list": [{
"model": "claude-sonnet-4-6",
"api_key": os.getenv("ANTHROPIC_API_KEY"),
"api_type": "anthropic",
"max_tokens": 4096,
"temperature": 0.3,
"cache_seed": 42 # cache local pour économiser
}]
}
config_claude_opus = {
"config_list": [{
"model": "claude-opus-4-7",
"api_key": os.getenv("ANTHROPIC_API_KEY"),
"api_type": "anthropic",
"max_tokens": 8192,
"temperature": 0.2
}]
}Étape 4 — Créer l’agent Strategist (Opus pour réflexion profonde)
strategist = autogen.AssistantAgent(
name="Strategist",
llm_config=config_claude_opus,
system_message=(
"Tu es un consultant stratégique senior basé à Dakar, "
"ancien partner chez BCG. Tu maîtrises Porter, BCG Matrix, "
"Blue Ocean. Tu réfléchis en profondeur avant de proposer "
"et tu chiffres toujours en FCFA. Tu connais le contexte "
"OHADA, UEMOA et la fiscalité sénégalaise. Quand tu as fini, "
"termine ton message par STRATEGY_DONE."
)
)Étape 5 — Créer l’agent Financial_Analyst
analyste_fin = autogen.AssistantAgent(
name="Financial_Analyst",
llm_config=config_claude_sonnet,
system_message=(
"Tu es analyste financier sénior, expert PME ouest-africaines. "
"Tu construis modèles financiers : compte de résultat 3 ans, "
"bilan, cash-flow, calcul de VAN, TRI. Tu utilises taux "
"BCEAO actuel (3.5%) comme taux sans risque. Toutes valeurs "
"en FCFA, format français (1 234 567 FCFA)."
)
)Étape 6 — Créer l’agent Market_Researcher
researcher = autogen.AssistantAgent(
name="Market_Researcher",
llm_config=config_claude_sonnet,
system_message=(
"Tu connais les marchés ouest-africains : sources ANSD, BCEAO, "
"DPEE, rapports Jeune Afrique, Financial Afrik. Tu donnes "
"tailles de marché, taux de croissance, parts des leaders. "
"Tu cites tes sources entre crochets [Source: ANSD 2025]."
)
)Étape 7 — Créer l’agent Critic (challenger)
critic = autogen.AssistantAgent(
name="Critic",
llm_config=config_claude_sonnet,
system_message=(
"Tu es l'avocat du diable. Tu challenges chaque hypothèse : "
"réaliste ? sources fiables ? hypothèses chiffrées défendables ? "
"Tu identifies risques cachés (politique, change FCFA, "
"concurrence informelle). Tu es exigeant mais constructif."
)
)Étape 8 — UserProxyAgent : l’interface humaine
user_proxy = autogen.UserProxyAgent(
name="DG_Cabinet",
human_input_mode="NEVER", # automatique pour la démo
max_consecutive_auto_reply=2,
is_termination_msg=lambda x: "RAPPORT_FINAL" in x.get("content", ""),
code_execution_config={
"work_dir": "livrables",
"use_docker": False # mettre True en production
},
system_message=(
"Tu représentes le DG d'un cabinet de conseil à Dakar. "
"Tu poses des questions précises, valides les livrables, "
"et conclus par RAPPORT_FINAL quand satisfait."
)
)Étape 9 — Assembler le GroupChat
group_chat = autogen.GroupChat(
agents=[user_proxy, strategist, analyste_fin, researcher, critic],
messages=[],
max_round=15,
speaker_selection_method="auto", # le manager choisit dynamiquement
allow_repeat_speaker=False
)
manager = autogen.GroupChatManager(
groupchat=group_chat,
llm_config=config_claude_sonnet,
system_message=(
"Tu orchestres une équipe de consultants. À chaque tour, choisis "
"le meilleur agent pour avancer. Ordre logique : Researcher d'abord "
"(données), puis Strategist (analyse), puis Financial_Analyst "
"(chiffres), puis Critic (challenge), puis Strategist (synthèse)."
)
)Étape 10 — Lancer une mission concrète
mission = """
Notre client est une PME sénégalaise de transformation de céréales
(mil, sorgho) à Thiès. Chiffre d'affaires actuel : 180 millions FCFA.
Elle veut lever 500 millions FCFA pour industrialiser et exporter
vers la France et le Maroc.
Produisez un rapport stratégique complet :
1. Étude marché (Senegal + export)
2. Analyse concurrentielle
3. Modèle financier 3 ans
4. Recommandations de financement (DER, banques, BAD)
5. Plan d'action 12 mois
Critic : challengez chaque chiffre.
Terminez par RAPPORT_FINAL.
"""
resultat = user_proxy.initiate_chat(
manager,
message=mission
)
print(f"\nNombre de tours : {len(group_chat.messages)}")
print(f"Coût estimé : {len(group_chat.messages) * 250} FCFA")Étape 11 — Speaker selection : auto vs round_robin vs custom
Méthode | Comportement | Coût | Cas d'usage
--------------------|---------------------------|---------|------------------
auto | Manager LLM choisit | Élevé | Discussions complexes
round_robin | Tour de table fixe | Faible | Workflows simples
random | Aléatoire | Moyen | Brainstorming
manual | Humain choisit | Nul | Prototypage
custom (function) | Logique métier | Variable| Production maîtriséePour un cabinet de conseil en production, on recommande custom avec une fonction de routage métier qui économise 40 % de tokens.
Étape 12 — Custom speaker selection (économique)
def selectionner_orateur(last_speaker, groupchat):
"""Routage métier : Researcher → Strategist → Financial → Critic → Strategist"""
sequence = {
"DG_Cabinet": researcher,
"Market_Researcher": strategist,
"Strategist": analyste_fin if last_speaker.name != "Critic" else user_proxy,
"Financial_Analyst": critic,
"Critic": strategist
}
return sequence.get(last_speaker.name, user_proxy)
group_chat = autogen.GroupChat(
agents=[user_proxy, strategist, analyste_fin, researcher, critic],
messages=[],
max_round=12,
speaker_selection_method=selectionner_orateur
)Étape 13 — Sauvegarder la conversation et générer un livrable
import json
from datetime import datetime
from pathlib import Path
def sauvegarder_mission(group_chat, nom_client):
dossier = Path(f"missions/{nom_client}_{datetime.now():%Y%m%d}")
dossier.mkdir(parents=True, exist_ok=True)
# Conversation brute
with open(dossier / "conversation.json", "w", encoding="utf-8") as f:
json.dump(group_chat.messages, f, ensure_ascii=False, indent=2)
# Rapport final (dernier message du Strategist)
rapport = next(
(m["content"] for m in reversed(group_chat.messages)
if m.get("name") == "Strategist"),
None
)
if rapport:
(dossier / "rapport_final.md").write_text(rapport, encoding="utf-8")
print(f"Livrables sauvegardés dans {dossier}")
sauvegarder_mission(group_chat, "PME_cereales_Thies")Étape 14 — Production : API REST exposant le cabinet virtuel
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import asyncio
app = FastAPI(title="Cabinet Virtuel AutoGen")
class Mission(BaseModel):
client: str
secteur: str
enonce: str
budget_max_fcfa: int = 25000
@app.post("/mission")
async def lancer_mission(mission: Mission):
if mission.budget_max_fcfa < 5000:
raise HTTPException(400, "Budget minimum 5 000 FCFA")
# Lancement asynchrone
loop = asyncio.get_event_loop()
resultat = await loop.run_in_executor(
None,
lambda: user_proxy.initiate_chat(manager, message=mission.enonce)
)
return {
"client": mission.client,
"tours": len(group_chat.messages),
"rapport": group_chat.messages[-2]["content"]
}Erreurs classiques à éviter
- Erreur : max_round trop élevé. 25 tours sur claude-opus-4-7 coûtent 30 000 FCFA. Limitez à 12-15 en production.
- Erreur : human_input_mode= »ALWAYS » en API. Le serveur attend une saisie clavier indéfiniment et timeout après quelques minutes.
- Erreur : oublier is_termination_msg. La conversation tourne jusqu’à max_round sans s’arrêter, gaspillant des tokens.
- Erreur : code_execution avec use_docker=False en production. Risque de sécurité majeur, l’agent peut exécuter rm -rf sur votre serveur.
- Erreur : speaker_selection= »auto » pour tâches simples. Le manager LLM coûte 30 % du budget total, inutile pour un workflow linéaire.
- Erreur : ne pas désactiver allow_repeat_speaker. Le même agent peut prendre 5 tours d’affilée et bloquer le workflow.
Checklist déploiement AutoGen Claude
✓ Python 3.10+ et venv isolé
✓ pyautogen 0.3.2+ installé
✓ Clé ANTHROPIC_API_KEY dans .env
✓ api_type="anthropic" dans config_list
✓ Sonnet pour analystes, Opus pour Strategist
✓ Chaque AssistantAgent a un system_message clair
✓ UserProxyAgent avec human_input_mode adapté
✓ is_termination_msg défini sur le UserProxy
✓ max_round limité (12 à 15 max)
✓ max_consecutive_auto_reply=2 ou 3
✓ speaker_selection custom pour workflows métier
✓ cache_seed défini pour économiser
✓ use_docker=True si exécution de code
✓ Sauvegarde conversation après chaque mission
✓ Monitoring coût par mission (budget alert)Étape 1 : poser le cas d’usage consulting avant d’écrire une ligne de code
AutoGen orchestre plusieurs agents Claude qui se passent la balle (rédacteur, reviewer, fact-checker, formatteur). En consulting à Dakar, Abidjan ou Lomé, le scénario classique est l’audit express d’un dossier client : un agent extrait les faits, un deuxième vérifie les chiffres, un troisième rédige la note de synthèse. Avant de coder, écrivez en deux phrases la mission, le livrable, et le critère de succès. Sans ce cadrage, les agents tournent en rond et brûlent vos crédits API.
Notez aussi le budget unitaire visé. Une note de synthèse de 3 pages avec deux passes de review tourne autour de 0,30 à 0,60 USD avec Claude Sonnet, soit 200 à 400 FCFA. À ce prix, l’industrialisation devient rentable dès la deuxième mission.
Étape 2 : installer AutoGen et configurer le client Claude
AutoGen s’installe en une commande. Créez d’abord un environnement Python isolé pour ne pas polluer votre système.
python -m venv .venv
source .venv/bin/activate # Linux/macOS, ou .venv\Scripts\activate sur Windows
pip install pyautogen anthropic python-dotenvVous devez voir Successfully installed pyautogen-... en fin de sortie. Si pip échoue, vérifiez que Python est en version 3.10 minimum avec python --version. Stockez ensuite la clé API dans un fichier .env à la racine du projet, jamais dans le code.
ANTHROPIC_API_KEY=sk-ant-...Ajoutez immédiatement .env à votre .gitignore. Une clé fuitée sur un repo public se fait scanner en moins de 60 secondes par les bots GitHub.
Étape 3 : définir le premier agent rédacteur
Le rédacteur est l’agent qui produit le brouillon. On lui donne un system prompt précis : ton, longueur, structure attendue. Plus le prompt est cadré, moins il dérive.
from autogen import AssistantAgent
config_list = [{
"model": "claude-sonnet-4-5",
"api_key": os.getenv("ANTHROPIC_API_KEY"),
"api_type": "anthropic",
}]
redacteur = AssistantAgent(
name="redacteur",
llm_config={"config_list": config_list, "temperature": 0.4},
system_message="Tu rédiges des notes de synthèse consulting pour un cabinet basé à Dakar. Style sobre, 400 mots, 3 sections : Constat, Risques, Recommandations. Aucune phrase publicitaire."
)La température 0.4 limite les hallucinations sans rendre le ton plat. Au-delà de 0.7, vous obtenez des envolées qui ne passent pas le filtre du fact-check.
Étape 4 : ajouter un agent reviewer qui pousse le rédacteur
Un seul agent ne suffit jamais. Le reviewer relit, pointe les faiblesses, et renvoie au rédacteur. C’est cette boucle qui distingue un workflow AutoGen d’un simple appel d’API.
reviewer = AssistantAgent(
name="reviewer",
llm_config={"config_list": config_list, "temperature": 0.2},
system_message="Tu relis la note du rédacteur. Tu relèves : chiffres non sourcés, généralités, jargon. Tu écris un retour bullet en 8 lignes maximum. Si la note est bonne, tu écris uniquement APPROVED."
)Le mot-clé APPROVED sert de signal d’arrêt à AutoGen. Sans ce token, la boucle ne se termine jamais et votre facture API explose. Testez le signal sur un cas simple avant de brancher la boucle complète.
Étape 5 : orchestrer la boucle avec GroupChat
AutoGen propose plusieurs orchestrateurs. Pour un duo, GroupChat avec max_round=4 couvre le cas standard : draft, review, correction, validation.
from autogen import GroupChat, GroupChatManager
groupchat = GroupChat(
agents=[redacteur, reviewer],
messages=[],
max_round=4,
)
manager = GroupChatManager(groupchat=groupchat, llm_config={"config_list": config_list})
user = UserProxyAgent("user", human_input_mode="NEVER", code_execution_config=False)
user.initiate_chat(manager, message="Rédige une note sur l'opportunité d'ouvrir un Data Center de proximité à Diamniadio.")Lancez le script. Vous voyez en console le rédacteur produire la première version, le reviewer commenter, le rédacteur corriger, puis le reviewer écrire APPROVED. La note finale est dans groupchat.messages[-2]["content"].
Étape 6 : ajouter un fact-checker qui vérifie les chiffres
En consulting, un chiffre faux ruine la crédibilité du livrable. Un troisième agent dédié au fact-check prend chaque assertion chiffrée et la marque ✅, ⚠️ ou ❌. Vous lui donnez une instruction stricte : ne jamais inventer de source, signaler explicitement les chiffres invérifiables.
factchecker = AssistantAgent(
name="factchecker",
llm_config={"config_list": config_list, "temperature": 0.0},
system_message="Tu lis la note. Pour chaque chiffre ou statistique, tu indiques ✅ vérifié, ⚠️ plausible mais non sourcé, ❌ invraisemblable. Tu n'inventes jamais de source. Si tu n'as pas accès au web, tu signales clairement les ⚠️."
)Température 0.0 obligatoire pour cette tâche. Le moindre degré d’aléa fait dériver le verdict. Ajoutez ce troisième agent au GroupChat et passez max_round à 6.
Étape 7 : tracer les coûts et les tokens en production
Sans observabilité, un workflow multi-agents peut consommer 50 000 tokens pour une note de 400 mots à cause des reprises. AutoGen expose cost sur chaque message. Loggez-le dans un fichier CSV.
import csv
with open("autogen_costs.csv", "a", newline="") as f:
w = csv.writer(f)
for m in groupchat.messages:
w.writerow([m.get("name"), m.get("usage", {}).get("total_tokens", 0)])Sur 50 missions, vous obtenez la distribution réelle de coûts par mission. C’est cette donnée qui sert à fixer le prix du livrable au client. Un rapport vendu 50 000 FCFA avec un coût API de 400 FCFA dégage une marge brute saine.
Étape 8 : durcir le workflow pour la production
Trois ajouts transforment un POC en outil cabinet. D’abord, un timeout réseau de 60 secondes par appel API pour éviter qu’une coupure 4G d’Orange ou de Mixx by Yas bloque le script. Ensuite, un cache local sur les prompts identiques : un dossier client analysé deux fois ne doit pas coûter deux fois. Enfin, un export Word ou Markdown formaté en sortie, prêt à envoyer au client.
from python_docx import Document
doc = Document()
doc.add_heading("Note de synthèse", 0)
for paragraph in note_finale.split("\n\n"):
doc.add_paragraph(paragraph)
doc.save("note_client.docx")Le document apparaît dans le dossier courant. Ouvrez-le, vérifiez la mise en forme, ajustez le pied de page avec votre raison sociale et votre NINEA, et envoyez.
Pour creuser ce sujet, lisez notre guide Python automatisation et le tour d’horizon de Claude.