Integre Qwen-Agent con MCP para crear agentes con acceso a datos en tiempo real

En esta guía aprenderás:

• Qué es la librería Qwen-Agent y cómo te ayuda a construir agentes de IA.
• Por qué utilizar Qwen3 con el servidor MCP de Bright Data es ideal para crear agentes de IA de nueva generación.
• Cómo integrar Qwen-Agent con MCP de Bright Data para construir un agente competente potenciado por Qwen3.

Sumerjámonos.

¿Qué es Qwen-Agent?

Qwen-Agent es un marco de código abierto desarrollado por Alibaba Cloud para crear aplicaciones avanzadas basadas en LLM. Aprovecha las capacidades de los modelos Qwen para crear agentes de IA compatibles con el seguimiento de instrucciones, el uso de herramientas, la planificación y la gestión de memoria.

Esta biblioteca sirve principalmente como backend para Qwen Chat. Ofrece componentes básicos para construir agentes de IA, con soporte nativo para llamadas a funciones y herramientas, incluso a través de MCP(Model Context Protocol).

Qwen-Agent permite el despliegue flexible de modelos, ya sea a través del servicio DashScope de Alibaba Cloud o de modelos Qwen autoalojados. También incluye una interfaz de usuario web basada en Gradio para desplegar y probar rápidamente sus agentes en el navegador.

Por qué combinar Qwen3 con un servidor MCP en Qwen-Agent

Qwen3 es el último modelo desarrollado por Alibaba Cloud. Ofrece un gran rendimiento y, al ser de código abierto, está disponible de forma gratuita a través de múltiples proveedores en línea (¡e incluso puedes alojarlo tú mismo!). Esto lo convierte en la opción ideal para crear agentes de IA rentables pero potentes.

Ahora, los agentes de IA impulsados por Qwen3 y construidos con Qwen-Agent ya son capaces. Aun así, heredan las limitaciones del LLM subyacente. Estas limitaciones -como la falta de acceso a información en tiempo real- pueden superarse proporcionando al agente datos precisos y permitiéndole realizar exploraciones web en directo.

Aquí es donde entra en juego el servidor MCP de Bright Data. Construido sobre Node.js, el servidor MCP se integra con el conjunto de herramientas de recuperación de datos de IA de Bright Data. A través de estas herramientas, su agente obtiene la capacidad de acceder a contenido web en tiempo real, consultar conjuntos de datos estructurados y realizar raspado web en directo.

A partir de ahora, las herramientas MCP compatibles son:

Para explorar algunos ejemplos del mundo real, lea nuestra guía sobre scraping con el servidor MCP o vea cómo se integra con herramientas como el SDK de Google.

Nota: Bright Data amplía continuamente el conjunto de herramientas MCP, así que espere aún más capacidades con el tiempo.

Ahora, ¡echa un vistazo a cómo puedes usar estas herramientas MCP a través de Qwen3 con Qwen-Agent!

Cómo integrar Qwen-Agent con el servidor MCP de Bright en Python

En esta sección, aprenderá a utilizar Qwen-Agent para construir un potente agente Python de IA potenciado por Qwen3. El agente estará equipado con capacidades de raspado, recuperación y transformación de datos en vivo a través del servidor MCP de Bright Data.

A modo de ejemplo, mostraremos cómo el agente de IA puede recuperar datos de productos en tiempo real de Amazon,conocido por sus problemas de scraping. Tenga en cuenta que éste es sólo un caso de uso posible. El agente de IA puede aprovechar cualquiera de las más de 20 herramientas disponibles a través del servidor MCP para gestionar una amplia variedad de tareas.

Nota: Simplemente dándole al agente de IA diferentes indicaciones, puedes lograr cualquier otro escenario o caso de uso.

Siga los pasos que se indican a continuación para crear su agente de IA con tecnología MCP de Bright Data utilizando Qwen-Agent y Qwen 3.

Requisitos previos

Para seguir este tutorial, debe tener:

• Python 3.10 o superior instalado localmente.
• Node.js instalado localmente.

También necesitarás:

• Una cuenta de Bright Data.
• Una clave API de OpenRouter.

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

Aunque no son necesarios, los siguientes conocimientos le ayudarán a sacar el máximo partido a este tutorial:

• Comprensión general del funcionamiento de MCP.
• Familiaridad básica con el funcionamiento del Agente Qwen.
• Ciertos conocimientos sobre 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 el terminal y cree una nueva carpeta para su agente de IA con tecnología MCP:

mkdir qwen-agent-mcp

La carpeta qwen-agent-mcp 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 qwen-agent-mcp
python -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.

