BroadRouter

Servidores MCP com modelos compatíveis com OpenAI (qualquer provedor)

Pela equipe da BroadNet Inference · 4 min de leitura · Publicado em · Atualizado em

O MCP não depende do modelo. O cliente MCP do seu app lista as ferramentas de cada servidor, passa-as ao modelo como ferramentas comuns de function calling e executa tools/call quando o modelo pede. Qualquer modelo compatível com a OpenAI com tool calling confiável pode usar servidores MCP. Configure-os no Cline, Continue, opencode ou n8n, ou faça a ponte com umas 40 linhas de Python.

O Model Context Protocol (MCP) dá aos agentes um jeito padrão de acessar ferramentas: GitHub, bancos de dados, sistemas de arquivos, navegadores. Muitos tutoriais de MCP pressupõem Claude ou GPT. Você não precisa de nenhum dos dois. Este post explica por que o MCP funciona com qualquer modelo compatível com a OpenAI que suporte tool calling, como configurá-lo nos clientes que os desenvolvedores realmente usam e como fazer a ponte entre o MCP e um modelo aberto no seu próprio código.

Por que o MCP funciona com qualquer modelo?

O MCP fica entre a sua aplicação e os servidores de ferramentas, não entre a sua aplicação e o modelo. A documentação de arquitetura do MCP descreve três papéis:

  • Host: a aplicação de IA, como uma extensão do editor ou o seu script.
  • Cliente: uma conexão que o host mantém com cada servidor MCP.
  • Servidor: um programa que expõe ferramentas, recursos e prompts, localmente via stdio ou remotamente via Streamable HTTP.

A documentação é explícita: o MCP “does not dictate how AI applications use LLMs or manage the provided context.” (tradução: não determina como aplicações de IA usam LLMs nem como gerenciam o contexto fornecido). O host lista as ferramentas de cada servidor com tools/list, junta tudo em um registro que o modelo consegue ver e, quando o modelo pede uma ferramenta, envia tools/call ao servidor certo.

Em uma API compatível com a OpenAI, “o modelo consegue ver” significa que as ferramentas entram no array tools comum. Uma ferramenta MCP já tem nome, descrição e inputSchema, que correspondem um a um a uma definição de função. O modelo nem sabe que o MCP está envolvido. Tudo de que ele precisa é um tool calling confiável.

Qual modelo usar com MCP?

Modelo na BroadNet Tool calling listado Contexto Encaixe com MCP
GLM 5.3 Sim 1.048.576 Boa escolha padrão para muitos servidores
Qwen3.8 27B Sim 262.144 Bom, e ainda aceita imagens
DeepSeek V4.1 Flash Não listado 1.048.576 Teste antes; entrada de imagem
Gemma 4 VL 26B Não listado 32.768 Não recomendado

Para comparar lado a lado os dois modelos com ferramentas, veja GLM 5.3 vs Qwen3.8 27B. O contexto pesa mais do que se imagina. Todo schema de ferramenta MCP vai junto em toda chamada. A documentação do opencode diz: “MCP tools consume model context, so add only the servers you need.” (tradução: ferramentas MCP consomem contexto do modelo, então adicione só os servidores de que você precisa). O post sobre orçamento de tokens de agentes mostra como medir isso.

Como configurar MCP nos clientes mais comuns?

Cliente Onde ficam os servidores MCP Transportes Observação
Cline Painel MCP Servers, JSON mcpServers stdio, Streamable HTTP, SSE legado Tipo remoto "streamableHttp"
Continue mcpServers em config.yaml ou .continue/mcpServers/ stdio, sse, streamable-http Só no modo Agent
opencode mcp.servers em opencode.jsonc local, remote Use {env:NAME} para segredos
n8n Nó MCP Client Tool em um AI Agent Endpoint de servidor remoto (a documentação descreve um endpoint SSE) Escolha as ferramentas com All, Selected ou All Except
OpenAI Agents SDK mcp_servers=[...] no Agent stdio, Streamable HTTP, SSE Não o HostedMCPTool

Depois aponte o modelo do cliente para o seu provedor: os guias do Cline, do Continue e do opencode cobrem o lado do modelo para a BroadNet. No Continue, lembre-se da capability tool_use, senão o modo Agent não fica disponível.

Um exemplo do Continue, tirado da documentação dele:

mcpServers:
  - name: SQLite MCP
    type: stdio
    command: npx
    args: ["-y", "mcp-sqlite", "/path/to/your/database.db"]

Como fazer a ponte entre MCP e um modelo aberto em Python?

Se você está construindo o seu próprio agente, a ponte é curta. Este código usa o Client do MCP Python SDK (versão 2.0 ou posterior; pip install "mcp>=2"), que inicia um servidor stdio quando recebe StdioServerParameters, e o SDK da OpenAI apontado para a BroadNet:

import asyncio, json, os
from mcp import Client, StdioServerParameters
from mcp.types import TextContent
from openai import OpenAI

llm = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
server = StdioServerParameters(command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "."])

