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:
- Erros viram resultados de ferramenta. O MCP SDK informa falhas de ferramenta com
is_errorem vez de levantar exceção. Devolva-as para o modelo poder se ajustar. Nosso guia de tool calling cobre validação e retries. - Limite o loop. Aqui são oito passos. Servidores MCP que retornam resultados grandes enchem o contexto rápido.
- Filtre as ferramentas. Exponha só as ferramentas de que a tarefa precisa. O OpenAI Agents SDK oferece
tool_filterpara 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
parameterslimpo 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.