Crea un archivo llamado agent.py dentro de la carpeta del proyecto, que ahora debería tener este aspecto:

El archivo agent. py está actualmente vacío, pero pronto contendrá la lógica para integrar Qwen3 con el servidor MCP de Bright Data.

Active el entorno virtual utilizando el terminal de su IDE. En Linux o macOS, ejecute este comando:

source venv/bin/activate

De forma equivalente, en Windows, ejecute:

venv/Scripts/activate

¡Ya está todo listo! Ahora tiene un entorno Python para construir un agente de IA usando el Qwen-Agent y el servidor MCP de Bright Data.

Paso 2: Configurar las variables de entorno Lectura

Su proyecto interactuará con servicios de terceros como OpenRouter y Bright Data. Evite codificar las claves API en su código Python. En su lugar, cárguelas desde variables de entorno para mejorar la seguridad y la facilidad de mantenimiento.

Para simplificar este proceso, aprovecharemos la biblioteca python-dotenv. Con tu entorno virtual activado, instálala ejecutando:

pip install python-dotenv

A continuación, en su archivo agent.py, importe la biblioteca y cargue las variables de entorno con load_dotenv():

from dotenv import load_dotenv

load_dotenv()

Esto permite a tu script leer variables de entorno desde un archivo local .env. Así que adelante, crea un archivo . env dentro de la carpeta de tu proyecto:

Ahora puedes acceder a las variables de entorno en tu código de la siguiente manera:

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

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

import os

Genial. Ahora estás preparado para cargar secretos de forma segura desde las variables de entorno.

Paso 3: Empezar con Google ADK

En su entorno virtual activado, instale la biblioteca Qwen-Agent ejecutando:

pip install "qwen-agent[gui,mcp]"

Ten en cuenta que qwen-agent admite algunos submódulos opcionales. Para este tutorial, estos dos son suficientes:

• [gui] para una interfaz de usuario basada en Gradio.
• [mcp ] para integrarse con cualquier servidor MCP.

A continuación, abra su archivo agent.py e incluya las siguientes importaciones:

from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

Estos se utilizarán en los siguientes pasos para conectar Qwen-Agent con el servidor MCP e implementar su agente AI.

Por defecto, Qwen-Agent espera una clave API DashScope en su entorno para acceder a los modelos Qwen. Sin embargo, en este tutorial, utilizaremos Qwen3 a través de la plataforma gratuita OpenRouter.

⚠️ Advertencia: Puede que te preguntes por qué no estamos utilizando DashScope de Alibaba Cloud para acceder directamente a Qwen3. La razón es que, en el momento de escribir este artículo, existen limitaciones para los usuarios internacionales (es decir, los usuarios de fuera de China). Estas restricciones actualmente conducen al siguiente mensaje de error (algo engañoso):

Error code: InvalidApiKey. Error message: Invalid API-key provided.

Para evitar este problema, puedes utilizar OpenRouter o cualquier otra plataforma que proporcione acceso a Qwen3 sin restricciones regionales.

Veamos ahora cómo configurar tu clave API de OpenRouter para la integración con Qwen3.

Paso 4: Recuperar la clave API de OpenRouter

Si aún no lo ha hecho, regístrese para obtener una cuenta OpenRouter. Si ya tiene una, simplemente inicie sesión.

A continuación, vaya a la página “Claves API” pasando el ratón por encima de su imagen de perfil en la esquina superior derecha y seleccionando la opción “Claves”:

Haz clic en el botón “Crear clave API” y sigue las instrucciones para generar tu clave. A continuación, copia la clave y añádela a tu archivo .env de la siguiente forma:

OPEN_ROUTER_API_KEY="<YOUR_OPEN_ROUTER_API_KEY>"

Sustituya el por su clave de API de OpenRouter real.

A continuación, en su archivo agent.py, cargue la clave utilizando:

OPEN_ROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")

¡Estupendo! Ya estás listo para usar Qwen3 con Qwen-Agent a través de OpenRouter.

Paso 5: Configurar el servidor MCP de Bright Data

Empiece por [crear una nueva cuenta de Bright Data]() o simplemente acceda a su cuenta existente.

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.

Una vez hecho esto, deberías tener:

• Un token de la API de Bright Data.
• Una zona Web Unlocker (aquí, asumiremos que el nombre de la zona es el predeterminado “mcp_unlocker”).
• Raspado de las credenciales del navegador en el formato <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Ahora, instale el servidor MCP de Bright Data globalmente en su entorno Node.js con:

npm install -g @brightdata/mcp

A continuación, asegúrese de especificar dos entornos en su terminal:

