Integración de Google ADK con un servidor MCP para el desarrollo de agentes de IA

En esta guía, verá:

• Qué es la biblioteca Google ADK para construir agentes de IA.
• Por qué su compatibilidad nativa con MCP lo hace especial.
• Cómo integrarlo con el servidor MCP de Bright Data para construir un agente de IA extremadamente potente.

Sumerjámonos.

¿Qué es Google ADK?

Google ADK, abreviatura de Google Agent Development Kit, es un marco Python de código abierto para crear y desplegar agentes de IA. Aunque está optimizado para Gemini y el ecosistema de Google en general, sigue siendo independiente del modelo y del despliegue.

ADK hace hincapié en la experiencia del desarrollador, ofreciendo herramientas y estructuras de datos que facilitan la creación de potentes sistemas multiagente. Permite definir agentes de IA que pueden razonar, colaborar e interactuar con el mundo mediante herramientas e integraciones.

El objetivo final de Google ADK es hacer que el desarrollo de agentes se parezca más al desarrollo de software tradicional. Esto se consigue simplificando el proceso de creación, despliegue y orquestación de arquitecturas de agentes.

Qué hace especial al ADK de Google

En comparación con otras bibliotecas de creación de agentes de IA, Google ADK destaca por su compatibilidad integrada con MCP (Managed Connectivity Platform). Si no estás familiarizado con ella, MCP es una forma estandarizada para que los modelos de IA interactúen con herramientas externas y fuentes de datos, como API, bases de datos y sistemas de archivos.

En términos más sencillos, MCP permite a tu agente Google ADK aprovechar las capacidades de cualquier servidor compatible con MCP. Piense en ello como una integración plug-and-play que amplía su agente de IA más allá de las limitaciones del LLM subyacente, dándole acceso a datos y acciones del mundo real.

Esa opción proporciona una forma estructurada, segura y escalable de conectar su agente con capacidades externas, sin necesidad de crear esas conexiones desde cero. La integración MCP resulta especialmente atractiva cuando se integra con un servidor MCP enriquecido como el servidor MCP de Bright Data.

Ese servidor MCP funciona sobre Node.js y se conecta sin problemas a todas las potentes herramientas de recuperación de datos de IA de Bright Data. Estas herramientas permiten a su agente interactuar con datos web en directo, conjuntos de datos estructurados y capacidades de scraping.

En el momento de redactar este documento, las herramientas MCP compatibles son:

Para otra posible integración, consulte nuestro artículo sobre web scraping utilizando los servidores MCP.

Nota: periódicamente se añaden nuevas herramientas al servidor MCP de Bright Data, lo que lo hace cada vez más potente y rico en funciones con el paso del tiempo.

Descubre cómo sacar partido de estas herramientas con Google ADK.

Cómo integrar Google ADK con el servidor MCP de Bright Data

En esta sección del tutorial, aprenderá a utilizar Google ADK para construir un potente agente de IA. Este estará equipado con capacidades de raspado en vivo, recuperación de datos y transformación proporcionadas por el servidor MCP de Bright Data.

Esta configuración fue implementada inicialmente por Meir Kadosh, así que asegúrate de consultar su repositorio GitHub original.

En concreto, el agente de IA será capaz de:

1. Recuperar URL de los motores de búsqueda.
2. Raspe el texto de esas páginas web.
3. Generar respuestas basadas en la fuente utilizando los datos extraídos.

Nota: Cambiando las instrucciones en el código, puedes adaptar fácilmente el agente de IA a cualquier otro escenario o caso de uso.

Siga los pasos que se indican a continuación para crear su agente Google ADK en Python con Bright Data MCP.

Requisitos previos

Para seguir este tutorial, necesitas:

• Python 3.9 o superior instalado localmente.
• Node.js instalado localmente.
• Un sistema basado en UNIX, como Linux o macOS, o el WSL(Windows Subsystem for Linux).

Nota: La integración de Google ADK con el servidor MCP de Bright Data no funciona actualmente de forma nativa en Windows. Al intentar ejecutarlo puede aparecer un NotImplementedError de esta sección de código:

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

Por esta razón, el tutorial asume que usted está usando Linux, macOS, o el WSL.

También necesitarás:

• Una cuenta de Bright Data
• Una clave API Gemini

Este tutorial le guiará en la configuración de las credenciales de Gemini y Bright Data cuando sea necesario. Por lo tanto, no se preocupe por ellas en este momento.

Aunque no es obligatorio, lo siguiente le ayudará a sacar el máximo provecho de este tutorial:

• Una idea general del funcionamiento del MCP.
• Una comprensión básica de cómo funciona Google ADK.
• Familiaridad con el servidor MCP de Bright Data y sus herramientas disponibles.
• Alguna experiencia con programación asíncrona en Python.

Paso nº 1: Configuración del proyecto

Abra su terminal y cree una nueva carpeta para su agente de raspado:

mkdir google_adk_mcp_agent

La carpeta google_adk_mcp_agent contendrá todo el código para tu agente Python de IA.

A continuación, navega hasta la carpeta del proyecto y crea un entorno virtual dentro de ella:

cd google_adk_mcp_agent
python3 -m venv .venv

Abra la carpeta del proyecto en su IDE de Python preferido. Recomendamos usar Visual Studio Code con la extensión Python o PyCharm Community Edition.

Dentro de google_adk_mcp_agent, crea una subcarpeta llamada web_search_agent. Esta subcarpeta contendrá la lógica central de su agente y debe incluir los dos archivos siguientes:

• __init__.py: Exporta la lógica de agent.py.
• agent.py: Contiene la definición del agente Google ADK.

Esta es la estructura de carpetas necesaria para que la biblioteca Google ADK funcione correctamente:

Ahora, inicializa el archivo __init__.py con la siguiente línea:

from . import agent

En su lugar, agent.py se definirá con la lógica del agente AI pronto.

En el terminal del IDE, active el entorno virtual. En Linux o macOS, ejecute este comando:

./.venv/bin/activate

De forma equivalente, en Windows, ejecute:

.venv/Scripts/activate

¡Ya está todo listo! Ya dispone de un entorno Python para crear un agente de IA utilizando el ADK de Google y el servidor MCP de Bright Data.

Paso 2: Configurar las variables de entorno Lectura

Su proyecto interactuará con servicios de terceros como Gemini y Bright Data. En lugar de codificar las claves API y los secretos de autenticación directamente en el código Python, lo mejor es cargarlos desde las variables de entorno.

Para simplificar esa tarea, utilizaremos la biblioteca python-dotenv. Con tu entorno virtual activado, instálala ejecutando:

pip install python-dotenv

En tu archivo agent.py, importa la librería y carga las variables de entorno con load_dotenv():

from dotenv import load_dotenv

load_dotenv()

Esto le permite leer variables desde un fichero .env local. Por lo tanto, añada un archivo . env a su directorio de agente anidado:

Ahora puedes leer variables de entorno en tu código con esta línea de código:

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

No olvides importar el módulo os de la biblioteca estándar de Python:

import os

¡Genial! Ya está listo para leer los secretos del env para integrarse de forma segura con servicios de terceros.

Paso 3: Empezar con Google ADK

En su entorno virtual activado, instale la biblioteca Google ADK Python ejecutando:

pip install google-adk

A continuación, abre agent.py y añade las siguientes importaciones:

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

Estos se utilizarán en los próximos pasos para la integración de Google ADK.

Ahora, ten en cuenta que Google ADK requiere la integración con un proveedor de IA. En este caso, utilizaremos Gemini, ya que la biblioteca está optimizada para los modelos de IA de Google.

Si aún no has obtenido tu clave API, sigue la documentación oficial de Google. Inicia sesión en tu cuenta de Google y accede a Google AI Studio. A continuación, ve a la sección“Obtener clave de API” y verás este modal:

Pulse el botón “Obtener clave API”. En la siguiente pantalla, pulse el botón “Crear clave API”:

Una vez generada, verá su clave mostrada en un modal:

Copia la clave y guárdala en un lugar seguro. Ten en cuenta que con la misma clave puedes realizar web scraping con Gemini.

Nota: el nivel Gemini gratuito es suficiente para este tutorial. El nivel de pago solo es necesario si necesitas límites de tarifa más altos o si no quieres que tus preguntas y respuestas se utilicen para mejorar los productos de Google. Consulta la página de facturación de Gemini.

Ahora, inicialice su archivo .env con las siguientes variables de entorno:

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

Sustituya por la clave que acabas de generar. No se requiere código adicional en agent.py ya que la librería google-adk busca automáticamente la variable de entorno GOOGLE_API_KEY.

Del mismo modo, el ajuste GOOGLE_GENAI_USE_VERTEXAI determina si Google ADK debe integrarse con Vertex AI. Establécelo en "False" para utilizar directamente la API Gemini.

¡Sorprendente! Ya puedes utilizar Gemini en Google ADK. Continuemos con la configuración inicial de la solución de terceros necesaria para la integración.

Paso 4: Configurar el servidor MCP de Bright Data

Si aún no lo ha hecho, [cree una cuenta de Bright Data](). Si ya tiene una, simplemente inicie sesión.

A continuación, siga las instrucciones oficiales para:

1. Recupere su token de API de Bright Data.
2. Configurar Web Unlocker y Scraping Browser para la integración MCP.

Terminarás con:

• Un token de la API de Bright Data.
• Una zona Web Unlocker (aquí, asumiremos que tiene el nombre por defecto, que es mcp_unlocker).
• Scraping Credenciales de autenticación del navegador en el formato: <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Ahora está listo para instalar el servidor MCP de Bright Data globalmente en su entorno Node.js con:

npm install -g @brightdata/mcp

A continuación, ejecute el servidor MCP a través del paquete @brightdata/mcp npm con:

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

El comando anterior establece las variables de entorno necesarias(API_TOKEN y BROWSER_AUTH) e inicia el servidor MCP localmente. Si todo está configurado correctamente, debería ver una salida indicando que el servidor se está ejecutando correctamente:

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

¡Fantástico! El servidor MCP de Bright Data funciona a las mil maravillas.

Añade esas variables de entorno a tu archivo .env en la raíz de tu proyecto Google ADK:

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

Sustituya los marcadores de posición por los valores reales.

Luego, lee esos envs en tu código con:

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

Perfecto. Ya tiene todo configurado para integrar el servidor MCP de Bright Data con Google ADK. Pero primero, es hora de definir los agentes de IA.

Paso nº 5: Definir los agentes

Como se mencionó en la introducción, el agente Google ADK basado en MCP actuará como agente de resumen de contenidos. Su objetivo principal es recibir la información de un usuario y devolverle un resumen de alta calidad y bien documentado.

En detalle, el agente seguirá el siguiente flujo de trabajo:

1. Interpretar la petición del usuario y descomponerla en consultas de búsqueda al estilo Google.
2. Procesar las consultas de búsqueda mediante un subagente que

   :Marcador de posición de polylang no modificar

3. Generar un informe Markdown en respuesta a la consulta original del usuario. El proceso utilizará el contenido recién recopilado como fuente e incluirá enlaces para una lectura adicional.

Dado que el proceso se divide naturalmente en tres etapas distintas, tiene sentido dividir el agente de IA de nivel superior en tres subagentes:

• Planificador: Convierte temas complejos en consultas de búsqueda bien formadas.
• Investigador: Ejecuta las búsquedas y extrae información significativa de las páginas web resultantes.
• Editorial: Sintetiza la investigación en un documento bien redactado y estructurado.

Implementa estos tres agentes en Google ADK usando el siguiente código Python:

• Planificador:

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"
    )

• Investigadora:

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
    )

Nota: El argumento de entrada mcp_tools es una lista que especifica con qué herramientas MCP puede interactuar el agente. En el siguiente paso, verá cómo rellenar esta lista utilizando las herramientas proporcionadas por el servidor MCP de Bright Data.

• Editor:
  “`python
  def crear_agente_editor():
  return Agente(
  name=”editor”,
  model=”gemini-2.0-flash”,
  description=”Sintetiza los resultados de la investigación en un documento final completo y bien estructurado”,
  instruction=”””
  Eres un escritor experto. Su tarea consiste en tomar el resultado estructurado de la investigación del agente scraper y elaborar un informe claro, perspicaz y bien organizado. DIRECTRICES: - Utilice una estructura similar a la de Markdown: título (#), subtítulo, introducción, capítulos (##), subcapítulos (###) y conclusión (##). - Integre enlaces contextuales (cuando sea necesario) utilizando las URL de la salida del agente investigador. - Mantenga un tono profesional, objetivo e informativo. - No te limites a repetir los resultados: sintetiza la información, conecta las ideas y preséntalas como una narración coherente. """ )

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(“Conectando a 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 “Conjunto de herramientas MCP creado correctamente con {len(tools)} tools”)
tool_names = [tool.name para tool en tools]
print(f “Las herramientas disponibles son: {‘, ‘.join(nombres_herramientas)}”)

print("MCP initialization complete!")

return tools, exit_stack

Para cargar las herramientas MCP, Google ADK proporciona la función MCPToolset.from_server(). Este método acepta el comando utilizado para iniciar el servidor MCP, junto con cualquier variable de entorno necesaria. En este caso, el comando configurado en el código corresponde al comando que utilizaste en el paso nº 4 para probar el servidor MCP localmente.

⚠️ Advertencia: Configurar las herramientas MCP y mencionarlas en los mensajes del agente no garantiza que la biblioteca vaya a utilizarlas. En última instancia, depende del LLM decidir si esas herramientas son necesarias para realizar la tarea. Tenga en cuenta que la integración de MCP en Google ADK está todavía en sus primeras etapas y puede que no siempre se comporte como se espera.

¡Buen trabajo! Sólo queda llamar a esta función e integrar las herramientas resultantes en un agente que ejecute sus subagentes secuencialmente.

Paso 7: Crear el agente raíz

Google ADK soporta varios tipos de agentes. En este caso, su flujo de trabajo sigue una secuencia clara de pasos, por lo que un agente secuencial raíz es la elección correcta. Puede definir uno así:

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

Para que esto funcione, Google ADK espera que definas una variable root_agent en tu archivo agent.py. Hazlo con:

root_agent = create_root_agent()

Nota: No te preocupes por llamar a una función asíncrona sin await aquí. Ese es el enfoque recomendado en los documentos oficiales de Google ADK. Así, el framework se encargará de la ejecución asíncrona por ti.

Buen trabajo. Su integración entre el servidor MCP de Bright Data y Google ADK ya está completa.

Paso 8: Póngalo todo junto

Tu archivo agent.py debería contener ahora:

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()

En la carpeta raíz de tu proyecto, y con el entorno virtual activado, lanza tu agente de IA en una interfaz web con:

adk web

La siguiente aplicación se iniciará en http://localhost:8000:

Después de ejecutar tu primera petición, la librería Google ADK intentará acceder a la variable root_agent. Esto activará la función create_root_agent(), que a su vez llama a initialize_mcp_tools().

Como resultado, en el terminal, verás:

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!

Como puede ver, Google ADK ha cargado correctamente las 30 herramientas MCP de Bright Data.
Ahora, tras introducir una solicitud en el chat, el agente de IA:

1. Convierta su solicitud en frases clave al estilo de los motores de búsqueda.
2. Envíe esas frases clave a la herramienta MCP search_engine a

   :Polylang placeholder do not modify

3. Genere un artículo o informe contextualmente relevante basado en esos datos para responder a su consulta.

Tenga en cuenta que, como se menciona en el paso nº 6, Gemini (o cualquier otro LLM) a veces puede omitir por completo las herramientas MCP. Esto es así aunque estén configuradas en el código y se mencionen explícitamente en las indicaciones de los subagentes. En detalle, podría devolver una respuesta directa o ejecutar subagentes sin utilizar las herramientas MCP recomendadas.

Para evitar ese efecto secundario, ajuste con cuidado las indicaciones de su subagente. Además, recuerde que la integración de MCP en Google ADK sigue evolucionando y puede que no siempre se comporte como se espera. Por lo tanto, asegúrese de que la biblioteca está actualizada.

Supongamos que quiere conocer la biografía del Papa recién elegido. Normalmente, los LLM tendrían problemas con las consultas de actualidad. Pero gracias a la API SERP de Bright Data y a sus capacidades de raspado web, su agente de IA puede obtener y resumir información en tiempo real sin esfuerzo:

¡Et voilà! Misión cumplida.

Conclusión

En esta entrada de blog, ha aprendido a utilizar el marco Google ADK en combinación con el MCP de Bright Data para crear un potente agente de IA en Python.

Como se ha demostrado, la combinación de un servidor MCP rico en funciones con Google ADK permite crear agentes de IA capaces de recuperar datos en tiempo real de la web y mucho más. Este es solo un ejemplo de cómo las herramientas y servicios de Bright Data pueden potenciar la automatización avanzada impulsada por IA.

Explore nuestras soluciones para el desarrollo de agentes de IA:

• Agentes autónomos de IA: Busque, acceda e interactúe con cualquier sitio web en tiempo real mediante un potente conjunto de API.
• Aplicaciones verticales de IA: cree canalizaciones de datos fiables y personalizadas para extraer datos web de fuentes específicas del sector.
• Modelos básicos: Acceda a conjuntos de datos compatibles a escala web para potenciar el preentrenamiento, la evaluación y el ajuste.
• IA multimodal: aproveche el mayor repositorio del mundo de imágenes, vídeos y audio optimizados para la IA.
• Proveedores de datos: Conéctese con proveedores de confianza para obtener conjuntos de datos de alta calidad preparados para la IA a escala.
• Paquetes de datos: Obtenga conjuntos de datos comisariados, listos para usar, estructurados, enriquecidos y anotados.

Para más información, explore nuestro centro de IA.

Cree una cuenta de Bright Data y pruebe todos nuestros productos y servicios para el desarrollo de agentes de IA.