Ecosistema MCP — El Protocolo Que Une Todo

1 Introducción — ¿Qué es MCP?

El Model Context Protocol (MCP) es un protocolo abierto que define cómo los modelos de lenguaje grandes (LLMs) se conectan con herramientas externas, fuentes de datos, APIs y sistemas. Su nombre completo es revelador: no es solo un protocolo de "tools" — es un protocolo de contexto. Esto significa que no solo permite ejecutar herramientas, sino también inyectar información contextual (documentos, bases de conocimiento, resultados de queries) directamente en el prompt del modelo.

Datos Clave

• Creado por: Anthropic (David Soria Paria, Justin Spahr-Summers) — Noviembre 2024
• Gobierno: Linux Foundation (desde 2025) — vendor-neutral, MIT license
• Comunidad: 47.8K followers en GitHub, 10 SDKs oficiales, 31,800+ servidores listados en Glama
• Versiones: 2024-11-05 (draft), 2025-03-26, 2025-06-18, 2025-11-25 (latest stable)
• Inspiración: LSP (Language Server Protocol) de Microsoft — mismo patrón de protocolo abierto para estandarizar una interfaz crítica

2 Arquitectura — Host-Client-Server, Transportes, Lifecycle, Primitivas

MCP tiene una arquitectura de tres capas bien definida, tomando prestados conceptos de LSP pero adaptándolos al contexto de LLMs. Es un protocolo stateful (a diferencia de REST), bidireccional (el server puede hacer solicitudes al host), y negociado (cliente y server acuerdan capacidades al iniciar).

Las 3 Capas

Transportes

MCP define múltiples transportes, cada uno optimizado para un escenario distinto. La versión 2025-11-25 estabiliza Streamable HTTP como el transporte remoto recomendado, deprecando SSE.

Lifecycle de una Conexión MCP

El lifecycle es simple pero estricto, y sigue el patrón JSON-RPC 2.0 con tres fases:

1. Initialize — Cliente envía initialize con su versión y capacidades. Server responde con su versión y capacidades. Sin esto, no hay sesión.
2. Session — Una vez inicializado, cliente y server intercambian mensajes del protocolo: tools/list, tools/call, resources/list, resources/read, prompts/get, etc.
3. Shutdown — Cierre ordenado de la conexión. El cliente envía shutdown y cierra el transporte.

// Handshake de inicialización MCP (JSON-RPC 2.0)
{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-11-25",
    "capabilities": {
      "tools": {},
      "resources": {},
      "prompts": {},
      "sampling": {}
    },
    "clientInfo": {
      "name": "my-client",
      "version": "1.0.0"
    }
  }
}

Primitivas del Protocolo

MCP define tres primitivas del lado del server y tres del lado del client. No confundir: las primitivas definen qué puede hacer cada lado, no qué debe implementar.

Primitivas Server → Host

Primitivas Host → Server

3 Historia — De Anthropic a Linux Foundation

La historia de MCP es inusualmente rápida para un protocolo abierto. En menos de 18 meses pasó de ser un experimento interno de Anthropic a un estándar bajo la Linux Foundation con adopción masiva.

Línea de Tiempo

El Momento LSP

MCP está viviendo su "momento LSP" — así como LSP unificó la experiencia de editores de código con lenguajes de programación, MCP está unificando la experiencia de LLMs con herramientas. La analogía es casi perfecta:

4 SDKs Oficiales — Python, TypeScript, Go, Rust y más

Actualmente hay 10 SDKs oficiales para MCP, cubriendo los lenguajes más populares del ecosistema de IA. La calidad y madurez varía significativamente entre ellos.

Python SDK: El Más Usado

El SDK de Python es, con diferencia, el más popular del ecosistema MCP. Incluye FastMCP, una abstracción de alto nivel que permite crear servidores en pocas líneas:

from mcp.server.fastmcp import FastMCP

# Crear server con FastMCP
mcp = FastMCP("Mi Servidor", port=8080)

# Tool — ejecutable por el LLM
@mcp.tool()
def calcular_precio(producto: str, cantidad: int) -> float:
    """Calcula el precio total para un producto"""
    precio_base = {"laptop": 999.99, "mouse": 29.99}
    return precio_base.get(producto, 0) * cantidad

# Resource — datos accesibles por URI
@mcp.resource("catalog://productos/{producto}")
def get_producto(producto: str) -> dict:
    """Obtiene info de un producto"""
    return {"nombre": producto, "stock": 42}

# Prompt — plantilla reutilizable
@mcp.prompt()
def revisar_pedido(pedido_id: str) -> str:
    """Prompt para revisar un pedido"""
    return f"Revisa el pedido {pedido_id} y verifica..."

if __name__ == "__main__":
    mcp.run()  # STDIO por defecto

FastMCP maneja automáticamente la serialización JSON-RPC, el descubrimiento de tools/resources/prompts, y la negociación de capacidades. El mismo server funciona con STDIO (local) y Streamable HTTP (remoto) sin cambiar código.

