--- title: "Integración de Google ADK con un servidor MCP para el desarrollo de agentes de IA" slug: google-adk-with-bright-data-mcp-server date: 2025-05-13T08:52:14+00:00 modified: 2025-11-04T08:50:54+00:00 permalink: https://brightdata.es/blog/ai/google-adk-with-bright-data-mcp-server type: blog --- [ Blog ](https://brightdata.es/blog "Blog") / [AI](https://brightdata.es/blog/ai) [AI](https://brightdata.es/blog/ai) # Integración de Google ADK con un servidor MCP para el desarrollo de agentes de IA Descubra cómo crear agentes de IA utilizando Google ADK y Bright Data MCP, permitiendo la recuperación de datos web en directo y la automatización inteligente en Python. 24 min de lectura [ ![Antonello Zanini](https://media.brightdata.es/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) ![Google ADK × Bright Data MCP blog image](https://media.brightdata.es/2025/05/Google-ADK%E2%80%AF%C3%97%E2%80%AFBright%E2%80%AFData-MCP.svg) 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](https://google.github.io/adk-docs/), 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)](https://google.github.io/adk-docs/tools/mcp-tools/). 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](https://docs.brightdata.com/api-reference/MCP-Server). 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](/ai). 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](https://github.com/luminati-io/brightdata-mcp/blob/main/assets/Tools.md) compatibles son: **Herramienta****Descripción**`motor_de_busqueda`Extrae resultados de búsqueda de Google, Bing o Yandex. Devuelve los resultados de las SERP en formato markdown (URL, título, descripción).`scrape_as_markdown`Raspe una sola página web y devuelva el contenido extraído en formato Markdown. Funciona incluso en páginas protegidas contra bots o CAPTCHA.`scrape_as_html`Igual que el anterior, pero devuelve el contenido en HTML crudo.`estadísticas_de_sesión`Proporciona un resumen del uso de la herramienta durante la sesión actual.`datos_web_producto_amazon`Recupera datos estructurados de productos de Amazon utilizando una URL `/dp/`. Más fiable que el scraping gracias al almacenamiento en caché.`web_data_amazon_product_reviews`Recupera datos estructurados de reseñas de Amazon utilizando una URL `/dp/`. En caché y fiable.`web_data_linkedin_perfil_persona`Accede a datos estructurados del perfil de LinkedIn. Almacenados en caché para mayor coherencia y velocidad.`web_data_linkedin_perfil_empresa`Accede a los datos estructurados de empresa de LinkedIn. La versión en caché mejora la fiabilidad.`datos_web_zoominfo_perfil_empresa`Recuperar datos estructurados de empresa de ZoomInfo. Requiere una URL de ZoomInfo válida.`web_datos_instagram_perfiles`Datos estructurados del perfil de Instagram. Requiere una URL de Instagram válida.`web_data_instagram_posts`Recuperar datos estructurados de las publicaciones de Instagram.`web_data_instagram_reels`Recuperar datos estructurados para los carretes de Instagram.`datos_web_instagram_comentarios`Recupera los comentarios de Instagram como datos estructurados.`datos_web_posts_facebook`Accede a los datos estructurados de las publicaciones de Facebook.`web_data_facebook_marketplace_listings`Recupera anuncios estructurados de Facebook Marketplace.`web_data_facebook_company_reviews`Recuperar reseñas de empresas en Facebook. Requiere la URL de la empresa y el número de opiniones.`datos_web_x_posts`Recupera datos estructurados de las publicaciones de X (antes Twitter).`web_data_zillow_properties_listing`Accede a los datos estructurados de los listados de Zillow.`datos_web_reserva_listados_hoteles`Recuperar listados estructurados de hoteles de Booking.com.`web_data_youtube_videos`Datos de vídeo estructurados de YouTube. Requiere una URL de vídeo válida.`scraping_browser_navigate`Navegue con el navegador de raspado a una nueva URL.`scraping_browser_go_back`Volver a la página anterior.`scraping_browser_go_forward`Navegar hacia adelante en el historial del navegador.`scraping_browser_click`Haga clic en un elemento específico de la página. Requiere selector de elementos.`scraping_browser_links`Recupera todos los enlaces de la página actual junto con sus selectores y texto.`scraping_browser_type`Simular la introducción de texto en un campo de entrada.`scraping_browser_wait_for`Esperar a que un elemento específico se haga visible.`scraping_browser_screenshot`Haga una captura de pantalla de la página actual.`scraping_browser_get_html`Recupera el HTML completo de la página actual. Utilícelo con precaución si no necesita el contenido completo de la página.`scraping_browser_get_text`Recupera el contenido de texto visible de la página actual.Para otra posible integración, consulte nuestro artículo sobre [web scraping utilizando los servidores MCP](/blog/ai/web-scraping-with-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](https://github.com/MeirKaD/MCP_ADK). 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](/use-cases). 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](https://www.python.org/downloads/release/python-390/) o superior instalado localmente. - [Node.js](https://nodejs.org/en/download) instalado localmente. - Un sistema basado en UNIX, como Linux o macOS, o el WSL[(Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/install)). **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`](https://docs.python.org/3/library/exceptions.html#NotImplementedError) de esta sección de código: ```none 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](https://google.github.io/adk-docs/get-started/). - Familiaridad con el servidor MCP de Bright Data y sus herramientas disponibles. - Alguna experiencia con [programación asíncrona en Python](https://docs.python.org/3/library/asyncio.html). ### Paso nº 1: Configuración del proyecto Abra su terminal y cree una nueva carpeta para su agente de raspado: ```none 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](https://docs.python.org/3/library/venv.html) dentro de ella: ```none 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](https://code.visualstudio.com/docs/languages/python) o [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/#section=windows). 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](https://google.github.io/adk-docs/get-started/quickstart/#project-structure): ![Estructura de archivos de un proyecto Python llamado 'GOOGLE_ADK_MCP_AGENT', con un directorio de entorno virtual '.venv' y un subdirectorio 'web_search_agent' que contiene dos archivos Python: '__init__.py' y 'agent.py'.](https://media.brightdata.com/2025/05/The-file-structure-of-the-Google-ADK-agent-project.png)Ahora, inicializa el archivo `__init__.py` con la siguiente línea: ```none 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: ```none ./.venv/bin/activate ``` De forma equivalente, en Windows, ejecute: ```none .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`](https://pypi.org/project/python-dotenv/). Con tu entorno virtual activado, instálala ejecutando: ```none pip install python-dotenv ``` En tu archivo `agent.py`, importa la librería y carga las variables de entorno con `load_dotenv()`: ```none 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: ![Archivo de configuración .env resaltado dentro de una estructura de directorios para un proyecto llamado 'GOOGLE_ADK_MCP_AGENT', que incluye una carpeta de entorno virtual y archivos Python relevantes.](https://media.brightdata.com/2025/05/The-.env-file-in-your-nested-agent-folder.png)Ahora puedes leer variables de entorno en tu código con esta línea de código: ```none env_value = os.getenv("") ``` No olvides importar el módulo [`os`](https://docs.python.org/3/library/os.html) de la biblioteca estándar de Python: ```none 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](https://github.com/google/adk-python) ejecutando: ```none pip install google-adk ``` A continuación, abre `agent.py` y añade las siguientes importaciones: ```none 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](https://ai.google.dev/gemini-api/docs/api-key). 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](https://aistudio.google.com/app/apikey)” y verás este modal: ![Una ventana emergente titulada "Es hora de construir" muestra opciones para utilizar Google AI Studio y obtener una clave API para la API Gemini, con dos botones azules etiquetados como "Probar Gemini" y "Obtener clave API".](https://media.brightdata.com/2025/05/Note-the-Get-API-key-button.png)Pulse el botón “Obtener clave API”. En la siguiente pantalla, pulse el botón “Crear clave API”: ![Captura de pantalla que muestra una interfaz para generar una clave API para la API Gemini, incluyendo un fragmento de código para realizar una solicitud POST utilizando curl y un botón resaltado para crear la clave API.](https://media.brightdata.com/2025/05/Note-the-Create-API-key-button.png)Una vez generada, verá su clave mostrada en un modal: ![Un cuadro de diálogo de notificación que indica "Clave API generada" con instrucciones para utilizar las claves API de forma segura y no compartirlas públicamente. Aparece una clave API oculta en un recuadro y un botón "Copiar".](https://media.brightdata.com/2025/05/Copying-the-Gemini-API-key.png)Copia la clave y guárdala en un lugar seguro. Ten en cuenta que con la misma clave puedes realizar [web scraping con Gemini](/blog/datos-web/web-scraping-with-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](https://ai.google.dev/gemini-api/docs/api-key). Ahora, inicialice su archivo `.env` con las siguientes variables de entorno: ```none GOOGLE_GENAI_USE_VERTEXAI="False" GOOGLE_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`](https://googleapis.github.io/python-genai/#create-a-client). Del mismo modo, el ajuste `GOOGLE_GENAI_USE_VERTEXAI` determina si Google ADK debe integrarse con [Vertex AI](https://cloud.google.com/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](/cp/start). A continuación, [siga las instrucciones oficiales](https://github.com/luminati-io/brightdata-mcp?tab=readme-ov-file#-account-setup) 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: `:`. Ahora está listo para instalar el [servidor MCP de Bright Data](https://github.com/luminati-io/brightdata-mcp) globalmente en su entorno Node.js con: ```none npm install -g @brightdata/mcp ``` A continuación, ejecute el servidor MCP a través del paquete [`@brightdata/mcp`](https://www.npmjs.com/package/@brightdata/mcp) npm con: ```none API_TOKEN="" BROWSER_AUTH=":" 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: ```none 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: ```none BRIGHT_DATA_API_TOKEN="" BRIGHT_DATA_BROWSER_AUTH=":" ``` Sustituya los marcadores de posición por los valores reales. Luego, lee esos envs en tu código con: ```none 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: ```none 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: ```none 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](https://modelcontextprotocol.io/docs/concepts/tools) qué [herramientas MCP puede interactuar el agente](https://modelcontextprotocol.io/docs/concepts/tools). 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. """` ) ```none 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)}”) ```none print("MCP initialization complete!") return tools, exit_stack ``` Para cargar las herramientas MCP, Google ADK proporciona la función [`MCPToolset.from_server()`](https://google.github.io/adk-docs/tools/mcp-tools/). 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](https://google.github.io/adk-docs/agents/workflow-agents/sequential-agents/) raíz es la elección correcta. Puede definir uno así: ```none 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: ```none 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: ```none 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: ```none adk web ``` La siguiente aplicación se iniciará en `http://localhost:8000:` ![Una interfaz de usuario de temática oscura para un agente de búsqueda web, que muestra una barra lateral izquierda con pestañas para Eventos, Estado, Artefactos, Sesiones y Eval, y un área central que indica "Sin conversaciones" con un área de entrada de texto etiquetada como "Escriba un mensaje..." en la parte inferior, junto con iconos para las opciones de micrófono y vídeo.](https://media.brightdata.com/2025/05/The-Google-ADK-web-platform.png)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: ```none 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: ![Observe cómo el agente de IA proporciona un resultado respaldado por fuentes reales y verificables](https://media.brightdata.com/2025/05/Notice-how-the-AI-agent-provides-a-result-backed-by-real-verifiable-sources.png)¡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**](/ai/data-for-ai-agents): Busque, acceda e interactúe con cualquier sitio web en tiempo real mediante un potente conjunto de API. - [**Aplicaciones verticales de IA**](/ai/data-for-vertical-ai-solutions): cree canalizaciones de datos fiables y personalizadas para extraer datos web de fuentes específicas del sector. - [**Modelos básicos**](/ai/data-for-llms-and-foundation-models): Acceda a conjuntos de datos compatibles a escala web para potenciar el preentrenamiento, la evaluación y el ajuste. - [**IA multimodal**](/ai): aproveche el mayor repositorio del mundo de imágenes, vídeos y audio optimizados para la IA. - [**Proveedores de datos**](/blog/datos-web/best-b2b-data-providers): Conéctese con proveedores de confianza para obtener conjuntos de datos de alta calidad preparados para la IA a escala. - [**Paquetes de datos**](/ai/data-packages-for-ai): Obtenga conjuntos de datos comisariados, listos para usar, estructurados, enriquecidos y anotados. Para más información, explore nuestro [centro de IA](/ai). Cree una cuenta de Bright Data y pruebe todos nuestros productos y servicios para el desarrollo de agentes de IA. Contactar ventasPrueba gratuita![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Tabla de Contenidos [ ](https://news.ycombinator.com/submitlink?t=Integraci%C3%B3n+de+Google+ADK+con+un+servidor+MCP+para+el+desarrollo+de+agentes+de+IA&u=https://brightdata.es/blog/ai/google-adk-with-bright-data-mcp-server) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Integraci%C3%B3n+de+Google+ADK+con+un+servidor+MCP+para+el+desarrollo+de+agentes+de+IA&url=https://brightdata.es/blog/ai/google-adk-with-bright-data-mcp-server) [ ](http://www.reddit.com/submit?title=Integraci%C3%B3n+de+Google+ADK+con+un+servidor+MCP+para+el+desarrollo+de+agentes+de+IA&url=https://brightdata.es/blog/ai/google-adk-with-bright-data-mcp-server) ## Usted también puede estar interesado en [ ![OpenHuman with Bright Data](https://media.brightdata.es/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.es/blog/ai/openhuman-with-bright-data "Acceso Web Listo para Producción en OpenHuman a Través de la CLI de Bright Data") [AI ![Antonello Zanini](https://media.brightdata.es/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Acceso Web Listo para Producción en OpenHuman a Través de la CLI de Bright Data Integra la CLI de Bright Data con OpenHuman para habilitar acceso web listo para producción y recopilación de datos para agentes de IA. 09-Sep-2026 14 min de lectura ](https://brightdata.es/blog/ai/openhuman-with-bright-data) [ ![Multimodal Web Scraping with MiniMax](https://media.brightdata.es/2026/09/Multimodal-Web-Scraping-with-MiniMax.png) ](https://brightdata.es/blog/datos-web/multimodal-web-scraping-with-minimax "Scraping Web Multimodal con MiniMax") [Datos web ![Antonello Zanini](https://media.brightdata.es/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Scraping Web Multimodal con MiniMax Combina Bright Data Web Unlocker con la visión de MiniMax M3 para extraer datos estructurados de imágenes y capturas de pantalla de páginas web. 09-Sep-2026 5 min de lectura ](https://brightdata.es/blog/datos-web/multimodal-web-scraping-with-minimax) [ ![The 10 Best CLI Tools for Codex in 2026](https://media.brightdata.es/2026/08/The-10-Best-CLI-Tools-for-Codex-in-2026.png) ](https://brightdata.es/blog/ai/best-cli-tools-for-codex "Las 10 mejores herramientas CLI para Codex en 2026 – Probadas y clasificadas") [AI ![Daniel Shashko](https://media.brightdata.es/2022/04/Daniel-Shashko-2-50x50.png) Daniel Shashko Web Data & AI Expert ### Las 10 mejores herramientas CLI para Codex en 2026 – Probadas y clasificadas Las 10 herramientas CLI que hacen a Codex más rápido y capaz, comenzando con la Bright Data CLI para acceso web real desde dentro del sandbox. 06-Sep-2026 24 min de lectura ](https://brightdata.es/blog/ai/best-cli-tools-for-codex)