## ¿Qué es MCP?

MCP (Model Context Protocol) es el estándar abierto para conectar asistentes de IA con herramientas externas, fuentes de datos y servicios. Tu servidor expone "herramientas" — funciones con nombre, descripción y esquemas de entrada — y el modelo de IA decide cuándo llamarlas durante una conversación. Creado por Anthropic a finales de 2024 y ahora soportado por Claude, ChatGPT, complementos de IDE y una lista creciente de frameworks de agentes, MCP cumple para la IA el mismo rol que USB cumple para el hardware: un cable, cualquier dispositivo.

## Por qué MCP importa

Antes de MCP, cada asistente de IA se conectaba a cada servicio externo mediante código de "plugin" o "function calling" hecho a medida. Cada proveedor de IA tenía su propio formato. Cada integración había que reescribirla por proveedor — una vez para Claude, otra para ChatGPT, otra para Cursor, otra para un agente personalizado.

MCP estandariza la interfaz. Un único servidor MCP funciona con todos los clientes compatibles. Eso significa:

- Los desarrolladores escriben la integración **una vez** en lugar de N
- Los clientes de IA recogen herramientas nuevas en cuanto se publican, sin actualizar el cliente
- Los agentes pueden descubrir, listar y llamar herramientas en tiempo de ejecución — sin cableado en tiempo de compilación
- Los servidores de código abierto pueden ser auditados, bifurcados y autoalojados

Es la diferencia entre drivers de impresora propietarios y el estándar IP. El protocolo es aburrido. Estandarizarse en él desbloquea un ecosistema.

## Cómo funciona

Toda la comunicación usa **JSON-RPC 2.0** sobre HTTP POST a un único endpoint (por ejemplo, `/mcp`):

1. El cliente envía `initialize` para establecer la sesión
2. El servidor responde con su nombre, versión y capacidades
3. El cliente envía `tools/list` para descubrir las herramientas disponibles
4. El servidor devuelve una lista de herramientas con descripciones y esquemas
5. El cliente envía `tools/call` con un nombre de herramienta y argumentos
6. El servidor ejecuta la herramienta y devuelve el resultado

## MCP vs alternativas

| Aspecto | Function calling de OpenAI | [OpenAPI](/kb/es/openapi) / Swagger | MCP |
|---|---|---|---|
| Alcance del proveedor | Un solo proveedor | Neutral | Neutral |
| Diseñado para | Llamadas a herramientas LLM | APIs REST | Agentes de IA |
| Descubrimiento | Hardcodeado en el cliente | Archivo de spec estático | En tiempo de ejecución vía `tools/list` |
| Streaming | Limitado | Sin soporte nativo | Integrado (SSE / Streamable HTTP) |
| Sesiones con estado | No | No | Sí (initialize → llamadas) |
| Autenticación | Claves del lado cliente | Claves API, OAuth | OAuth, bearer, personalizada |
| Ecosistema | Solo OpenAI | Maduro, amplio | Nuevo, creciendo rápido |

OpenAPI describe una API REST en tiempo de diseño. MCP describe una superficie de herramientas *viva* en tiempo de ejecución. Son complementarios — muchos servidores MCP envuelven servicios OpenAPI existentes y los exponen como herramientas invocables por agentes.

## Ejemplo de implementación

```javascript
app.post('/mcp', (req, res) => {
  const { method, params, id } = req.body;

  if (method === 'initialize') {
    return res.json({ jsonrpc: '2.0', id, result: {
      protocolVersion: '2024-11-05',
      capabilities: { tools: {} },
      serverInfo: { name: 'my-service', version: '1.0' }
    }});
  }

  if (method === 'tools/list') {
    return res.json({ jsonrpc: '2.0', id, result: {
      tools: [{
        name: 'search',
        description: 'Search for items',
        inputSchema: {
          type: 'object',
          properties: { query: { type: 'string' } },
          required: ['query']
        }
      }]
    }});
  }

  if (method === 'tools/call') {
    const { name, arguments: args } = params;
    return res.json({ jsonrpc: '2.0', id, result: {
      content: [{ type: 'text', text: 'Search results...' }]
    }});
  }

  res.json({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' }});
});
```

## Opciones de transporte

MCP soporta tres transportes — elige según dónde se ejecute tu cliente:

- **Streamable HTTP** *(recomendado para servidores remotos)*: HTTP POST plano a un endpoint. El servidor devuelve una respuesta JSON o un stream SSE para herramientas que emiten progreso. Funciona a través de CDNs, balanceadores y firewalls. Es lo que esperan claude.ai web y la mayoría de clientes alojados.
- **SSE (Server-Sent Events)**: Transporte más antiguo con un GET de larga duración para servidor→cliente y POST para cliente→servidor. Aún soportado, pero Streamable HTTP lo reemplaza en servidores nuevos.
- **stdio**: Tubos de proceso — el cliente lanza tu servidor como subproceso y se comunica vía stdin/stdout. Usado por Claude Desktop y agentes CLI. Sin red, sin CORS, pero el cliente debe poder ejecutar tu código localmente.

