Intégration d'AutoGen AgentChat avec le Web MCP de Bright Data

Dans cet article, vous découvrirez :

Ce qu’est AutoGen et ce qui le rend unique.
Pourquoi vous devriez étendre les capacités de vos agents avec des fonctionnalités de récupération de données web et d’interaction via MCP.
Comment créer un agent AutoGen AgentChat qui s’intègre au Web MCP de Bright Data.
Comment tester le même agent dans l’application web visuelle AutoGen Studio.

C’est parti !

Qu’est-ce qu’AutoGen ?

AutoGen est un framework open source développé par Microsoft pour créer des systèmes d’IA multi-agents. Il permet à plusieurs agents IA de collaborer et de communiquer entre eux pour accomplir des tâches complexes, de manière autonome ou avec l’aide d’un humain.

La bibliothèque a gagné en popularité, avec plus de 50 000 étoiles sur GitHub, et est disponible pour Python et C# (.NET).

Principales fonctionnalités

Les principales fonctionnalités offertes par AutoGen sont les suivantes :

Agents personnalisables et conversationnels: intègre des agents IA avec des LLM, des contributions humaines et divers outils. Vous pouvez définir des comportements et des modèles de conversation personnalisés à l’aide d’une API de haut niveau ou même en JSON.
Workflows avec intervention humaine: prend en charge l’intégration des commentaires humains à plusieurs étapes du workflow. Par exemple, UserProxyAgent peut agir comme un Proxy pour un humain, permettant ainsi la supervision et l’intervention.
Intégration d’outils: les agents peuvent être équipés d’une large gamme d’outils, tels que des fonctions de recherche sur le Web, d’exécution de code ou de gestion de fichiers. Cela inclut également la prise en charge de l’intégration MCP.
Types d’agents intégrés: AutoGen fournit plusieurs types d’agents prédéfinis, notamment :
- UserProxyAgent: représente un utilisateur humain et peut exécuter du code.
- AssistantAgent: assistant polyvalent basé sur LLM capable d’effectuer des tâches et d’utiliser des outils.
- CodeExecutorAgent: spécialisé dans l’exécution et le test de code.
Observabilité et débogage: comprend des outils intégrés pour le traçage et le débogage des interactions et des flux de travail des agents, avec prise en charge de normes telles que OpenTelemetry.
AutoGen Studio: interface web graphique low-code permettant de prototyper, tester et déployer rapidement des systèmes multi-agents.

Pourquoi étendre les agents AutoGen avec le Web MCP de Bright Data

AutoGen prend en charge plusieurs fournisseurs de modèles IA. Cependant, quel que soit le LLM que vous choisissez (OpenAI, Anthropic, Ollama ou un autre fournisseur), tous les modèles partagent la même limitation fondamentale : leurs connaissances sont statiques.

Les LLM sont entraînés sur des données qui représentent un instantané dans le temps, ce qui signifie que leurs connaissances peuvent rapidement devenir obsolètes. Plus important encore, ils ne peuvent pas interagir de manière native avec des sites web en direct ni accéder à des sources de données par eux-mêmes.

Heureusement, AutoGen prend en charge MCP. Cela signifie que vous pouvez combiner vos agents avec le Web MCP de Bright Data. Cela étend les LLM, leur donnant des outils pour récupérer des données fraîches et de haute qualité directement sur le web, ainsi que d’autres capacités.

Plus précisément, le Web MCP est un serveur open source qui fournit plus de 60 outils prêts pour l’IA. Ceux-ci sont tous alimentés par l’infrastructure de Bright Data pour l’interaction web et la collecte de données.

Même avec un abonnement gratuit, vous aurez accès à ces deux outils révolutionnaires :

Outil	Description
`search_engine`	Récupérez les résultats de recherche de Google, Bing ou Yandex au format JSON ou Markdown.
`scrape_as_markdown`	Récupérez n’importe quelle page web au format Markdown propre, en contournant la détection des robots et les CAPTCHA.

Au-delà de cela, Web MCP débloque des dizaines d’outils spécialisés pour la collecte structurée de données sur des plateformes populaires telles qu’Amazon, LinkedIn, TikTok, Google Play, App Store, Yahoo Finance, etc. Pour en savoir plus, rendez-vous sur la page GitHub officielle.

