Qwen 3 com Suporte a Servidor MCP: Como Usar

Se você está empolgado com o Qwen 3 e seu brilhante suporte a MCP (Model-Context-Protocol), prepare-se para uma ótima experiência! Recentemente, explorei as capacidades do Qwen 3 no meu computador Windows e, acredite, ele muda o jogo para a criação de agentes de IA que interagem com ferramentas como bancos de dados SQLite. Neste tutorial, vamos explorar como o Qwen 3 aproveita o MCP para facilitar sua vida de codificação, com um exemplo prático de consulta a um banco de dados. Também abordaremos os impressionantes benchmarks do Qwen 3 e mostraremos como usar OpenRouter e Roo Code para começar rapidamente. Pronto para fazer de Qwen 3 e MCP seus novos melhores amigos? Vamos mergulhar!

O que é Qwen 3 com Suporte a MCP?

Qwen 3 é a mais recente série de modelos de linguagem grande da equipe Qwen da Alibaba Cloud, lançada no final de abril de 2025. É uma potência com modelos que variam de 0.6B a 235B de parâmetros, incluindo variantes densas e Mixture-of-Experts (MoE) como Qwen3-235B-A22B (22B parâmetros ativos). De acordo com qwen3.org, o Qwen 3 compete com modelos de ponta como DeepSeek-R1, OpenAI’s o1, o3-mini, Grok-3 e Gemini-2.5-Pro em tarefas de codificação, matemática e gerais. Seu modelo MoE menor, Qwen3-30B-A3B, supera até mesmo o QwQ-32B, apesar de ter 10 vezes menos parâmetros ativos — bastante impressionante, certo?

O que torna o Qwen 3 ainda mais interessante é seu suporte a MCP, que permite interagir perfeitamente com ferramentas externas como bancos de dados SQLite, memória e sistemas de arquivos. O MCP (Model-Context-Protocol) permite que o Qwen 3 chame ferramentas baseadas em servidor, possibilitando fluxos de trabalho de agente onde o modelo pode buscar dados, executar comandos e muito mais. Posts no X estão comentando sobre este recurso, com usuários observando sua otimização para chamadas de função avançadas e capacidades de agente. Vamos configurá-lo e vê-lo em ação com um exemplo de consulta a banco de dados!

Configurando Seu Ambiente para Trabalhar com Qwen 3: O Básico

Vamos preparar seu sistema para usar o Qwen 3 com MCP. Não se preocupe — vou detalhar passo a passo para que você não se perca.

Verificar Pré-requisitos: Certifique-se de ter estas ferramentas instaladas:

• Python: Versão 3.10 ou superior. Execute python --version no seu terminal. Se estiver faltando, baixe em python.org.
• Node.js: Necessário para alguns servidores MCP. Verifique com node --version ou baixe em nodejs.org.
• uv: Versão 0.4.18 ou superior para executar servidores MCP. Verifique com uv --version. Instale via pip install uv se necessário.
• Git: Para clonar repositórios. Verifique com git --version ou instale usando Homebrew (brew install git no Mac) ou winget (winget install git.git no Windows).
• SQLite: Para o nosso exemplo. Confirme com sqlite3 --version ou instale via Homebrew (brew install sqlite3) ou winget (winget install sqlite.sqlite).
• Hardware: Uma CPU com 4+ núcleos, 16GB+ de RAM e 10GB+ de armazenamento livre para lidar com o processamento de IA.

Criar uma Pasta de Projeto: Vamos manter as coisas organizadas:

mkdir qwen3-mcp
cd qwen3-mcp

Esta pasta será seu espaço de trabalho para a mágica de Qwen 3 e MCP.

Configurar um Ambiente Virtual: Para evitar conflitos de dependência, crie um ambiente virtual Python:

python -m venv venv

Ative-o:

• Mac/Linux: source venv/bin/activate
• Windows: venv\Scripts\activate

O prompt (venv) no seu terminal significa que você está pronto para começar.

Instalando Qwen-Agent para Suporte a MCP

O Qwen 3 usa o framework Qwen-Agent para habilitar o suporte a MCP, conforme observado no GitHub. Vamos instalá-lo e configurar as dependências para o nosso exemplo SQLite.

Instalar Qwen-Agent com Suporte a MCP:

pip install -U "qwen-agent[gui,rag,code_interpreter,mcp]"

