Guide d'intégration du SDK Claude Agent + Bright Data Web MCP

Dans cet article de blog, vous découvrirez :

Ce qu’est le SDK Claude Agent et ce qui le rend unique.
Pourquoi son extension via le Web MCP de Bright Data est l’approche idéale pour des agents IA plus puissants.
Comment connecter un agent IA créé avec le SDK Claude Agent aux outils web de Bright Data via Web MCP.

C’est parti !

Qu’est-ce que le SDK Claude Agent ?

Le SDK Claude Agent est un framework open source d’Anthropic qui vous permet de créer des agents IA autonomes alimentés par Claude Code. Il permet notamment aux agents de lire des fichiers, d’exécuter des commandes, d’effectuer des recherches sur le web, de modifier du code et d’interagir avec des outils sans nécessiter de logique d’orchestration personnalisée.

Le SDK fournit une boucle d’agent robuste qui peut recueillir du contexte, prendre des mesures et vérifier les résultats. De cette façon, il permet à vos agents d’exécuter des flux de travail complexes de manière fiable. Le SDK est disponible en :

Python, avec une bibliothèque qui compte plus de 4 500 étoiles GitHub.
TypeScript, avec une bibliothèque comptant plus de 720 étoiles GitHub.

Le SDK Claude Agent prend en charge les outils intégrés, les sous-agents et l’intégration native avec le MCP (Model Context Protocol) pour les services externes. Son objectif final est de simplifier le développement d’agents IA, en vous fournissant une API simple pour créer des assistants spécialisés, des agents de recherche et des robots d’automatisation qui exploitent les capacités de raisonnement et d’exécution d’outils de Claude.

Pourquoi étendre le SDK Claude Agent avec les capacités de données Web de Bright Data

Découvrez les limites de Claude Agent et comment les contourner !

Quelques informations sur les outils du SDK Claude Agent

Même les modèles d’IA Claude les plus performants ont des limites inhérentes à tous les LLM. Ces limites découlent du fait que les modèles d’IA sont entraînés sur des données qui représentent un instantané du passé.

Par conséquent, les LLM ne peuvent générer que des réponses basées sur ce pour quoi ils ont été formés. Lorsqu’on leur pose des questions sur des sujets qu’ils ne connaissent pas (ou sur des événements très récents), ils peuvent échouer complètement ou, pire encore, produire des hallucinations. De plus, ils ne peuvent pas interagir avec le monde extérieur par eux-mêmes.

Comme les agents IA sont alimentés par des LLM, ils héritent de toutes ces limites. Mais les agents ont aussi un gros avantage : ils peuvent utiliser des outils ! Ces outils leur permettent d’appeler des services et des systèmes externes, ce qui élargit leurs capacités, qui seraient autrement limitées aux LLM.

Le SDK Claude Agent fournit aux agents un ensemble d’outils intégrés par défaut pour travailler avec des fichiers, exécuter des commandes, effectuer des recherches sur le web, modifier du code, etc.

Il introduit également une approche distinctive de la définition d’outils personnalisés. Dans le SDK Claude Agent, les outils personnalisés sont implémentés en tant que serveurs MCP en cours de traitement. Cela n’a rien de surprenant, étant donné que MCP est défini par Anthropic, la société à l’origine de Claude.

Bien que les outils par défaut du SDK Claude Agent soient utiles, ils ne sont pas toujours suffisants pour les cas d’utilisation de niveau production. Dans la pratique, il est préférable d’intégrer des fournisseurs tiers spécialisés conçus pour pallier les limites courantes des LLM, telles que des connaissances obsolètes et une interaction limitée avec le web en direct.

C’est là que le Bright Data Web MCP entre en jeu !

Présentation du Bright Data Web MCP

Les outils personnalisés du SDK Claude Agent s’exécutent en arrière-plan sur MCP. Il est donc logique d’étendre les builds d’agents avec un MCP qui fournit déjà un ensemble complet d’outils prêts à l’emploi.