En bref, la configuration de Web MCP dans AutoGen vous aide à créer des agents IA complexes capables d’interagir avec des sites web en direct et d’accéder à des données web actualisées afin de générer des informations fondées sur le monde réel.

Comment créer un agent IA avec les outils de Web MCP dans AutoGen AgentChat à l’aide de Python

Dans cette section guidée, vous apprendrez à créer un agent à l’aide d’AutoGen AgentChat, l’API de haut niveau pour la création d’applications multi-agents. Plus précisément, l’agent sera capable d’utiliser tous les outils exposés par le serveur Web MCP, étendant ainsi les capacités du LLM sous-jacent.

Remarque: l’agent suivant sera écrit en Python, mais vous pouvez facilement l’adapter à .NET.

Suivez les étapes ci-dessous pour créer un agent en Python avec l’intégration AutoGen et MCP !

Prérequis

Pour suivre ce tutoriel, assurez-vous de disposer des éléments suivants :

Python 3.10+ installé sur votre machine.
Node.js installé (nous recommandons la dernière version LTS).
Une clé API OpenAI (ou une clé API de l’un des autres LLM pris en charge).

Vous aurez également besoin d’un compte Bright Data avec une clé API, mais ne vous inquiétez pas, nous vous guiderons dans cette démarche dans quelques instants. Il sera également utile d’avoir une compréhension de base du fonctionnement du MCP et des outils proposés par le Web MCP.

Étape n° 1 : configuration du projet AutoGen

Ouvrez un terminal et créez un nouveau répertoire pour votre projet AutoGen IA :

mkdir autogen-mcp-agent

Le dossier autogen-mcp-agent/ contiendra le code Python de votre agent intégré à MCP.

Ensuite, accédez au répertoire du projet et initialisez un environnement virtuel à l’intérieur :

cd autogen-mcp-agent
python -m venv .venv

Activez l’environnement virtuel. Sous Linux ou macOS, exécutez :

source .venv/bin/activate

De manière équivalente, sous Windows, exécutez :

.venv/Scripts/activate

Ajoutez un nouveau fichier appelé agent.py à votre projet, qui devrait désormais contenir :

autogen-mcp-agent/
├── .venv/
└── agent.py

agent.py servira de fichier Python principal et contiendra la logique de l’agent IA.

Chargez le dossier du projet dans votre IDE Python préféré, tel que Visual Studio Code avec l’extension Python ou PyCharm Community Edition.

Une fois l’environnement virtuel activé, installez les dépendances requises :

pip install autogen-agentchat « autogen-ext[openai] » « autogen-ext[mcp] » python-dotenv

Les bibliothèques que vous venez d’installer sont les suivantes :

autogen-agentchat: pour développer des applications à agent unique ou multi-agents grâce à une API facile à utiliser, construite sur autogen-core.
« autogen-ext[openai] »: extension pour AutoGen permettant de créer des agents alimentés par des modèles OpenAI.
« autogen-ext[mcp] »: extension permettant de connecter les agents AutoGen aux serveurs MCP.
python-dotenv: pour charger les variables d’environnement à partir d’un fichier .env local.

Remarque: si vous ne prévoyez pas d’utiliser les modèles OpenAI, installez le package approprié pour votre fournisseur LLM préféré, comme expliqué dans la documentation.

C’est fait ! Votre environnement Python est désormais prêt pour le développement d’agents IA avec AutoGen.

Étape n° 2 : configurer la lecture des variables d’environnement

Votre agent s’appuiera sur des connexions à des services tiers tels que OpenAI et Bright Data. Pour authentifier ces connexions, vous devez fournir vos clés API. Au lieu de les coder en dur dans votre fichier agent.py, ce qui est une mauvaise pratique et peut poser des problèmes de sécurité, configurez votre script pour qu’il lise les secrets à partir des variables d’environnement.

C’est la raison pour laquelle le paquet python-dotenv a été installé au départ. Dans votre fichier agent.py, importez la bibliothèque et appelez load_dotenv() pour charger vos variables d’environnement :