Si quieres que un servidor MCP funcione con Claude Desktop *y* la web de Claude *y* ChatGPT *y* Cursor, lanza Streamable HTTP. Casi todos lo hablan ya.

## CORS — necesario para agentes basados en navegador

Una clase creciente de clientes MCP corre *en el navegador*: Claude.ai web, ChatGPT browser, extensiones, widgets de chat embebidos. Cuando JavaScript ejecutándose en `claude.ai` llama `fetch('https://tudominio.com/mcp')`, el navegador hace dos cosas por su cuenta:

1. Envía la petición a tu servidor.
2. Se niega a entregar la respuesta al JavaScript que la pidió — *a menos que* tu respuesta incluya un encabezado `Access-Control-Allow-Origin` que nombre a `claude.ai` (o `*`).

Sin encabezados CORS, tu servidor funciona bien y devuelve 200, pero el cliente MCP en el navegador ve un error de red y nunca puede leer el cuerpo. Es el navegador protegiendo a los usuarios. Los clientes del lado servidor como Claude Desktop o el CLI no están sujetos a esto.

Para soportar clientes MCP basados en navegador, envía estos encabezados en cada respuesta de `/mcp` y maneja el preflight OPTIONS:

```javascript
app.use('/mcp', (req, res, next) => {
  res.set('Access-Control-Allow-Origin', '*');
  res.set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
  res.set('Access-Control-Allow-Headers', 'Content-Type, Accept, Authorization');
  if (req.method === 'OPTIONS') return res.sendStatus(204);
  next();
});
```

### Comodín vs origen específico

`Access-Control-Allow-Origin: *` está bien para endpoints MCP **públicos y de solo lectura**. Si tu endpoint MCP requiere autenticación o cobra por las llamadas, devuelve un origen específico (o haz eco del `Origin` de la petición contra una lista permitida) y pon `Access-Control-Allow-Credentials: true`. El comodín no se puede usar con credenciales según la especificación CORS.

### Por qué importa el preflight

Para una petición "simple" — un `GET` plano o un `POST` con `Content-Type: text/plain` — el navegador simplemente la envía y solo bloquea la respuesta. Pero MCP usa `POST` con `Content-Type: application/json`, que el navegador considera lo bastante arriesgado como para *consultar primero*. Antes de enviar el POST real, manda un `OPTIONS` preguntando: "¿Aceptarás un POST de este origen con estos encabezados?"

Si tu servidor no responde al OPTIONS con un 2xx y los encabezados CORS correctos, el navegador cancela el POST por completo — nunca llega a tu servidor. Por eso el middleware CORS tiene que manejar ambos: el preflight OPTIONS *y* el POST real.

## Autenticación

Para servidores públicos de solo lectura, ninguna autenticación está bien. Para herramientas privadas o de pago, MCP soporta:

- **Tokens bearer** en el encabezado `Authorization` (lo más simple)
- **OAuth 2.1** con PKCE — el estándar para acceso delegado por usuario; la especificación MCP define un endpoint de metadatos en `/.well-known/oauth-authorization-server` para que los clientes descubran tu flujo OAuth automáticamente
- **Pago por petición** vía [x402](/kb/es/x402) — devuelve HTTP 402 con instrucciones de pago en lugar de autenticar por adelantado

OAuth es el default correcto cuando humanos autorizan en su propio nombre. Los tokens bearer son para servicio-a-servicio. x402 es para llamadas de pago sin estado.

## Quién está usando MCP

- **Anthropic Claude** — cliente MCP nativo en Claude Desktop, Claude.ai web y la API de Claude
- **OpenAI ChatGPT** — añadió soporte MCP en 2025
- **Integraciones de IDE** — Cursor, Zed, Windsurf y los plugins de JetBrains hablan MCP
- **Frameworks de agentes** — LangChain, LlamaIndex y la mayoría de SDKs incluyen transportes MCP
- **Registro oficial de MCP** en `registry.modelcontextprotocol.io` lista cientos de servidores públicos
- **Smithery** en `smithery.ai` es el mayor marketplace MCP mantenido por la comunidad

agentgrade publica su propio servidor MCP (`com.agentgrade/mcp-server`) para agentes que quieran escanear sitios desde dentro de un cliente MCP.

## Errores comunes y depuración