Le Web MCP de Bright Data fournit plus de 60 outils prêts pour l’IA pour la collecte automatisée de données web, l’extraction de données structurées et les interactions au niveau du navigateur. Il est disponible à la fois comme service distant et comme serveur local, soutenu par un référentiel public avec plus de 2 000 étoiles GitHub.

Même dans sa version gratuite, le serveur MCP propose deux outils particulièrement utiles (ainsi que leurs variantes par lots) :

Outil	Description
`search_engine`	Récupère 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, en contournant les mesures anti-bot.

C’est en mode Pro que Web MCP révèle tout son potentiel, en débloquant des outils premium pour l’extraction de données structurées à partir de plateformes telles qu’Amazon, LinkedIn, Yahoo Finance, YouTube, TikTok, Zillow, Google Maps et bien d’autres encore. De plus, il permet à n’importe quel agent IA de naviguer sur le web et d’interagir avec les pages web comme le ferait un utilisateur humain.

Voyons maintenant comment intégrer Bright Data Web MCP dans le SDK Claude Agent !

Comment connecter le SDK Claude Agent aux outils de Bright Data via Web MCP

Dans ce guide étape par étape, vous apprendrez comment intégrer les services Bright Data à un agent IA créé avec le SDK Claude Agent via MCP. Plus précisément, vous connecterez le Web MCP de Bright Data à un agent IA SDK Claude Agent, lui donnant ainsi accès à toute la gamme d’outils de données web disponibles.

Remarque: le SDK Claude Agent est également disponible en TypeScript. La section suivante peut être facilement convertie de Python en JavaScript ou TypeScript en se référant à la documentation officielle.

Suivez les instructions ci-dessous !

Prérequis

Pour suivre ce tutoriel, assurez-vous de remplir les conditions suivantes :

Python 3.10 ou version ultérieure installé localement.
Claude Code installé sur votre machine.
Une clé API Claude avec des crédits disponibles.
Un compte Bright Data avec une clé API.

Remarque: vous serez guidé tout au long du processus de configuration de votre compte Bright Data pour l’utilisation de Web MCP dans une section dédiée plus loin dans le tutoriel.

N’oubliez pas que le SDK Claude Agent utilise Claude Code comme environnement d’exécution, c’est pourquoi Claude Code doit être installé localement. Pour obtenir des instructions détaillées, consultez notre guide sur l’intégration de Claude Code + Bright Data Web MCP.

Enfin, une connaissance de base du protocole MCP et des outils fournis par le Web MCP vous sera utile.

Étape n° 1 : Configurer un projet Claude Agent SDK en Python

Commencez par vérifier que Claude Code est installé sur votre machine. Exécutez la commande suivante :

claude --version

Vous devriez obtenir un résultat similaire à :

2.1.29 (Claude Code)

Si c’est le cas, tant mieux ! Cela confirme que la principale condition préalable à l’utilisation du SDK Claude Agent est remplie.

Ensuite, créez un répertoire de projet. Accédez-y depuis votre terminal :

mkdir claude-agent-sdk-bright-data-IA-agent
cd claude-agent-sdk-bright-data-IA-agent

Maintenant, initialisez un environnement virtuel à l’intérieur du projet :

python -m venv .venv

Créez un nouveau fichier appelé agent.py à la racine du projet, qui devrait maintenant ressembler à ceci :

claude-agent-sdk-bright-data-IA-agent/
├── .venv/
└── agent.py

Le fichier agent.py contiendra la logique de votre agent IA, construit avec le SDK Claude Agent et interagissant avec le MCP Web Bright Data.

Ouvrez le dossier du projet dans votre IDE Python préféré. Par exemple, chargez-le dans PyCharm Community Edition ou Visual Studio Code avec l’extension Python.

Activez maintenant l’environnement virtuel que vous avez créé précédemment. Sous Linux ou macOS, exécutez :

source .venv/bin/activate

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