from dotenv import load_dotenv

load_dotenv()

Votre assistant peut désormais lire les variables à partir d’un fichier .env local.

Ajoutez donc un fichier .env à la racine de votre répertoire de projet :

autogen-mcp-agent/
├── .venv/
├── .env         # <------
└── agent.py

Vous pouvez désormais accéder aux variables d’environnement dans votre code avec :

import os

os.getenv("ENV_NAME")

Parfait ! Votre script charge les secrets d’intégration tiers à l’aide de variables d’environnement.

Étape n° 3 : commencez à utiliser le Web MCP de Bright Data

Avant de connecter votre agent au Web MCP de Bright Data, vous devez d’abord vous assurer que votre machine peut exécuter le serveur. Cela est nécessaire car vous allez demander à AutoGen de lancer le Web MCP localement, et l’agent s’y connectera ensuite.

Si vous n’avez pas encore de compte Bright Data, créez-en un. Si vous en avez déjà un, connectez-vous simplement. Pour une configuration rapide, consultez la section« MCP »de votre compte :

The “MCP” section in your Bright Data account

Pour plus d’informations, suivez les instructions ci-dessous.

Commencez par générer une clé API Bright Data. Ensuite, conservez-la dans un endroit sûr, car vous en aurez besoin rapidement. Ici, nous supposons que la clé API dispose des autorisations d’administrateur, car cela simplifie le processus d’intégration du Web MCP.

Poursuivez en installant le Web MCP globalement sur votre système via le package npm @brightdata/mcp:

npm install -g @brightdata/mcp

Vérifiez ensuite que le serveur MCP local fonctionne en le lançant :

$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; npx -y @brightdata/mcp

Ou, de manière équivalente, sous Linux/macOS :

API_TOKEN="<VOTRE_API_BRIGHT_DATA>" npx -y @brightdata/mcp

Remplacez l’espace réservé <YOUR_BRIGHT_DATA_API> par votre jeton API Bright Data réel. Les deux commandes définissent la variable d’environnement API_TOKEN requise et lancent le MCP Web localement.

Si l’opération réussit, vous devriez voir un résultat similaire à celui-ci :

Lors du premier lancement, le Web MCP crée automatiquement deux zones par défaut dans votre compte Bright Data :

mcp_unlocker: une zone pour Web Unlocker.
mcp_browser: une zone pour Browser API.

Web MCP s’appuie sur ces deux produits Bright Data pour alimenter ses plus de 60 outils.

Pour vérifier que les zones ont bien été créées, connectez-vous à votre tableau de bord Bright Data et accédez à la page «Proxies & Scraping Infrastructure » (Proxys et infrastructure de scraping). Vous devriez voir les deux zones dans le tableau :

The mcp_unlocker and mcp_browser zones created by the Web MCP at startup

Remarque: si votre jeton API ne dispose pas des autorisations d’administrateur, ces zones ne seront pas créées. Dans ce cas, vous devez les définir manuellement dans le tableau de bord et configurer leurs noms dans la commande via des variables d’environnement (consultez la page GitHub pour plus de détails).

N’oubliez pas que, par défaut, le serveur MCP n’expose que les outils search_engine et scrape_as_markdown (et leurs versions batch). Ces outils sont inclus dans l’offre gratuite Web MCP, vous pouvez donc les utiliser gratuitement.

Pour débloquer des outils avancés, tels que l’automatisation du navigateur et les flux de données structurées, vous devez activer le mode Pro. Pour ce faire, définissez la variable d’environnement PRO_MODE="true" avant de lancer le Web MCP :

$Env:API_TOKEN="<YOUR_BRIGHT_DATA_API>"; $Env:PRO_MODE="true"; npx -y @brightdata/mcp

Ou, sous Linux/macOS :

API_TOKEN="<VOTRE_API_BRIGHT_DATA>" PRO_MODE="true" npx -y @brightdata/mcp

Le mode Pro débloque plus de 60 outils, mais il n’est pas inclus dans l’offre gratuite et entraînera des frais supplémentaires.

