---
title: "Servidores MCP com modelos compatíveis com a OpenAI | BroadRouter"
description: "MCP funciona com qualquer LLM: o cliente transforma ferramentas MCP em function calls. Como usar MCP com modelos abertos no Cline, Continue, opencode, n8n ou Python."
url: https://broadrouter.com/pt/blog/mcp-with-openai-compatible-models/
lang: pt-BR
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (atualizado em 2026-11-16).

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

Pela equipe da BroadNet Inference · 4 min de leitura · Publicado em 2026-11-14 · Atualizado em 2026-11-16

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.

## Pontos principais

-   A documentação do MCP diz que ele "does not dictate how AI applications use LLMs" (tradução: não determina como aplicações de IA usam LLMs). É o app host que traduz as ferramentas MCP para o formato de ferramentas do modelo.
-   O modelo precisa de tool calling. Na BroadNet Inference, GLM 5.3 e Qwen3.8 27B listam esse suporte.
-   Cline, Continue (só no modo Agent), opencode, n8n e o OpenAI Agents SDK funcionam como clientes MCP com um modelo personalizado.
-   Todo schema de ferramenta MCP é enviado em toda chamada ao modelo. A documentação do opencode avisa que ferramentas MCP consomem contexto do modelo; adicione só os servidores de que você precisa.
-   Ferramentas MCP hospedadas que rodam dentro da Responses API da OpenAI não funcionam com outros provedores; clientes MCP locais funcionam.

**Nesta página**

