--- title: "Bright Data MCP de Bright Data avec AutoGen AgentChat et Studio" slug: autogen-agentchat-with-web-mcp date: 2025-11-26T12:54:29+00:00 modified: 2025-11-26T12:54:31+00:00 permalink: https://brightdata.fr/blog/ai/autogen-agentchat-with-web-mcp type: blog --- [ Blog ](https://brightdata.fr/blog "Blog") / [AI](https://brightdata.fr/blog/ai) [AI](https://brightdata.fr/blog/ai) # Bright Data MCP de Bright Data avec AutoGen AgentChat et Studio Découvrez comment améliorer les agents AutoGen IA avec des données web en direct à l’aide du Web MCP de Bright Data. Comprend des guides étape par étape pour AgentChat et AutoGen Studio. 7 min de lecture [ ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![AutoGen AgentChat × Bright Data MCP](https://media.brightdata.fr/2025/10/AutoGen-AgentChat-%C3%97-Bright-Data-MCP.png) 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 Bright Data 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](https://www.microsoft.com/en-us/research/project/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](https://github.com/microsoft/autogen), 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 Bright Data 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](/blog/web-data/llm-training-data) 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 Bright Data MCP de Bright Data**](/ai/mcp-server). 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 Bright Data MCP est un serveur open source qui fournit [plus de 60 outils prêts pour l’IA](https://docs.brightdata.com/mcp-server/tools). 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](/blog/ai/web-mcp-free-tier), 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, Bright Data 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](https://github.com/brightdata/brightdata-mcp). En bref, la configuration de Bright Data 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 Bright Data MCP dans AutoGen AgentChat à l’aide de Python Dans cette section guidée, vous apprendrez à créer un agent à l’aide [d’AutoGen AgentChat](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/index.html), 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 Bright Data 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](https://microsoft.github.io/autogen-for-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+](https://www.python.org/downloads/) installé sur votre machine. - Node.js installé (nous recommandons la [dernière](https://nodejs.org/en/download)[version LTS](https://nodejs.org/en/download)). - [Une clé API OpenAI](https://platform.openai.com/api-keys) (ou une clé API de l’un des [autres LLM pris en charge](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/models.html)). 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](https://modelcontextprotocol.io/specification/2025-06-18) et [des outils proposés par le Bright Data MCP](https://docs.brightdata.com/mcp-server/tools). ### Étape n° 1 : configuration du projet AutoGen Ouvrez un terminal et créez un nouveau répertoire pour votre projet AutoGen IA : ```none 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](https://docs.python.org/3/library/venv.html) à l’intérieur : ```none cd autogen-mcp-agent python -m venv .venv ``` Activez l’environnement virtuel. Sous Linux ou macOS, exécutez : ```none source .venv/bin/activate ``` De manière équivalente, sous Windows, exécutez : ```none .venv/Scripts/activate ``` Ajoutez un nouveau fichier appelé `agent.py` à votre projet, qui devrait désormais contenir : ```none 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](https://code.visualstudio.com/docs/languages/python) ou [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/). Une fois l’environnement virtuel activé, installez les dépendances requises : ```none 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`](https://pypi.org/project/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] »`](https://pypi.org/project/autogen-ext/): extension pour AutoGen permettant de créer des agents alimentés par des modèles OpenAI. - [`« autogen-ext[mcp] »`](https://pypi.org/project/autogen-ext/)[:](https://pypi.org/project/autogen-ext/) extension permettant de connecter les agents AutoGen aux serveurs MCP. - [`python-dotenv`](https://pypi.org/project/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](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/models.html). 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 : ```none 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 : ```none autogen-mcp-agent/ ├── .venv/ ├── .env # <------ └── agent.py ``` Vous pouvez désormais accéder aux variables d’environnement dans votre code avec : ```none 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 Bright Data MCP de Bright Data Avant de connecter votre agent au Bright Data 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 Bright Data MCP localement, et l’agent s’y connectera ensuite. Si vous n’avez pas encore de compte Bright Data, [créez-en un](/?hs_signup=1). Si vous en avez déjà un, [connectez-vous simplement](/cp/start). Pour une configuration rapide, consultez la section[« MCP »](/cp/mcp)de votre compte : ![The “MCP” section in your Bright Data account](https://media.brightdata.com/2025/10/image-11-1024x548.png)Pour plus d’informations, suivez les instructions ci-dessous. Commencez par [générer une clé API Bright Data](https://docs.brightdata.com/api-reference/authentication#generating-an-api-key%3A). 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 Bright Data MCP. Poursuivez en installant le Bright Data MCP globalement sur votre système via le package npm [`@brightdata/mcp`](https://www.npmjs.com/package/@brightdata/mcp): ```none npm install -g @brightdata/mcp ``` Vérifiez ensuite que le serveur MCP local fonctionne en le lançant : ```none $Env:API_TOKEN=""; npx -y @brightdata/mcp ``` Ou, de manière équivalente, sous Linux/macOS : ```none API_TOKEN="" npx -y @brightdata/mcp ``` Remplacez l’espace réservé `` 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 : ![Bright Data MCP startup logs](https://media.brightdata.com/2025/10/image-12-1024x157.png)Lors du premier lancement, le Bright Data MCP crée automatiquement deux zones par défaut dans votre compte Bright Data : - `mcp_unlocker`: une zone pour [Web Unlocker](/products/web-unlocker). - `mcp_browser`: une zone pour [Browser API](/products/scraping-browser). Bright Data 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 » (](/cp/zones)Proxys et infrastructure de scraping). Vous devriez voir les deux zones dans le tableau : ![The mcp_unlocker and mcp_browser zones created by the Bright Data MCP at startup](https://media.brightdata.com/2025/10/image-13-1024x539.png)**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](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-account-setup)). 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 Bright Data MCP](/blog/ai/web-mcp-free-tier), 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 Bright Data MCP : ```none $Env:API_TOKEN=""; $Env:PRO_MODE="true"; npx -y @brightdata/mcp ``` Ou, sous Linux/macOS : ```none API_TOKEN="" 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](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-pricing--modes). Parfait ! Vous venez de vérifier que le serveur Bright Data 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 Bright Data MCP Maintenant que votre machine peut exécuter le Bright Data 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`: ```none BRIGHT_DATA_API_KEY="" ``` Remplacez `` par votre clé API réelle. Dans `agent.py`, chargez la valeur de la clé API Bright Data avec : ```none BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") ``` Ensuite, définissez une fonction [`asynchrone`](https://docs.python.org/3/library/asyncio.html) et configurez la connexion MCP à un processus MCP Web local : ```none 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 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 Bright Data MCP et [s’y connecter via STDIO](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#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 : ```none 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](https://media.brightdata.com/2025/10/image-14-1024x225.png)Sinon, avec le mode Pro activé, vous verrez les 60 outils et plus : ![The tool list output with Pro mode enabled](https://media.brightdata.com/2025/10/image-15-1024x525.png)Et voilà ! Le résultat confirme que votre intégration Bright Data MCP fonctionne parfaitement. ### Étape n° 5 : définir votre agent AutoGen AutoGen AgentChat est fourni avec un ensemble [d’agents prédéfinis,](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/agents.html) chacun étant conçu avec différents styles de réponse. Dans ce cas, [`l'AssistantAgent`](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/agents.html#assistant-agent) à 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`: ```none OPENAI_API_KEY="" ``` Ensuite, configurez l’intégration OpenAI dans votre code avec : ```none from autogen_ext.models.openai import OpenAIChatCompletionClient model_client = OpenAIChatCompletionClient( model="gpt-4o-mini", ) ``` [`OpenAIChatCompletionClient`](https://microsoft.github.io/autogen/stable//reference/python/autogen_ext.models.openai.html#autogen_ext.models.openai.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](https://platform.openai.com/docs/models/gpt-4o). 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 : ```none 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](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/teams.html) travaillant ensemble vers un objectif commun. Dans votre cas, l’équipe ne comptera qu’un seul agent ([ce qui est une configuration valide](https://microsoft.github.io/autogen/stable//user-guide/agentchat-user-guide/tutorial/teams.html#single-agent-team)). 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`](https://microsoft.github.io/autogen/stable//reference/python/autogen_agentchat.teams.html#autogen_agentchat.teams.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`](https://microsoft.github.io/autogen/stable//reference/python/autogen_agentchat.conditions.html#autogen_agentchat.conditions.TextMentionTermination), configuré pour mettre fin au processus lorsque le mot « TERMINATE » apparaît dans la réponse de l’agent : ```none 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 : ```none 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 : ```none 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 Bright Data 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 : ```none await model_client.close() ``` ### Étape n° 8 : rassembler tous les éléments Votre fichier `agent.py` doit contenir : ```none # 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 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 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 Bright Data 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 : ```none python agent.py ``` Voici ce que vous devriez voir dans le terminal : ![Note the tool execution from the agent](https://media.brightdata.com/2025/10/image-16-1024x224.png)Comme vous pouvez le constater, l’agent a correctement identifié que `web_data_apple_app_store` de Bright Data 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](https://media.brightdata.com/2025/10/image-17-1024x190.png)Cette sortie structurée est ensuite analysée et traitée par le LLM, qui génère un rapport Markdown : ![The report produced by the AI model](https://media.brightdata.com/2025/10/image-18-1024x804.png)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](https://apps.apple.com/us/app/brave-browser-search-engine/id1052879175): ![The target page](https://media.brightdata.com/2025/10/image-19-1024x604.png)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 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](/ai/web-access). Et voilà ! Vous venez de découvrir la puissance de l’intégration du Bright Data MCP de Bright Data dans un agent IA AutoGen AgentChat en Python. ## Testez visuellement l’agent amélioré par Bright Data MCP dans Agent Studio AutoGen fournit également [Studio](https://microsoft.github.io/autogen/stable/user-guide/autogenstudio-user-guide/index.html), 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 : ```none 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 : ```none 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 Bright Data MCP de Bright Data. ### Étape n° 2 : charger le fichier JSON dans AutoGen Studio Lancez AutoGen Studio localement avec : ```none 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 : ![The default team in AutoGen Studio](https://media.brightdata.com/2025/10/image-20-1024x551.png)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 » : ![Enabling the “View JSON” mode](https://media.brightdata.com/2025/10/image-21-1024x783.png)Dans l’éditeur JSON, collez le contenu de votre fichier bd\_mcp\_team.json et appuyez sur le bouton « Save Changes » : ![Pressing the “Save Changes” button](https://media.brightdata.com/2025/10/image-22-1024x749.png)Votre « RoundRobin Team » mise à jour devrait maintenant ressembler à ceci : ![The updated team](https://media.brightdata.com/2025/10/image-23-1024x784.png)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é à Bright Data 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 : ![Note the chat section on the right](https://media.brightdata.com/2025/10/image-24-1024x550.png)Collez la même invite de tâche que précédemment et lancez-la : ![Executing the same task as before](https://media.brightdata.com/2025/10/Executing-the-same-task-as-before-1024x548.gif)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](https://media.brightdata.com/2025/10/image-25-1024x1006.png)À 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 Bright Data MCP de Bright Data ([qui propose également une offre gratuite !](/blog/ai/web-mcp-free-tier)). 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](/ai). 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 ventesEssai gratuit![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Table des matières Data for AI Supercharge your AI with instant and reliable access to web data. No blockers. No hassle. Talk to an expert Bright Data MCP Get started with Bright Data’s Web MCP Server today with 5000 free monthly requests and unlock your AI’s full potential. Start free now [ ](https://news.ycombinator.com/submitlink?t=Bright+Data+MCP+de+Bright+Data+avec+AutoGen+AgentChat+et+Studio&u=https://brightdata.fr/blog/ai/autogen-agentchat-with-web-mcp) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Bright+Data+MCP+de+Bright+Data+avec+AutoGen+AgentChat+et+Studio&url=https://brightdata.fr/blog/ai/autogen-agentchat-with-web-mcp) [ ](http://www.reddit.com/submit?title=Bright+Data+MCP+de+Bright+Data+avec+AutoGen+AgentChat+et+Studio&url=https://brightdata.fr/blog/ai/autogen-agentchat-with-web-mcp) ## Vous pourriez aussi être intéressé par [ ![OpenHuman with Bright Data](https://media.brightdata.fr/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.fr/blog/ai/openhuman-with-bright-data "Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data") [AI ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Accès Web Prêt pour la Production dans OpenHuman via le CLI Bright Data Intégrez le CLI Bright Data avec OpenHuman pour permettre un accès web prêt pour la production et la collecte de données pour les agents IA. 09-Sep-2026 14 min de lecture ](https://brightdata.fr/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.fr/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax "Scraping Web Multimodal avec MiniMax") [Données Web ![Antonello Zanini](https://media.brightdata.fr/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Scraping Web Multimodal avec MiniMax Associez Bright Data Web Unlocker avec la vision MiniMax M3 pour extraire des données structurées à partir d’images et de captures d’écran de pages web. 09-Sep-2026 5 min de lecture ](https://brightdata.fr/blog/donnees-web/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.fr/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.fr/blog/ai/best-cli-tools-for-codex "Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés") [AI ![Daniel Shashko](https://media.brightdata.fr/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### Les 10 meilleurs outils CLI pour Codex en 2026 – Testés & Classés Les 10 outils CLI qui rendent Codex plus rapide et plus capable, en commençant par le Bright Data CLI pour un accès web réel depuis l’intérieur du sandbox. 06-Sep-2026 24 min de lecture ](https://brightdata.fr/blog/ai/best-cli-tools-for-codex)