Parfait ! Vous venez de vérifier que le serveur Web MCP fonctionne sur votre machine. Arrêtez le processus MCP, car vous allez configurer votre agent AutoGen AgentChat pour le lancer et vous y connecter à l’étape suivante.

Étape n° 4 : configurer la connexion Web MCP

Maintenant que votre machine peut exécuter le Web MCP, vous devez demander à votre script de se connecter au serveur.

Commencez par ajouter la clé API Bright Data que vous avez récupérée précédemment à votre fichier .env:

BRIGHT_DATA_API_KEY="<VOTRE_CLÉ_API_BRIGHT_DATA>"

Remplacez <VOTRE_CLÉ_API_BRIGHT_DATA> par votre clé API réelle.

Dans agent.py, chargez la valeur de la clé API Bright Data avec :

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

Ensuite, définissez une fonction asynchrone et configurez la connexion MCP à un processus MCP Web local :

from autogen_ext.tools.mcp import (
    StdioServerParams,
    mcp_server_tools
)

async def main():
    # Configurations pour se connecter au MCP Web Bright Data
    bright_data_mcp_server = StdioServerParams(
        command="npx",
        args=[
            "-y",
            "@brightdata/mcp"
        ],
        env={
            "API_TOKEN": BRIGHT_DATA_API_KEY,
            "PRO_MODE": "true" # Facultatif
        }
    )

    # Charger les outils exposés par le serveur Bright Data Web MCP
    bright_data_tools = await mcp_server_tools(bright_data_mcp_server)

    # Définition de l'agent...

Cette configuration reflète la commande npx de l’étape précédente, en utilisant la variable d’environnement pour le jeton API. Notez que PRO_MODE est facultatif, tandis que API_TOKEN est obligatoire.

Concrètement, votre script agent.py va désormais lancer un processus Web MCP et s’y connecter via STDIO. Le résultat est un ensemble d’outils que vous pouvez transmettre à vos agents AutoGen.

Vérifiez la connexion en listant les outils disponibles :

for bright_data_tool in bright_data_tools:

print(f"TOOL: {bright_data_tool.name} - {bright_data_tool.description}n")

Si vous exécutez votre script avec le mode Pro désactivé, vous devriez obtenir un résultat similaire à celui-ci :

The tool list output with Pro mode disabled

Sinon, avec le mode Pro activé, vous verrez les 60 outils et plus :

The tool list output with Pro mode enabled

Et voilà ! Le résultat confirme que votre intégration Web MCP fonctionne parfaitement.

Étape n° 5 : définir votre agent AutoGen

AutoGen AgentChat est fourni avec un ensemble d’agents prédéfinis, chacun étant conçu avec différents styles de réponse. Dans ce cas, l'AssistantAgent à usage général est le plus adapté.

Avant de définir l’agent, vous devez configurer une intégration LLM, car un agent ne peut pas fonctionner sans un modèle d’IA sous-jacent.

Commencez par ajouter votre clé API OpenAI au fichier .env:

OPENAI_API_KEY="<VOTRE_CLÉ_API_OPENAI>"

Ensuite, configurez l’intégration OpenAI dans votre code avec :

from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(
    model="gpt-4o-mini",
)

OpenAIChatCompletionClient lit automatiquement la variable d’environnement OPENAI_API_KEY, il n’est donc pas nécessaire de la charger dans votre code. Cette variable d’environnement sera utilisée pour authentifier les appels API sous-jacents à OpenAI.

Notez que l’exemple ci-dessus connecte votre agent au modèle GPT-4o d’OpenAI. Si vous prévoyez d’utiliser un autre modèle ou fournisseur LLM, consultez leur documentation et procédez aux ajustements nécessaires.

Remarque: à la date de rédaction de cet article, les modèles GPT-5 ne sont pas encore pris en charge dans autogen-ext[openai].

Maintenant, combinez le modèle avec les outils MCP que vous avez chargés précédemment pour créer un agent assistant :

from autogen_agentchat.agents import AssistantAgent

agent = AssistantAgent(
    name="web_agent",
    model_client=model_client,
    tools=bright_data_tools,
)