.venv/Scripts/activate

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

pip install claude-agent-sdk python-dotenv

Les dépendances pour cette application sont les suivantes :

claude-agent-sdk: pour créer des agents IA en Python via le SDK Claude Agent.
python-dotenv: pour charger des secrets (tels que votre clé API Claude et votre clé API Bright Data) à partir d’un fichier .env local.

Tout est prêt ! Votre environnement Python est désormais prêt pour créer des agents IA avec le SDK Claude Agent.

Étape n° 2 : préparation du chargement des variables d’environnement

Votre agent IA se connectera à des services tiers, tels que Bright Data et (évidemment) Claude. Pour ce faire, vous devez utiliser les clés API associées à vos comptes sur ces services. Il est recommandé de ne jamais coder en dur les informations d’identification directement dans votre code source.

Vous devez plutôt charger les clés API requises à partir d’un fichier .env. C’est exactement pour cette raison que vous avez installé python-dotenv à l’étape précédente. Commencez par importer la bibliothèque dans votre fichier agent.py:

from dotenv import load_dotenv

Ensuite, créez un fichier .env à la racine du projet :

claude-agent-sdk-bright-data-IA-agent/
├─── .venv/
├─── agent.py
└─── .env # <-----

Le fichier .env stockera votre clé API Claude et votre clé API Bright Data, qui sont les deux secrets requis pour ce projet.

Maintenant, chargez les variables d’environnement à partir du fichier .env en appelant la fonction suivante dans agent.py:

load_dotenv()

Parfait ! Votre script peut lire en toute sécurité les informations d’identification sensibles à partir des variables d’environnement, sans les inclure dans votre base de code.

Étape n° 3 : démarrer avec le SDK Claude Agent

Dans agent.py, ajoutez le code suivant pour créer un agent IA simple à l’aide du SDK Claude Agent :

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions
from claude_agent_sdk.types import StreamEvent

async def main():
    # Configurer l'agent Claude
    options = ClaudeAgentOptions(
        model="claude-haiku-4-5",     # Remplacer par votre modèle Claude préféré
        include_partial_messages=True # Activer les réponses en streaming
    )

    # L'invite envoyée à l'agent
    prompt = "Salut ! Comment ça va ?"

    # Boucle agentique : diffuse les événements renvoyés par le SDK Claude Agent
    async for message in query(prompt=prompt, options=options):
        # Intercepter uniquement les événements en streaming
        if isinstance(message, StreamEvent):
            event = message.event
            event_type = event.get("type")

            # Gérer la sortie de texte incrémentielle
            if event_type == "content_block_delta" :
                delta = event.get("delta", {})

                if delta.get("type") == "text_delta" :
                    # Imprimer le texte diffusé à mesure qu'il arrive
                    print(delta.get("text", ""), end="", flush=True)

asyncio.run(main())

Ce script comporte trois éléments principaux :

options: configure l’agent. Dans cet exemple, l’agent utilise le modèle Claude Haiku 4.5 et active les réponses en continu, ce qui permet d’imprimer la sortie de manière incrémentielle.
invite: définit ce que vous voulez que l’agent IA Claude fasse. Claude décide automatiquement comment traiter la tâche en fonction de cette entrée.
query: point d’entrée principal qui lance la boucle de l’agent. Il renvoie un itérateur asynchrone, c’est pourquoi vous utilisez async for pour diffuser les messages pendant que Claude raisonne, appelle des outils, observe les résultats et produit des sorties.

La boucle async for continue de s’exécuter pendant que Claude « réfléchit ». Chaque itération peut produire différents types de messages, tels que des étapes de raisonnement, des appels d’outils, des résultats d’outils ou la réponse finale. Dans cet exemple, vous ne diffusez en continu que le texte final vers le terminal.

Pour fonctionner correctement, le SDK Claude Agent nécessite l’accès à l’API Claude. Par défaut, il lit la clé API à partir de la variable d’environnement ANTHROPIC_API_KEY. Ajoutez-la donc à votre fichier .env comme suit :

ANTHROPIC_API_KEY="<VOTRE_ANTHROPIC_API_KEY>"

Remplacez <VOTRE_CLÉ_ANTHROPIC_API_KEY> par votre clé API Anthropic Claude réelle.

Remarque: si votre agent Claude Agent SDK ne peut pas accéder à la clé API, il échouera avec l’erreur suivante :

Votre organisation n'a pas accès à Claude. Veuillez vous reconnecter ou contacter votre administrateur.

En tenant compte du code de l’étape précédente, démarrez l’agent en exécutant :

python agent.py

Dans votre terminal, vous devriez voir une réponse en continu similaire à celle-ci :
The streamed response produced by the AI agent
Parfait ! La réponse correspond à l’invite de saisie, ce qui signifie que l’agent IA alimenté par le SDK Claude Agent fonctionne parfaitement.

Étape n° 4 : lancez-vous avec le Web MCP de Bright Data

N’oubliez pas que les outils personnalisés du SDK Claude Agent sont implémentés via des serveurs MCP en cours de traitement. C’est pourquoi il est logique de connecter votre agent IA directement à une instance de serveur Bright Data Web MCP.

Après tout, définir des outils personnalisés en les intégrant directement aux services Bright Data, puis les exposer via MCP n’aurait pas beaucoup de sens. En effet, il existe déjà un serveur MCP officiel (et largement utilisé !).

Dans cette section, nous allons vous montrer comment vous connecter à une instance locale. Parallèlement, vous pouvez également vous connecter à des serveurs Web MCP distants pour des configurations plus évolutives et adaptées aux entreprises.

Avant de connecter le SDK Claude Agent au Web MCP de Bright Data, vérifiez que le serveur MCP peut fonctionner sur votre machine !

Commencez par créer un compte Bright Data. Si vous en avez déjà un, connectez-vous simplement. Pour une configuration rapide, suivez l’assistant dans la section «MCP »de votre tableau de bord :
The “MCP” section in your Bright Data account
Sinon, pour obtenir des conseils supplémentaires, reportez-vous aux instructions ci-dessous.

Commencez par générer votre clé API Bright Data. Vous utiliserez bientôt la clé API pour authentifier votre instance Web MCP locale avec votre compte Bright Data. Comme vous devrez y accéder dans votre code, ajoutez-la à votre fichier .env avec :

BRIGHT_DATA_API_KEY="<VOTRE_CLÉ_API_BRIGHT_DATA>"

Ensuite, chargez-la dans votre fichier agent.py:

import os

BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

Poursuivez en installant Web MCP globalement via le package @brightdata/mcp:

npm install -g @brightdata/mcp

Sous Linux/macOS, vérifiez que le serveur MCP fonctionne localement avec :

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

Ou, de manière équivalente, dans PowerShell :

$Env: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. Ces commandes (équivalentes) définissent la variable d’environnement API_TOKEN requise et démarrent le serveur Web MCP localement.

Si l’opération réussit, vous devriez recevoir des journaux similaires à ceux ci-dessous :
Bright Data's Web MCP startup logs

Lors du premier lancement, le package Web MCP configure automatiquement deux zones dans votre compte Bright Data :

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

Ces deux zones alimentent les plus de 60 outils disponibles dans Web MCP. Notez que vous pouvez également remplacer les noms par défaut des deux zones, comme expliqué dans la documentation.

Si vous souhaitez vérifier qu’elles ont bien été créées, rendez-vous sur la page «Proxies & Infrastructure de scraping »(Proxys etInfrastructurede scraping) de votre tableau de bord Bright Data. Vous devriez voir les deux zones répertoriées dans le tableau « My Zones » (Mes zones) :
The mcp_unlocker and mcp_browser zones created by the Web MCP at startup

N’oubliez pas que le niveau gratuit de Web MCP ne vous donne accès qu’aux outils search_engine et scrape_as_markdown (et à leurs versions batch).

