--- title: "Intégration de Bright Data dans une architecture IA multi-agents AG2 (AutoGen)" slug: ag2-with-bright-data date: 2026-01-28T07:24:56+00:00 modified: 2026-01-28T07:25:00+00:00 permalink: https://brightdata.fr/blog/ai/ag2-with-bright-data type: blog --- [ Blog ](https://brightdata.fr/blog "Blog") / [AI](https://brightdata.fr/blog/ai) [AI](https://brightdata.fr/blog/ai) # Intégration de Bright Data dans une architecture IA multi-agents AG2 (AutoGen) Découvrez comment optimiser les workflows multi-agents AG2 avec les outils Bright Data, qui permettent la recherche de données web en direct, le scraping web et la création de rapports autonomes. 4 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) ![AG2 with Bright Data](https://media.brightdata.fr/2025/12/AG2-with-Bright-Data.png) Dans ce guide, vous découvrirez : - Ce qu’est AG2 et comment il prend en charge le développement de systèmes à agent unique et à agents multiples, ainsi que les avantages de son extension avec Bright Data. - Les conditions préalables pour commencer à utiliser cette intégration. - Comment alimenter une architecture multi-agents AG2 avec Bright Data via des outils personnalisés. - Comment connecter AG2 au Bright Data MCP de Bright Data. C’est parti ! ## Présentation d’AG2 (anciennement AutoGen) [AG2](https://ag2.ai/) est un framework AgentOS open source permettant de créer des agents IA et des systèmes multi-agents capables de collaborer de manière autonome pour résoudre des tâches complexes. Il vous permet de créer des workflows à agent unique, d’orchestrer plusieurs agents spécialisés et d’intégrer des outils externes dans des pipelines modulaires prêts à l’emploi. AG2, anciennement AutoGen, est une évolution de la bibliothèque [Microfost AutoGen](https://microsoft.github.io/autogen/stable//index.html). Il conserve l’architecture d’origine et la rétrocompatibilité tout en permettant des flux de travail multi-agents, l’intégration d’outils et l’IA avec intervention humaine. Écrit en Python, il [compte plus de 4 000 étoiles GitHub](https://github.com/ag2ai/ag2). *(Si vous cherchez des conseils sur l’intégration de Bright Data avec AutoGen,* [*consultez l’article de blog dédié*](/blog/ai/autogen-agentchat-with-web-mcp)*.)* AG2 offre la flexibilité et les modèles d’orchestration avancés nécessaires pour faire passer les projets d’IA agentielle de l’expérimentation à la production. Parmi ses principales fonctionnalités, on trouve des modèles de conversation multi-agents, la prise en charge de l’intervention humaine, l’intégration d’outils et la gestion structurée des flux de travail. Son objectif final est de vous aider à créer des systèmes d’IA sophistiqués avec un minimum de frais généraux. Malgré ces formidables capacités, les agents AG2 sont toujours confrontés aux limitations fondamentales des LLM : des connaissances statiques issues des données d’entraînement et aucun accès natif aux informations web en temps réel ! L’intégration d’AG2 à un fournisseur de données web tel que Bright Data permet de résoudre tous ces problèmes. La connexion des agents AG2 aux API de Bright Data pour le Scraping web, la recherche et l’automatisation des navigateurs permet d’obtenir des données web structurées en temps réel, ce qui renforce leur intelligence, leur autonomie et leur utilité pratique. ## Prérequis Pour suivre ce guide, vous devez disposer des éléments suivants : - [Python 3.10 ou supérieur installé](https://www.python.org/downloads/) sur votre ordinateur local. - [Un compte Bright Data](/) avec l’API Web Unlocker, l’API SERP et une clé API configurée. (Ce tutoriel vous guidera à travers toutes les configurations requises.) - Une [clé API OpenAI](https://openai.com/index/openai-api/) (ou une clé API de [tout autre LLM pris en charge par AG2](https://docs.ag2.ai/latest/docs/user-guide/basic-concepts/llm-configuration/#supported-llm-providers)). Il est également utile de se familiariser avec [les produits et services de Bright Data](/products), ainsi que d’avoir une compréhension de base [du fonctionnement du système d’outils AG2](https://docs.ag2.ai/latest/docs/user-guide/advanced-concepts/orchestration/group-chat/agent-tools-functions/). ## Comment intégrer Bright Data dans un flux de travail multi-agents AG2 Dans cette section étape par étape, vous allez créer un workflow AG2 multi-agents basé sur les services Bright Data. Plus précisément, un agent dédié à la récupération de données web accédera à Web Unlocker et à l’API SERP de Bright Data via des fonctions personnalisées de l’outil AG2. Ce système multi-agents identifiera les principaux influenceurs sur des plateformes telles que Twitch dans le secteur alimentaire afin de soutenir la promotion d’un nouveau type de hamburger. Cet exemple montre comment AG2 peut automatiser la collecte de données, produire des rapports commerciaux structurés et permettre une prise de décision éclairée, le tout sans effort manuel. Découvrez comment le mettre en œuvre ! ### Étape n° 1 : créer un projet AG2 Ouvrez un terminal et créez un nouveau dossier pour votre projet AG2. Par exemple, nommez-le `ag2-bright-data-agent`: ```none mkdir ag2-bright-data-agent ``` `ag2-bright-data-agent/` contiendra le code Python permettant de mettre en œuvre et d’orchestrer les agents AG2 qui s’intègrent aux fonctions Bright Data. Ensuite, accédez au répertoire du projet et [créez un environnement virtuel](https://docs.python.org/3/library/venv.html) à l’intérieur : ```none cd ag2-bright-data-agent python -m venv .venv ``` Ajoutez un nouveau fichier appelé `agent.py` à la racine du projet. La structure de votre projet devrait maintenant ressembler à ceci : ```none ag2-bright-data-agent/ ├── .venv/ └── agent.py # <---- ``` Le fichier `agent.py` contiendra la définition de l’agent AG2 et la logique d’orchestration. Ouvrez 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/). Activez maintenant l’environnement virtuel que vous venez de créer. Sous Linux ou macOS, exécutez : ```none source .venv/bin/activate ``` De manière équivalente, sous Windows, exécutez : ```none .venv/Scripts/activate ``` Une fois l’environnement virtuel activé, installez les dépendances PyPI requises : ```none pip install ag2[openai] requests python-dotenv ``` Cette application s’appuie sur les bibliothèques suivantes : - [`ag2[openai]`](https://pypi.org/project/ag2/): pour créer et orchestrer des workflows IA multi-agents alimentés par les modèles OpenAI. - [`requests`](https://pypi.org/project/requests/): pour effectuer des requêtes HTTP vers les services Bright Data via des outils personnalisés. - [`python-dotenv`](https://pypi.org/project/python-dotenv/): pour charger les secrets requis à partir des variables d’environnement définies dans un fichier `.env` Bravo ! Vous disposez désormais d’un environnement Python prêt à l’emploi pour le développement d’IA multi-agents avec AG2. ### Étape n° 2 : configurer l’intégration LLM Les agents AG2 que vous allez créer dans les étapes suivantes ont besoin d’un cerveau, qui est fourni par un LLM. Chaque agent peut utiliser sa [propre configuration LLM](https://docs.ag2.ai/latest/docs/user-guide/basic-concepts/llm-configuration/#creating-an-llm-configuration), mais pour simplifier, nous allons connecter tous les agents au même modèle OpenAI. AG2 inclut un mécanisme intégré pour charger les paramètres LLM à partir d’un [fichier de configuration dédié](https://docs.ag2.ai/latest/docs/user-guide/advanced-concepts/llm-configuration-deep-dive/#oai_config_list-pattern). Pour ce faire, ajoutez le code suivant à `agent.py`: ```none from autogen import LLMConfig # Charger la configuration LLM à partir du fichier de liste de configuration OpenAI llm_config = LLMConfig.from_json(path="OAI_CONFIG_LIST") ``` Ce code charge la configuration LLM à partir d’un fichier nommé `OAI_CONFIG_LIST.json`. Créez ce fichier dans le répertoire racine de votre projet : ```none ag2-bright-data-agent/ ├── .venv/ ├── OAI_CONFIG_LIST.json # <---- └── agent.py ``` Maintenant, remplissez `OAI_CONFIG_LIST.json` avec le contenu suivant : ```none [ { "model": "gpt-5-mini", "api_key": "" } ] ``` Remplacez l’espace réservé `` par votre clé API OpenAI réelle. Cette configuration alimente vos agents AG2 à l’aide du modèle [GPT-5 Mini](https://platform.openai.com/docs/models/gpt-5-mini), mais vous pouvez remplacer celui-ci par n’importe quel autre modèle OpenAI pris en charge si nécessaire. La variable `llm_config` sera transmise à vos agents et à l’orchestrateur de chat de groupe. Cela leur permet de raisonner, de communiquer et d’exécuter des tâches à l’aide du LLM configuré. Génial ! ### Étape n° 3 : gérer la lecture des variables d’environnement Vos agents AG2 peuvent désormais se connecter à OpenAI, mais ils ont également besoin d’accéder à un autre service tiers : Bright Data. Tout comme OpenAI, Bright Data authentifie les requêtes [à l’aide d’une clé API externe](https://docs.brightdata.com/api-reference/authentication#how-do-i-authenticate-with-api-key). Pour éviter les risques de sécurité, vous ne devez jamais coder en dur les clés API directement dans votre code. La meilleure pratique consiste plutôt à les charger à partir de variables d’environnement. C’est exactement pour cette raison que vous avez installé `python-dotenv` précédemment. Commencez par importer `python-dotenv` dans `agent.py.` Utilisez-le pour charger les variables d’environnement à partir d’un fichier `.env` à l’aide de la fonction `load_dotenv()`: ```none from dotenv import load_dotenv import os # Charger les variables d'environnement à partir du fichier .env load_dotenv() ``` Ensuite, ajoutez un fichier `.env` au répertoire racine de votre projet, qui doit contenir : ```none ag2-bright-data-agent/ ├── .venv/ ├── OAI_CONFIG_LIST.json ├── .env # <---- └── agent.py ``` Après avoir ajouté vos valeurs secrètes au fichier `.env`, vous pourrez y accéder dans le code à l’aide de `os.getenv()`: ```none ENV_VALUE = os.getenv("ENV_NAME") ``` Super ! Votre script peut désormais charger en toute sécurité les secrets d’intégration tiers à partir des variables d’environnement. ### Étape n° 4 : configurer les services Bright Data Comme prévu dans l’introduction, l’agent de données web se connectera à l’API SERP et à l’API Web Unlocker de Bright Data pour gérer les recherches web et la récupération de contenu à partir de pages web. Ensemble, ces services permettent à l’agent de récupérer des données web en direct dans une [couche de récupération de données de type RAG](/blog/ai/build-an-agentic-rag). Pour interagir avec ces deux services, vous devrez définir deux outils AG2 personnalisés ultérieurement. Avant cela, vous devez tout configurer dans votre compte Bright Data. Commencez par [créer un compte Bright Data](/?hs_signup=1), si vous n’en avez pas déjà un. Sinon, [connectez-vous](/cp/start) et accédez à votre tableau de bord. À partir de là, naviguez vers la page « Proxies & Scraping » et consultez le tableau « My Zones » qui répertorie les services configurés dans votre profil : ![Note the “web_unlocker” Web Unlocker API zone and “serp_api” SERP API zone](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1766068789896_image.png) Si, comme ci-dessus, le tableau comprend déjà une zone Web Unlocker API (dans ce cas, appelée `web_unlocker`) et une zone API SERP (dans ce cas, appelée `serp_api`), alors tout est prêt. Ces deux zones seront utilisées par vos outils AG2 personnalisés pour appeler les services Bright Data requis. Si l’une des zones ou les deux manquent, faites défiler vers le bas jusqu’aux cartes « Unblocker API » et « API SERP » et cliquez sur « Create zone » (Créer une zone) pour chacune d’elles. Suivez l’assistant de configuration pour créer les deux zones : ![Note the “Create zone” buttons](https://media.brightdata.com/2025/12/s_15C5171743EEDBEF0993090D3D85589F5C79171362D5F7D117C738A5456FCA68_1764757915299_image-2.png) Pour obtenir des instructions détaillées étape par étape, consultez la documentation officielle : - [*Comment démarrer avec l’API SERP*](https://docs.brightdata.com/scraping-automation/serp-api/quickstart) - [*Guide de démarrage rapide pour l’API Web Unlocker de Bright Data*](https://docs.brightdata.com/scraping-automation/web-unlocker/quickstart) **Important**: à partir de maintenant, nous supposerons que vos zones s’appellent respectivement `serp_api` et `web_unlocker`. Une fois vos zones prêtes, [générez votre clé API Bright Data](https://docs.brightdata.com/api-reference/authentication#how-do-i-generate-a-new-api-key). Enregistrez-la en tant que variable d’environnement dans `.env`: ```none BRIGHT_DATA_API_KEY="" ``` Ensuite, chargez-la dans `agent.py` comme indiqué ci-dessous : ```none BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") ``` Parfait ! Vous disposez désormais de tous les éléments nécessaires pour connecter vos agents AG2 aux services API SERP et Web Unlocker de Bright Data via des outils personnalisés. ### Étape n° 5 : définir les outils Bright Data pour vos agents AG2 Dans AG2, [les outils fournissent des capacités spécialisées](https://docs.ag2.ai/latest/docs/user-guide/advanced-concepts/orchestration/group-chat/agent-tools-functions/) que les agents peuvent invoquer pour effectuer des actions et prendre des décisions. En réalité, les outils sont simplement des fonctions Python personnalisées qu’AG2 expose aux agents de manière structurée. Dans cette étape, vous allez implémenter deux fonctions d’outil dans `agent.py`: - `serp_api_tool()`: se connecte à l’API SERP de Bright Data pour effectuer des recherches Google. - `web_unlocker_api_tool()`: se connecte à l’API Bright Data Web Unlocker pour récupérer le contenu des pages web, en contournant tous les systèmes anti-bot. Les deux outils utilisent le [client HTTP Python Requests](/blog/web-data/python-requests-guide) pour effectuer des requêtes POST authentifiées vers Bright Data, conformément à la documentation : - [*Envoyez votre première requête avec l’API SERP de Bright Data*](https://docs.brightdata.com/scraping-automation/serp-api/send-your-first-request) - [*Envoyez votre première requête avec l’API Web Unlocker de Bright Data*](https://docs.brightdata.com/scraping-automation/web-unlocker/send-your-first-request) Pour définir les deux fonctions de l’outil, ajoutez le code suivant à `agent.py`: ```none from typing import Annotated import requests import urllib.parse def serp_api_tool( query: Annotated[str, "La requête de recherche Google"],) -> str: payload = { "zone": "serp_api", # Remplacez-le par le nom de votre zone API SERP Bright Data "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1", "format": "raw", } headers = { "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}", "Content-Type": "application/json", } response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers, ) response.raise_for_status() return response.text def web_unlocker_api_tool( url_to_fetch: Annotated[str, "URL de la page cible à récupérer"], data_format: Annotated[ str | None, "Format de la page de sortie (par exemple, 'markdown', ou omettre pour du HTML brut)" ] = "markdown",) -> str: payload = { "zone": "web_unlocker", # Remplacez-le par le nom de votre zone Bright Data Web Unlocker "url": url_to_fetch, "format": "raw", "data_format": data_format, } headers = { « Authorization » : f« Bearer {BRIGHT_DATA_API_KEY} », « Content-Type » : « application/json », } response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers ) response.raise_for_status() return response.text ``` Les deux outils authentifient les requêtes à l’aide de votre clé API Bright Data et envoient des requêtes POST au point de terminaison de l’API Bright Data : - `serp_api_tool()` interroge Google et récupère les résultats de recherche au [format JSON structuré](https://docs.brightdata.com/scraping-automation/serp-api/parsed-json-results/parsing-search-results) en activant le paramètre `brd_json=1`. - `web_unlocker_api_tool()` récupère n’importe quelle page web et [renvoie son contenu au format Markdown](https://docs.brightdata.com/scraping-automation/web-unlocker/features#scrape-as-markdown) (ou HTML brut si vous le souhaitez). **Important**: JSON et Markdown sont deux formats excellents pour [l’ingestion LLM dans les agents IA](https://www.kaggle.com/code/brightdataml/benchmarking-ai-agents-on-different-data-formats). Notez que les deux fonctions utilisent le typage Python ainsi que `Annotated` pour décrire leurs arguments. Les types sont nécessaires pour transformer ces fonctions en outils AG2 appropriés, tandis que les descriptions des annotations aident le LLM à comprendre comment remplir chaque argument lors de l’invocation des outils à partir d’un agent. Parfait ! Votre application AG2 comprend désormais deux outils Bright Data, prêts à être configurés et utilisés par vos agents IA. ### Étape n° 6 : implémenter les agents AG2 Maintenant que vos outils sont en place, il est temps de construire la structure de l’agent IA décrite dans l’introduction. Cette configuration se compose de trois agents complémentaires : 1. **`user_proxy`**: agit comme couche d’exécution, exécutant en toute sécurité les appels d’outils et orchestrant le flux de travail sans intervention humaine. Il s’agit d’une instance de [`UserProxyAgent`](https://docs.ag2.ai/latest/docs/api-reference/autogen/UserProxyAgent/), un agent AG2 spécial qui fonctionne comme un Proxy pour l’utilisateur, exécutant du code et fournissant des commentaires aux autres agents si nécessaire. 2. **`web_data_agent`**: responsable de la découverte et de la récupération des données web. Cet agent effectue des recherches sur le web à l’aide de l’API SERP de Bright Data et récupère le contenu des pages via l’API Web Unlocker. En tant qu’agent [`ConversableAgent`](https://docs.ag2.ai/latest/docs/user-guide/basic-concepts/conversable-agent/), il peut communiquer avec d’autres agents et des humains, traiter des informations, suivre les instructions définies dans son message système, etc. 3. **`reporting_agent`**: analyse les données collectées et les transforme en un rapport Markdown structuré et prêt à l’emploi pour les décideurs. Ensemble, ces agents forment un pipeline multi-agents entièrement autonome conçu pour l’identification des streamers Twitch et la promotion d’un produit ciblé. Dans `agent.py`, spécifiez les trois agents avec le code suivant : ```none from autogen import ( UserProxyAgent, ConversableAgent,) # Exécute les appels d'outils et orchestre le flux de travail sans intervention humaine. user_proxy = UserProxyAgent( name="user_proxy", code_execution_config=False, human_input_mode="NEVER", llm_config=llm_config, ) # Responsable de la recherche et de la récupération des données web web_data_agent = ConversableAgent( name="web_data_agent", code_execution_config=False, llm_config=llm_config, system_message=( """ Vous êtes un agent de récupération de données web. Vous effectuez des recherches sur le Web à l'aide de l'outil API SERP de Bright Data et récupérez le contenu des pages à l'aide de l'outil API Web Unlocker. """ ), ) # Analyse les données collectées et produit un rapport structuré reporting_agent = ConversableAgent( name="reporting_agent", code_execution_config=False, system_message=( """ Vous êtes analyste marketing. Vous produisez des rapports Markdown structurés et prêts à l'emploi destinés aux décideurs. """ ), llm_config=llm_config, # Met automatiquement fin à la conversation dès que le mot « rapport » apparaît. is_termination_msg=lambda msg: "report" in (msg.get("content", "") or "").lower() ) ``` Dans le code ci-dessus, notez que : - [Les agents AG2 peuvent exécuter le code](https://docs.ag2.ai/latest/docs/user-guide/advanced-concepts/code-execution/) contenu dans les messages (par exemple, les blocs de code) et transmettre les résultats à l’agent suivant. Dans cette configuration, l’exécution du code est désactivée via `code_execution_config=False` pour des raisons de sécurité. - Tous les agents sont alimentés par le `llm_config` chargé à l’étape n° 2. - Le `reporting_agent` inclut une [fonction`is_termination_msg` qui met automatiquement fin au flux de travail](https://docs.ag2.ai/latest/docs/user-guide/advanced-concepts/ending-a-chat/) dès que le message contient le mot « report », signalant que le résultat final a été produit. Ensuite, vous allez enregistrer les outils Bright Data avec le `web_data_agent` pour activer la récupération Web ! ### Étape n° 7 : Enregistrer les outils AG2 Bright Data Enregistrez les fonctions Bright Data en tant qu’outils et attribuez-les au `web_data_agent` via [`register_function()`](https://docs.ag2.ai/0.8.7/docs/api-reference/autogen/register_function/). L’agent `user_proxy` agira en tant qu’exécuteur pour ces outils, comme l’exige l’architecture AG2 : ```none from autogen import register_function # Enregistrer l'outil de recherche SERP pour l'agent de données web register_function( serp_api_tool, caller=web_data_agent, executor=user_proxy, description="Utiliser l'API SERP de Bright Data pour effectuer une recherche Google et renvoyer les résultats bruts." ) # Enregistrer l'outil Web Unlocker pour récupérer les pages protégées register_function( web_unlocker_api_tool, caller=web_data_agent, executor=user_proxy, description="Récupérer une page web à l'aide de l'API Web Unlocker de Bright Data, en contournant les protections anti-bot courantes.", ) ``` Notez que chaque fonction comprend une description concise pour aider le LLM à comprendre son objectif et à savoir quand l’appeler. Une fois ces outils enregistrés, le `web_data_agent` peut désormais planifier les recherches sur le Web et l’accès aux pages Web, tandis que le `user_proxy` se charge de l’exécution. Votre pipeline multi-agents AG2 est désormais pleinement capable de découvrir et d’extraire des données de manière autonome à l’aide des API de Bright Data. Mission accomplie ! ### Étape n° 8 : Introduire la logique d’orchestration multi-agents AG2 AG2 prend en charge plusieurs façons [d’orchestrer et de gérer plusieurs agents](https://docs.ag2.ai/latest/docs/user-guide/basic-concepts/introducing-swarm-orchestration/). Dans cet exemple, vous verrez le modèle [`GroupChat`](https://docs.ag2.ai/latest/docs/user-guide/advanced-concepts/groupchat/groupchat/). Le principe fondamental d’un chat de groupe AG2 est que tous les agents contribuent à un seul fil de conversation, partageant le même contexte. Cette approche est idéale pour les tâches qui nécessitent une collaboration entre plusieurs agents, comme dans notre pipeline. Ensuite, un [`GroupChatManager`](https://docs.ag2.ai/latest/docs/api-reference/autogen/GroupChatManager/) gère la coordination des agents au sein du chat de groupe. Il prend en charge différentes stratégies pour sélectionner le prochain agent à agir. Ici, vous allez configurer la stratégie `automatique` par défaut, qui utilise le LLM du gestionnaire pour décider quel agent doit parler ensuite. Combinez tous les éléments pour l’orchestration multi-agents comme ci-dessous : ```none from autogen import ( GroupChat, GroupChatManager,) # Définir le chat de groupe multi-agents groupchat = GroupChat( agents=[user_proxy, web_data_agent, reporting_agent], speaker_selection_method="auto", messages=[], max_round=20 ) # Gestionnaire responsable de la coordination des interactions entre les agents manager = GroupChatManager( name="group_manager", groupchat=groupchat, llm_config=llm_config ) ``` **Remarque**: le flux de travail prendra fin lorsque `l'agent reporting_agent` produira un message qui déclenchera sa logique `is_termination_msg` ou après `20` cycles d’interactions entre les agents (en raison de l’argument `max_round` ), selon la première éventualité. C’est parti ! Les définitions des agents et la logique d’orchestration sont terminées. La dernière étape consiste à lancer le workflow et à exporter les résultats. ### Étape n° 9 : lancer le workflow Agentic et exporter le résultat Décrivez en détail la tâche de recherche d’influenceurs streamers sur Twitch et transmettez-la sous forme de message à l’agent `user_proxy` pour exécution : ```none prompt_message = """ Scénario : --------- Une marque de produits alimentaires et de boissons souhaite promouvoir un nouveau type de hamburger. Objectif : - Rechercher la page de la catégorie Alimentation et boissons sur TwitchMetrics - Récupérer le contenu de la page de catégorie TwitchMetrics extraite du SERP et sélectionner les 5 meilleurs streamers - Visiter la page de profil TwitchMetrics de chaque streamer et récupérer les informations pertinentes - Produire un rapport Markdown structuré comprenant : - Le nom de la chaîne - La portée estimée - Le thème principal du contenu - L'adéquation avec l'audience - La faisabilité de la promotion de la marque """ # Démarrer le workflow multi-agents user_proxy.initiate_chat(recipient=manager, message=prompt_message) ``` Une fois le workflow terminé, enregistrez le résultat (c’est-à-dire le rapport Markdown) sur le disque avec : ```none with open("report.md", "w", encoding="utf-8") as f: f.write(user_proxy.last_message()["content"]) ``` Incroyable ! Votre workflow multi-agents AG2 + Bright Data est désormais pleinement opérationnel et prêt à collecter, analyser et rapporter les données des influenceurs Twitch. ### Étape n° 10 : assembler le tout Le code final dans votre fichier `agent.py` sera : ```none from autogen import ( LLMConfig, UserProxyAgent, ConversableAgent, register_function, GroupChat, GroupChatManager,) from dotenv import load_dotenv import os from typing import Annotated import requests import urllib.parse # Charger la configuration LLM à partir du fichier de liste de configuration OpenAI llm_config = LLMConfig.from_json(path="OAI_CONFIG_LIST") # Charger les variables d'environnement à partir du fichier .env load_dotenv() # Récupérer la clé API Bright Data à partir des variables d'environnement BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") # Définir les fonctions pour implémenter les outils Bright Data def serp_api_tool( query: Annotated[str, "La requête de recherche Google"],) -> str: payload = { "zone": "serp_api", # Remplacez-la par le nom de votre zone API SERP Bright Data "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1", "format": "raw", } headers = { "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}", "Content-Type": "application/json", } response = requests.post( "https://api.brightdata.com/request", json=payload, headers=headers, ) response.raise_for_status() return response.text def web_unlocker_api_tool( url_to_fetch: Annotated[str, "URL de la page cible à récupérer"], data_format: Annotated[ str | None, "Format de la page de sortie (par exemple, 'markdown', ou omettre pour du HTML brut)" ] = "markdown",) -> str: payload = { "zone": "web_unlocker", # Remplacez-le par le nom de votre zone Bright Data Web Unlocker "url": url_to_fetch, "format": "raw", "data_format": data_format, } headers = { « Authorization » : f« Bearer {BRIGHT_DATA_API_KEY} », « Content-Type » : « application/json », } response = requests.post( « https://api.brightdata.com/request », json=payload, headers=headers ) response.raise_for_status() return response.text # Exécute les appels d'outils et orchestre le flux de travail sans intervention humaine. user_proxy = UserProxyAgent( name="user_proxy", code_execution_config=False, human_input_mode="NEVER", llm_config=llm_config, ) # Responsable de la recherche et de la récupération des données web web_data_agent = ConversableAgent( name="web_data_agent", code_execution_config=False, llm_config=llm_config, system_message=( """ Vous êtes un agent de récupération de données web. Vous effectuez des recherches sur le Web à l'aide de l'outil API SERP de Bright Data et récupérez le contenu des pages à l'aide de l'outil API Web Unlocker. """ ), ) # Analyse les données collectées et produit un rapport structuré reporting_agent = ConversableAgent( name="reporting_agent", code_execution_config=False, system_message=( """ Vous êtes analyste marketing. Vous produisez des rapports Markdown structurés et prêts à l'emploi destinés aux décideurs. """ ), llm_config=llm_config, # Met automatiquement fin à la conversation dès que le mot « rapport » apparaît. is_termination_msg=lambda msg: "rapport" in (msg.get("content", "") or "").lower() ) # Enregistrer l'outil de recherche SERP pour l'agent de données Web. register_function( serp_api_tool, caller=web_data_agent, executor=user_proxy, description="Utiliser l'API SERP de Bright Data pour effectuer une recherche Google et renvoyer les résultats bruts." ) # Enregistrer l'outil Web Unlocker pour récupérer les pages protégées register_function( web_unlocker_api_tool, caller=web_data_agent, executor=user_proxy, description="Récupérer une page web à l'aide de l'API Web Unlocker de Bright Data, en contournant les protections anti-bot courantes.", ) # Définir le chat de groupe multi-agents groupchat = GroupChat( agents=[user_proxy, web_data_agent, reporting_agent], speaker_selection_method="auto", messages=[], max_round=20 ) # Gestionnaire chargé de coordonner les interactions entre les agents manager = GroupChatManager( name="group_manager", groupchat=groupchat, llm_config=llm_config) prompt_message = """ Scénario : --------- Une marque de produits alimentaires et de boissons souhaite promouvoir un nouveau type de hamburger. Objectif : - Rechercher la page de la catégorie Alimentation et boissons sur TwitchMetrics - Récupérer le contenu de la page de catégorie TwitchMetrics extraite du SERP et sélectionner les 5 meilleurs streamers - Visiter la page de profil TwitchMetrics de chaque streamer et récupérer les informations pertinentes - Produire un rapport Markdown structuré comprenant : - Nom de la chaîne - Portée estimée - Thème principal du contenu - Adéquation avec l'audience - Faisabilité de la promotion de la marque """ # Démarrer le workflow multi-agents user_proxy.initiate_chat(recipient=manager, message=prompt_message) # Enregistrer le rapport final dans un fichier Markdown with open("report.md", "w", encoding="utf-8") as f: f.write(user_proxy.last_message()["content"]) ``` Grâce à la puissante API AG2, vous avez créé, en seulement 170 lignes de code, un workflow multi-agents complexe, prêt à l’emploi et optimisé par Bright Data ! ### Étape n° 11 : tester le système multi-agents Dans votre terminal, vérifiez que votre application agentique AG2 fonctionne avec : ```none python agent.py ``` Le résultat attendu ressemblera à ceci : ![The AG2 run](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765984277632_11.gif) Plus précisément, notez comment le flux de travail multi-agents se déroule étape par étape : 1. Le `web_data_agent` détermine qu’il doit appeler le `serp_api_tool` pour localiser la page de catégorie « Food & Drink » requise de TwitchMetrics. 2. Grâce à l’agent `user_proxy`, l’outil exécute plusieurs requêtes de recherche. 3. Une fois la bonne page de catégorie TwitchMetrics identifiée, il appelle l’outil `web_unlocker_api_tool` pour extraire le contenu au format Markdown. 4. À partir de la sortie Markdown, il extrait les URL des 5 profils TwitchMetrics les plus influents dans la catégorie « Food & Drink ». 5. L’outil `web_unlocker_api_tool` est à nouveau appelé pour récupérer le contenu de la page de chaque profil au format Markdown. 6. Toutes les données collectées sont transmises à `l'agent de rapport`, qui les analyse et produit le rapport final. Ce rapport final est enregistré sur le disque sous le nom `report.md`, comme spécifié dans le code : ![The report.md file produced by the agent](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765984446763_image.png) Consultez-le dans VS Code à l’aide de l’aperçu Markdown pour voir à quel point le rapport est détaillé et riche en informations : ![Scrolling through the output report](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765984709391_21.gif) Si vous vous demandez d’où proviennent les données sources, consultez la [page de la catégorie Food & Drink Twitch stream sur TwitchMetrics](https://www.twitchmetrics.net/channels/popularity?game=Food+%26+Drink): ![The target category page from TwitchMetrics](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765991791425_image.png) Notez que les informations sur les streamers Twitch figurant dans le rapport correspondent aux pages de profil TwitchMetrics dédiées à chacun des 5 profils les plus populaires : ![An example of one of the selected TwitchMetrics profile pages](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765991806867_image.png) Toutes ces informations ont été récupérées automatiquement par le système multi-agents, démontrant la puissance d’AG2 et son intégration avec Bright Data. N’hésitez pas à tester différentes invites de saisie. Grâce à Bright Data, votre workflow multi-agents AG2 peut gérer une grande [variété de tâches concrètes](/use-cases). Et voilà ! Vous venez de découvrir les capacités d’un flux de travail AG2 amélioré avec Bright Data ## Connexion d’AG2 à Bright Data MCP : guide étape par étape Une autre façon d’intégrer Bright Data à AG2 consiste à utiliser le [ **serveur** Bright Data **Bright Data MCP**](/ai/mcp-server). Bright Data MCP vous donne accès à [plus de 60 outils](https://docs.brightdata.com/ai/mcp-server/tools) basés sur la plateforme d’automatisation web et de collecte de données de Bright Data. Même dans sa version gratuite, il offre deux outils puissants : **Outil****Description**`search_engine`Récupérez les résultats 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 tout en contournant les mesures anti-bot.[Le mode Pro](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-pricing--modes) de Bright Data MCP va encore plus loin. Cette option premium permet l’extraction de données structurées pour les principales plateformes telles qu’Amazon, LinkedIn, Instagram, Reddit, YouTube, TikTok, Google Maps, etc. Elle ajoute également des outils pour l’automatisation avancée du navigateur. **Remarque**: pour la configuration du projet, reportez-vous à l’étape n° 1 du chapitre précédent. Voyons maintenant comment utiliser Bright Data MCP de Bright Data dans AG2 ! ### Prérequis Pour suivre cette section du tutoriel, vous devez [avoir installé Node.js localement](https://nodejs.org/en/download), car il est nécessaire pour exécuter Bright Data MCP sur votre machine. Vous devez également installer le [package MCP pour AG2 avec](https://docs.ag2.ai/0.9.1/docs/use-cases/notebooks/notebooks/mcp_client/): ```none pip install ag2[mcp] ``` Cela permet à AG2 d’agir comme un client MCP. ### Étape n° 1 : commencer à utiliser le Bright Data MCP de Bright Data Avant de connecter AG2 au Bright Data MCP de Bright Data, assurez-vous que votre ordinateur local peut exécuter le serveur MCP. Ceci est important, car nous allons vous montrer comment vous [connecter au serveur Bright Data MCP localement](https://docs.brightdata.com/ai/mcp-server/local/quickstart). **Remarque**: le Bright Data MCP est également disponible en tant que [serveur distant via Streamable HTTP](https://docs.brightdata.com/ai/mcp-server/remote/quickstart), qui est plus adapté aux cas d’utilisation de niveau entreprise grâce à son évolutivité illimitée. Tout d’abord, assurez-vous que vous [disposez d’un compte Bright Data](/?hs_signup=1). Si c’est déjà le cas, [connectez-vous simplement](/cp/start). Pour une configuration rapide, suivez les instructions de la section «[MCP »](/cp/mcp)de votre tableau de bord : ![The “MCP” section in your Bright Data account](https://media.brightdata.com/2025/12/s_617A939C2A6B92FCCF16B1E930DCB4B684B2A2710DFD16F65F8DAEBFBDCD6C08_1756112369396_image-2.png) Pour plus d’informations, reportez-vous aux étapes ci-dessous. Commencez par [générer votre clé API Bright Data](https://docs.brightdata.com/api-reference/authentication#how-do-i-generate-a-new-api-key). Conservez-la en lieu sûr, car vous l’utiliserez bientôt pour authentifier votre instance Bright Data MCP locale. Ensuite, installez Bright Data MCP globalement sur votre machine à l’aide du package [`@brightdata/mcp`](https://www.npmjs.com/package/@brightdata/mcp): ```none npm install -g @brightdata/mcp ``` Démarrez le serveur MCP en exécutant : ```none API_TOKEN="" npx -y @brightdata/mcp ``` Ou, de manière équivalente, dans PowerShell : ```none $Env:API_TOKEN=""; npx -y @brightdata/mcp ``` Remplacez `` par votre jeton API Bright Data. Ces commandes définissent la variable d’environnement `API_TOKEN` requise et lancent le serveur Bright Data MCP 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/12/s_BC694EB0496142EE3DF329451640C6FC748F9687F72E8A71DE02C0DAB36E05E7_1753192240616_image-2.png) Par défaut, Bright Data MCP crée deux zones dans votre compte Bright Data lors du premier lancement : - `mcp_unlocker`: une zone pour [Web Unlocker](/products/web-unlocker). - `mcp_browser`: une zone pour [Browser API.](/products/scraping-browser) Ces zones alimentent les plus de 60 outils disponibles dans Bright Data MCP. Vous pouvez vérifier que les zones ont bien été créées en vous rendant dans « Proxies & Infrastructure de scraping » (Proxys et Infrastructure de scraping) dans votre tableau de bord Bright Data : ![The mcp_unlocker and mcp_browser zones created by the Bright Data MCP at startup](https://media.brightdata.com/2025/12/s_BC694EB0496142EE3DF329451640C6FC748F9687F72E8A71DE02C0DAB36E05E7_1753192341603_image-2.png) Dans la [version gratuite de Bright Data MCP](/blog/ai/web-mcp-free-tier), seuls les outils `search_engine` et `scrape_as_markdown` (et leurs versions batch) sont disponibles. Pour débloquer tous les outils, activez le mode Pro en définissant la variable d’environnement `PRO_MODE="true"`: ```none API_TOKEN="" PRO_MODE="true" npx -y @brightdata/mcp ``` Ou, sous Windows : ```none $Env:API_TOKEN=""; $Env: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 peut entraîner des frais supplémentaires. C’est fait ! Vous avez maintenant vérifié que le serveur Bright Data MCP fonctionne localement. Arrêtez le processus MCP pour l’instant, car l’étape suivante consiste à configurer AG2 pour démarrer le serveur localement et s’y connecter. ### Étape n° 2 : intégration de Bright Data MCP dans AG2 Utilisez le client AG2 MCP pour vous connecter à une instance Bright Data MCP locale [via STDIO](https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#stdio) et récupérer les outils disponibles : ```none from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client from autogen.mcp import create_toolkit # Instructions pour se connecter à une instance Bright Data MCP locale server_params = StdioServerParameters( command="npx", args=["-y", "@brightdata/mcp"], env={ "API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true" # Facultatif },) async with stdio_client(server_params) as (read, write), ClientSession(read, write) as session: # Créer une session de connexion MCP et récupérer les outils await session.initialize() web_mcp_toolkit = await create_toolkit(session, use_mcp_resources=False) ``` L’objet `StdioServerParameters` reflète la commande `npx` que vous avez exécutée précédemment, y compris les variables d’environnement pour les informations d’identification et les paramètres : - `API_TOKEN`: obligatoire. Définissez votre clé API Bright Data. - `PRO_MODE`: facultatif. Supprimez-le si vous souhaitez rester sur le niveau gratuit (`search_engine` et `scrape_as_markdown` et leurs versions batch uniquement). La session est utilisée pour se connecter à Bright Data MCP et créer une boîte à outils AG2 MCP à l’aide de `create_toolkit`. **Remarque**: comme souligné dans un [ticket GitHub dédié](https://github.com/ag2ai/ag2/issues/1959), l’option `use_mcp_resources=False` est requise pour éviter l’erreur `mcp.shared.exceptions.McpError: Method not found`. Une fois créé, l’objet `web_mcp_toolkit` contient tous les outils Bright Data MCP. Vérifiez cela avec : ```none for tool in web_mcp_toolkit.tools: print(tool.name) print(tool.description) print("---n") ``` Le résultat sera : ![The tools contained in the web_mcp_toolkit object](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765987132484_image.png) En fonction du niveau configuré, vous disposerez soit de l’ensemble des 60+ outils Bright Data MCP (mode Pro), soit uniquement des outils du niveau gratuit. Excellent ! Votre connexion Bright Data MCP est désormais pleinement fonctionnelle dans AG2. ### Étape n° 3 : connecter les outils Bright Data MCP à un agent La façon la plus simple de tester l’intégration Bright Data MCP dans AG2 est d’utiliser [`AssistantAgent`](https://docs.ag2.ai/latest/docs/api-reference/autogen/AssistantAgent/), une sous-classe de `ConversableAgent` conçue pour résoudre rapidement des tâches à l’aide du LLM. Commencez par définir l’agent et enregistrez-y la boîte à outils Bright Data MCP : ```none from autogen import AssistantAgent # Définir un agent capable de rechercher et de récupérer des données Web assistant_agent = AssistantAgent( name="assistant", code_execution_config=False, llm_config=llm_config, system_message=""" Vous avez accès à tous les outils exposés par le Bright Data MCP, notamment : - Recherche Web - Scraping web et récupération de pages - Flux de données Web - Simulation d'utilisateur basée sur un navigateur Utilisez ces outils lorsque cela est nécessaire. """) # Enregistrer les outils Bright Data MCP auprès de l'agent web_mcp_toolkit.register_for_llm(assistant_agent) ``` Une fois enregistré, vous pouvez lancer l’agent à l’aide de la fonction `a_run()` et spécifier directement les outils à utiliser. Voici, par exemple, comment tester l’agent sur une tâche de Scraping web Amazon : ```none prompt = """ Récupérez les données du produit Amazon suivant et produisez un résumé rapide avec les informations principales : """ # Exécutez l'agent Bright Data MCP étendu de manière asynchrone. result = await assistant_agent.a_run( message=prompt, tools=web_mcp_toolkit.tools, user_input=False,) await result.process() ``` **Important**: gardez à l’esprit qu’il s’agit uniquement d’une démonstration visant à présenter l’intégration. Grâce à tous les outils Bright Data MCP, l’agent peut gérer des tâches beaucoup plus complexes, en plusieurs étapes, sur différentes plateformes Web et sources de données. ### Étape n° 4 : code final + exécution Vous trouverez ci-dessous le code final pour votre intégration AG2 + Bright Data MCP : ```none import asyncio from autogen import ( LLMConfig, AssistantAgent,) from dotenv import load_dotenv import os from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client from autogen.mcp import create_toolkit # Charger les variables d'environnement à partir du fichier .env load_dotenv() # Récupérer la clé API Bright Data à partir des variables d'environnement BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") # Définir la boîte à outils MCP contenant tous les outils Bright Data MCP async def launch_mcp_agent(): # Charger la configuration LLM à partir du fichier de liste de configuration OpenAI llm_config = LLMConfig.from_json(path="OAI_CONFIG_LIST") # Instructions pour se connecter à une instance Bright Data MCP locale server_params = StdioServerParameters( command="npx", args=["-y", "@brightdata/mcp"], env={ "API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true" # Facultatif }, ) async with stdio_client(server_params) as (read, write), ClientSession(read, write) as session: # Créer une session de connexion MCP et récupérer les outils await session.initialize() web_mcp_toolkit = await create_toolkit(session, use_mcp_resources=False) # Définir un agent capable de rechercher et de récupérer des données Web assistant_agent = AssistantAgent( name="assistant", code_execution_config=False, llm_config=llm_config, system_message=""" Vous avez accès à tous les outils exposés par le Bright Data MCP, notamment : - Recherche Web - Scraping web et récupération de pages - Flux de données Web - Simulation utilisateur basée sur un navigateur Utilisez ces outils lorsque cela est nécessaire. """ ) # Enregistrer les outils Bright Data MCP auprès de l'agent web_mcp_toolkit.register_for_llm(assistant_agent) # Invite à transmettre à l'agent prompt = """ Récupérez les données du produit Amazon suivant et produisez un résumé rapide contenant les informations principales : """ # Exécutez l'agent Bright Data MCP étendu de manière asynchrone result = await assistant_agent.a_run( message=prompt, tools=web_mcp_toolkit.tools, user_input=False, ) await result.process() asyncio.run(launch_mcp_agent()) ``` Exécutez-le, et le résultat sera : ![The output produced by the AG2 script](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765991715639_image.png) Notez que le rapport généré comprend toutes les données pertinentes de la page produit Amazon cible : ![The target Amazon product page](https://media.brightdata.com/2025/12/s_14E8BA101B64F7DD69B536C6FABC31D1B2715A2EF247A0A987A1C7454A8E09B3_1765991611330_image.png) Si vous avez déjà essayé d’extraire [des données de produits Amazon en Python](/blog/how-tos/how-to-scrape-amazon), vous savez que ce n’est pas une mince affaire. Amazon utilise le [CAPTCHA Amazon](/blog/web-data/bypass-amazon-captcha), réputé pour sa difficulté, ainsi que d’autres mesures anti-bot. De plus, les pages de produits changent constamment et ont des structures variables. Bright Data MCP de Bright Data s’occupe de tout cela pour vous. Dans la version gratuite, il appelle l’outil `scrape_as_markdown` en arrière-plan pour récupérer la structure de la page dans un format Markdown propre via Web Unlocker. En mode Pro, il utilise le produit `web_data_amazon_product`, qui appelle [Amazon Scraper de Bright Data](/products/web-scraper/amazon) pour recueillir des données de produits entièrement structurées. Et voilà ! Vous savez maintenant comment étendre AG2 avec Bright Data MCP. ## Conclusion Dans ce tutoriel, vous avez appris à intégrer Bright Data à AG2, soit via des fonctions personnalisées, soit via Bright Data MCP. Cette intégration permet aux agents AG2 d’effectuer des recherches sur le web, d’extraire des données structurées, d’accéder à des flux web en direct et d’automatiser les interactions web. Tout cela est rendu possible grâce à [la suite de services pour l’IA de Bright Data](/ai/web-access). Créez gratuitement un compte Bright Data et commencez dès aujourd’hui à explorer nos 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 [ ](https://news.ycombinator.com/submitlink?t=Int%C3%A9gration+de+Bright+Data+dans+une+architecture+IA+multi-agents+AG2+%28AutoGen%29&u=https://brightdata.fr/blog/ai/ag2-with-bright-data) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Int%C3%A9gration+de+Bright+Data+dans+une+architecture+IA+multi-agents+AG2+%28AutoGen%29&url=https://brightdata.fr/blog/ai/ag2-with-bright-data) [ ](http://www.reddit.com/submit?title=Int%C3%A9gration+de+Bright+Data+dans+une+architecture+IA+multi-agents+AG2+%28AutoGen%29&url=https://brightdata.fr/blog/ai/ag2-with-bright-data) ## 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)