Formidable ! Vous venez de créer votre premier agent AutoGen AgentChat, optimisé par OpenAI et intégré aux outils MCP de Bright Data.

Étape n° 6 : créez votre équipe AutoGen

Vous pouvez transmettre une tâche directement à votre agent et l’exécuter. Cependant, cela ne vous offrira pas la meilleure expérience possible, car l’agent s’arrêtera après une seule exécution de l’outil. Bien que vous puissiez modifier ce comportement à l’aide de l’argument max_tool_iterations, il est généralement préférable de définir une équipe.

Dans AutoGen, une équipe est un groupe d’agents travaillant ensemble vers un objectif commun. Dans votre cas, l’équipe ne comptera qu’un seul agent (ce qui est une configuration valide). Néanmoins, définir une équipe dès maintenant facilitera son extension ultérieure si vous souhaitez ajouter d’autres agents et créer un flux de travail multi-agents.

Une configuration courante est l’équipe RoundRobinGroupChat, dans laquelle les agents se relaient à tour de rôle. Vous aurez également besoin d’une condition de terminaison pour décider quand la boucle doit s’arrêter. Ici, nous utiliserons TextMentionTermination, configuré pour mettre fin au processus lorsque le mot « TERMINATE » apparaît dans la réponse de l’agent :

from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat

# Définir une condition de terminaison pour la boucle
text_termination = TextMentionTermination("TERMINATE")

# Créer une équipe avec le seul agent
team = RoundRobinGroupChat([agent], termination_condition=text_termination)

Notez qu’il s’agit d’une configuration standard présentée dans la plupart des exemples AutoGen.

Même avec un seul agent, l’équipe continuera à l’appeler de manière répétée jusqu’à ce que la tâche soit terminée. Cela est particulièrement utile pour les tâches complexes qui peuvent nécessiter plusieurs appels d’outils, et donc plusieurs cycles d’interaction, avant d’être terminées.

Parfait ! Il ne reste plus qu’à exécuter l’équipe et à enregistrer le résultat.

Étape n° 7 : exécuter la tâche

Pour exécuter votre application AutoGen AgentChat, transmettez une tâche à l’équipe à laquelle appartient votre agent. Pour tester les capacités étendues de récupération de données Web, essayez d’exécuter une invite comme celle-ci :

task = """
Récupérez les informations de l'application suivante sur l'App Store :
« https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175 »

En vous basant sur les avis des utilisateurs, les prix et toutes les informations disponibles, dites-moi si vous pensez que cette application vaut la peine d'être installée et si elle est fiable.
"""

Bien sûr, les modèles OpenAI ne peuvent pas accomplir cette tâche à eux seuls, car ils ne peuvent pas récupérer toutes les données de l’App Store. C’est là que votre intégration avec les outils Bright Data entre en jeu. Grâce à cette configuration, votre agent peut extraire les données de la page de l’application, analyser les avis et les détails des prix, puis laisser le LLM traiter les informations pour les transformer en un rapport clair et lisible par l’utilisateur.

Il s’agit d’un exemple pratique de la manière dont vous pourriez créer un agent qui évalue les applications avant leur installation, en mettant en évidence les problèmes potentiels ou les préoccupations des utilisateurs. Après tout, installer des applications sans diligence raisonnable peut être risqué du point de vue de la sécurité.

Maintenant, exécutez la tâche et diffusez la réponse directement dans votre terminal avec :

from autogen_agentchat.ui import Console

await Console(team.run_stream(task=task))

Super ! À ce stade, l’équipe se mettra au travail et la tâche sera confiée à l’agent que vous avez configuré. L’agent peut effectuer plusieurs itérations pour atteindre l’objectif. Le résultat attendu est que l’agent utilise les outils de Bright Data à partir de Web MCP pour extraire les données de l’App Store, puis que le LLM synthétise ces données afin d’évaluer si l’application choisie mérite d’être installée.

Enfin, n’oubliez pas de fermer la connexion à votre modèle choisi à la fin de votre script :

await model_client.close()

Étape n° 8 : rassembler tous les éléments

Votre fichier agent.py doit contenir :