5 MCP vs REST vs A2A vs Function Calling

MCP no es la única forma de conectar LLMs con el mundo exterior. Existen al menos cuatro paradigmas compitiendo. Entender sus diferencias es crucial para elegir el correcto.

¿Cuándo usar cada uno?

6 Soporte por Plataforma — Claude Code, OpenCode, Cursor, Codex CLI

No todas las plataformas agenticas soportan MCP por igual. Esta tabla muestra el nivel de soporte real de cada plataforma a junio 2026, basado en documentación oficial y análisis de código fuente.

Claude Code: El Más Maduro

Al ser el inventor de MCP, Claude Code tiene el soporte más completo y maduro. Algunas capacidades exclusivas:

• Tres scopes de configuración: ~/.claude/settings.local.json (local), .mcp.json (proyecto), .mcp.json en home (user). Precedencia clara y predecible.
• Elicitation nativa: Los MCP servers pueden pedir input humano via elicitation/prompt. Esto permite flujos de "confirmar antes de ejecutar" sin salir del chat.
• MCP Server mode: claude mcp serve expone la sesión de Claude Code como un MCP server. Esto permite que otro cliente MCP (u otro agente) interactúe con Claude Code programáticamente.
• Plugins como wrappers: Los plugins de Claude Code pueden envolver MCP servers para añadir lógica pre/post a cada tool call.

OpenCode: Per-Agent MCP Nativo

OpenCode es la única plataforma que ofrece MCP per-agent nativo, sin necesidad de plugins. Esto significa que puedes configurar qué MCP servers están disponibles para cada agente individualmente:

// opencode.json — configuración MCP
{
  "mcp": {
    "servers": {
      "filesystem": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
      },
      "db": {
        "command": "python",
        "args": ["mcp_server_db.py"]
      }
    }
  },
  "agents": {
    "coder": {
      "model": "anthropic/claude-sonnet-4-20250514",
      "mcp": {"filesystem": "allow"}  // solo filesystem para coder
    },
    "analyst": {
      "model": "openai/gpt-5",
      "mcp": {"db": "allow"}  // solo DB para analyst
    }
  }
}

OpenCode también soporta Remote MCP Discovery via .well-known/opencode — un estándar que permite que un proyecto declare sus MCP servers remotos automáticamente al abrirse, sin configuración manual.

7 Servidores Destacados — 15+ Servidores MCP

El ecosistema de servidores MCP es vasto y crece rápidamente. Estos son los servidores más importantes, categorizados por función. Datos verificados a junio 2026.

Navegación y Web

Sistema y Archivos

Bases de Datos

Productividad y Colaboración

Observabilidad y DevOps

Memoria y Conocimiento

Integración Multi-Servicio (Composio)

8 Marketplaces y Hosting — Glama, Smithery, PulseMCP, Composio

El ecosistema MCP ha generado múltiples marketplaces y plataformas de hosting. Cada uno tiene un enfoque distinto:

Hosting de MCP Servers

Además de los marketplaces, existen opciones para hostear tus propios MCP servers:

• Vercel MCP Adapter — Despliega MCP servers como funciones serverless en Vercel. Ideal para servidores ligeros con Streamable HTTP.
• Glama Gateway — Hosting gerenciado con auto-scaling, auth, y monitoreo. Paga por uso.
• Servidor dedicado — Despliegue tradicional con Docker + Streamable HTTP. Control total.
• Local (STDIO) — Para desarrollo y uso personal. Sin infraestructura, sin costos.

9 Herramientas y Debugging — Inspector, mcp-cli, mcp-guardian

El ecosistema MCP incluye herramientas para desarrollo, debugging, testing, y seguridad en producción.

MCP Inspector en Acción

El MCP Inspector es la herramienta más útil para desarrollo. Se ejecuta en el navegador y permite:

• Conectarse a cualquier servidor MCP (local STDIO o remoto HTTP)
• Ver el handshake de inicialización completo
• Listar tools, resources, y prompts disponibles
• Ejecutar tools con argumentos personalizados
• Ver el log completo de mensajes JSON-RPC
• Probar escenarios de error y edge cases

# Usar MCP Inspector vía CLI
npx @modelcontextprotocol/inspector \
  npx @modelcontextprotocol/server-filesystem /tmp

# O vía Python
mcp inspector run my_server.py

# mcp-cli: conectar a un server y listar tools
mcp-cli connect stdio --command "python my_server.py"
> tools/list

10 Fortalezas y Debilidades

MCP no es perfecto. Como protocolo joven (18 meses desde su creación), tiene áreas de mejora importantes. Este análisis balanceado cubre ambos lados.

Fortalezas

Debilidades

11 Guía de Decisión

¿Cuándo deberías usar MCP? ¿Cuándo NO? Esta guía te ayuda a decidir.

Usa MCP cuando...

