Integre o Qwen-Agent com o MCP para criar agentes com acesso a dados em tempo real

Neste guia, você aprenderá:

• O que é a biblioteca Qwen-Agent e como ela ajuda você a criar agentes de IA.
• Por que usar o Qwen3 com o servidor MCP da Bright Data é ideal para criar agentes de IA de última geração.
• Como integrar o Qwen-Agent com o MCP da Bright Data para criar um agente competente com o Qwen3.

Vamos mergulhar de cabeça!

O que é o Qwen-Agent?

O Qwen-Agent é uma estrutura de código aberto desenvolvida pela Alibaba Cloud para a criação de aplicativos avançados alimentados por LLM. Ele aproveita os recursos dos modelos Qwen para criar agentes de IA com suporte para acompanhamento de instruções, uso de ferramentas, planejamento e gerenciamento de memória.

Essa biblioteca serve principalmente como backend para o Qwen Chat. Ela oferece componentes essenciais para a criação de agentes de IA, com suporte nativo para chamadas de funções e ferramentas, inclusive via MCP(Model Context Protocol).

O Qwen-Agent permite a implantação flexível de modelos, seja por meio do serviço DashScope da Alibaba Cloud ou de modelos Qwen auto-hospedados. Ele também inclui uma interface de usuário da Web baseada em Gradio para implementar e testar rapidamente seus agentes no navegador.

Por que combinar o Qwen3 com um servidor MCP no Qwen-Agent

O Qwen3 é o modelo mais recente desenvolvido pela Alibaba Cloud. Ele oferece excelente desempenho e, por ser de código aberto, está disponível gratuitamente em vários provedores on-line (e você pode até hospedá-lo por conta própria!). Isso o torna a escolha ideal para a criação de agentes de IA econômicos, porém poderosos.

Agora, os agentes de IA com tecnologia Qwen3 e criados com o Qwen-Agent já são capazes. Ainda assim, eles herdam as limitações do LLM subjacente. Essas limitações, como a falta de acesso a informações em tempo real, podem ser superadas fornecendo ao agente dados precisos e permitindo que ele realize a exploração da Web ao vivo.

É aí que entra o servidor MCP da Bright Data. Criado em Node.js, o servidor MCP se integra ao conjunto de ferramentas de recuperação de dados de IA da Bright Data. Por meio dessas ferramentas, seu agente ganha a capacidade de acessar conteúdo da Web em tempo real, consultar conjuntos de dados estruturados e realizar raspagem da Web ao vivo.

No momento, as ferramentas MCP compatíveis são:

Para explorar alguns exemplos do mundo real, leia nosso guia sobre raspagem com o servidor MCP ou veja como ele se integra a ferramentas como o Google SDK.

Observação: a Bright Data expande continuamente o conjunto de ferramentas do MCP, portanto, espere ainda mais recursos ao longo do tempo.

Agora, dê uma olhada em como você pode usar essas ferramentas MCP por meio do Qwen3 com o Qwen-Agent!

Como integrar o Qwen-Agent com o servidor Bright MCP em Python

Nesta seção, você aprenderá a usar o Qwen-Agent para criar um poderoso agente de IA Python alimentado pelo Qwen3. O agente será equipado com recursos de raspagem, recuperação e transformação de dados ao vivo por meio do servidor Bright Data MCP.

Como exemplo, mostraremos como o agente de IA pode recuperar dados de produtos em tempo real da Amazon, queé conhecida por seus desafios de raspagem. Observe que esse é apenas um caso de uso possível. O agente de IA pode aproveitar qualquer uma das mais de 20 ferramentas disponíveis no servidor MCP para lidar com uma ampla variedade de tarefas.

Observação: simplesmente dando ao agente de IA prompts diferentes, você pode realizar qualquer outro cenário ou caso de uso.

Siga as etapas abaixo para criar seu agente de IA com tecnologia MCP da Bright Data usando o Qwen-Agent e o Qwen 3!

Pré-requisitos

Para seguir este tutorial, você deve ter:

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

Você também precisará de:

• Uma conta da Bright Data.
• Uma chave de API do OpenRouter.

As etapas abaixo o orientarão na configuração das credenciais do Bright Data e do OpenRouter, quando necessário. Portanto, não se preocupe com elas no momento.

Embora não seja obrigatório, o conhecimento a seguir o ajudará a tirar o máximo proveito deste tutorial:

• Uma compreensão geral de como o MCP funciona.
• Familiaridade básica com o funcionamento do Qwen Agent.
• Algum conhecimento do servidor Bright Data MCP e de suas ferramentas disponíveis.
• Alguma experiência com programação assíncrona em Python.

Etapa 1: Configuração do projeto

Abra o terminal e crie uma nova pasta para seu agente de IA com tecnologia MCP:

mkdir qwen-agent-mcp

A pasta qwen-agent-mcp conterá todo o código do seu agente de IA Python.

Em seguida, navegue até a pasta do projeto e crie um ambiente virtual dentro dela:

cd qwen-agent-mcp
python -m venv venv

Abra a pasta do projeto em seu IDE Python preferido. Recomendamos usar o Visual Studio Code com a extensão Python ou o PyCharm Community Edition.

