Intégration de Google ADK avec un serveur MCP pour le développement d’agents d’intelligence artificielle

Dans ce guide, vous verrez :

• Ce qu’est la bibliothèque Google ADK pour la construction d’agents d’intelligence artificielle.
• Pourquoi sa prise en charge native de MCP en fait un produit spécial.
• Comment l’intégrer au serveur MCP de Bright Data pour créer un agent d’IA extrêmement puissant ?

Plongeons dans l’aventure !

Qu’est-ce que Google ADK ?

Google ADK, abréviation de Google Agent Development Kit, est un framework Python open-source pour la construction et le déploiement d’agents d’intelligence artificielle. Bien qu’il soit optimisé pour Gemini et l’écosystème Google au sens large, il reste indépendant des modèles et des déploiements.

ADK met l’accent sur l’expérience du développeur, en offrant des outils et des structures de données qui facilitent la construction de puissants systèmes multi-agents. Il vous permet de définir des agents d’intelligence artificielle capables de raisonner, de collaborer et d’interagir avec le monde au moyen d’outils et d’intégrations.

L’objectif ultime de Google ADK est de faire en sorte que le développement d’agents ressemble davantage au développement de logiciels traditionnels. Pour ce faire, il simplifie le processus de création, de déploiement et d’orchestration des architectures agentiques.

Ce qui fait la spécificité de Google ADK

Par rapport à d’autres bibliothèques de création d’agents d’IA, Google ADK se distingue par sa prise en charge intégrée de MCP (Managed Connectivity Platform). Si vous ne le savez pas, MCP est un moyen normalisé permettant aux modèles d’IA d’interagir avec des outils et des sources de données externes, tels que les API, les bases de données et les systèmes de fichiers.

En termes plus simples, MCP permet à votre agent Google ADK d’exploiter les capacités de n’importe quel serveur compatible MCP. Il s’agit d’une intégration plug-and-play qui étend votre agent d’intelligence artificielle au-delà des limites du LLM sous-jacent en lui donnant accès à des données et à des actions du monde réel.

Cette option offre un moyen structuré, sécurisé et évolutif de connecter votre agent à des capacités externes, sans que vous ayez à créer ces connexions à partir de zéro. L’intégration MCP devient particulièrement intéressante lorsqu’elle est intégrée à un serveur MCP riche tel que le serveur MCP de Bright Data.

Ce serveur MCP fonctionne sur Node.js et se connecte de manière transparente à tous les puissants outils d’extraction de données d’IA de Bright Data. Ces outils permettent à votre agent d’interagir avec des données web en direct, des ensembles de données structurées et des capacités de scraping.

À ce jour, les outils MCP pris en charge sont les suivants :

Pour une autre intégration possible, voir notre article sur le web scraping à l’aide des serveurs MCP.

Remarque: de nouveaux outils sont régulièrement ajoutés au serveur MCP de Bright Data, ce qui le rend de plus en plus puissant et riche en fonctionnalités au fil du temps.

Découvrez comment tirer parti de ces outils avec Google ADK !

Comment intégrer Google ADK au serveur MCP de Bright Data ?

Dans cette section du tutoriel, vous apprendrez à utiliser Google ADK pour construire un puissant agent d’intelligence artificielle. Celui-ci sera équipé de capacités de scraping, d’extraction et de transformation de données en direct fournies par le serveur MCP de Bright Data.

Cette configuration a été initialement mise en œuvre par Meir Kadosh, alors n’oubliez pas de consulter son dépôt GitHub original.

Plus précisément, l’agent d’intelligence artificielle sera capable de.. :

1. Récupérer les URL des moteurs de recherche.
2. Récupérer le texte de ces pages web.
3. Générer des réponses basées sur la source en utilisant les données extraites.

Remarque: en modifiant les invites dans le code, vous pouvez facilement adapter l’agent d’intelligence artificielle à tout autre scénario ou cas d’utilisation.

Suivez les étapes ci-dessous pour créer votre agent Google ADK alimenté par Bright Data MCP en Python !

Conditions préalables

Pour suivre ce tutoriel, vous avez besoin de :

• Python 3.9 ou supérieur installé localement.
• Node.js installé localement.
• Un système basé sur UNIX, tel que Linux ou macOS, ou le WSL(Windows Subsystem for Linux).

Remarque: l’intégration de Google ADK avec le serveur MCP de Bright Data ne fonctionne actuellement pas de manière native sous Windows. Toute tentative d’exécution peut entraîner une erreur NotImplementedError dans cette section du code :

transport = await self._make_subprocess_transport(
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        protocol, popen_args, False, stdin, stdout, stderr,
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        bufsize, **kwargs)
        ^^^^^^^^^^^^^^^^^^
    raise NotImplementedError

Pour cette raison, le tutoriel suppose que vous utilisez Linux, macOS ou le WSL.

Vous aurez également besoin de

• Un compte Bright Data
• Une clé API Gemini

Ce tutoriel vous guidera dans la configuration des identifiants Gemini et Bright Data lorsque cela est nécessaire. Ne vous en préoccupez donc pas pour l’instant.

Bien qu’ils ne soient pas obligatoires, les éléments suivants vous aideront à tirer le meilleur parti de ce didacticiel :

• Une idée générale du fonctionnement du GPE.
• Une compréhension de base du fonctionnement de Google ADK.
• Familiarité avec le serveur MCP de Bright Data et ses outils disponibles.
• Une certaine expérience de la programmation asynchrone en Python.

Étape 1 : Configuration du projet

Ouvrez votre terminal et créez un nouveau dossier pour votre agent de scraping :

mkdir google_adk_mcp_agent

Le dossier google_adk_mcp_agent contiendra tout le code de votre agent IA Python.

Ensuite, naviguez dans le dossier du projet et créez un environnement virtuel à l’intérieur de celui-ci :

cd google_adk_mcp_agent
python3 -m venv .venv

Ouvrez le dossier du projet dans votre IDE Python préféré. Nous recommandons d’utiliser Visual Studio Code avec l’extension Python ou PyCharm Community Edition.

Dans google_adk_mcp_agent, créez un sous-dossier nommé web_search_agent. Ce sous-dossier contiendra la logique de base de votre agent et devrait inclure les deux fichiers suivants :

• __init__.py: Exporte la logique de agent.py.
• agent.py: Contient la définition de l’agent Google ADK.

Il s’agit de la structure de dossier nécessaire au bon fonctionnement de la bibliothèque Google ADK:

Maintenant, initialisez le fichier __init__.py avec la ligne suivante :

from . import agent

Au lieu de cela, le fichier agent.py sera bientôt défini avec la logique de l’agent AI.

Dans le terminal de l’IDE, activer l’environnement virtuel. Sous Linux ou macOS, exécuter cette commande :

./.venv/bin/activate

De manière équivalente, sous Windows, lancez :

.venv/Scripts/activate

Vous êtes prêt ! Vous disposez maintenant d’un environnement Python pour créer un agent d’intelligence artificielle à l’aide de l’ADK de Google et du serveur MCP de Bright Data.

Étape 2 : Configurer les variables d’environnement Lecture

Votre projet interagira avec des services tiers tels que Gemini et Bright Data. Plutôt que de coder en dur les clés d’API et les secrets d’authentification directement dans votre code Python, il est préférable de les charger à partir de variables d’environnement.

Pour simplifier cette tâche, nous utiliserons la bibliothèque python-dotenv. Avec votre environnement virtuel activé, installez-la en exécutant :

pip install python-dotenv

Dans votre fichier agent.py, importez la bibliothèque et chargez les variables d’environnement avec load_dotenv() :

from dotenv import load_dotenv

load_dotenv()

Cela vous permet de lire des variables à partir d’un fichier .env local. Ajoutez donc un fichier .env à votre répertoire d’agents imbriqués :

Vous pouvez maintenant lire les variables d’environnement dans votre code avec cette ligne de code :

env_value = os.getenv("<ENV_NAME>")

N’oubliez pas d’importer le module os de la bibliothèque standard de Python :

import os

C’est très bien ! Vous êtes maintenant prêt à lire les secrets de l’env pour intégrer en toute sécurité des services tiers.

