---
title: "Servidores MCP con modelos compatibles con OpenAI | BroadRouter"
description: "MCP sirve con cualquier LLM: el cliente convierte sus herramientas en function calls. Cómo usar MCP con modelos abiertos en Cline, Continue, opencode, n8n o Python."
url: https://broadrouter.com/es/blog/mcp-with-openai-compatible-models/
lang: es
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (actualizado el 2026-11-16).

# Servidores MCP con cualquier modelo compatible con OpenAI

Por el equipo de BroadNet Inference · 4 min de lectura · Publicado 2026-11-14 · Actualizado 2026-11-16

MCP es independiente del modelo. El cliente MCP de su aplicación lista las herramientas de cada servidor, se las pasa al modelo como herramientas normales de function calling y ejecuta tools/call cuando el modelo lo pide. Cualquier modelo compatible con OpenAI con un tool calling fiable puede usar servidores MCP. Configúrelos en Cline, Continue, opencode o n8n, o conéctelos con unas 40 líneas de Python.

## Puntos clave

-   La documentación de MCP dice que "does not dictate how AI applications use LLMs" (Traducción: «no dicta cómo las aplicaciones de IA usan los LLM»). La aplicación anfitriona traduce las herramientas MCP al formato de herramientas del modelo.
-   El modelo necesita tool calling. En BroadNet Inference, GLM 5.3 y Qwen3.8 27B lo listan.
-   Cline, Continue (solo en modo Agent), opencode, n8n y el OpenAI Agents SDK funcionan como clientes MCP con un modelo personalizado.
-   Cada esquema de herramienta MCP se envía en cada llamada al modelo. La documentación de opencode advierte que las herramientas MCP consumen contexto del modelo; añada solo los servidores que necesite.
-   Las herramientas MCP alojadas que se ejecutan dentro de la Responses API de OpenAI no funcionan con otros proveedores; los clientes MCP locales sí.

**En esta página**

1.  ¿Por qué MCP funciona con cualquier modelo?
2.  ¿Qué modelo usar con MCP?
3.  ¿Cómo se configura MCP en los clientes más comunes?
4.  ¿Cómo conectar MCP con un modelo abierto en Python?
5.  ¿Qué falla con MCP en modelos abiertos?
6.  Dónde encaja BroadNet Inference