Pour débloquer les plus de 60 outils, vous devez activer le mode Pro en définissant la variable d’environnement PRO_MODE="true":

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

Ou, sous Windows :

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

Important: le mode Pro n’est pas inclus dans l’offre gratuite et entraîne des frais supplémentaires.

Parfait ! Vous êtes désormais certain que le serveur Web MCP fonctionne sur votre machine. Vous allez maintenant configurer le SDK Claude Agent pour démarrer automatiquement le serveur et vous y connecter.

Étape n° 5 : connecter le SDK Claude Agent au Web MCP

Le SDK Claude Agent prend en charge les connexions MCP via l’option mcp_servers de la classe ClaudeAgentOptions. Cela permet à votre agent de communiquer directement avec le Web MCP de Bright Data.

Pour vous connecter au Web MCP, mettez à jour votre variable options comme suit :

options = ClaudeAgentOptions(
    # Se connecter au Web MCP de Bright Data
    mcp_servers={
        "bright_data": {
            "command": "npx",
            "args": ["-y", "@brightdata/mcp"],
            "env": {
                "API_TOKEN": BRIGHT_DATA_API_KEY,
                "PRO_MODE": "true" # Pour activer le mode Pro
            }
        }
    },
    allowed_tools=["mcp__bright_data__*"], # Activer tous les outils Web MCP de Bright Data 
    model="claude-haiku-4-5", # Remplacer par votre modèle Claude préféré
    include_partial_messages=True, # Activer les réponses en streaming
)

Cette configuration reflète la commande npx que vous avez testée précédemment, en transmettant les informations d’identification et la configuration via des variables d’environnement :

API_TOKEN: requis pour l’authentification. Définissez cette variable sur votre clé API Bright Data.
PRO_MODE: requis pour activer le mode Pro.

Important: le champ allowed_tools utilise un caractère générique pour autoriser tous les outils du serveur bright_data configuré. Sans cela, l’agent alimenté par Claude peut voir les outils, mais ne peut pas les utiliser.

Si vous préférez ne pas spécifier l’option mcp_servers dans le code, vous pouvez également créer un fichier .mcp.json à la racine de votre projet avec la structure suivante :

{
  "mcpServers": {
    "bright_data": {
        "command": "npx",
        "args": ["-y", "@brightdata/mcp"],
        "env": {
            "API_TOKEN": "<YOUR_BRIGHT_DATA_API_KEY>",
            "PRO_MODE": "true"
        }
    }
  }
}

Pour vérifier la connexion Web MCP, testez l’agent à l’aide d’une invite simple :

prompt = « À quel outil Bright Data MCP avez-vous accès ? »

En mode Pro (PRO_MODE="true"), la réponse devrait répertorier les plus de 60 outils disponibles, comme ceci :
The Web MCP tools listed by the AI agent
Votre agent peut désormais voir et utiliser tous les outils de haut niveau disponibles sur le serveur Web MCP. Mission accomplie ! Votre agent IA, créé avec le SDK Claude Agent, est désormais enrichi des capacités de données Web de Bright Data via les outils Web MCP.

Étape n° 6 : Exécuter l’agent

Pour démontrer l’efficacité d’un agent IA lorsqu’il est intégré au Bright Data Web MCP, vous devez disposer de la bonne invite. En particulier, l’invite doit impliquer la récupération de données web et/ou l’interaction web.

Par exemple, imaginez que vous souhaitiez créer un agent IA qui surveille les sites web de vos concurrents en prenant automatiquement des captures d’écran et en extrayant le texte des pages. Il s’agit d’une tâche qu’un agent IA standard ne peut pas effectuer seul sans les outils appropriés.

Supposons que Nike soit votre concurrent. Vous pourriez écrire une invite telle que :