# pip install autogen-agentchat "autogen-ext[openai]" "autogen-ext[mcp]" python-dotenv
import asyncio
from dotenv import load_dotenv
import os
from autogen_ext.tools.mcp import (
    StdioServerParams,
    mcp_server_tools
)
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.conditions import TextMentionTermination
from autogen_agentchat.teams import RoundRobinGroupChat
from autogen_agentchat.ui import Console

# Chargez les variables d'environnement à partir du fichier .env
load_dotenv()

# Charger votre clé API Bright Data à partir des envs
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

async def main():
    # Configurations pour se connecter au Bright Data Web MCP
    bright_data_mcp_server = StdioServerParams(
        command="npx",
        args=[
            "-y",
            "@brightdata/mcp"
        ],
        env={
            "API_TOKEN": BRIGHT_DATA_API_KEY,
            "PRO_MODE": "true" # Facultatif
        }
    )

    # Chargez les outils exposés par le serveur Bright Data Web MCP
    bright_data_tools = await mcp_server_tools(bright_data_mcp_server)

    # Intégration LLM
    model_client = OpenAIChatCompletionClient(
        model="gpt-4o-mini",
    )

    # Définissez votre agent assistant IA alimenté par les outils Web MCP
    agent = AssistantAgent(
        name="web_agent",
        model_client=model_client,
        tools=bright_data_tools,
    )

    # Définir une condition de terminaison pour la boucle
    text_termination = TextMentionTermination("TERMINATE")

    # Créer une équipe avec le seul agent
    team = RoundRobinGroupChat([agent], termination_condition=text_termination)

    # La tâche à exécuter par l'équipe
    task = """
    Récupérer les informations de l'application suivante sur l'App Store :
    « https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175 »

    En vous basant sur les avis des utilisateurs, les prix et toutes les informations disponibles, dites-moi si vous pensez que cette application vaut la peine d'être installée et si elle est fiable.
    """

    # Diffuser la réponse de l'équipe sur le terminal
    await Console(team.run_stream(task=task))

    # Fermer la connexion IA
    await model_client.close()

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

Waouh ! En environ 70 lignes de code, vous venez de créer une équipe à agent unique pour analyser les applications à installer sur l’App Store.

Exécutez l’agent avec :

python agent.py

Voici ce que vous devriez voir dans le terminal :

Comme vous pouvez le constater, l’agent a correctement identifié que web_data_apple_app_store de Web MCP était l’outil approprié pour cette tâche. Il s’agit d’un outil Pro permettant de « récupérer rapidement des données structurées de l’App Store d’Apple ». C’était donc un excellent choix. Si vous n’aviez pas activé le mode Pro, l’agent aurait utilisé l’outil scrape_as_markdown à la place.

L’exécution de l’outil peut prendre un peu de temps. Le résultat est une donnée structurée (au format JSON) extraite de la page de l’App Store, comme prévu :

Note the JSON result returned by the tool

Cette sortie structurée est ensuite analysée et traitée par le LLM, qui génère un rapport Markdown :

Notez les informations détaillées fournies au début du rapport généré. Elles correspondent exactement à ce qui est affiché sur la page App Store cible:

Mission accomplie ! Votre agent peut désormais récupérer des données sur le Web et les traiter pour effectuer des tâches utiles.

Gardez à l’esprit qu’il ne s’agit là que d’un exemple simple. Grâce à la large gamme d’outils Bright Data Web MCP disponibles dans AutoGen AgentChat, vous pouvez concevoir des agents beaucoup plus avancés, adaptés à une grande variété de cas d’utilisation réels.

Et voilà ! Vous venez de découvrir la puissance de l’intégration du Web MCP de Bright Data dans un agent IA AutoGen AgentChat en Python.

Testez visuellement l’agent amélioré par Web MCP dans Agent Studio

AutoGen fournit également Studio, un outil low-code basé sur un navigateur qui vous permet de créer et d’expérimenter visuellement des agents. Vous pouvez l’utiliser pour tester l’agent avec l’intégration MCP de manière simplifiée. Découvrez comment !

Prérequis

La seule condition préalable pour suivre cette section facultative du tutoriel est d’avoir installé AutoGen Studio. À partir de votre environnement virtuel activé dans le répertoire du projet, installez-le avec :