Étape 3 : Démarrer avec Google ADK

Dans votre environnement virtuel activé, installez la bibliothèque Google ADK Python en exécutant :

pip install google-adk

Ensuite, ouvrez agent.py et ajoutez les importations suivantes :

from google.adk.agents import Agent, SequentialAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters

Ils seront utilisés dans les étapes suivantes pour l’intégration de Google ADK.

N’oubliez pas que Google ADK nécessite une intégration avec un fournisseur d’IA. Dans le cas présent, nous utiliserons Gemini, car la bibliothèque est optimisée pour les modèles d’IA de Google.

Si vous n’avez pas encore obtenu votre clé API, suivez la documentation officielle de Google. Connectez-vous à votre compte Google et accédez à Google AI Studio. Naviguez ensuite jusqu’à la section“Get API Key“(Obtenir une clé API), et vous verrez cette fenêtre modale :

Cliquez sur le bouton “Get API key”. Dans l’écran suivant, cliquez sur le bouton “Créer une clé API” :

Une fois générée, votre clé s’affichera dans une fenêtre modale :

Copiez la clé et conservez-la en lieu sûr. Notez qu’avec la même clé, vous pouvez effectuer du web scraping avec Gemini.

Remarque: la version gratuite de Gemini est suffisante pour ce tutoriel. Le niveau payant n’est nécessaire que si vous avez besoin de limites de débit plus élevées ou si vous ne souhaitez pas que vos invites et vos réponses soient utilisées pour améliorer les produits Google. Reportez-vous à la page de facturation de Gemini.

Maintenant, initialisez votre fichier .env avec les variables d’environnement suivantes :

GOOGLE_GENAI_USE_VERTEXAI="False"
GOOGLE_API_KEY="<YOUR_GEMINI_API_KEY>"

Remplacer par la clé que vous venez de générer. Aucun code supplémentaire n’est nécessaire dans agent.py car la bibliothèque google-adk recherche automatiquement la variable d’environnement GOOGLE_API_KEY.

De même, le paramètre GOOGLE_GENAI_USE_VERTEXAI détermine si Google ADK doit s’intégrer à Vertex AI. Donnez-lui la valeur "False" pour utiliser directement l’API Gemini.

C’est incroyable ! Vous pouvez maintenant utiliser Gemini dans Google ADK. Continuons avec la configuration initiale de la solution tierce requise pour l’intégration.

Étape 4 : configuration du serveur MCP de Bright Data

Si vous ne l’avez pas encore fait, [créez un compte Bright Data](). Si vous en avez déjà un, il vous suffit de vous connecter.

Ensuite, suivez les instructions officielles pour :

1. Récupérez votre clé API Bright Data.
2. Configurer Web Unlocker et Scraping Browser pour l’intégration MCP.

Vous obtiendrez ainsi

• Un jeton d’API Bright Data.
• Une zone Web Unlocker (ici, nous supposerons qu’elle porte le nom par défaut, à savoir mcp_unlocker).
• Récupération des informations d’authentification du navigateur au format : <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Vous êtes maintenant prêt à installer le serveur MCP de Bright Data globalement dans votre environnement Node.js avec :

npm install -g @brightdata/mcp

Ensuite, lancez le serveur MCP via le paquetage @brightdata/mcp npm avec :

API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>" \
BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>" \
npx -y @brightdata/mcp

La commande ci-dessus définit les variables d’environnement requises(API_TOKEN et BROWSER_AUTH) et démarre le serveur MCP localement. Si tout est configuré correctement, vous devriez voir un message indiquant que le serveur fonctionne correctement :

Checking for required zones...
Required zone "mcp_unlocker" already exists
Starting server...

Génial ! Le serveur MCP de Bright Data fonctionne comme un charme.

Ajoutez ces variables d’environnement à votre fichier .env à la racine de votre projet Google ADK :

BRIGHT_DATA_API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>"
BRIGHT_DATA_BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>"

Remplacer les espaces réservés par les valeurs réelles.

Ensuite, lisez ces envs dans votre code avec :

BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

C’est parfait ! Vous avez maintenant tout ce qu’il faut pour intégrer le serveur MCP de Bright Data à Google ADK. Mais tout d’abord, il est temps de définir les agents d’intelligence artificielle.

Étape 5 : Définir les agents

Comme mentionné dans l’introduction, l’agent Google ADK alimenté par MCP agira en tant qu’agent de résumé de contenu. Son objectif principal est de prendre les données d’un utilisateur et de lui renvoyer un résumé de haute qualité et bien sourcé.

En détail, l’agent suivra le processus suivant :

1. Interpréter la demande de l’utilisateur et la décomposer en requêtes de recherche de type Google.
2. Traiter les requêtes de recherche à l’aide d’un sous-agent qui

   :Polylang placeholder do not modify

3. Générer un rapport Markdown en réponse à la requête initiale de l’utilisateur. Le processus utilisera le contenu fraîchement recueilli comme source et inclura des liens pour une lecture plus approfondie.

Comme le processus se décompose naturellement en trois étapes distinctes, il est logique de diviser l’agent IA de haut niveau en trois sous-agents :

• Planificateur: Convertit les sujets complexes en requêtes de recherche bien formées.
• Chercheur: Il exécute les recherches et extrait des informations utiles des pages web qui en résultent.
• Éditeur: Synthétise la recherche dans un document bien écrit et structuré.

Mettez en œuvre ces trois agents dans Google ADK à l’aide du code Python suivant :

• Planificateur :

def create_planner_agent():
    return Agent(
        name="planner",
        model="gemini-2.0-flash",
        description="Breaks down user input into focused search queries for research purposes.",
        instruction="""
        You are a research planning assistant. Your task is to:
        1. Analyze the user's input topic or question.
        2. Break it down into 3 to 5 focused and diverse search engine-like queries that collectively cover the topic.
        3. Return your output as a JSON object in the following format:

        {
            "queries": ["query1", "query2", "query3"]
        }

        IMPORTANT:
        - The queries should be phrased as if typed into a search engine.
        """,
        output_key="search_queries"
    )

• Chercheur :

def create_researcher_agent(mcp_tools):
    return Agent(
        name="researcher",
        model="gemini-2.0-flash",
        description="Performs web searches and extracts key insights from web pages using the configured tools.",
        instruction="""
        You are a web research agent. Your task is to:
        1. Receive a list of search queries from the planner agent.
        2. For each search query, apply the `search_engine` tool to get Google search results.
        3. From the global results, select the top 3 most relevant URLs.
        4. Pass each URL to the `scraping_browser_navigate` tool.
        5. From each page, use the `scraping_browser_get_text` tool to extract the main page content.
        6. Analyze the extracted text and summarize the key insights in the following JSON format:
        [
            {
                "url": "https://example.com",
                "insights": [
                    "Main insight one",
                    "Main insight two"
                ]
            },
            ...
        ]

        IMPORTANT:
        - You are only allowed to use the following tools: `search_engine`, `scraping_browser_navigate`, and `scraping_browser_get_text`.
        """,
        tools=mcp_tools
    )

Remarque: l’argument d’entrée mcp_tools est une liste qui spécifie les outils MCP avec lesquels l’agent peut interagir. Dans l’étape suivante, vous verrez comment remplir cette liste à l’aide des outils fournis par le serveur MCP de Bright Data.