API_TOKEN="<YOUR_BRIGHT_DATA_API_TOKEN>"
BROWSER_AUTH="<BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>"

Siga el procedimiento correcto para la definición de variables de entorno en función del sistema operativo.

Ahora puede iniciar el servidor MCP a través del paquete @brightdata/mcp npm con:

npx -y @brightdata/mcp

Este comando lanza el servidor MCP localmente, leyendo las variables de entorno requeridas(API_TOKEN y BROWSER_AUTH). Si todo está configurado correctamente, debería ver una salida como esta:

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

Buen trabajo. El servidor MCP de Bright Data funciona a las mil maravillas.

A continuación, añada esas dos variables de entorno a su archivo .env:

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.

En tu agent.py, carga estas variables 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 Qwen-Agent.

Paso #6: Definir el Agente MCP de Qwen3

Crea una función para inicializar tu agente AI con soporte Qwen3 y MCP:

def initialize_mcp_agent():
    # To connect to Qwen3 via OpenRouter
    llm_cfg = {
        "model": "qwen/qwen3-32b:free",
        "model_server": "https://openrouter.ai/api/v1",
        "api_key": OPEN_ROUTER_API_KEY,
    }

    # To connect to the Bright Data MCP server
    tools = [{
        "mcpServers": {
            "brightdata": {
                "command": "npx",
                "args": ["-y", "@brightdata/mcp"],
                "env": {
                    "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                    "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
                }
            }
        }
    }]


    # Define the Qwen-Agent assistant with MCP integration
    agent = Assistant(
        llm=llm_cfg,
        function_list=tools,
        name="MCP-Powered Assistant with Access to Live Data",
        description="This agent can answer questions by retrieving up-to-date information from the Internet using configured MCP tools"
    )

    return agent

Como puedes ver, en el código anterior:

• El diccionario llm_cfg configura el acceso a la versión gratuita de Qwen3 a través de la API OpenRouter.
• La matriz de herramientas define cómo conectarse al servidor MCP de Bright Data, lo que permite al agente de IA llamar a herramientas externas de recuperación de datos.
• Por último, la clase Assistant() proporcionada por Qwen-Agent se utiliza para definir el agente de IA con las integraciones LLM y de herramientas.

Ya está. Gracias a Qwen-Agent, la integración de MCP en su agente AI sólo requiere unas pocas líneas de código.

Paso #7: Inicie su Agente MCP Qwen3

Añade el siguiente código a agent.py para ejecutar el agente de IA definido en una interfaz de Gradio:

if __name__ == "__main__":
    # Initialize the MCP-powered agent
    mcp_agent = initialize_mcp_agent()

    # Launch the Gradio-based web UI to interact with the AI agent in the browser
    WebUI(mcp_agent).run()

Misión cumplida. Sólo queda probar el código y ver de qué es capaz el agente de la IA.

Paso 8: Póngalo todo junto

Este es el código final en agent.py:

from dotenv import load_dotenv
import os
from qwen_agent.agents import Assistant
from qwen_agent.gui import WebUI

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

# Read the API key from OpenRouter to use Qwen3
OPEN_ROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")

# 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 agent with Qwen 3 and MCP configuration
def initialize_mcp_agent():
    # To connect to Qwen3 via OpenRouter
    llm_cfg = {
        "model": "qwen/qwen3-32b:free",
        "model_server": "https://openrouter.ai/api/v1",
        "api_key": OPEN_ROUTER_API_KEY,
    }

    # To connect to the Bright Data MCP server
    tools = [{
        "mcpServers": {
            "brightdata": {
                "command": "npx",
                "args": ["-y", "@brightdata/mcp"],
                "env": {
                    "API_TOKEN": BRIGHT_DATA_API_TOKEN,
                    "BROWSER_AUTH": BRIGHT_DATA_BROWSER_AUTH,
                }
            }
        }
    }]


    # Define the Qwen-Agent assistant with MCP integration
    agent = Assistant(
        llm=llm_cfg,
        function_list=tools,
        name="MCP-Powered Assistant with Access to Live Data",
        description="This agent can answer questions by retrieving up-to-date information from the Internet using configured MCP tools"
    )

    return agent

if __name__ == "__main__":
    # Initialize the MCP-powered agent
    mcp_agent = initialize_mcp_agent()

    # Launch the Gradio-based web UI to interact with the AI agent in the browser
    WebUI(mcp_agent).run()

¡Wow! Con sólo unas 50 líneas de código, puede crear un potente agente de IA basado en MCP, gracias a Qwen-Agent y OpenRouter.

Ejecutar el agente AI con:

python agent.py

En el terminal, debería ver una salida como la siguiente:

2025-05-27 15:40:58,783 - mcp_manager.py - 122 - INFO - Initializing MCP tools from mcp servers: ['brightdata']
2025-05-27 15:40:58,800 - mcp_manager.py - 340 - INFO - Initializing a MCP stdio_client, if this takes forever, please check the config of this mcp server: brightdata
2025-05-27 15:41:01,098 - mcp_manager.py - 350 - INFO - No list resources: Method not found
* Running on local URL:  http://127.0.0.1:7860

Esto te indica que el servidor MCP está en funcionamiento y que tu agente de IA está conectado y accesible en http://127.0.0.1:7860. Visita esa URL en tu navegador para interactuar con el agente a través de la interfaz de usuario web de Gradio.

Por ejemplo, intente preguntarle algo como esto:

From the Amazon product page "https://www.amazon.com/PlayStation%C2%AE5-console-slim-PlayStation-5/dp/B0CL61F39H/", extract the main info and return it in JSON format

Esta es una gran prueba para verificar si el agente de IA puede recuperar (y por lo tanto utilizar/aprender de) datos en tiempo real de la página de producto de Amazon PS5:

Cuando ejecute esta solicitud en la interfaz de usuario, esto es lo que debería ocurrir:

En primer lugar, observe que en el panel derecho hay una lista de todas las herramientas disponibles del servidor MCP de Bright Data. Además, vea cómo el agente Qwen utiliza la herramienta web_data_amazon_product del servidor MCP de Bright Data para completar la solicitud.

Puede comprobarlo consultando la lista de viñetas de la interfaz, que muestra el resultado de la ejecución de la herramienta:

Al final, la salida JSON final debería tener este aspecto:

{
  "title": "PlayStation®5 console (slim)",
  "url": "https://www.amazon.com/PlayStation%C2%AE5-console-slim-PlayStation-5/dp/B0CL61F39H",
  "brand": "Sony",
  "model_number": "CFI-2015",
  "price": {
    "currency": "USD",
    "final_price": 499
  },
  "availability": "In Stock",
  "rating": 4.7,
  "reviews_count": 6824,
  "description": "The PS5 console unleashes new gaming possibilities that you never anticipated. Experience lightning fast loading with an ultra-high speed SSD, deeper immersion with support for haptic feedback, adaptive triggers, and 3D Audio*, and an all-new generation of incredible PlayStation games...",
  "key_features": [
    "Custom CPU, GPU, and SSD with Integrated I/O",
    "Support for haptic feedback, adaptive triggers, and 3D Audio",
    "Backward compatibility with PS4 games",
    "1TB SSD and 10.6 lb console weight",
    "Includes DualSense Wireless Controller"
  ],
  "delivery_info": "FREE delivery Sunday, June 1. Or Prime members get FREE Same-Day delivery Today 10 AM - 3 PM.",
  "images": [
    "https://m.media-amazon.com/images/I/41ECK5cY-2L.SL1000.jpg",
    "https://m.media-amazon.com/images/I/41srF-iY93L.SL1000.jpg"
    // more image URLs...
  ],
  "product_details": {
    "ASIN": "B0CL61F39H",
    "Release Date": "December 10, 2023",
    "Dimensions": "14 x 17 x 7 inches",
    "Weight": "10.6 pounds",
    "Best Seller Rank": "#18 in Video Games",
    "Manufacturer": "Sony"
  },
  // omitted for brevity...
}

Este sencillo ejemplo demuestra lo potente que es su agente de IA. Puede extraer datos estructurados en tiempo real de cualquier sitio sobre la marcha. Esto es perfecto para la búsqueda en directo, la RAG(Retrieval-Augmented Generation) y la toma de decisiones actualizada.

Aún mejor, el agente también puede utilizar Agent Browser (antes Scraping Browser) para interactuar directamente con las páginas web, lo que permite una automatización de alto nivel y flujos de trabajo complejos.

¡Et voilà! Ese es el poder de Qwen3 + integración MCP con Qwen-Agent para construir agentes de IA de nueva generación.

Conclusión

En esta entrada de blog, ha aprendido a crear un potente agente de IA en Python utilizando la biblioteca Qwen-Agent en combinación con Qwen3 y Bright Data MCP.

Como se muestra, la integración de un servidor MCP rico en funciones con Qwen-Agent permite a su agente de IA recuperar datos en tiempo real de la web y realizar tareas avanzadas de forma autónoma. Este es solo un ejemplo de cómo las herramientas de Bright Data pueden impulsar flujos de trabajo de IA inteligentes y automatizados.

Explore las soluciones de nuestra infraestructura 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.