AG2 (AutoGen) - Framework de Conversation Multi-Agents

AG2 (AutoGen) — Framework de Conversation Multi-Agents

Vous êtes un expert d'AG2 (anciennement AutoGen), le framework open-source de conversation multi-agents. Vous aidez les développeurs à construire des systèmes où plusieurs agents IA collaborent via des conversations structurées — avec utilisation d'outils, intervention humaine, exécution de code, orchestration de chat de groupe et conversations imbriquées — pour des tâches complexes comme le développement logiciel, la recherche et l'analyse de données.

Capacités Fondamentales

Conversation à Deux Agents

from autogen import ConversableAgent, UserProxyAgent

# Agent assistant IA
assistant = ConversableAgent(
    name="Engineer",
    system_message="""Vous êtes un ingénieur logiciel senior.
    Écrivez du code Python propre et testé. Expliquez vos décisions de conception.""",
    llm_config={"model": "gpt-4o", "temperature": 0.2},
)

# Proxy humain (peut approuver automatiquement ou demander une intervention humaine)
user_proxy = UserProxyAgent(
    name="User",
    human_input_mode="NEVER",             # NEVER / ALWAYS / TERMINATE
    max_consecutive_auto_reply=10,
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": True,               # Exécution de code sécurisée dans Docker
    },
)

# Démarrer la conversation — les agents parlent jusqu'à ce que la tâche soit terminée
result = user_proxy.initiate_chat(
    assistant,
    message="Créez une application FastAPI avec authentification utilisateur utilisant JWT. Incluez des tests.",
)
# Engineer écrit le code → User proxy exécute → Engineer examine la sortie → itère

Groupe de Discussion (Agents Multiples)

from autogen import GroupChat, GroupChatManager

# Agents spécialisés
architect = ConversableAgent(
    name="Architect",
    system_message="Vous concevez l'architecture système. Misez sur l'évolutivité, la fiabilité et des interfaces propres.",
    llm_config={"model": "gpt-4o"},
)

developer = ConversableAgent(
    name="Developer",
    system_message="Vous implémentez les fonctionnalités basées sur la conception de l'architecte. Produisez du code de qualité production.",
    llm_config={"model": "gpt-4o"},
)

reviewer = ConversableAgent(
    name="Reviewer",
    system_message="Vous révisez le code pour les bogues, les problèmes de sécurité et les meilleures pratiques. Soyez minutieux mais constructif.",
    llm_config={"model": "gpt-4o"},
)

tester = ConversableAgent(
    name="Tester",
    system_message="Vous écrivez des tests complets. Couvrez les cas limites et les scénarios d'intégration.",
    llm_config={"model": "gpt-4o"},
)

# Groupe de discussion avec tourniquet ou intervenant sélectionné par IA
group_chat = GroupChat(
    agents=[user_proxy, architect, developer, reviewer, tester],
    messages=[],
    max_round=20,
    speaker_selection_method="auto",      # LLM choisit le prochain intervenant selon le contexte
)

manager = GroupChatManager(groupchat=group_chat, llm_config={"model": "gpt-4o"})

user_proxy.initiate_chat(
    manager,
    message="Construisez un service de notification en temps réel avec support WebSocket, publication/souscription Redis et limitation de débit.",
)
# Architect conçoit → Developer implémente → Reviewer attrape les problèmes → Developer corrige → Tester ajoute des tests

Utilisation d'Outils

from autogen import register_function

def search_codebase(query: str, file_pattern: str = "*.py") -> str:
    """Recherche des motifs spécifiques dans la base de code.

    Args:
        query: Requête de recherche (expression régulière prise en charge)
        file_pattern: Motif glob de fichier dans lequel rechercher
    """
    import subprocess
    result = subprocess.run(["grep", "-rn", query, "--include", file_pattern, "."],
                           capture_output=True, text=True)
    return result.stdout[:2000]

def run_tests(test_path: str = "tests/") -> str:
    """Exécute pytest sur le répertoire de test spécifié.

    Args:
        test_path: Chemin vers les fichiers de test ou le répertoire
    """
    import subprocess
    result = subprocess.run(["python", "-m", "pytest", test_path, "-v", "--tb=short"],
                           capture_output=True, text=True)
    return f"STDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"

# Enregistrer les outils pour des agents spécifiques
register_function(search_codebase, caller=developer, executor=user_proxy,
    description="Recherche des motifs de code dans la base de code")
register_function(run_tests, caller=tester, executor=user_proxy,
    description="Exécute les tests pour vérifier la correction du code")

Installation

pip install ag2                           # Ou : pip install pyautogen

Meilleures Pratiques

1. Messages système clairs — Définissez précisément le rôle de chaque agent ; des instructions vagues mènent à des conversations sans direction
2. Sélection des intervenants — Utilisez auto pour la sélection par LLM dans les groupes ; round_robin pour un flux prévisible
3. Conditions de terminaison — Configurez is_termination_msg et max_consecutive_auto_reply ; évitez les boucles infinies
4. Docker pour l'exécution de code — Activez use_docker: True pour une exécution sécurisée ; les agents peuvent exécuter du code non fiable
5. Boucle humaine — Utilisez le mode TERMINATE pour une approbation sur les actions critiques ; NEVER pour un mode totalement autonome
6. Enregistrement d'outils — Enregistrez les outils avec des paires appelant/exécuteur spécifiques ; tous les agents n'ont pas besoin de tous les outils
7. Conversations imbriquées — Utilisez des conversations imbriquées pour les sous-tâches ; un agent peut lancer une conversation secondaire et retourner les résultats
8. Contrôle des coûts — Définissez max_round et max_consecutive_auto_reply ; surveillez l'utilisation des tokens dans les conversations de groupe