• ✅ Necesitas que un LLM acceda a herramientas externas (APIs, DBs, sistema de archivos, navegador)
• ✅ Quieres que tu integración sea provider-agnostic — funcionar con Claude, GPT, Gemini, etc.
• ✅ Construyes un ecosistema de herramientas reutilizables que múltiples agentes/plataformas consumirán
• ✅ Necesitas datos contextuales (resources) además de tools — documentos, resultados de queries, archivos
• ✅ Quieres plantillas de prompt reutilizables que los usuarios puedan invocar desde el chat
• ✅ Deseas portabilidad entre Claude Code, OpenCode, Cursor, Windsurf, y Continue.dev
• ✅ Construyes un sistema multi-agente donde cada agente necesita su propio conjunto de herramientas MCP

NO uses MCP cuando...

• ❌ Tu plataforma target es Zencoder — no soporta MCP
• ❌ Necesitas una API REST tradicional para consumo humano o machine-to-machine stateless — REST sigue siendo mejor
• ❌ Tu caso de uso es orquestación entre agentes autónomos — A2A es más apropiado (aunque MCP + A2A es la combinación ideal)
• ❌ Necesitas máximo rendimiento y baja latencia — JSON-RPC añade overhead comparado con gRPC o protocolos binarios
• ❌ Tu equipo no tiene experiencia con protocolos stateful — MCP requiere entender lifecycle, negociación, y sesiones
• ❌ Solo integras con un proveedor de IA y no planeas migrar — function calling de OpenAI puede ser más simple si no necesitas portabilidad

Árbol de Decisión

¿Necesitas conectar un LLM con herramientas externas?
├── Sí
│   ├── ¿Tu plataforma target soporta MCP?
│   │   ├── Sí (Claude Code, OpenCode, Cursor, Windsurf, Continue)
│   │   │   └── ✅ Usa MCP — ganas portabilidad y estandarización
│   │   └── No (Zencoder)
│   │       └── ❌ No puedes usar MCP — usa plugin system nativo
│   │
│   ├── ¿Necesitas también orquestación multi-agente?
│   │   ├── Sí → MCP + A2A (combinación ideal)
│   │   └── No → MCP solo es suficiente
│   │
│   └── ¿Necesitas solo function calling simple?
│       ├── Sí → MCP puede ser overkill; considera function calling nativo
│       │        si usas un solo proveedor
│       └── No → MCP es la mejor opción
│
└── No
    ├── ¿Necesitas API web tradicional?
    │   ├── Sí → REST
    │   └── No → No necesitas MCP ni REST
    │
    └── ¿Necesitas orquestación agent-to-agent?
        ├── Sí → A2A
        └── No → Evalúa si realmente necesitas un protocolo

📚 Fuentes Verificadas

Todas las afirmaciones en esta clase están respaldadas por documentación oficial, especificaciones, y datos de mercado verificados a junio 2026.

Especificación y Documentación Oficial

• MCP Oficial — modelcontextprotocol.io — Portal oficial con especificación, documentación, tutoriales
• Especificación 2025-11-25 — Versión estable más reciente del protocolo
• GitHub — Model Context Protocol — Repositorio oficial con SDKs, servidores, especificación
• Especificación en GitHub — Código fuente de la especificación
• MCP Spec (renderizado) — Versión navegable de la especificación

Plataformas

• Claude Code — Documentación MCP — Transportes, CLI, plugin integration, tool search
• OpenCode — Documentación MCP — Configuración, per-agent, remote discovery
• Cursor — Documentación MCP — Configuración y uso
• Windsurf — Documentación MCP — Configuración y uso
• Continue.dev — MCP Servers — Configuración experimental

SDKs y Paquetes

• mcp en PyPI — Python SDK oficial con FastMCP
• @modelcontextprotocol/sdk — TypeScript SDK oficial
• mcp-go (Go) — SDK de Go mantenido por mark3labs
• mcp-core (Rust) — SDK oficial de Rust
• Spring AI MCP (Java) — Integración con Spring AI

Marketplaces y Hosting

• Glama AI — 31,818 servidores, hosting, gateway, quality scoring
• Smithery — Marketplace comunitario de MCP servers
• PulseMCP — Comunidad + newsletter + descubrimiento
• MCP Registry (GitHub) — Registro oficial de metadatos vendor-neutral
• Composio — 985 toolkits, 20K+ tools SaaS, auth gerenciado

Servidores Destacados

• Playwright MCP (Microsoft) — 33.6K stars, browser automation
• MCP Official Servers — Filesystem, Git, Memory, Fetch, PostgreSQL, SQLite, etc.

Herramientas

• MCP Inspector — 10K stars, debugging UI browser-based
• mcp-guardian — Security layer para MCP
• Vercel MCP Adapter — Despliegue serverless de MCP servers

Última verificación: Junio 2026. Las especificaciones y documentación pueden cambiar; consulte las fuentes oficiales para información actualizada.