Este comando instala o Qwen-Agent com todas as dependências opcionais, incluindo [mcp] para suporte a MCP, [gui] para interface web, [rag] para geração aumentada por recuperação e [code_interpreter] para execução de código.

Verificar Instalação: Certifique-se de que o Qwen-Agent foi instalado corretamente executando:

python -c "import qwen_agent; print(qwen_agent.__version__)"

Se você vir um número de versão (por exemplo, 0.1.0), você está pronto. Caso contrário, reinstale ou verifique seu ambiente Python.

Configurando Qwen 3 com Servidor MCP

Agora, vamos configurar o Qwen 3 para funcionar com um servidor MCP para chamadas de ferramentas. Usaremos o exemplo SQLite do repositório GitHub do Qwen-Agent para consultar um banco de dados.

Configurar o Servidor MCP para SQLite:

O exemplo usa um servidor MCP para lidar com interações de banco de dados SQLite. Primeiro, crie um banco de dados de teste (test.db) se você não tiver um:

sqlite3 test.db "CREATE TABLE example (id INTEGER PRIMARY KEY, name TEXT); INSERT INTO example (name) VALUES ('Alice'), ('Bob');"

Agora, inicie o servidor MCP SQLite:

uvx mcp-server-sqlite --db-path test.db

Isso executa o servidor MCP SQLite, permitindo que o Qwen 3 consulte test.db. Mantenha este terminal em execução.

Configurar Qwen 3 no Seu Código:

Vamos escrever um script Python para usar o Qwen 3 com o servidor MCP, baseado no exemplo assistant_mcp_sqlite_bot.py. Crie um arquivo chamado qwen3_mcp_sqlite.py:

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

# Define o agente com a configuração de Qwen 3 e MCP
def init_agent_service():
    llm_cfg = {
        'model': 'qwen3-32b',  # Usar modelo Qwen 3
        'model_type': 'qwen_dashscope',
        'api_key': os.getenv('DASHSCOPE_API_KEY'),
    }
    tools = [{
        'mcpServers': {
            'sqlite': {
                'command': 'uvx',
                'args': ['mcp-server-sqlite', '--db-path', 'test.db']
            }
        }
    }]
    bot = Assistant(
        llm=llm_cfg,
        function_list=tools,
        name='MCP-SQLite-Bot',
        description='Este bot pode responder a perguntas usando o banco de dados SQLite'
    )
    return bot

# Testar o agente com uma consulta
def test(query='Quantas tabelas existem no banco de dados?'):
    bot = init_agent_service()
    messages = [{'role': 'user', 'content': query}]
    for response in bot.run(messages=messages):
        print(response)

# Executar uma interface web para teste interativo
def app_gui():
    bot = init_agent_service()
    WebUI(bot).run()

if __name__ == '__main__':
    test()
    # Descomente para executar a interface web
    # app_gui()

Este script configura o Qwen 3 (especificamente qwen3-32b) para funcionar com um servidor MCP SQLite. Ele define um bot que pode consultar o banco de dados e inclui uma opção de interface web para teste interativo.

Definir a Chave de API do DashScope:

O script usa o serviço DashScope da Alibaba Cloud para o Qwen 3. Você precisará de uma chave de API do DashScope:

• Cadastre-se em dashscope.aliyuncs.com.
• Navegue até as configurações de API, gere uma chave e defina-a como uma variável de ambiente:

export DASHSCOPE_API_KEY="sua-chave-api-dashscope"

Adicione isso ao seu perfil de shell (por exemplo, ~/.zshrc) e recarregue com source ~/.zshrc.

Usando OpenRouter e Roo Code para Qwen 3 com MCP

Se você não quiser lidar com o DashScope, pode usar o OpenRouter para acessar o Qwen 3 e aproveitar o servidor MCP pré-configurado do Roo Code. Veja como:

Obter uma Chave de API do OpenRouter:

• Visite openrouter.ai e cadastre-se.
• Vá para as configurações da sua conta, gere uma chave de API e copie-a.

Configurar o Roo Code com OpenRouter:

Roo Code é uma plataforma que simplifica fluxos de trabalho de agentes de IA e frequentemente vem com servidores MCP pré-configurados. Assumindo que você tenha o Roo Code configurado:

• Configure sua chave de API do OpenRouter nas configurações do Roo Code (geralmente em integrações de API).
• Atualize a configuração do modelo no Roo Code para usar o Qwen 3 via OpenRouter:

{
    "model": "qwen3-32b",
    "model_server": "https://openrouter.ai/api/v1",
    "api_key": "sua-chave-api-openrouter"
}

• O Roo Code geralmente tem uma configuração de servidor MCP semelhante à do nosso script. Verifique a documentação para garantir que o servidor SQLite esteja em execução (por exemplo, uvx mcp-server-sqlite --db-path test.db).

Executar o Mesmo Script com Roo Code:

Modifique o llm_cfg no seu script qwen3_mcp_sqlite.py para usar o OpenRouter:

llm_cfg = {
    'model': 'qwen3-32b',
    'model_server': 'https://openrouter.ai/api/v1',
    'api_key': 'sua-chave-api-openrouter'
}

Execute o script como antes — o servidor MCP do Roo Code lidará com as consultas SQLite, e o Qwen 3 as processará via OpenRouter.

Opção 2: Configurando o Roo Code para Funcionar com o OpenRouter:
Se você preferir não usar um script personalizado, pode configurar facilmente o Roo Code com o OpenRouter seguindo estas etapas:

1. Abra as configurações do Roo.
2. Mude o provedor padrão para OpenRouter.
3. Selecione o modelo Qwen 3.

Uma vez configurado, seus servidores MCP existentes no Roo Code funcionarão perfeitamente com o modelo Qwen 3.

Testando Qwen 3 com MCP: Consultando um Banco de Dados

Vamos testar o Qwen 3 com nossa configuração MCP consultando o banco de dados SQLite.

Executar o Script:

Com o servidor MCP SQLite em execução (do passo 1 em “Configurando Qwen 3 com Servidor MCP”), execute seu script:

python qwen3_mcp_sqlite.py

A consulta padrão (“Quantas tabelas existem no banco de dados?”) deve retornar uma resposta indicando uma tabela (example), já que a criamos anteriormente.

Teste Interativo com Interface Web:

Descomente a chamada app_gui() no script e execute-o novamente:

if __name__ == '__main__':
    # test()
    app_gui()

Isso inicia uma interface web baseada em Gradio. Abra o URL fornecido (geralmente http://127.0.0.1:7860) no seu navegador, digite consultas como “Listar todos os nomes na tabela example”, e o Qwen 3 usará o servidor MCP para buscar os resultados (por exemplo, “Alice, Bob”).

Entender os Resultados:

O exemplo SQLite mostra como o Qwen 3 usa o MCP para interagir com ferramentas externas. O modelo envia uma consulta ao servidor MCP, que a executa contra test.db e retorna o resultado. Essa configuração é perfeita para construir agentes que precisam buscar dados dinamicamente — bastante poderoso, não é?

Dicas para Usar Qwen 3 com MCP Efetivamente

• Mantenha as Consultas Simples: Para tarefas de banco de dados, use prompts claros como “Listar todos os nomes na tabela example” para obter resultados precisos de Qwen 3.
• Monitore o Uso da API: Seja usando DashScope ou OpenRouter, acompanhe seu uso da API para evitar atingir limites de taxa.
• Explore Mais Ferramentas MCP: MCP suporta ferramentas como memória e sistema de arquivos — verifique o GitHub do Qwen-Agent para mais exemplos.
• Teste Localmente Primeiro: Use a interface web para testar consultas interativamente antes de implantar em produção.

Minhas Impressões sobre Qwen 3 com MCP

Depois de brincar com o Qwen 3 e MCP, aqui está o que penso:

• Integração Perfeita: A configuração do servidor MCP é simples, e o Qwen 3 lida com chamadas de ferramentas como um campeão.
• Poderoso para Agentes: Consultar bancos de dados é apenas o começo — MCP abre infinitas possibilidades para fluxos de trabalho de agente.
• Aumento de Performance: Os benchmarks de Qwen 3 mostram que ele é um forte concorrente, e o suporte a MCP o torna ainda mais versátil.

Se encontrar algum problema, verifique novamente sua chave de API e certifique-se de que o servidor MCP está em execução.

Concluindo: Sua Jornada com Qwen 3 e MCP

Você acabou de desbloquear o poder do Qwen 3 com suporte a MCP, tornando seus agentes de IA mais inteligentes e capazes! De consultar bancos de dados a explorar outras ferramentas MCP, você está pronto para construir coisas incríveis. Para mais detalhes, sinta-se à vontade para conferir o repositório GitHub do Qwen-Agent ou qwen3.org. Continue mandando bem com Qwen 3 e MCP!