- **`Method not found`** (-32601): El cliente llamó un método que tu servidor no implementa. Siempre devuelve un error elegante para métodos desconocidos.
- **El preflight CORS falla**: OPTIONS devuelve 404 o 405. Añade el middleware mostrado arriba.
- **La lista de herramientas aparece vacía en la UI del cliente**: Tu respuesta `tools/list` está bien formada pero el cliente espera un array `tools` no vacío. Confirma que al menos una herramienta está registrada.
- **`Invalid params`** (-32602): Los argumentos enviados por el cliente no coinciden con tu `inputSchema`. Revisa el JSON Schema — campos requeridos faltantes o tipos incorrectos son los sospechosos habituales.
- **Funciona en Desktop, falla en la web**: Casi siempre es CORS. El navegador bloquea la respuesta; los logs del servidor muestran 200s pero el cliente no ve nada.

## Conceptos clave

- **Tools**: Funciones que tu servidor expone (por ejemplo, "search", "create_invoice")
- **inputSchema**: JSON Schema describiendo qué argumentos acepta cada herramienta
- **Resources**: Datos de solo lectura que tu servidor puede entregar al modelo (archivos, fragmentos, resultados de queries)
- **Prompts**: Plantillas de prompt reutilizables que el servidor publica para que el cliente las use
- **Streamable HTTP**: El transporte recomendado — todos los mensajes vía POST a un endpoint
- **SSE**: Server-Sent Events — transporte más antiguo, mantenido por compatibilidad

## FAQ

### ¿MCP es un protocolo de Anthropic o un estándar abierto?

Fue creado por Anthropic y publicado como especificación abierta. Las implementaciones de referencia están bajo licencia MIT. OpenAI, vendedores de IDE y frameworks de agentes lo han adoptado de forma independiente — es un estándar comunitario ahora, no un protocolo de un solo proveedor.

### ¿En qué se diferencia MCP del function calling de OpenAI?

Function calling es una característica de la API de un proveedor. MCP es un protocolo a nivel de transporte que cualquier cliente puede hablar. Con function calling, el modelo y la definición de la herramienta viven dentro de la misma petición OpenAI; con MCP, el modelo vive en el cliente y las herramientas en tu servidor, y se comunican por un formato definido.

### ¿Debo exponer mi API REST existente como MCP o solo darle al IA mi spec OpenAPI?

Ambos funcionan, pero apuntan a clientes distintos. Modelos con soporte MCP nativo (Claude, Cursor) llaman herramientas directamente vía MCP. Si solo tienes tiempo para uno, lanza MCP — la mayoría de clientes de agente lo prefieren para descubrimiento en tiempo de ejecución.

### ¿MCP requiere WebSockets?

No. El estándar actual es Streamable HTTP — POST plano a un endpoint, con streaming SSE opcional. Los borradores anteriores usaban WebSockets; esa ruta fue abandonada porque HTTP plano atraviesa CDNs, balanceadores y firewalls corporativos sin configuración.

### ¿Pueden los servidores MCP cobrar por las llamadas?

Sí. El protocolo no incluye pagos, pero puedes superponer x402: haz que tu servidor devuelva HTTP 402 desde `tools/call` hasta que el agente adjunte un recibo de pago válido. Es uno de los patrones más activos en el ecosistema de agentes.

### ¿Cómo listo mi servidor MCP en el registro?

Envía un manifiesto a [registry.modelcontextprotocol.io](https://registry.modelcontextprotocol.io). Smithery.ai espeja el registro y añade funciones de descubrimiento. Listar es gratis y la cola de revisión es corta.

### ¿Por qué mi servidor MCP es lento?

El protocolo en sí es barato — JSON-RPC sobre HTTP. La lentitud casi siempre es (a) la implementación de la herramienta, o (b) un cold start de serverless. Perfila el handler de `tools/call` antes de culpar al transporte.

### ¿Necesito un servidor separado por herramienta, o uno con muchas?

Uno con muchas herramientas es la norma. Agrupa las herramientas por servicio lógico (por ejemplo, todas las operaciones de GitHub en un servidor). Los clientes pueden conectarse a varios servidores a la vez, así que dividir solo tiene sentido cuando los permisos o el hosting difieren.

## Madurez de la especificación

**Especificación formal.** MCP es mantenido por Anthropic con una spec versionada. Versión actual del protocolo: `2024-11-05`. Soportado nativamente por Claude, ChatGPT, Cursor y la mayoría de frameworks de agentes. El transporte Streamable HTTP es estable y usado por todos los clientes principales.

## Saber más

- [modelcontextprotocol.io](https://modelcontextprotocol.io) — Especificación oficial
- [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk) — Implementación de referencia
- [Registro oficial de MCP](https://registry.modelcontextprotocol.io) — Catálogo público de servidores
- [Smithery](https://smithery.ai) — Mayor marketplace comunitario
- [MDN: CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) — Referencia de Cross-Origin Resource Sharing
- [Preparación de agentes](/agent-readiness) — Cómo MCP encaja en el panorama más amplio de la web agéntica

## Relacionado

- [SKILL.md](/kb/es/skills)
- [A2A](/kb/es/a2a)
- [WebMCP](/kb/es/webmcp)
- [llms.txt](/kb/es/llms-txt)