• L’éditeur :
  “python
  def create_publisher_agent() :
  return Agent(
  name=”publisher”,
  model=”gemini-2.0-flash”,
  description=”Synthétise les résultats de la recherche dans un document final complet et bien structuré”,
  instruction=”””
  Vous êtes un expert en rédaction. Votre tâche consiste à prendre les résultats de recherche structurés de l’agent scrapeur et à rédiger un rapport clair, perspicace et bien organisé. LIGNES DIRECTRICES : - Utilisez une structure appropriée de type Markdown : titre (#), sous-titre, introduction, chapitres (##), sous-chapitres (###) et conclusion (##). - Intégrer des liens contextuels (si nécessaire) en utilisant les URL de la sortie de l'agent de recherche. - Maintenir un ton professionnel, objectif et informatif. - Ne vous contentez pas de répéter les résultats ; synthétisez les informations, reliez les idées et présentez-les sous la forme d'un récit cohérent. """ )

Note that each AI agent prompt corresponds to one specific step in the overall 3-step workflow. In other words, each sub-agent is responsible for a distinct task within the process.

### Step #6: Add the MCP Integration
As mentioned in the previous step, the `reasearch` agent depends on the tools exported by the Bright Data MCP server. Retrieve them with this function:

python
async def initialize_mcp_tools() :
print(“Connexion au MCP de Bright Data…”)
tools, exit_stack = await MCPToolset.from_server(
connection_params=StdioServerParameters(
command=’npx’,
args=[“-y”, “@brightdata/mcp”],
env={
“API_TOKEN” : BRIGHT_DATA_API_TOKEN,
“BROWSER_AUTH” : BRIGHT_DATA_BROWSER_AUTH,
}
)
)
print(f “MCP Toolset created successfully with {len(tools)} tools”)
tool_names = [tool.name for tool in tools]
print(f “Les outils disponibles comprennent : {‘, ‘.join(tool_names)}”)

print("MCP initialization complete!")

return tools, exit_stack

Pour charger les outils MCP, Google ADK fournit la fonction MCPToolset.from_server(). Cette méthode accepte la commande utilisée pour démarrer le serveur MCP, ainsi que toutes les variables d’environnement requises. Dans ce cas, la commande configurée dans le code correspond à la commande que vous avez utilisée à l’étape 4 pour tester le serveur MCP localement.

⚠️ Avertissement: La configuration des outils MCP et leur mention dans les invites de votre agent ne garantissent pas que la bibliothèque les utilisera effectivement. C’est au LLM de décider si ces outils sont nécessaires pour accomplir la tâche. Gardez à l’esprit que l’intégration de MCP dans Google ADK en est encore à ses débuts et qu’elle ne se comporte pas toujours comme prévu.

Beau travail ! Il ne reste plus qu’à appeler cette fonction et à intégrer les outils résultants dans un agent qui exécute vos sous-agents de manière séquentielle.

Étape n° 7 : Création de l’agent racine

Google ADK prend en charge plusieurs types d’agents. Dans ce cas, votre flux de travail suit une séquence claire d’étapes, de sorte qu’un agent séquentiel racine est le bon choix. Vous pouvez le définir comme suit :

async def create_root_agent():
    # Load the MCP tools
    mcp_tools, exit_stack = await initialize_mcp_tools()

    # Define an agent that applies the configured sub-agents sequentially
    root_agent = SequentialAgent(
        name="web_research_agent",
        description="An agent that researches topics on the web and creates comprehensive reports.",
        sub_agents=[
            create_planner_agent(),
            create_researcher_agent(mcp_tools),
            create_publisher_agent(),
        ]
    )

    return root_agent, exit_stack

Pour que cela fonctionne, Google ADK s’attend à ce que vous définissiez une variable root_agent dans votre fichier agent.py. Réalisez cela avec :

root_agent = create_root_agent()

Note: Ne vous inquiétez pas d’appeler une fonction asynchrone sans await ici. C’est l’approche recommandée dans les documents officiels de Google ADK. Ainsi, le framework gérera l’exécution asynchrone pour vous.

Excellent travail ! Votre intégration entre le serveur MCP de Bright Data et Google ADK est maintenant terminée.

Étape n° 8 : Assembler le tout

Votre fichier agent.py doit maintenant contenir :

from dotenv import load_dotenv
import os
from google.adk.agents import Agent, SequentialAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StdioServerParameters

# Load the environment variables from the .env file
load_dotenv()

# Read the envs for integration with the Bright Data MCP server
BRIGHT_DATA_API_TOKEN = os.getenv("BRIGHT_DATA_API_TOKEN")
BRIGHT_DATA_BROWSER_AUTH = os.getenv("BRIGHT_DATA_BROWSER_AUTH")

# Define the functions for the creation of the required sub-agents
def create_planner_agent():
    return Agent(
        name="planner",
        model="gemini-2.0-flash",
        description="Breaks down user input into focused search queries for research purposes.",
        instruction="""
        You are a research planning assistant. Your task is to:
        1. Analyze the user"s input topic or question.
        2. Break it down into 3 to 5 focused and diverse search engine-like queries that collectively cover the topic.
        3. Return your output as a JSON object in the following format:

        {
            "queries": ["query1", "query2", "query3"]
        }

        IMPORTANT:
        - The queries should be phrased as if typed into a search engine.
        """,
        output_key="search_queries"
    )

def create_researcher_agent(mcp_tools):
    return Agent(
        name="researcher",
        model="gemini-2.0-flash",
        description="Performs web searches and extracts key insights from web pages using the configured tools.",
        instruction="""
        You are a web research agent. Your task is to:
        1. Receive a list of search queries from the planner agent.
        2. For each search query, apply the `search_engine` tool to get Google search results.
        3. From the global results, select the top 3 most relevant URLs.
        4. Pass each URL to the `scraping_browser_navigate` tool.
        5. From each page, use the `scraping_browser_get_text` tool to extract the main page content.
        6. Analyze the extracted text and summarize the key insights in the following JSON format:
        [
            {
                "url": "https://example.com",
                "insights": [
                    "Main insight one",
                    "Main insight two"
                ]
            },
            ...
        ]

        IMPORTANT:
        - You are only allowed to use the following tools: `search_engine`, `scraping_browser_navigate`, and `scraping_browser_get_text`.
        """,
        tools=mcp_tools
    )

def create_publisher_agent():
    return Agent(
        name="publisher",
        model="gemini-2.0-flash",
        description="Synthesizes research findings into a comprehensive, well-structured final document.",
        instruction="""
        You are an expert writer. Your task is to take the structured research output from the scraper agent and craft a clear, insightful, and well-organized report.

        GUIDELINES:
        - Use proper Markdown-like structure: title (#), subtitle, introduction, chapters (##), subchapters (###), and conclusion (##).
        - Integrate contextual links (where needed) using the URLs from the output of the researcher agent.
        - Maintain a professional, objective, and informative tone.
        - Go beyond restating findings—synthesize the information, connect ideas, and present them as a coherent narrative.
        """
    )

# To load the MCP tools exposed by the Bright Data MCP server
async def initialize_mcp_tools():
    print("Connecting to Bright Data MCP...")
    tools, exit_stack = await MCPToolset.from_server(
        connection_params=StdioServerParameters(
            command="npx",
            args=["-y", "@brightdata/mcp"],
            env={
                "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
            }
        )
    )
    print(f"MCP Toolset created successfully with {len(tools)} tools")
    tool_names = [tool.name for tool in tools]
    print(f"Available tools include: {", ".join(tool_names)}")

    print("MCP initialization complete!")

    return tools, exit_stack

# Define the root agent required by Google ADK to start
async def create_root_agent():
    # Load the MCP tools
    mcp_tools, exit_stack = await initialize_mcp_tools()

    # Define an agent that applies the configured sub-agents sequentially
    root_agent = SequentialAgent(
        name="web_research_agent",
        description="An agent that researches topics on the web and creates comprehensive reports.",
        sub_agents=[
            create_planner_agent(),
            create_researcher_agent(mcp_tools),
            create_publisher_agent(),
        ]
    )

    return root_agent, exit_stack

# Google ADK will load the root agent in the web UI or CLI
root_agent = create_root_agent()

Dans le dossier racine de votre projet, et avec l’environnement virtuel activé, lancez votre agent AI dans une interface web avec :

adk web

L’application suivante démarrera sur http://localhost:8000:

Après l’exécution de votre première requête, la bibliothèque Google ADK tentera d’accéder à la variable root_agent. Cela déclenche la fonction create_root_agent(), qui à son tour appelle initialize_mcp_tools().

En conséquence, dans le terminal, vous verrez :

Connecting to Bright Data MCP...
Checking for required zones...
Required zone "mcp_unlocker" already exists
Starting server...
MCP Toolset created successfully with 30 tools
Available tools include: search_engine, scrape_as_markdown, scrape_as_html, session_stats, web_data_amazon_product, web_data_amazon_product_reviews, web_data_linkedin_person_profile, web_data_linkedin_company_profile, web_data_zoominfo_company_profile, web_data_instagram_profiles, web_data_instagram_posts, web_data_instagram_reels, web_data_instagram_comments, web_data_facebook_posts, web_data_facebook_marketplace_listings, web_data_facebook_company_reviews, web_data_x_posts, web_data_zillow_properties_listing, web_data_booking_hotel_listings, web_data_youtube_videos, scraping_browser_navigate, scraping_browser_go_back, scraping_browser_go_forward, scraping_browser_links, scraping_browser_click, scraping_browser_type, scraping_browser_wait_for, scraping_browser_screenshot, scraping_browser_get_text, scraping_browser_get_html
MCP initialization complete!

Comme vous pouvez le voir, Google ADK a correctement chargé les 30 outils MCP de Bright Data.
Désormais, après avoir saisi une demande dans le chat, l’agent d’IA va.. :

1. Convertissez votre demande en phrases clés de type moteur de recherche.
2. Envoyer ces phrases clés à l’outil MCP du moteur de recherche à

   :Polylang placeholder do not modify

3. Générer un article ou un rapport pertinent sur le plan contextuel, basé sur ces informations, pour répondre à votre demande.

Notez que, comme mentionné à l’étape 6, Gemini (ou tout autre LLM) peut parfois ignorer complètement les outils MCP. Cela est vrai même s’ils sont configurés dans le code et explicitement mentionnés dans les invites des sous-agents. En détail, il peut renvoyer une réponse directe ou exécuter des sous-agents sans utiliser les outils MCP recommandés.

Pour éviter cet effet secondaire, modifiez soigneusement les invites de votre sous-agent. N’oubliez pas non plus que l’intégration de MCP dans Google ADK évolue encore et ne se comporte pas toujours comme prévu. Assurez-vous donc que la bibliothèque est à jour.

Supposons maintenant que vous souhaitiez connaître la biographie du pape récemment élu. Normalement, les LLM auraient du mal à répondre à des requêtes portant sur des événements récents. Mais grâce à l’API SERP de Bright Data et aux capacités de scraping web, votre agent IA peut récupérer et résumer des informations en temps réel sans effort :

Et voilà ! Mission accomplie.

Conclusion

Dans cet article de blog, vous avez appris à utiliser le cadre Google ADK en combinaison avec le MCP Bright Data pour construire un puissant agent d’intelligence artificielle en Python.

Comme nous l’avons démontré, la combinaison d’un serveur MCP riche en fonctionnalités et de Google ADK vous permet de créer des agents d’intelligence artificielle capables de récupérer des données en temps réel sur le Web et bien plus encore. Ce n’est qu’un exemple de la façon dont les outils et les services de Bright Data peuvent permettre une automatisation avancée, basée sur l’IA.

Découvrez nos solutions pour le développement d’agents d’IA :

• Agents d’intelligence artificielle autonomes: Recherchez, accédez et interagissez avec n’importe quel site web en temps réel à l’aide d’un puissant ensemble d’API.
• Apps d’IA verticales: créez des pipelines de données fiables et personnalisés pour extraire des données web à partir de sources spécifiques à votre secteur d’activité.
• Modèles de base: Accédez à des ensembles de données conformes à l’échelle du web pour faciliter le pré-entraînement, l’évaluation et la mise au point.
• IA multimodale: exploitez le plus grand référentiel d’images, de vidéos et d’audios au monde, optimisé pour l’IA.
• Fournisseurs de données: Connectez-vous avec des fournisseurs de confiance pour obtenir des ensembles de données de haute qualité, prêts pour l’IA, à grande échelle.
• Paquets de données: Obtenez des ensembles de données curatées, prêtes à l’emploi, structurées, enrichies et annotées.

Pour plus d’informations, consultez notre centre d’information sur l’IA.

Créez un compte Bright Data et essayez tous nos produits et services pour le développement d’agents d’IA !