1.  Por que o MCP funciona com qualquer modelo?
2.  Qual modelo usar com MCP?
3.  Como configurar MCP nos clientes mais comuns?
4.  Como fazer a ponte entre MCP e um modelo aberto em Python?
5.  O que dá errado com MCP em modelos abertos?
6.  Onde a BroadNet Inference se encaixa

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](https://broadrouter.com/pt/glossary/openai-compatible-api/) 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](https://broadrouter.com/pt/glossary/tool-calling/) confiável.

## Qual modelo usar com MCP?

| Modelo na BroadNet | Tool calling listado | Contexto | Encaixe com MCP |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) | Sim | 1.048.576 | Boa escolha padrão para muitos servidores |
| [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) | Sim | 262.144 | Bom, e ainda aceita imagens |
| [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) | Não listado | 1.048.576 | Teste antes; entrada de imagem |
| [Gemma 4 VL 26B](https://broadrouter.com/pt/models/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](https://broadrouter.com/compare/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](https://broadrouter.com/pt/blog/agent-token-budget/) 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](https://broadrouter.com/pt/guides/cline-openai-compatible/), do [Continue](https://broadrouter.com/pt/guides/continue-dev-openai-compatible/) e do [opencode](https://broadrouter.com/pt/guides/opencode-custom-provider/) 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:

```yaml
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:

```python
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](https://broadrouter.com/pt/blog/tool-calling-open-models/) 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](https://broadrouter.com/pt/guides/openai-agents-sdk-custom-provider/). 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](https://broadrouter.com/tools/json-schema-generator/) 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](https://broadrouter.com/pt/glossary/context-window/). 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](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).
-   **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](https://broadrouter.com/pt/pricing/), e as chaves ficam em [inference.broadnet.ai](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-mcp-with-openai-compatible-models&utm_content=body).

Ferramentas gratuitas sobre o tema (em inglês)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[MCP (Model Context Protocol)](https://broadrouter.com/pt/glossary/mcp/)

MCP (Model Context Protocol) é um protocolo aberto, baseado em JSON-RPC 2.0, que padroniza como aplicações de LLM se conectam a ferramentas e dados externos. Um servidor MCP expõe ferramentas, recursos e prompts; um client MCP dentro da aplicação host os descobre e repassa ao servidor as chamadas de ferramenta feitas pelo modelo.

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Server-sent events (SSE)](https://broadrouter.com/pt/glossary/sse/)

Server-sent events (SSE) é um padrão web para um servidor enviar a um cliente um fluxo de eventos de texto por uma única resposta HTTP de longa duração, com content type text/event-stream. Cada evento tem uma ou mais linhas de campo, como data:, e termina com uma linha em branco.

[Modelo de pesos abertos (open-weight)](https://broadrouter.com/pt/glossary/open-weight-model/)

Um modelo de pesos abertos (open-weight) é um modelo de machine learning cujos pesos treinados são publicados para qualquer pessoa baixar e rodar, em geral sob uma licença com condições. Ele difere da IA totalmente open source, que também libera o código de treinamento e informações detalhadas sobre os dados, para que outros possam estudar e reproduzir o modelo.

[Agente de IA (AI agent)](https://broadrouter.com/pt/glossary/agent/)

Um agente de IA é um sistema em que um modelo de linguagem conduz os próprios passos rumo a um objetivo: decide quais ferramentas chamar, lê os resultados e repete até produzir uma resposta final ou atingir um limite. Um script fixo que chama um modelo em pontos definidos costuma ser chamado de workflow.

[API compatível com a OpenAI](https://broadrouter.com/pt/glossary/openai-compatible-api/)

Uma API compatível com a OpenAI é uma API HTTP que aceita os mesmos formatos de requisição e de resposta da API da OpenAI, como POST /v1/chat/completions, de modo que SDKs e ferramentas da OpenAI podem usá-la trocando só a base URL, a chave de API e o nome do modelo.

[Chat Completions API](https://broadrouter.com/pt/glossary/chat-completions-api/)

A Chat Completions API é o endpoint HTTP da OpenAI, POST /v1/chat/completions, que recebe o nome de um modelo e uma lista de mensagens marcadas com papéis e devolve a próxima mensagem do modelo. O formato da requisição e da resposta virou o padrão comum que provedores e SDKs compatíveis com a OpenAI reutilizam.

## 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.

## Continue lendo

-   [Tool calling com modelos abertos: schemas, chamadas paralelas, retry](https://broadrouter.com/pt/blog/tool-calling-open-models/)
-   [Modelos abertos em agentes de código: Aider, Cline, opencode, Codex](https://broadrouter.com/pt/blog/use-open-models-in-coding-agents/)
-   [Orçamento de tokens de agentes: para onde vão os tokens de um loop](https://broadrouter.com/pt/blog/agent-token-budget/)
-   [AI Agent do n8n num LLM barato: setup, modelo e custo por execução](https://broadrouter.com/pt/blog/n8n-ai-agent-cheap-llm/)
-   [Custo de uma execução de agente de código: passos, contexto e cache](https://broadrouter.com/pt/blog/ai-coding-agent-run-cost/)
-   [Claude Code com modelos abertos: proxies, endpoints nativos e limites](https://broadrouter.com/pt/blog/claude-code-with-openai-compatible-models/)
-   [Guia: Use o Cline com a BroadNet Inference (provedor OpenAI Compatible)](https://broadrouter.com/pt/guides/cline-openai-compatible/)
-   [Guia: Use o Continue com a BroadNet Inference (config.yaml e apiBase)](https://broadrouter.com/pt/guides/continue-dev-openai-compatible/)
-   [Guia: Adicionar a BroadNet Inference ao opencode como provedor personalizado](https://broadrouter.com/pt/guides/opencode-custom-provider/)
-   [Guia: Rodar o OpenAI Agents SDK na BroadNet Inference](https://broadrouter.com/pt/guides/openai-agents-sdk-custom-provider/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-mcp-with-openai-compatible-models&utm_content=page-cta) ·

**Fontes**

-   [Model Context Protocol, visão geral da arquitetura (verificado em 2026-11-14)](https://modelcontextprotocol.io/docs/learn/architecture)
-   [MCP Python SDK, clientes e transportes (verificado em 2026-11-14)](https://py.sdk.modelcontextprotocol.io/client/transports/)
-   [Documentação do Cline, visão geral do MCP (verificado em 2026-11-14)](https://docs.cline.bot/mcp/mcp-overview)
-   [Documentação do Continue, MCP (verificado em 2026-11-14)](https://docs.continue.dev/customize/deep-dives/mcp)
-   [Documentação do opencode, servidores MCP (verificado em 2026-11-14)](https://opencode.ai/docs/mcp-servers/)
-   [Documentação do n8n, nó MCP Client Tool (verificado em 2026-11-14)](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/)
-   [Documentação do OpenAI Agents SDK, MCP (verificado em 2026-11-14)](https://openai.github.io/openai-agents-python/mcp/)
