Tutoriel AutoGen : Créer des applications d'IA multi-agents

L'IA moderne a commencé avec les grands modèles de langage (LLM), suivis par l'appel de fonctions pour des résultats structurés, puis par le développement d'agents et d'outils, ce qui a conduit à la création de serveurs MCP. Actuellement, l'accent est mis sur les systèmes multi-agents. Les entreprises recherchent des solutions pour construire des systèmes automatisés intelligents à l'aide de divers outils.utions pour construire des systèmes automatisés intelligents à l'aide de divers outils, AutoGen étant le plus populaire d'entre eux.

Dans ce tutoriel, nous allons explorer AutoGen, son écosystème, ses différents cas d'utilisation, et comment utiliser chaque composant au sein de cet écosystème. Il est important de noter qu'AutoGen n'est pas un simple outil d'orchestration de modèles de langue comme LangChain ; il offre bien plus que cela.

Si vous êtes novice en matière d'IA, veuillez suivre le cours Principes fondamentaux de l'IA avant de poursuivre ce tutoriel. Vous pouvez également vous informer sur IA agentique dans un autre article.

Qu'est-ce qu'AutoGen ?

AutoGen est un cadre open-source conçu pour créer des applications d'IA multi-agents qui peuvent fonctionner de manière semi-autonome et totalement autonome. Il fournit aux développeurs des outils pour construire des systèmes dans lesquels plusieurs agents d'intelligence artificielle peuvent communiquer, coopérer et effectuer des tâches ensemble.

AutoGen prend en charge un large éventail de cas d'utilisation, notamment les flux de travail automatisés, la collaboration multi-agents et la résolution dynamique des tâches. Il permet aux développeurs de créer des systèmes dans lesquels les agents peuvent interagir en langage naturel, exécuter des codes, récupérer des informations et s'adapter à des flux de travail complexes.

L'écosystème AutoGen est divisé en quatre composants principaux :

1. AutoGen Studio : Une interface graphique sans code pour construire et tester des flux de travail multi-agents.
2. AutoGent AgentChat : Une API simplifiée pour construire des applications conversationnelles simples et multi-agents.
3. AutoGen Core : L'API fondamentale pour la construction de systèmes d'IA multi-agents évolutifs. 
4. Extension AutoGen : Une bibliothèque d'extensions de première et de tierce parties qui étendent les capacités du cadre.

Source : microsoft/AutoGen

AutoGen se distingue par sa capacité à :

• Simplifiez l'orchestration et l'optimisation des flux de travail LLM complexes.
• Améliorer les performances des LLM tout en tenant compte de leurs limites.
• Permettre la création transparente de systèmes multi-agents qui intègrent des LLM, des outils et des données humaines.

Son extensibilité et sa modularité en font un outil puissant pour les développeurs dans tous les secteurs, de la finance à la santé en passant par l'éducation et la robotique.

Lire Comprendre les agents d'intelligence artificielle : L'avenir des systèmes autonomes pour apprendre comment tirer parti des agents d'IA pour l'innovation et l'efficacité dans vos projets.

Démarrer avec l'écosystème AutoGen

Dans cette section, nous allons explorer les quatre principaux composants de l'écosystème AutoGen en les installant et en les exécutant localement.

1. AutoGen Studio

AutoGen Studio est une interface à code basique conçue pour vous aider à prototyper rapidement des agents d'intelligence artificielle. Il fournit une interface conviviale, par glisser-déposer, pour créer des systèmes multi-agents et les tester en temps réel.

1. Pour installer le Studio, utilisez la commande pip.

pip install -U AutoGenstudio

2. Une fois installé, vous pouvez lancer l'interface utilisateur d'AutoGen Studio en spécifiant le port et le répertoire d'application où tous les agents et modèles seront stockés. 

AutoGenstudio ui --port 8080 --appdir ./app

Après avoir exécuté la commande, vous devriez voir la sortie suivante dans votre terminal :

INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
2025-05-09 15:15:22.825 | INFO     | AutoGenstudio.web.app:lifespan:39 - Application startup complete. Navigate to http://127.0.0.1:8080

3. Rendez-vous sur http://127.0.0.1:8080 dans votre navigateur pour accéder au tableau de bord d'AutoGen Studio.

Une fois l'application lancée, vous serez accueilli par une interface utilisateur propre et intuitive.

AutoGen Studio propose plusieurs fonctionnalités clés pour vous aider à créer et à gérer des flux de travail multi-agents :

1. Team Builder (Bâtisseur d'équipe) : Une interface "glisser-déposer" pour créer des équipes d'agents.
2. Terrain de jeux: Un environnement interactif pour tester et exécuter les flux de travail des agents.
3. Galerie: Un centre de découverte et d'importation de composants créés par la communauté.
4. Laboratoires: Il s'agit d'une fonction expérimentale d'AutoGen Studio qui permet aux utilisateurs d'explorer des flux de travail avancés et de prototyper des idées de pointe.
5. Déployer: Exportez et exécutez les flux de travail des agents sous forme de code Python.

AutoGen Studio est une application à code bas, ce qui signifie qu'elle vous permet de créer des flux de travail avec un minimum de codage. Cependant, il offre également la possibilité de personnaliser les agents et les flux de travail à l'aide de code Python.

2. AutoGen AgentChat

AgentChat est un cadre de haut niveau permettant de créer des flux de conversation multi-agents. Il simplifie le processus de création d'applications dans lesquelles plusieurs agents (IA, outils ou humains) collaborent pour résoudre des tâches. 

Installez d'abord les paquets nécessaires :

pip install -U "AutoGen-agentchat" "AutoGen-ext[openai]"

Nous mettrons ensuite en place trois agents - un utilisateur, un codeur et un exécuteur de code - qui collaboreront dans le cadre d'un chat de groupe round-robin pour générer, exécuter et raconter du code Python. Le système est conçu pour faciliter la génération et l'exécution de codes dynamiques tout en permettant l'interaction humaine et les conditions d'arrêt.

Pour cet exemple, nous utilisons le modèle gpt-4.1-mini pour la génération de code, CodeExecutorAgent pour l'exécution du code en ligne de commande et UserProxyAgent pour maintenir les humains dans la boucle.

import asyncio
from pathlib import Path

from AutoGen_agentchat.agents import AssistantAgent, CodeExecutorAgent, UserProxyAgent
from AutoGen_agentchat.conditions import TextMentionTermination
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_agentchat.ui import Console
from AutoGen_ext.code_executors.local import LocalCommandLineCodeExecutor
from AutoGen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4.1-mini")

    coder = AssistantAgent(
        "coder",
        model_client=model_client,
        system_message=(
            "You are a senior engineer. Think step-by-step, then output ONLY runnable "
            "Python inside ```pythonthon``` blocks—no commentary."
        ),
    )

    executor = CodeExecutorAgent(
        "executor",
        model_client=model_client,  # lets it narrate results
        code_executor=LocalCommandLineCodeExecutor(work_dir=Path.cwd() / "runs"),
    )

    user = UserProxyAgent("user")  # human in the loop

    termination = TextMentionTermination("exit", sources=["user"])
    team = RoundRobinGroupChat(
        [user, coder, executor], termination_condition=termination
    )

    try:
        await Console(
            team.run_stream()
        )
    finally:
        await model_client.close()

if __name__ == "__main__":
    asyncio.run(main())

Enregistrez le code ci-dessus dans un fichier chat_app.py, et exécutez-le en utilisant :

python chat_app.py 

Nous avons demandé à l'application Agent de générer un code pour imprimer les étoiles en forme de triangle, puis d'exécuter ce code. 

Il a généré le code et l'a exécuté avec succès, tout en proposant des options supplémentaires. L'utilisateur peut taper "exit" pour quitter l'application ou poser des questions complémentaires dans le cadre d'une conversation.

Sortie : 

Enter your response: Write a Python script that prints stars and run it.
---------- TextMessage (user) ----------
Write a Python script that prints stars and run it.

---------- TextMessage (coder) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeGenerationEvent (executor) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeExecutionEvent (executor) ----------

*

**

***

****

*****

---------- TextMessage (executor) ----------

The star pattern has been printed successfully. If you'd like a different pattern or further modifications, just let me know!

Enter your response:

3. AutoGen Core

Le noyau AutoGen est un cadre de bas niveau qui permet de créer et de gérer des systèmes multi-agents. 

Dans cet exemple, nous allons créer deux agents : un agent Echo qui inverse le contenu d'un message et un agent Printer qui imprime le contenu du message sur la console.

pip install "autogen-core"

Composants utilisés dans cette application :

1. Structure du message : La classe Text est une structure de données simple qui contient le contenu d'un message.

2. Agent Echo : L' agent Echo inverse le contenu de tout message qu'il reçoit et publie le message inversé dans le thème par défaut à l'aide de publish_message.

3. Agent imprimeur : L' agent Printer écoute les messages et affiche leur contenu sur la console.

4. Durée d'exécution : Le site SingleThreadedAgentRuntime est utilisé pour gérer le cycle de vie des agents et l'acheminement des messages.

import asyncio
from dataclasses import dataclass

from AutoGen_core import (
    AgentId,
    DefaultTopicId,
    MessageContext,
    RoutedAgent,
    SingleThreadedAgentRuntime,
    default_subscription,
    message_handler,
)

@dataclass
class Text:
    content: str

@default_subscription
class Echo(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("echo")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        await self.publish_message(Text(message.content[::-1]), DefaultTopicId())

@default_subscription
class Printer(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("printer")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        print(message.content)

async def main() -> None:
    rt = SingleThreadedAgentRuntime()
    await Echo.register(rt, "echo", lambda: Echo())
    await Printer.register(rt, "printer", lambda: Printer())
    rt.start()
    await rt.send_message(Text("DataCamp"), AgentId("echo", "default"))
    await rt.stop_when_idle()

if __name__ == "__main__":
    asyncio.run(main())

Enregistrez le code dans un fichier core_app.py, et exécutez-le en utilisant :

python core_app.py            

Flux de messages :

• Un message avec le contenu "DataCamp" est envoyé à l'agent Echo.
• L'agent Echo renverse le message vers "pmaCataD" et le publie.
• L'agent Printer reçoit le message inversé et l'imprime sur la console.

Sortie : 

pmaCataD

4. Extensions AutoGen

La structure AutoGen Extensions fournit des extensions de première et de tierce parties qui étendent les capacités de la structure. 

Dans cet exemple, nous allons montrer comment utiliser l' agent MultimodalWebSurfer, qui peut interagir avec des pages web, effectuer des recherches et extraire des informations .

Avant d'exécuter l'exemple, assurez-vous que vous avez installé Playwright:

playwright install 

Comment fonctionne le code : 

1. Initialisation de l'agent: Un agent MultimodalWebSurfer est créé, qui utilise le modèle gpt-4.1-mini d'OpenAI pour la prise de décision et un navigateur (via Playwright) pour les interactions web.
2. Mise en place de l'équipe : L'agent est ajouté à une équipe RoundRobinGroupChat, qui gère le flux de travail de l'agent et limite la tâche à 3 tours.
3. Exécution des tâches : L'équipe est chargée d'exécuter la tâche : "Naviguez sur Google et effectuez une recherche sur Abid Ali Awan. L'agent ouvre un navigateur, se rend sur Google, effectue la recherche et extrait les informations pertinentes.
4. Sortie en continu : Les actions de l'agent (par exemple, naviguer vers une page, cliquer sur des liens, extraire des métadonnées) sont transmises à la console en temps réel.
5. Nettoyage : Une fois la tâche accomplie, le navigateur est fermé pour libérer les ressources.

import asyncio
from AutoGen_agentchat.ui import Console
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_ext.models.openai import OpenAIChatCompletionClient
from AutoGen_ext.agents.web_surfer import MultimodalWebSurfer

async def main() -> None:
    # Define an agent
    web_surfer_agent = MultimodalWebSurfer(
        name="MultimodalWebSurfer",
        model_client=OpenAIChatCompletionClient(model="gpt-4.1-mini"),
    )

    # Define a team
    agent_team = RoundRobinGroupChat([web_surfer_agent], max_turns=3)

    # Run the team and stream messages to the console
    stream = agent_team.run_stream(task="Navigate to Google and search about Abid Ali Awan.")
    await Console(stream)
    # Close the browser controlled by the agent
    await web_surfer_agent.close()

asyncio.run(main())

Enregistrez le code dans un fichier, web_ext_app.py, et exécutez-le en utilisant :

python web_ext_app.py          

Lorsque vous exécutez l'application, l'interaction suivante se produit :

                                                           
---------- TextMessage (user) ----------
Navigate to Google and search about Abid Ali Awan.
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I typed 'https://www.google.com' into the browser address bar.

The web browser is open to the page [Google](https://www.google.com/).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Gmail
Images
Sign in
Google offered in:
اردو
پښتو
سنڌيPakistan
About
Advertising
Business
 How Search works
Privacy
Terms
Settings
Google recommends using Chrome
Try a fast, secure browser with updates built in
Don't switch
Yes

The following metadata was extracted from the webpage:

{
    "microdata": [
        {
            "itemType": "http://schema.org/WebPage",
            "image": "/images/branding/googleg/1x/googleg_standard_color_128dp.png"
        }
    ],
    "meta_tags": {
        "referrer": "origin"
    }
}

Here is a screenshot of the page.
<image>
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I clicked 'Sign in'.

The web browser is open to the page [Sign in - Google Accounts](https://accounts.google.com/v3/signin/identifier?continue=https%3A%2F%2Fwww.google.com%2F&ec=futura_exp_og_so_72776762_e&hl=en&ifkv=ASKV5MhAzFZnwDH-Aw10tuqQN1ppsY8OZ2-OJ3YavFHXMDlX9iTddg1d_k78ZZ0SogFUivcY7Td0Hg&passive=true&flowName=GlifWebSignIn&flowEntry=ServiceLogin&dsh=S1980923188%3A1746809726624486).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Sign inUse your Google AccountEmail or phone
Forgot email?
Not your computer? Use a private browsing window to sign in.
Learn more about using Guest modeNext
Create account
English (United States)
Help
Privacy
Terms
Sign in Use your Google Account

The following metadata was extracted from the webpage:

{
    "meta_tags": {
        "referrer": "origin",
        "chrome": "nointentdetection",
        "viewport": "width=device-width, initial-scale=1",
        "description": ""
    }
}

Here is a screenshot of the page.
<image>
---------- TextMessage (MultimodalWebSurfer) ----------
Please provide the email or phone number you want to use to sign in, or let me know if you want to create a new account or need help with something else on this page.

Tout comme AutoGen, CrewAI est un autre cadre préféré des fans d'IA pour la création de flux de travail agentiques. Suivez le site CrewAI : A Guide With Examples of Multi AI Agent Systems tutoriel pour en savoir plus.

Cas d'utilisation d'AutoGen

AutoGen ouvre de nombreuses possibilités pour créer des systèmes intelligents et multi-agents. Voici quelques-uns des principaux cas d'utilisation de l'écosystème AutoGen :

1. Génération de code, exécution et débogage : Automatise les tâches de codage, réduisant les erreurs et améliorant l'efficacité.
2. Collaboration multi-agents : Permet aux agents de travailler en équipe pour résoudre des tâches complexes.
3. Discussions séquentielles multi-agents : Gérer des séquences de tâches structurées en vue d'une réalisation efficace.
4. Chats imbriqués : Traite des tâches complexes par le biais de conversations détaillées et complexes.
5. Utilisation de l'outil : Extension des fonctionnalités de l'agent par l'intégration d'outils tels que la recherche sur le web et les requêtes SQL.
6. Implication humaine : Incorpore le retour d'information humain pour améliorer les flux de travail.
7. L'enseignement et l'apprentissage par les agents : Améliore les compétences et les connaissances des agents.
8. Chat multi-agents avec les assistants OpenAI : Combine les capacités d'OpenAI avec AutoGen pour les tâches avancées.
9. Agent multimodal : Gère le texte, les images et d'autres médias pour des interactions plus riches.
10. Traitement des contextes longs : Maintenir la cohérence dans des conversations prolongées.

Conclusion

Il y a une raison pour laquelle AutoGen a gagné tant d'attention et de reconnaissance, gagnant sa place comme l'un des frameworks Agentic les plus étoilés sur GitHub. 

Il s'agit d'un cadre complet qui s'adresse à tous, des développeurs professionnels aux programmeurs occasionnels, et même aux personnes n'ayant aucune expérience préalable du codage. 

Avec AutoGen, vous pouvez rapidement prototyper des flux de travail à l'aide d'AutoGen Studio, créer des applications robustes avec le framework Core et les extensions, et les déployer de manière transparente dans le cloud. Il s'agit véritablement d'une solution tout-en-un pour créer et gérer des systèmes multi-agents intelligents.

Prenez le Construire des agents LangChain dynamiques et apprenez à construire votre première application d'agent d'intelligence artificielle en utilisant le célèbre framework LLM.