El Model Context Protocol (MCP) ofrece a los agentes una forma estándar de llegar a herramientas: GitHub, bases de datos, sistemas de archivos, navegadores. Muchos tutoriales de MCP dan por hecho Claude o GPT, pero no necesita ninguno de los dos. Este artículo explica por qué MCP funciona con cualquier modelo [compatible con OpenAI](https://broadrouter.com/es/glossary/openai-compatible-api/) que admita tool calling, cómo configurarlo en los clientes que de verdad usan los desarrolladores y cómo conectar MCP con un modelo abierto en su propio código.

## ¿Por qué MCP funciona con cualquier modelo?

MCP se sitúa entre su aplicación y los servidores de herramientas, no entre su aplicación y el modelo. La documentación de arquitectura de MCP describe tres roles:

-   **Host (anfitrión):** la aplicación de IA, como una extensión del editor o su script.
-   **Client (cliente):** una conexión que el host mantiene con cada servidor MCP.
-   **Server (servidor):** un programa que expone herramientas, recursos y prompts, en local por stdio o en remoto por Streamable HTTP.

La documentación es explícita: MCP “does not dictate how AI applications use LLMs or manage the provided context.” (Traducción: «no dicta cómo las aplicaciones de IA usan los LLM ni cómo gestionan el contexto proporcionado»). El host lista las herramientas de cada servidor con `tools/list`, las une en un registro que el modelo puede ver y, cuando el modelo pide una herramienta, envía `tools/call` al servidor que corresponde.

En una API compatible con OpenAI, «que el modelo puede ver» significa que las herramientas van en el array `tools` de siempre. Una herramienta MCP ya tiene nombre, descripción y un `inputSchema`, que se corresponde uno a uno con una definición de función. El modelo nunca sabe que hay MCP de por medio. Lo único que necesita es un [tool calling](https://broadrouter.com/es/glossary/tool-calling/) fiable.

## ¿Qué modelo usar con MCP?

| Modelo en BroadNet | Tool calling listado | Contexto | Encaje con MCP |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) | Sí | 1,048,576 | Buena opción por defecto con muchos servidores |
| [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/) | Sí | 262,144 | Bueno, además con entrada de imágenes |
| [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) | No listado | 1,048,576 | Pruébelo primero; entrada de imágenes |
| [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/) | No listado | 32,768 | No recomendado |

Para ver los dos modelos con herramientas lado a lado, consulte [GLM 5.3 frente a Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). El contexto importa más de lo que se suele pensar: cada esquema de herramienta MCP viaja en cada llamada. La documentación de opencode dice “MCP tools consume model context, so add only the servers you need.” (Traducción: «las herramientas MCP consumen contexto del modelo, así que añada solo los servidores que necesite»). El artículo sobre el [presupuesto de tokens del agente](https://broadrouter.com/es/blog/agent-token-budget/) muestra cómo medirlo.

## ¿Cómo se configura MCP en los clientes más comunes?

| Cliente | Dónde van los servidores MCP | Transportes | Nota |
| --- | --- | --- | --- |
| Cline | Panel MCP Servers, JSON `mcpServers` | stdio, Streamable HTTP, SSE heredado | Tipo remoto `"streamableHttp"` |
| Continue | `mcpServers` en `config.yaml` o `.continue/mcpServers/` | stdio, sse, streamable-http | Solo en modo Agent |
| opencode | `mcp.servers` en `opencode.jsonc` | `local`, `remote` | Use `{env:NAME}` para los secretos |
| n8n | Nodo MCP Client Tool en un AI Agent | Endpoint de servidor remoto (su documentación describe un endpoint SSE) | Elija herramientas con All, Selected o All Except |
| OpenAI Agents SDK | `mcp_servers=[...]` en el Agent | stdio, Streamable HTTP, SSE | No `HostedMCPTool` |

Después, apunte el modelo del cliente a su proveedor: las guías de [Cline](https://broadrouter.com/es/guides/cline-openai-compatible/), [Continue](https://broadrouter.com/es/guides/continue-dev-openai-compatible/) y [opencode](https://broadrouter.com/es/guides/opencode-custom-provider/) cubren la parte del modelo para BroadNet. En Continue, recuerde la capacidad `tool_use`, o el modo Agent no estará disponible.

Un ejemplo de Continue, tomado de su documentación:

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

## ¿Cómo conectar MCP con un modelo abierto en Python?

Si está construyendo su propio agente, el puente es corto. Este usa el `Client` del MCP Python SDK (versión 2.0 o posterior; `pip install "mcp>=2"`), que lanza un servidor stdio cuando recibe `StdioServerParameters`, y el SDK de OpenAI apuntando 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.")))
```

En `mcp` 1.x no existe la clase `Client`: abra el servidor con `stdio_client(...)`, envuélvalo en una `ClientSession`, llame a `initialize()` y lea los campos en camelCase `inputSchema` e `isError`. Importan tres detalles:

1.  **Los errores se convierten en resultados de herramienta.** El SDK de MCP informa los fallos de herramientas con `is_error` en lugar de lanzar una excepción. Devuélvalos para que el modelo se ajuste. Nuestra [guía de tool calling](https://broadrouter.com/es/blog/tool-calling-open-models/) cubre la validación y los reintentos.
2.  **Acote el bucle.** Aquí, ocho pasos. Los servidores MCP que devuelven resultados grandes llenan el contexto rápido.
3.  **Filtre las herramientas.** Exponga solo las que necesite la tarea. El OpenAI Agents SDK ofrece `tool_filter` para ello, y n8n tiene Selected y All Except.

¿Usa el OpenAI Agents SDK? Sus clases `MCPServerStdio` y `MCPServerStreamableHttp` se ejecutan en su proceso. Combínelas con un proveedor personalizado como en nuestra [guía del Agents SDK](https://broadrouter.com/es/guides/openai-agents-sdk-custom-provider/). Su `HostedMCPTool` se ejecuta dentro de la Responses API de OpenAI y solo funciona con modelos de OpenAI.

## ¿Qué falla con MCP en modelos abiertos?

-   **Demasiadas herramientas.** El modelo elige la que no es o ignora las herramientas. Mantenga pequeño el conjunto activo. Para sus propias herramientas, el [generador de JSON Schema](https://broadrouter.com/tools/json-schema-generator/) produce un esquema `parameters` limpio y plano.
-   **Resultados de herramienta grandes.** Un servidor que devuelve una tabla entera de la base de datos puede desbordar la [ventana de contexto](https://broadrouter.com/es/glossary/context-window/). Limite o pagine.
-   **Respuestas vacías o cortadas.** GLM 5.3 y Qwen3.8 27B razonan primero, y el razonamiento cuenta dentro de `max_tokens`. [Súbalo](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/).
-   **Confianza.** Los servidores MCP ejecutan código en su máquina o llaman a servicios con sus credenciales. Instale servidores de confianza y confirme las acciones que escriben o gastan.

## Dónde encaja BroadNet Inference

BroadNet Inference aporta la parte del modelo: GLM 5.3 y Qwen3.8 27B con tool calling listado, mediante el formato estándar de chat completions que pueden usar todos los clientes MCP anteriores, sin retención de datos de prompts ni de salidas. No ejecuta servidores MCP ni herramientas alojadas por usted; eso lo hace su cliente. Los precios por token de ambos modelos están en la [página de precios](https://broadrouter.com/es/pricing/), y las claves, en [inference.broadnet.ai](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-mcp-with-openai-compatible-models&utm_content=body).

Herramientas gratuitas sobre este tema (en 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.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

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

MCP (Model Context Protocol, protocolo de contexto de modelo) es un protocolo abierto, basado en JSON-RPC 2.0, que estandariza cómo las aplicaciones de LLM se conectan con herramientas y datos externos. Un servidor MCP expone herramientas, recursos y prompts; un cliente MCP dentro de la aplicación host los descubre y pasa al servidor las llamadas a herramientas del modelo.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

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

Server-sent events (SSE), o eventos enviados por el servidor, es un estándar web para que un servidor envíe un flujo de eventos de texto a un cliente a través de una única respuesta HTTP de larga duración con el tipo de contenido text/event-stream. Cada evento es una o más líneas de campo, como data:, terminadas por una línea en blanco.

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

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

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

Un modelo de pesos abiertos es un modelo de aprendizaje automático cuyos pesos entrenados se publican para que cualquiera los descargue y ejecute, normalmente con una licencia con condiciones. Se diferencia de la IA totalmente de código abierto, que además publica el código de entrenamiento e información detallada sobre los datos, para que otros puedan estudiar y reproducir el modelo.

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

Un agente de IA es un sistema en el que un modelo de lenguaje dirige sus propios pasos hacia un objetivo: decide qué herramientas llamar, lee los resultados y repite hasta dar una respuesta final o alcanzar un límite. Un script fijo que llama a un modelo en puntos establecidos suele llamarse flujo de trabajo (workflow).

[API compatible con OpenAI](https://broadrouter.com/es/glossary/openai-compatible-api/)

Una API compatible con OpenAI es una API HTTP que acepta los mismos formatos de solicitud y respuesta que la API de OpenAI, como POST /v1/chat/completions, de modo que los SDKs y herramientas de OpenAI pueden usarla cambiando solo la URL base, la clave de API y el nombre del modelo.

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

La API de Chat Completions es el endpoint HTTP de OpenAI, POST /v1/chat/completions, que recibe un nombre de modelo y una lista de mensajes etiquetados con su rol y devuelve el siguiente mensaje del modelo. Su forma de solicitud y respuesta se convirtió en el formato común que reutilizan los proveedores y SDKs compatibles con OpenAI.

## Preguntas frecuentes

### ¿Puedo usar MCP con un modelo que no sea Claude ni GPT?

Sí. MCP es un protocolo entre su aplicación y los servidores de herramientas. La aplicación pasa las herramientas al modelo que use mediante el formato de tool calling de ese modelo. Cualquier modelo compatible con OpenAI con llamadas a herramientas que funcionen puede usar herramientas MCP.

### ¿El modelo tiene que admitir MCP?

No. El modelo solo necesita function calling. El cliente MCP de su aplicación hace el trabajo del protocolo: listar las herramientas y llamarlas.

### ¿Qué agentes de programación admiten MCP con un modelo personalizado compatible con OpenAI?

Cline, Continue en modo Agent y opencode permiten configurar servidores MCP y un modelo personalizado compatible con OpenAI. Zoo Code, la continuación de Roo Code, también indica soporte de MCP.

### ¿Por qué añadir servidores MCP hace mi agente más lento y caro?

Las definiciones de herramientas de cada servidor se añaden al prompt en cada llamada al modelo. Diez servidores con una docena de herramientas cada uno pueden sumar miles de tokens de entrada por paso. Active solo los servidores que necesite la tarea, o filtre herramientas.

### ¿Las herramientas MCP alojadas funcionan con otros proveedores?

Las alojadas por OpenAI, no. La documentación del OpenAI Agents SDK dice que HostedMCPTool funciona con modelos de OpenAI que admiten la integración MCP alojada de la Responses API. Con otros proveedores, use las clases de servidor MCP local del SDK.

## Siga leyendo

-   [Tool calling con modelos abiertos: esquemas, paralelismo, reintentos](https://broadrouter.com/es/blog/tool-calling-open-models/)
-   [Modelos abiertos en agentes de código: Aider, Cline, opencode, Codex](https://broadrouter.com/es/blog/use-open-models-in-coding-agents/)
-   [Presupuesto de tokens de un agente: adónde van los tokens del bucle](https://broadrouter.com/es/blog/agent-token-budget/)
-   [AI Agent de n8n con un LLM barato: configuración, modelo y costo](https://broadrouter.com/es/blog/n8n-ai-agent-cheap-llm/)
-   [Cuánto cuesta ejecutar un agente de IA: pasos, contexto y caché](https://broadrouter.com/es/blog/ai-coding-agent-run-cost/)
-   [Claude Code con modelos abiertos: proxies, endpoints nativos y límites](https://broadrouter.com/es/blog/claude-code-with-openai-compatible-models/)
-   [Guía: Cline con BroadNet Inference (proveedor OpenAI Compatible)](https://broadrouter.com/es/guides/cline-openai-compatible/)
-   [Guía: Continue con BroadNet Inference (config.yaml y apiBase)](https://broadrouter.com/es/guides/continue-dev-openai-compatible/)
-   [Guía: Agregue BroadNet Inference a opencode como proveedor personalizado](https://broadrouter.com/es/guides/opencode-custom-provider/)
-   [Guía: OpenAI Agents SDK con BroadNet Inference](https://broadrouter.com/es/guides/openai-agents-sdk-custom-provider/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

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

**Fuentes**

-   [Model Context Protocol, visión general de la arquitectura (consultado el 2026-11-14)](https://modelcontextprotocol.io/docs/learn/architecture)
-   [MCP Python SDK, clientes y transportes (consultado el 2026-11-14)](https://py.sdk.modelcontextprotocol.io/client/transports/)
-   [Documentación de Cline, visión general de MCP (consultado el 2026-11-14)](https://docs.cline.bot/mcp/mcp-overview)
-   [Documentación de Continue, MCP (consultado el 2026-11-14)](https://docs.continue.dev/customize/deep-dives/mcp)
-   [Documentación de opencode, servidores MCP (consultado el 2026-11-14)](https://opencode.ai/docs/mcp-servers/)
-   [Documentación de n8n, nodo MCP Client Tool (consultado el 2026-11-14)](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/)
-   [Documentación del OpenAI Agents SDK, MCP (consultado el 2026-11-14)](https://openai.github.io/openai-agents-python/mcp/)
