--- title: "Pydantic AI con Bright Data MCP de Bright Data para agentes con acceso a datos" slug: pydantic-ai-with-web-mcp date: 2025-08-24T14:04:04+00:00 modified: 2025-11-04T08:46:13+00:00 permalink: https://brightdata.es/blog/ai/pydantic-ai-with-web-mcp type: blog --- [ Blog ](https://brightdata.es/blog "Blog") / [AI](https://brightdata.es/blog/ai) [AI](https://brightdata.es/blog/ai) # Pydantic AI con Bright Data MCP de Bright Data para agentes con acceso a datos Descubra cómo combinar Pydantic AI con Bright Data MCP para construir agentes Python AI que accedan y extraigan datos web en tiempo real. 8 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) ![Pydantic AI × Bright Data's Bright Data MCP](https://media.brightdata.es/2025/08/Pydantic-AI%E2%80%AF%C3%97%E2%80%AFBright%E2%80%AFDatas-Web-MCP.png) En esta guía aprenderás: - Qué es Pydantic AI y qué la hace única como marco para construir agentes de IA. - Por qué Pydantic AI se empareja bien con el servidor Bright Data MCP de Bright Data para construir agentes que puedan acceder a la web. - Cómo integrar Pydantic con el Bright Data MCP de Bright Data para crear un agente de IA respaldado por datos reales. Sumerjámonos. ## ¿Qué es la IA pydántica? [Pydantic AI](//ai.pydantic.dev/) es un framework de agentes para Python desarrollado por los creadores de [Pydantic](https://docs.pydantic.dev/latest/), la biblioteca de validación de datos más utilizada para Python. En comparación con otros [marcos de agentes de IA](/blog/ai/best-ai-agent-frameworks), Pydantic AI hace hincapié en la seguridad de tipos, las salidas estructuradas y la integración con datos y herramientas del mundo real. En detalle, algunas de sus principales características son: - Compatibilidad con OpenAI, Anthropic, Gemini, Cohere, Mistral, Groq, HuggingFace, Deepseek, Ollama y otros proveedores de LLM. - Validación estructurada de resultados mediante modelos pydánticos. - Depuración y supervisión a través de [Pydantic Logfire](https://pydantic.dev/logfire). - Inyección de dependencia opcional para herramientas, avisos y validadores. - Respuestas LLM en tiempo real con validación de datos sobre la marcha. - Soporte multiagente y gráfico para flujos de trabajo complejos. - Integración de herramientas a través de MCP e incluyendo llamadas HTTP. - Flujo Pythonic familiar para construir agentes de IA como aplicaciones Python estándar. - Soporte integrado para pruebas unitarias y desarrollo iterativo. La biblioteca es de código abierto y ya ha alcanzado [más de 11 000 estrellas en GitHub](https://github.com/pydantic/pydantic-ai). ## Por qué combinar Pydantic AI con un servidor MCP para la recuperación de datos web Los agentes de IA construidos con Pydantic AI heredan las limitaciones del LLM subyacente. Entre ellas, la falta de acceso a información en tiempo real, que puede dar lugar a respuestas imprecisas. Afortunadamente, este problema puede solucionarse fácilmente dotando al agente de datos actualizados y de la capacidad de explorar la web en tiempo real. Aquí es donde entra en juego el [**MCP web de Bright Data**](/ai/mcp-server). Construido sobre Node.js, este servidor MCP se integra con el conjunto de herramientas de recuperación de datos preparadas para IA de Bright Data. Estas herramientas permiten a su agente acceder a contenido web, consultar conjuntos de datos estructurados, buscar en la web e interactuar con páginas web sobre la marcha. A partir de ahora, las [herramientas MCP del servidor](https://github.com/brightdata/brightdata-mcp/blob/main/assets/Tools.md) incluyen: **Herramienta****Descripción**`scrape_as_markdown`Raspe el contenido de una URL de una sola página web con opciones avanzadas de extracción, devolviendo los resultados como Markdown. Puede evitar la detección de bots y CAPTCHA.`motor_de_busqueda`Extrae los resultados de búsqueda de Google, Bing o Yandex, devolviendo los datos SERP en formato markdown (URL, título, snippet).`scrape_as_html`Recupera el contenido de una página web desde una URL con opciones avanzadas de extracción, devolviendo el HTML completo. Puede evitar la detección de bots y CAPTCHA.`estadísticas_sesión`Proporciona estadísticas sobre el uso de la herramienta durante la sesión actual.`scraping_browser_go_back`Vuelva a la página anterior en la sesión del navegador de raspado.`scraping_browser_go_forward`Avanzar a la página siguiente en la sesión del navegador de raspado.`scraping_browser_click`Realizar una acción de clic en un elemento específico por selector.`scraping_browser_links`Recupera todos los enlaces, incluyendo texto y selectores, de la página actual.`scraping_browser_type`Introducir texto en un elemento especificado dentro del navegador de raspado.`scraping_browser_wait_for`Espere a que un elemento concreto sea visible en la página antes de continuar.`scraping_browser_screenshot`Captura una pantalla de la página actual del navegador.`scraping_browser_get_html`Recupera el contenido HTML de la página actual en el navegador.`scraping_browser_get_text`Extrae el contenido de texto visible de la página actual.Además, existen más de 40 herramientas especializadas para recopilar datos estructurados de una amplia gama de sitios web (por ejemplo, Amazon, Yahoo Finance, TikTok, LinkedIn, etc.) mediante [las API de Web Scraper](/products/web-scraper). Por ejemplo, la herramienta `web_data_amazon_product` recopila información detallada y estructurada de productos de Amazon aceptando como entrada una URL válida del producto. Ahora, echa un vistazo a cómo puedes utilizar estas herramientas MCP en Pydantic AI. ## Cómo integrar Pydantic AI con el servidor Bright MCP en Python En esta sección, aprenderás a utilizar Pydantic AI para construir un agente de IA. El agente estará equipado con capacidades de raspado, recuperación e interacción de datos en vivo desde el servidor Bright Data MCP. Como ejemplo, demostraremos cómo el agente puede recuperar datos de productos de Amazon sobre la marcha. Tenga en cuenta que éste es sólo uno de los [muchos casos de uso posibles](/ai/data-for-ai-agents). El agente de IA puede aprovechar cualquiera de las más de 50 herramientas disponibles a través del servidor MCP para realizar una amplia gama de tareas. Siga este tutorial guiado para crear su agente Gemini + Bright Data MCP-powered AI con Pydantic AI. ### Requisitos previos Para reproducir el ejemplo de código, asegúrese de tener instalado localmente lo siguiente: - [Python 3.10 o superior](https://www.python.org/downloads/). - [Node.js](https://nodejs.org/en/download) (recomendamos la última versión LTS). También necesitarás: - Una cuenta de Bright Data. - Una clave API de Gemini (o una clave API de otro proveedor de LLM compatible, como OpenAI, Anthropic, Deepseek, Ollama, Groq, Cohere y Mistral). No se preocupe por configurar las claves API todavía. Los pasos siguientes le guiarán en la configuración de las credenciales de Bright Data y Gemini cuando llegue el momento. Aunque no es estrictamente necesario, estos conocimientos previos le ayudarán a seguir el tutorial: - Comprensión general del funcionamiento de MCP. - Familiaridad básica con [el funcionamiento de los agentes de IA](/blog/ai/ai-agent-tech-stack). - Cierto conocimiento del servidor Bright Data MCP y sus herramientas disponibles. - Conocimientos básicos de [programación asíncrona en Python](https://docs.python.org/3/library/asyncio.html). ### Paso 1: Cree su proyecto Python Abre tu terminal y crea una nueva carpeta para tu proyecto: ```none mkdir pydantic-ai-mcp-agent ``` La carpeta `pydantic-ai-mcp-agent` contendrá todo el código para tu agente Python de IA. Navega hasta la carpeta recién creada y configura un [entorno virtual](https://docs.python.org/3/library/venv.html) dentro de ella: ```none cd pydantic-ai-mcp-agent python -m venv venv ``` Ahora, abre la carpeta del proyecto en tu IDE de Python preferido. Recomendamos [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). Crea un archivo llamado `agent.py` en la raíz de tu proyecto. En este punto, la estructura de carpetas debería ser la siguiente: ```none pydantic-ai-mcp-agent/ ├── venv/ └── agent.py ``` El archivo `agent.` py está actualmente vacío, pero pronto contendrá la lógica para integrar Pydantic AI con el servidor MCP de Bright Data Web. Active el entorno virtual utilizando el terminal de su IDE. En Linux o macOS, ejecute este comando: ```none source venv/bin/activate ``` De forma equivalente, en Windows, ejecute: ```none venv/Scripts/activate ``` ¡Ya está todo listo! Ahora tienes un entorno Python listo para construir un agente de IA con acceso a datos web. ### Paso 2: Instalar Pydantic AI En su entorno virtual activado, instale todos los paquetes Pydantic AI necesarios con: ```none pip install "pydantic-ai-slim[google,mcp]" ``` Esto instala [`pydantic-ai-slim`](https://ai.pydantic.dev/install/#slim-install), una versión ligera del paquete completo [`pydantic-ai`](https://pypi.org/project/pydantic-ai/) que evita tirar de dependencias innecesarias. En este caso, dado que planea integrar su agente con el servidor MCP de Bright Data Web, necesitará la extensión `mcp`. Y como integraremos Gemini como proveedor LLM, también necesitará la extensión `google`. **Nota**: Para otros modelos o proveedores, consulte la [documentación del modelo](https://ai.pydantic.dev/models/) para ver qué dependencias opcionales son necesarias. A continuación, añade estas importaciones en tu archivo `agent.py`: ```none from pydantic_ai import Agent from pydantic_ai.mcp import MCPServerStdio from pydantic_ai.models.google import GoogleModel from pydantic_ai.providers.google import GoogleProvider ``` ¡Genial! Ya puedes usar la IA de Pydantic para construir agentes. ### Paso nº 3: Configurar las variables de entorno Lectura Su agente de IA interactuará con servicios de terceros como Bright Data y Gemini a través de la API. No codifique sus claves API en su código Python. En su lugar, cárgalas desde variables de entorno para mejorar la seguridad y la facilidad de mantenimiento. Para simplificar el proceso, aprovecha la biblioteca [`python-dotenv`](https://pypi.org/project/python-dotenv/). Con tu entorno virtual activado, instálala ejecutando: ```none pip install python-dotenv ``` A continuación, en su archivo `agent.py`, importe la biblioteca y cargue las variables de entorno con `load_dotenv()`: ```none from dotenv import load_dotenv load_dotenv() ``` Esto permite al script leer variables de entorno desde un archivo local `.env`. Así que adelante y crear un archivo `.env` dentro de la carpeta del proyecto: ```none pydantic-ai-mcp-agent/ ├── venv/ ├── agent.py └── .env # <--------------- ``` Ahora puedes acceder a las variables de entorno de la siguiente manera: ```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 ``` Ya está. Ahora está configurado para cargar de forma segura las claves Api desde el archivo `.env`. ### Paso 4: Empezar a utilizar el servidor MCP de Bright Data Si aún no lo ha hecho, [cree una cuenta de Bright Data](/?hs_signup=1). Si ya tiene una, simplemente inicie sesión. A continuación, [siga las instrucciones oficiales](https://docs.brightdata.com/api-reference/authentication#generating-an-api-key%3A) para configurar su clave de API de Bright Data. Para simplificar, asumimos que está utilizando un token con permisos de administrador en esta sección. Instale el [MCP Web de Bright](https://github.com/brightdata/brightdata-mcp) Data de forma global a través de `npm`: ```none npm install -g @brightdata/mcp ``` A continuación, comprueba que todo funciona con el siguiente comando Bash: ```none API_TOKEN="" npx -y @brightdata/mcp ``` O, en Windows, el comando PowerShell equivalente es: ```none $env:API_TOKEN=""; npx -y @brightdata/mcp ``` En el comando anterior, sustituya el marcador de posición `` por la API real de Bright Data que recuperó anteriormente. Ambos comandos establecen la variable de entorno `API_TOKEN` necesaria e inician el servidor MCP a través del paquete [`@brightdata/mcp`](https://www.npmjs.com/package/@brightdata/mcp) npm. Si todo funciona correctamente, su terminal mostrará registros similares a este: ![Registros de inicio del servidor Bright Data MCP](https://media.brightdata.com/2025/08/image-31-1024x157.png)La primera vez que inicie el servidor MCP, creará automáticamente dos zonas predeterminadas en su cuenta de Bright Data: - `mcp_unlocker`: Una zona para [Web Unlocker](/products/web-unlocker). - `mcp_browser`: Una zona para [la API del navegador](/products/scraping-browser). Estas dos zonas permiten al servidor MCP ejecutar todas las herramientas que expone. Para comprobarlo, inicie sesión en su panel de Bright Data y vaya a la página[“Proxies & Scraping Infrastructure](/cp/zones)“. Verá que se han creado automáticamente las siguientes zonas: ![Las zonas mcp_unlocker y mcp_browser creadas por el servidor MCP al iniciarse.](https://media.brightdata.com/2025/08/image-32-1024x539.png)**Nota**: Si no está utilizando un token de API con permisos de administrador, tendrá que crear las zonas manualmente. De todas formas, siempre puedes especificar los nombres de las zonas en los envs como se explica en la [documentación oficial](https://github.com/brightdata/brightdata-mcp?tab=readme-ov-file#-account-setup). Por defecto, el MCP Web sólo expone las herramientas `search_engine` y `scrape_as_markdown`. Para desbloquear capacidades avanzadas como la automatización del navegador y la extracción de datos estructurados, tienes que activar el modo Pro estableciendo la variable de entorno `PRO_MODE=true`. ¡Estupendo! El Bright Data MCP funciona a las mil maravillas. ### Paso nº 5: Conectarse a la Bright Data MCP Ahora que has confirmado que tu máquina puede ejecutar Bright Data MCP, ¡conéctate a ella! Empiece añadiendo su clave de API de Bright Data al archivo `.env`: ```none BRIGHT_DATA_API_KEY="" ``` Sustituya el `` por la clave real de la API de Bright Data que obtuvo anteriormente. Luego, léelo en el archivo `agent.py` con: ```none BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") ``` Tenga en cuenta que Pydantic AI admite [tres métodos de conexión a un servidor MCP](https://ai.pydantic.dev/mcp/client/#usage): 1. Utilización del transporte HTTP Streamable. 2. Utilización del transporte HTTP SSE. 3. Ejecutar el servidor como un subproceso y conectarse a través de [`stdio`](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#stdio). Si no está familiarizado con los dos primeros métodos, lea nuestra guía sobre [SSE vs Streamable HTTP](/blog/ai/sse-vs-streamable-http) para obtener una explicación más detallada. En este caso, desea ejecutar el servidor como un subproceso (tercer método). Para ello, inicialice una instancia [`MCPServerStdio`](https://ai.pydantic.dev/api/mcp/#pydantic_ai.mcp.MCPServerStdio) como se muestra a continuación: ```none server = MCPServerStdio( "npx", args=[ "-y", "@brightdata/mcp", ], env={ "API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true" # Enable the Pro Mode to access all Bright Data tools }, ) ``` Lo que hacen estas líneas de código es esencialmente lanzar el Bright Data MCP utilizando el mismo comando `npx` que ejecutó anteriormente. Establece la variable de entorno `API_TOKEN` utilizando su clave API de Bright Data para la autenticación. Además, habilita `PRO_MODE` para que tenga acceso a todas las herramientas disponibles, incluidas las avanzadas. Perfecto. Ahora ha configurado correctamente la conexión a su Bright Data MCP local en código. ### Paso nº 6: Configurar el LLM **Nota**: Esta sección se refiere a Gemini, el LLM elegido para el tutorial. Sin embargo, puedes adaptarlo fácilmente a [OpenAI](https://ai.pydantic.dev/models/openai/) o a cualquier otro LLM soportado [siguiendo la documentación oficial](https://ai.pydantic.dev/models/). Comience por [recuperar su clave API Gemini](https://aistudio.google.com/app/apikey) y añádala a su archivo `.env` de la siguiente manera: ```none GOOGLE_API_KEY="" ``` Sustituya el `` con su clave API real. A continuación, importe las bibliotecas Pydantic AI necesarias para la integración de Gemini: ```none from pydantic_ai.models.google import GoogleModel from pydantic_ai.providers.google import GoogleProvider ``` Estas importaciones le permiten conectarse a las API de Google y configurar un modelo Gemini. Fíjate en que no necesitas leer manualmente la `GOOGLE_API_KEY` del archivo `.env`. La razón es que `GoogleProvider` utiliza [`google-genai`](https://pypi.org/project/google-genai/) bajo el capó, que lee automáticamente la clave de API de la env `GOOGLE_API_KEY`. Ahora, inicialice las instancias del proveedor y del modelo: ```none provider = GoogleProvider() model = GoogleModel("gemini-2.5-flash", provider=provider) ``` ¡Asombroso! Esto permitirá al agente Pydantic AI conectarse al modelo [`gemini-2.5-flash`](https://cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/2-5-flash) a través de la API de Google, que es de uso gratuito. ### Paso 7: Definir el agente Pydantic AI Definir un Agente Pydantic AI que utilice el LLM previamente configurado y se conecte al servidor Bright Data MCP: ```none agent = Agent(model, toolsets=[server]) ``` Perfecto. Con una sola línea de código, acabas de instanciar un objeto [`Agente`](https://ai.pydantic.dev/api/agent/#pydantic_ai.agent.Agent). Esto representa un agente AI que puede manejar sus tareas usando las herramientas expuestas por el servidor Bright Data MCP. ### Paso 8: Ponga en marcha su agente Para probar su agente de IA, debe escribir una solicitud que implique una tarea de extracción de datos web (en interacción). Esto le ayudará a verificar si el agente utiliza las herramientas de Bright Data como se espera. Un buen punto de partida es pedirle que recupere los datos de un producto de una página de Amazon, así: > “Dame los datos del producto de https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/” Normalmente, si envías una solicitud como ésta directamente a Géminis, sucedería una de dos cosas: 1. La solicitud fallaría debido a los sistemas anti-bot de Amazon (por ejemplo, el [CAPTCHA de Amazon](/blog/datos-web/bypass-amazon-captcha)), que impiden a Gemini acceder al contenido de la página. 2. Devolvería información alucinada o inventada sobre el producto, ya que no puede acceder a la página en directo. Pruebe la solicitud directamente en Géminis. Es probable que aparezca un mensaje diciendo que no se pudo acceder a la página de Amazon, seguido de los detalles del producto fabricado, como a continuación: ![La respuesta infructuosa producida por Gemini](https://media.brightdata.com/2025/08/image-33-1024x538.png)Gracias a la integración con el servidor Bright Data MCP, esto no debería ocurrir en tu configuración. En lugar de fallar o adivinar, tu agente debería utilizar la herramienta `web_data_amazon_product` para recuperar datos de producto estructurados y en tiempo real de la página de Amazon y devolverlos después en un formato limpio y legible. Dado que el método para interrogar al agente Pydantic AI es asíncrono, envuelve la lógica de ejecución en una función `asíncrona` como esta: ```none async def main(): async with agent: result = await agent.run("Give me product data from https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/") output = result.output print(output) if __name__ == "__main__": asyncio.run(main()) ``` No olvides importar [`asyncio`](https://docs.python.org/3/library/asyncio.html) de la biblioteca estándar de Python: ```none import asyncio ``` Misión cumplida. Sólo queda ejecutar el código completo y ver si el agente está a la altura de las expectativas. ### Paso 9: Póngalo todo junto Este es el código final en `agent.py`: ```none from pydantic_ai import Agent from pydantic_ai.mcp import MCPServerStdio from pydantic_ai.models.google import GoogleModel from pydantic_ai.providers.google import GoogleProvider from dotenv import load_dotenv import os import asyncio # Load the environment variables from the .env file load_dotenv() # Read the API key from the envs for integration with the Bright Data MCP server BRIGHT_DATA_API_KEY = os.getenv("BRIGHT_DATA_API_KEY") # Connect to the Bright Data MCP server server = MCPServerStdio( "npx", args=[ "-y", "@brightdata/mcp", ], env={ "API_TOKEN": BRIGHT_DATA_API_KEY, "PRO_MODE": "true" # Enable the Pro Mode to access all Bright Data tools }, ) # Configure the Google LLM model provider = GoogleProvider() model = GoogleModel("gemini-2.5-flash", provider=provider) # Initialize the AI agent with Gemini and Bright Data MCP server integration agent = Agent(model, toolsets=[server]) async def main(): async with agent: # Ask the AI Agent to perform a scraping task result = await agent.run("Give me product data from https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/") # Get the result produced by the agent and print it output = result.output print(output) if __name__ == "__main__": asyncio.run(main()) ``` ¡Guau! Gracias a Pydantic AI y Bright Data, en unas 50 líneas de código, acabas de construir un potente agente de IA potenciado por MCP. Ejecutar el agente AI con: ```none python agent.py ``` En el terminal, debería ver una salida como la siguiente: ![Los resultados obtenidos por el agente Pydantic AI](https://media.brightdata.com/2025/08/image-34-1024x647.png)Como puede comprobar comprobando la [página de productos de Amazon mencionada en la solicitud](https://www.amazon.com/AmazonBasics-Pound-Neoprene-Dumbbells-Weights/dp/B01LR5S6HK/), la información devuelta por el agente de IA es exacta: ![El producto de Amazon mencionado en el aviso](https://media.brightdata.com/2025/08/The-Amazon-product-mentioned-in-the-prompt-1-1024x553.png)Esto se debe a que el agente utilizó la herramienta `web_data_amazon_product` proporcionada por el servidor Bright Data MCP para recuperar datos de productos frescos y estructurados de Amazon en formato JSON. ¡Et voilà! Se cumplieron las expectativas y la integración de Pydantic AI + MCP funcionó exactamente como estaba previsto. ### Próximos pasos El agente de IA construido aquí es funcional, pero sólo sirve como punto de partida. Considera la posibilidad de llevarlo al siguiente nivel: - Implementar un bucle REPL para chatear con el agente en la CLI o [integrarlo con herramientas de chat GUI como Gradio](https://www.gradio.app/guides/creating-a-chatbot-fast). - Ampliación de las herramientas MCP de Bright Data mediante la [definición de sus propias herramientas personalizadas](https://ai.pydantic.dev/tools/). - Añadir depuración y monitorización [usando Pydantic Logfire](https://ai.pydantic.dev/logfire/). - Transformación de su agente en un [agente autónomo RAG](/blog/ai/agentic-rag) dentro de un flujo de trabajo multiagente. - Definición de [validadores de funciones personalizados](https://ai.pydantic.dev/output/#output-validator-functions) para la integridad de los datos de salida. ## Conclusión En este artículo, has aprendido cómo integrar Pydantic AI con [el servidor Bright Data MCP de Bright Data](/ai/mcp-server) para construir un agente de IA capaz de acceder a la web. Esta integración es posible gracias al soporte integrado de Pydantic AI para MCP. Para crear agentes más sofisticados, explore toda la gama de servicios disponibles en la [infraestructura de IA de Bright Data](/ai). Estas soluciones pueden alimentar una amplia variedad de [escenarios de agentes](/ai/web-access). Cree una cuenta gratuita en Bright Data y empiece a experimentar con nuestras herramientas de datos web preparadas para la IA. Contactar ventasPrueba gratuita![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Tabla de Contenidos Data for AI Supercharge your AI with instant and reliable access to web data. No blockers. No hassle. Talk to an expert Bright Data MCP Get started with Bright Data’s Web MCP Server today with 5000 free monthly requests and unlock your AI’s full potential. Start free now [ ](https://news.ycombinator.com/submitlink?t=Pydantic+AI+con+Bright+Data+MCP+de+Bright+Data+para+agentes+con+acceso+a+datos&u=https://brightdata.es/blog/ai/pydantic-ai-with-web-mcp) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Pydantic+AI+con+Bright+Data+MCP+de+Bright+Data+para+agentes+con+acceso+a+datos&url=https://brightdata.es/blog/ai/pydantic-ai-with-web-mcp) [ ](http://www.reddit.com/submit?title=Pydantic+AI+con+Bright+Data+MCP+de+Bright+Data+para+agentes+con+acceso+a+datos&url=https://brightdata.es/blog/ai/pydantic-ai-with-web-mcp) ## 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)