prompt = """
Ouvrez une session de Navigateur de scraping et accédez à la page Web suivante :
« https://www.nike.com/ »
Attendez que la page se charge complètement, puis capturez une capture d'écran de la page entière. Extrayez également le texte de la page entière. Enregistrez la capture d'écran dans un fichier local « screenshot.png » et le texte de la page dans un fichier local « text.txt ».
"""

Grâce aux capacités de navigation disponibles dans les outils premium Bright Data Web MCP, l’agent IA peut désormais :

Ouvrir une session de navigation à distance dans le cloud via l’API du navigateur, en contournant les protections anti-bot courantes et en accédant à pratiquement n’importe quelle page web.
Attendre que la page se charge complètement.
Capturer une capture d’écran de la page entière et extraire tout le texte visible.

Enfin, l’agent utilise les outils intégrés fournis par le SDK Claude Agent pour enregistrer le résultat généré sur le disque comme demandé.

Notez que pour activer la gestion des images et l’écriture sur disque, vous aurez également besoin des deux options supplémentaires suivantes :

options = ClaudeAgentOptions(
    # ...
    permission_mode="acceptEdits", # Pour permettre à l'agent d'écrire des fichiers sur le disque
    max_buffer_size=10 * 1024 * 1024, # Augmenter à 10 Mo pour la gestion des images
)

Étant donné que l’exécution de l’agent impliquera l’utilisation d’outils, il est logique de mettre à jour la logique de streaming afin d’intercepter également les événements liés aux appels d’outils. Mettez à jour votre boucle async for comme suit :

# Suivre l'outil actuel et accumuler son entrée JSON
current_tool = None
tool_input = ""

# Boucle agentique : diffuse les événements renvoyés par le SDK Claude Agent
async for message in query(prompt=prompt, options=options):
     # Intercepter uniquement les événements de streaming
    if isinstance(message, StreamEvent):
        event = message.event
        event_type = event.get("type")

        if event_type == "content_block_start":
            # Un nouvel appel d'outil démarre
            content_block = event.get("content_block", {})
            if content_block.get("type") == "tool_use":
                current_tool = content_block.get("name")
                tool_input = ""
                print(f"nDémarrage de l'outil : {current_tool}")

        # Gestion de la sortie de texte incrémentielle
        elif event_type == "content_block_delta":
            delta = event.get("delta", {})
            if delta.get("type") == "text_delta":
                 # Impression du texte diffusé à mesure qu'il arrive
                print(delta.get("text", ""), end="", flush=True)
            elif delta.get("type") == "input_json_delta" :
                # Accumuler les entrées JSON au fur et à mesure de leur transmission
                chunk = delta.get("partial_json", "")
                tool_input += chunk

        elif event_type == "content_block_stop" :
            # Appel de l'outil terminé (afficher l'entrée finale)
            if current_tool :
                print(f"Outil {current_tool} appelé avec : {tool_input}")
                current_tool = None

Cette logique vous aidera à mieux comprendre les outils appelés par l’agent et leurs entrées respectives. Génial ! Il ne reste plus qu’à tester l’agent.

Étape n° 7 : tester l’agent IA

Votre fichier agent.py final contiendra :

from dotenv import load_dotenv
import os
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions
from claude_agent_sdk.types import StreamEvent

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

# Accéder à la variable d'environnement de la clé API Bright Data
BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY")