async def main(question):
    async with Client(server) as mcp:
        listed = await mcp.list_tools()
        tools = [{"type": "function", "function": {
                    "name": t.name, "description": t.description or "",
                    "parameters": t.input_schema}} for t in listed.tools]
        messages = [{"role": "user", "content": question}]
        for _ in range(8):
            r = llm.chat.completions.create(model="broadnet/glm-5.3",
                    messages=messages, tools=tools, max_tokens=4000)
            msg = r.choices[0].message
            messages.append(msg.model_dump(exclude_none=True))
            if not msg.tool_calls:
                return msg.content
            for call in msg.tool_calls:
                try:
                    res = await mcp.call_tool(call.function.name,
                                              json.loads(call.function.arguments or "{}"))
                    text = "\n".join(b.text for b in res.content if isinstance(b, TextContent))
                    out = f"Error: {text}" if res.is_error else text
                except Exception as e:
                    out = f"Error: {e}"
                messages.append({"role": "tool", "tool_call_id": call.id, "content": out})

print(asyncio.run(main("List the Markdown files here and summarize the README.")))

No mcp 1.x não existe a classe Client: abra o servidor com stdio_client(...), envolva-o em uma ClientSession, chame initialize() e leia os campos em camelCase inputSchema e isError. Três detalhes importam:

  1. Erros viram resultados de ferramenta. O MCP SDK informa falhas de ferramenta com is_error em vez de levantar exceção. Devolva-as para o modelo poder se ajustar. Nosso guia de tool calling cobre validação e retries.
  2. Limite o loop. Aqui são oito passos. Servidores MCP que retornam resultados grandes enchem o contexto rápido.
  3. Filtre as ferramentas. Exponha só as ferramentas de que a tarefa precisa. O OpenAI Agents SDK oferece tool_filter para isso, e o n8n tem Selected e All Except.

Usa o OpenAI Agents SDK? As classes MCPServerStdio e MCPServerStreamableHttp dele rodam no seu processo. Combine-as com um provedor personalizado como no nosso guia do Agents SDK. O HostedMCPTool dele roda dentro da Responses API da OpenAI e só funciona com modelos da OpenAI.

O que dá errado com MCP em modelos abertos?

  • Ferramentas demais. O modelo escolhe a errada ou ignora as ferramentas. Mantenha pequeno o conjunto ativo. Para as suas próprias ferramentas, o gerador de JSON schema produz um schema parameters limpo e plano.
  • Resultados de ferramenta grandes. Um servidor que retorna uma tabela inteira do banco pode estourar a janela de contexto. Limite ou pagine.
  • Respostas vazias ou cortadas. GLM 5.3 e Qwen3.8 27B raciocinam primeiro, e o raciocínio conta em max_tokens. Aumente-o.
  • Confiança. Servidores MCP executam código na sua máquina ou chamam serviços com as suas credenciais. Instale servidores em que você confia e confirme ações que gravam dados ou gastam dinheiro.

Onde a BroadNet Inference se encaixa

A BroadNet Inference fornece o lado do modelo: GLM 5.3 e Qwen3.8 27B com tool calling listado, pelo formato padrão de chat completions que todos os clientes MCP acima podem usar, com retenção zero de dados para prompts e saídas. Ela não roda servidores MCP nem ferramentas hospedadas para você; isso é trabalho do seu cliente. Os preços por token dos dois modelos estão na página de preços, e as chaves ficam em inference.broadnet.ai.

Perguntas frequentes

Posso usar MCP com um modelo que não seja Claude nem GPT?

Sim. O MCP é um protocolo entre o seu app e os servidores de ferramentas. O app passa as ferramentas para o modelo que usa, no formato de tool calling desse modelo. Qualquer modelo compatível com a OpenAI com chamadas de ferramenta funcionando pode usar ferramentas MCP.

O modelo precisa suportar MCP?

Não. O modelo só precisa de function calling. O trabalho de protocolo, listar e chamar as ferramentas, é feito pelo cliente MCP do seu app.

Quais agentes de código suportam MCP com um modelo personalizado compatível com a OpenAI?

Cline, Continue no modo Agent e opencode permitem configurar servidores MCP e um modelo personalizado compatível com a OpenAI. O Zoo Code, continuação do Roo Code, também lista suporte a MCP.

Por que adicionar servidores MCP deixa o meu agente mais lento e caro?

As definições de ferramentas de cada servidor são adicionadas ao prompt em toda chamada ao modelo. Dez servidores com uma dúzia de ferramentas cada podem somar milhares de tokens de entrada por passo. Ative só os servidores de que a tarefa precisa, ou filtre as ferramentas.

Ferramentas MCP hospedadas funcionam com outros provedores?

Não as hospedadas pela OpenAI. A documentação do OpenAI Agents SDK diz que o HostedMCPTool funciona com modelos da OpenAI que suportam a integração MCP hospedada da Responses API. Com outros provedores, use as classes de servidor MCP local do SDK.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity