Technical Tutorials

Les grands modèles de langage (LLM) ont révolutionné la génération de code, mais les sorties brutes contiennent souvent des bugs subtils ou des erreurs de logique. Bien que des modèles récents comme GPT-4 soient capables, se fier uniquement à une génération en une seule passe est rarement suffisant pour un code de qualité production. Entrez **Microsoft AutoGen**, un cadre qui permet la création de conversations multi-agents où différents rôles d'IA peuvent interagir, critiquer et affiner les sorties. Dans cet article, nous explorerons comment construire un agent de codage auto-corrigible qui intègre la validation **Human-in-the-Loop (HITL)** pour garantir des résultats de haute qualité et fiables.

L'avantage multi-agents

Les pipelines RAG traditionnels ou les chaînes de prompts simples manquent de la boucle de rétroaction dynamique nécessaire à la résolution de problèmes complexes. AutoGen résout ce problème en définissant des agents avec des rôles spécifiques, tels qu'un Codeur, un Revueur et un Proxy Utilisateur. Le Codeur génère le code initial, le Revueur l'analyse pour détecter d'éventuels défauts, et le Proxy Utilisateur facilite l'interaction avec le développeur humain. Cet écosystème collaboratif permet au système d'itérer en interne jusqu'à atteindre un niveau de confiance élevé avant de demander l'approbation humaine.

Mise en œuvre de l'équipe d'agents

Pour commencer, vous devez installer la bibliothèque pyautogen. L'exemple suivant démontre une configuration de base où un agent de codage génère une fonction Python et un agent de revue la critique. Nous utilisons AutoGenAssistantAgent pour les rôles d'IA et UserProxyAgent pour l'interface humaine.

import autogen
import os

# Configurer l'API
config_list = [{"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY"]}]

# Définir l'agent Codeur
coder = autogen.AssistantAgent(
    name="Coder",
    llm_config={"config_list": config_list, "temperature": 0.1},
    system_message="Vous êtes un développeur Python de classe mondiale. Écrivez un code propre et efficace. "
                   "Si on vous demande de corriger du code, fournissez la version corrigée complète."
)

# Définir l'agent Revueur
reviewer = autogen.AssistantAgent(
    name="Reviewer",
    llm_config={"config_list": config_list, "temperature": 0.1},
    system_message="Vous êtes un revueur de code senior. Analysez le code de manière critique pour "
                   "les erreurs de logique, les vulnérabilités de sécurité et les bonnes pratiques. "
                   "Si le code est défectueux, expliquez pourquoi et demandez au Codeur de le corriger. "
                   "S'il est parfait, dites 'APPROUVÉ'."
)

# Définir l'agent Proxy Utilisateur
user_proxy = autogen.UserProxyAgent(
    name="user_proxy",
    human_input_mode="ALWAYS",  # HITL : Toujours demander l'entrée humaine
    code_execution_config={"work_dir": "coding", "use_docker": False}
)

Ajouter la validation Human-in-the-Loop

Le véritable pouvoir de cette architecture réside dans le human_input_mode. En le définissant sur "ALWAYS", le système met en pause aux points critiques pour solliciter un retour humain. Cela garantit que, bien que les agents gèrent le travail lourd d'itération et de débogage, l'humain conserve l'autorité finale. Par exemple, si le Revueur approuve le code, le user_proxy présentera la solution finale au développeur. Le développeur peut alors l'accepter, demander des modifications supplémentaires ou la rejeter entièrement.

Lancer la conversation

Voici comment vous initiez la tâche. Nous demandons au Codeur de créer une fonction de recherche binaire, et la conversation bouclera automatiquement à travers les phases de codage et de revue jusqu'à ce qu'un consensus soit atteint ou qu'une intervention humaine soit déclenchée.

task = "Créez une fonction Python qui effectue une recherche binaire sur une liste triée d'entiers."

# Démarrer le chat
user_proxy.initiate_chat(
    speaker=coder,
    message=task,
    max_rounds=5,  # Empêcher les boucles infinies
    speaker_selection_method="round_robin" # Alterne entre Codeur et Revueur
)

Considérations pratiques et bonnes pratiques

Gestion des jetons : Les conversations multi-agents peuvent être coûteuses en jetons. Utilisez max_rounds pour limiter les interactions et assurez-vous que les prompts sont concis.
Exécution du code : Pour une fiabilité accrue, activez l'exécution du code dans le user_proxy ou un agent Testeur dédié. Cela permet aux agents d'exécuter réellement le code généré et de détecter les erreurs d'exécution, et non seulement les problèmes d'analyse statique.
Journalisation : Enregistrez toujours l'historique de la conversation. Examiner pourquoi un agent a rejeté un morceau de code est inestimable pour ajuster vos prompts système.

Conclusion

AutoGen fournit une base solide pour aller au-delà de la simple génération de code vers une ingénierie logicielle intelligente et collaborative. En combinant la puissance itérative des systèmes multi-agents avec la nuance de la validation human-in-the-loop, les développeurs peuvent construire des agents qui sont non seulement créatifs, mais aussi rigoureusement critiques. Cette approche réduit considérablement la charge sur les développeurs humains, leur permettant de se concentrer sur l'architecture et la résolution de problèmes complexes pendant que les agents gèrent le travail de routine et le débogage.