async def main():
    options = ClaudeAgentOptions(
        # Se connecter au Web MCP de Bright Data
        mcp_servers={
            "bright_data": {
                "command": "npx",
                "args": ["-y", "@brightdata/mcp"],
                "env": {
                    "API_TOKEN": BRIGHT_DATA_API_KEY,
                    "PRO_MODE": "true"  # Pour activer le mode Pro
                }
            }
        },
allowed_tools=["mcp__bright_data__*"],  # Activer tous les outils Web MCP de Bright Data
model="claude-haiku-4-5",     # Remplacer par votre modèle Claude préféré
include_partial_messages=True, # Activer les réponses en continu
permission_mode="acceptEdits", # Pour permettre à l'agent d'écrire des fichiers sur le disque
        max_buffer_size=10 * 1024 * 1024, # Augmenter à 10 Mo pour le traitement des images
    )

     # L'invite envoyée à l'agent
    prompt = """
    Ouvrez une session de Navigateur de scraping et accédez à la page Web suivante :
    "https://www.nike.com/"
    Attendez que la page soit entièrement chargée, puis capturez une capture d'écran de la page entière. Extrayez également l'intégralité du texte de la page. Enregistrez la capture d'écran dans un fichier local `screenshot.png` et le texte de la page dans un fichier local `text.txt`.
    """

    # Suivez l'outil actuel et accumulez ses entrées JSON
    current_tool = None
    tool_input = ""

    # Boucle agentique : diffuse les événements renvoyés par le SDK Claude Agent
    async for message in query(prompt=prompt, options=options):
         # Intercepte uniquement les événements en streaming
        if isinstance(message, StreamEvent):
            event = message.event
            event_type = event.get("type")

            if event_type == "content_block_start":
                # Un nouvel appel d'outil démarre
                content_block = event.get("content_block", {})
                if content_block.get("type") == "tool_use":
                    current_tool = content_block.get("name")
                    tool_input = ""
                    print(f"nDémarrage de l'outil : {current_tool}")

            # Traitement de la sortie de texte incrémentielle
            elif event_type == "content_block_delta":
                delta = event.get("delta", {})
                if delta.get("type") == "text_delta":
                     # Impression du texte diffusé à mesure qu'il arrive
                    print(delta.get("text", ""), end="", flush=True)
                elif delta.get("type") == "input_json_delta" :
                    # Accumuler les entrées JSON au fur et à mesure de leur transmission
                    chunk = delta.get("partial_json", "")
                    tool_input += chunk

            elif event_type == "content_block_stop" :
                # Appel de l'outil terminé (afficher l'entrée finale)
                if current_tool :
                    print(f"Outil {current_tool} appelé avec : {tool_input}")
                    current_tool = None

asyncio.run(main())

Lancez-le avec :

python agent.py

Si vous exécutez l’agent, vous devriez voir un résultat similaire à celui-ci :
The initial output produced by the AI agent

Comme vous pouvez le voir, l’agent se connecte au Web MCP et utilise les outils suivants :

mcp__bright_data__scraping_browser_screenshot pour capturer une capture d’écran pleine page
mcp__bright_data__scraping_browser_get_text pour extraire tout le texte de la page Web

Il utilise ensuite l’outil « Write » pour enregistrer le résultat dans les fichiers demandés. Après l’exécution, le dossier racine de votre projet devrait maintenant contenir les fichiers screenshot.png et text.txt:
The files produced by the agent
Ouvrez screenshot.png pour voir la capture d’écran pleine page de la page d’accueil Nike cible :
Note the Nike home page's screenshot taken by the agent

Ouvrez text.txt pour afficher le texte extrait de la page ci-dessus :
The text extracted from the page
Et voilà ! Votre agent IA, orchestré via le SDK Claude Agent et étendu avec Bright Data Web MCP, peut désormais gérer la navigation sur le Web et bien plus encore!

Conclusion

Dans ce tutoriel, vous avez appris à tirer parti des outils personnalisés via l’intégration MCP dans le SDK Claude Agent pour créer des agents IA étendus. Plus précisément, vous avez vu pourquoi et comment améliorer un agent IA alimenté par le SDK Python Claude Agent en le connectant au Web MCP de Bright Data.

Cette intégration dote votre agent IA alimenté par Claude de puissantes capacités telles que la recherche sur le Web, l’extraction de données structurées, la récupération de données Web en direct et les interactions Web automatisées, ce qui permet un large éventail de cas d’utilisation de l’agent.

Inscrivez-vous gratuitement dès aujourd’hui pour obtenir un compte Bright Data et découvrez les outils de données web prêts pour l’IA !

Contacter Ventes Essai gratuit