Crie um arquivo chamado agent.py dentro da pasta do projeto, que agora deve ter a seguinte aparência:

O arquivo agent.py está vazio no momento, mas em breve conterá a lógica de integração do Qwen3 com o servidor MCP da Bright Data.

Ative o ambiente virtual usando o terminal em seu IDE. No Linux ou macOS, execute este comando:

source venv/bin/activate

De forma equivalente, no Windows, inicie:

venv/Scripts/activate

Está tudo pronto! Agora você tem um ambiente Python para criar um agente de IA usando o Qwen-Agent e o servidor MCP da Bright Data.

Etapa 2: Configurar a leitura das variáveis de ambiente

Seu projeto interagirá com serviços de terceiros, como o OpenRouter e o Bright Data. Evite codificar chaves de API em seu código Python. Em vez disso, carregue-as a partir de variáveis de ambiente para aumentar a segurança e a facilidade de manutenção.

Para simplificar esse processo, usaremos a biblioteca python-dotenv. Com seu ambiente virtual ativado, instale-a executando:

pip install python-dotenv

Em seguida, em seu arquivo agent.py, importe a biblioteca e carregue as variáveis de ambiente com load_dotenv():

from dotenv import load_dotenv

load_dotenv()

Isso permite que seu script leia as variáveis de ambiente de um arquivo .env local. Portanto, vá em frente e crie um arquivo .env dentro da pasta do seu projeto:

Agora você pode acessar as variáveis de ambiente em seu código da seguinte forma:

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

Não se esqueça de importar o módulo os da biblioteca padrão do Python:

import os

Excelente! Agora você está pronto para carregar segredos de forma segura a partir das variáveis de ambiente.

Etapa 3: começar a usar o Google ADK

Em seu ambiente virtual ativado, instale a biblioteca Qwen-Agent executando:

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

Observe que o qwen-agent oferece suporte a alguns submódulos opcionais. Para este tutorial, esses dois são suficientes:

• [gui] para uma interface de usuário baseada no Gradio.
• [mcp] para integração com qualquer servidor MCP.

Em seguida, abra o arquivo agent.py e inclua as seguintes importações:

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

Eles serão usados nas próximas etapas para conectar o Qwen-Agent ao servidor MCP e implementar seu agente de IA.

Por padrão, o Qwen-Agent espera uma chave de API do DashScope em seu ambiente para acessar os modelos Qwen. No entanto, neste tutorial, usaremos o Qwen3 por meio da plataforma gratuita OpenRouter.

⚠️ Aviso: Talvez você se pergunte por que não estamos usando o DashScope do Alibaba Cloud para acessar o Qwen3 diretamente. O motivo é que, no momento em que escrevemos este texto, há limitações para usuários internacionais (ou seja, usuários fora da China). Essas restrições atualmente levam à seguinte mensagem de erro (um tanto enganosa):

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

Para evitar esse problema, você pode usar o OpenRouter ou qualquer outra plataforma que forneça acesso ao Qwen3 sem restrições regionais.

Vamos agora explicar como configurar sua chave de API do OpenRouter para a integração com o Qwen3!

Etapa 4: Recupere sua chave de API do OpenRouter

Se ainda não o fez, registre-se em uma conta do OpenRouter. Se já tiver uma, basta fazer login.

Em seguida, navegue até a página “API Keys” passando o mouse sobre a imagem do seu perfil no canto superior direito e selecionando a opção “Keys”:

Clique no botão “Create API Key” e siga as instruções para gerar sua chave. Em seguida, copie a chave e adicione-a ao seu arquivo .env da seguinte forma:

OPEN_ROUTER_API_KEY="<YOUR_OPEN_ROUTER_API_KEY>"

Substitua o por sua chave real da API do OpenRouter.

Em seguida, em seu arquivo agent.py, carregue a chave usando:

OPEN_ROUTER_API_KEY = os.getenv("OPEN_ROUTER_API_KEY")

Excelente! Agora você está pronto para usar o Qwen3 com o Qwen-Agent via OpenRouter.

Etapa 5: Configurar o servidor MCP da Bright Data

Comece [criando uma nova conta da Bright Data]() ou faça login em sua conta existente.

Em seguida, siga as instruções oficiais para:

1. Recupere seu token da API da Bright Data.
2. Configure o Web Unlocker e o Scraping Browser para integração com o MCP.

Uma vez concluído, você deverá ter:

• Um token da API da Bright Data.
• Uma zona do Web Unlocker (aqui, assumiremos que o nome da zona é o padrão “mcp_unlocker”).
• Raspagem das credenciais do navegador no formato <BRIGHT_DATA_SB_USERNAME>:<BRIGHT_DATA_SB_PASSWORD>.

Agora, instale o servidor Bright Data MCP globalmente em seu ambiente Node.js com:

npm install -g @brightdata/mcp

Em seguida, certifique-se de especificar dois ambientes em seu terminal:

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

Siga o procedimento correto para a definição da variável de ambiente com base no sistema operacional.

Agora você pode iniciar o servidor MCP por meio do pacote @brightdata/mcp npm com:

npx -y @brightdata/mcp

Esse comando inicia o servidor MCP localmente, lendo as variáveis de ambiente necessárias(API_TOKEN e BROWSER_AUTH). Se tudo estiver configurado corretamente, você verá uma saída como esta:

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

Bom trabalho! O servidor MCP da Bright Data funciona muito bem.

Em seguida, adicione essas duas variáveis de ambiente ao seu arquivo .env:

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

Substitua os espaços reservados pelos valores reais.

Em seu agent.py, carregue essas variáveis com:

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

Perfeito! Agora você tem tudo configurado para integrar o servidor MCP da Bright Data com o Qwen-Agent.

Etapa nº 6: Definir o agente com tecnologia MCP do Qwen3

Crie uma função para inicializar seu agente de IA com suporte a Qwen3 e 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 você pode ver, no código acima:

• O dicionário llm_cfg configura o acesso à versão gratuita do Qwen3 por meio da API do OpenRouter.
• A matriz de ferramentas define como se conectar ao servidor MCP da Bright Data, permitindo que o agente de IA chame ferramentas externas de recuperação de dados.
• Por fim, a classe Assistant() fornecida pelo Qwen-Agent é usada para definir o agente de IA com as integrações do LLM e da ferramenta.

É isso aí! Graças ao Qwen-Agent, a integração do MCP em seu agente de IA requer apenas algumas linhas de código.

Etapa nº 7: Inicie seu agente Qwen3 MCP

Adicione o seguinte código ao agent.py para executar o agente de IA definido em uma interface 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()

Missão concluída! Só falta testar o código e ver do que o agente de IA é capaz.

Etapa #8: Juntar tudo

Este é o código final do 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()

Uau! Com apenas cerca de 50 linhas de código, você pode criar um poderoso agente de IA com tecnologia MCP – graças ao Qwen-Agent e ao OpenRouter.

Execute o agente de IA com:

python agent.py

No terminal, você deve ver uma saída como a seguinte:

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

Isso informa que o servidor MCP está em funcionamento e que o agente de IA está conectado e acessível em http://127.0.0.1:7860. Visite essa URL em seu navegador para interagir com o agente por meio da interface do usuário da Web do Gradio.

Por exemplo, tente pedir a ele um prompt como este:

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

Esse é um ótimo teste para verificar se o agente de IA pode recuperar (e, portanto, utilizar/aprender com) dados em tempo real da página do produto Amazon PS5:

Quando você executa esse prompt na interface do usuário, o que deve acontecer é o seguinte:

Primeiro, observe que, no painel direito, há uma lista de todas as ferramentas disponíveis do servidor Bright Data MCP. Além disso, veja como o Qwen-Agent usa a ferramenta web_data_amazon_product do servidor Bright Data MCP para atender à solicitação.

Você pode verificar isso consultando a lista de marcadores na interface, que mostra o resultado da execução da ferramenta:

No final, a saída JSON final deve ter a seguinte aparência:

{
  "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...
}

Agora, esse exemplo simples demonstra o poder de seu agente de IA. Ele pode extrair dados estruturados e em tempo real de qualquer site. Isso é perfeito para pesquisa em tempo real, RAG(Retrieval-Augmented Generation) e tomada de decisões atualizadas.

Melhor ainda, o agente também pode usar o Agent Browser (anteriormente Scraping Browser) para interagir diretamente com páginas da Web, permitindo automação de alto nível e fluxos de trabalho complexos.

E pronto! Esse é o poder da integração do Qwen3 + MCP com o Qwen-Agent para criar agentes de IA de última geração.

Conclusão

Nesta postagem do blog, você aprendeu a criar um agente de IA poderoso em Python usando a biblioteca Qwen-Agent em combinação com o Qwen3 e o Bright Data MCP.

Como mostrado, a integração de um servidor MCP rico em recursos com o Qwen-Agent permite que seu agente de IA recupere dados em tempo real da Web e execute tarefas avançadas de forma autônoma. Esse é apenas um exemplo de como as ferramentas da Bright Data podem potencializar fluxos de trabalho de IA inteligentes e automatizados.

Explore as soluções em nossa infraestrutura de IA:

• Agentes autônomos de IA: Pesquise, acesse e interaja com qualquer site em tempo real usando um conjunto avançado de APIs.
• Aplicativos verticais de IA: crie pipelines de dados confiáveis e personalizados para extrair dados da Web de fontes específicas do setor.
• Modelos básicos: Acesse conjuntos de dados compatíveis e em escala da Web para potencializar o pré-treinamento, a avaliação e o ajuste fino.
• IA multimodal: aproveite o maior repositório do mundo de imagens, vídeos e áudio otimizados para IA.
• Provedores de dados: Conecte-se com provedores confiáveis para obter conjuntos de dados de alta qualidade e prontos para IA em escala.
• Pacotes de dados: Obtenha conjuntos de dados com curadoria, prontos para uso, estruturados, enriquecidos e anotados.

Para obter mais informações, explore nosso hub de IA.

Crie uma conta na Bright Data e experimente todos os nossos produtos e serviços para o desenvolvimento de agentes de IA!