pip install -U autogenstudio

AutoGen Studio lira automatiquement la clé OPENAI_API_KEY à partir de votre fichier .env, vous n’avez donc pas besoin de la configurer manuellement dans l’outil.

Étape n° 1 : obtenir le fichier de configuration JSON de l’équipe

Dans AutoGen, tout composant d’une configuration d’équipe peut être représenté sous forme de fichier JSON. Comme AutoGen Studio est basé sur AgentChat, vous pouvez exporter les composants AgentChat vers JSON, puis les charger dans AutoGen Studio. C’est exactement ce que nous allons faire ici !

Commencez par exporter la définition d’équipe que vous avez créée précédemment dans un fichier JSON local :

config = team.dump_component()
with open("bd_mcp_team.json", "w", encoding="utf-8") as f:
    f.write(config.model_dump_json())

Cela créera un fichier bd_mcp_team.json dans votre dossier de projet. Ouvrez-le.

Le fichier contient une représentation JSON de votre agent, y compris tous les détails nécessaires pour se connecter aux outils Web MCP de Bright Data.

Étape n° 2 : charger le fichier JSON dans AutoGen Studio

Lancez AutoGen Studio localement avec :

autogenstudio ui --port 8080

L’application sera disponible dans votre navigateur à l’adresse http://127.0.0.1:8080. Ouvrez-la et vous devriez obtenir l’application web suivante :

Par défaut, la solution est fournie avec une équipe appelée « RoundRobin Team ». Pour la configurer comme votre agent MCP étendu, activez le bouton « Visual Builder » et passez en mode « View JSON » :

Dans l’éditeur JSON, collez le contenu de votre fichier bd_mcp_team.json et appuyez sur le bouton « Save Changes » :

Votre « RoundRobin Team » mise à jour devrait maintenant ressembler à ceci :

Notez que le nom de l’agent est désormais web_agent, comme vous l’avez défini dans le code. Vous pouvez désormais tester votre agent intégré à Web MCP directement dans AutoGen Studio.

Étape n° 3 : tester visuellement l’agent

Appuyez sur le bouton « Exécuter » dans le coin supérieur droit. La section de chat permettant de tester votre équipe apparaîtra :

Collez la même invite de tâche que précédemment et lancez-la :

Comme précédemment, l’agent sélectionne et exécute l’outil web_data_apple_app_store. Le résultat final sera le suivant :

The final, visual result produced by the agent in AutoGen Studio

À gauche, l’avant-dernier message contient la réponse générée par l’agent. Cette fois-ci, vous pouvez également voir que l’agent se termine à l’aide d’un message « TERMINATE », qui est envoyé automatiquement. À droite, vous trouverez une représentation visuelle de l’exécution, qui vous aidera à comprendre ce qui se passe étape par étape.

Même si l’agent a terminé, son contexte est toujours partagé avec l’équipe. Cela signifie que vous pouvez poursuivre la conversation de manière transparente en passant une autre tâche, comme dans ChatGPT ou toute autre interface IA de type chat.

Cela démontre l’un des avantages réels de tester vos agents dans AutoGen Studio. Vous pouvez suivre visuellement les actions de l’agent, inspecter les résultats et conserver le contexte à travers plusieurs interactions. Incroyable !

Conclusion

Dans cet article, vous avez vu comment créer un agent IA à l’aide d’AutoGen AgentChat et le booster avec les outils de Web MCP de Bright Data (qui propose également une offre gratuite !). Vous avez également testé votre agent visuellement et l’avez exécuté dans une expérience de type chat via AutoGen Studio.

Cette intégration étend les capacités de votre agent avec la recherche sur le Web, l’extraction de données structurées, l’accès à des flux de données Web, des capacités d’interaction Web, et plus encore. Pour créer des agents IA plus avancés, explorez la gamme plus large de produits et services de l’infrastructure IA de Bright Data.

Inscrivez-vous dès aujourd’hui pour obtenir un compte Bright Data gratuit et commencez à expérimenter les outils de données web compatibles avec l’IA !

Contacter Ventes Essai gratuit