Protocolo de Contexto de Modelo (MCP) a fondo

RAG le da a un modelo acceso a información. Pero hay una limitación que RAG no resuelve por sí solo: los LLM no pueden actuar sobre el mundo — no pueden consultar un saldo en tiempo real, ni mucho menos tramitar una solicitud. El Protocolo de Contexto de Modelo (MCP), presentado por Anthropic en noviembre de 2024, es el estándar abierto diseñado para conectar aplicaciones de IA con herramientas y fuentes de contexto externas.

¿Qué es MCP?

MCP es, en esencia, un lenguaje común que permite a una aplicación con un LLM hablar con sistemas externos de forma estandarizada.

Analogía del conserje de un edificio: imagina que eres un ejecutivo que quiere saber cuántos días de vacaciones le quedan. No puedes entrar directamente a la base de datos de RR.HH. — no conoces el sistema interno, no tienes credenciales, no sabes qué consultas hacer. En cambio, llamas al conserje (el servidor MCP), que sí tiene acceso: entiende lo que necesitas, sabe qué sistema consultar, tiene las credenciales adecuadas y te devuelve la información en un formato que entiendes. El conserje no es el que tiene la información — es el que sabe dónde y cómo obtenerla, y puede ejecutar acciones autorizadas en tu nombre.

En términos técnicos, MCP usa mensajes JSON-RPC 2.0 y define primitivas para descubrir e invocar herramientas, acceder a recursos y obtener plantillas de prompts. El modelo puede proponer una llamada, pero es el host —a través del cliente MCP— el que envía los mensajes del protocolo y aplica las políticas de autorización.

Los transportes estándar vigentes son stdio (un subproceso local) y Streamable HTTP (un servicio accesible por red). El antiguo transporte HTTP+SSE de la especificación de 2024 fue reemplazado y está deprecado desde marzo de 2025; SSE todavía puede aparecer dentro de Streamable HTTP para transmitir respuestas, pero ya no es el nombre del transporte recomendado para implementaciones nuevas. MCP es agnóstico al modelo: no obliga a usar un proveedor de LLM particular.

La arquitectura: tres actores principales

Host: la aplicación que ejecuta el LLM — nuestra app de chat de RR.HH., un IDE o un chatbot. Contiene uno o más clientes MCP y decide qué capacidades exponer al modelo.
Cliente MCP: vive dentro del host. Mantiene una conexión con un servidor, traduce las solicitudes al protocolo y gestiona su ciclo de vida.
Servidor MCP: expone herramientas, recursos y prompts conectados a un sistema externo. En nuestro caso podríamos tener un servidor de RR.HH. (saldo de vacaciones), uno de Calendario (disponibilidad de equipo) y uno de Políticas (el mismo RAG, expuesto como herramienta o recurso).

El flujo completo, con nuestro escenario

Pregunta: “¿cuántos días de vacaciones me quedan a MÍ este año, y puedo pedir la próxima semana?”

Paso 1 — Descubrimiento de herramientas: el LLM entiende que necesita datos que no tiene en su preentrenamiento ni en RAG. A través del cliente MCP, el host descubre qué hay disponible:

// Solicitud
{"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}}

// Parte relevante de la respuesta
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "consultar_saldo_vacaciones",
        "description": "Obtiene el saldo disponible",
        "inputSchema": {"type": "object", "properties": {"empleado_id": {"type": "string"}}}
      },
      {
        "name": "consultar_calendario_equipo",
        "description": "Verifica disponibilidad del equipo",
        "inputSchema": {"type": "object", "properties": {"equipo_id": {"type": "string"}}}
      },
      {
        "name": "solicitar_vacaciones",
        "description": "Envía una solicitud",
        "inputSchema": {"type": "object", "properties": {"empleado_id": {"type": "string"}}}
      }
    ]
  }
}

Paso 2 — Invocar la primera herramienta:

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"consultar_saldo_vacaciones","arguments":{"empleado_id":"emp_12345"}}}

El servidor devuelve el resultado estructurado: Ana García tiene 18 días asignados, 6 usados y 12 disponibles.

Paso 3 — Invocar la segunda herramienta:

{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"consultar_calendario_equipo","arguments":{"fecha_inicio":"2026-09-01","fecha_fin":"2026-09-07","equipo_id":"equipo_456"}}}

El resultado indica disponibilidad alta, una persona ausente de un máximo permitido de tres y que la solicitud es viable.

Paso 4 — Respuesta con confirmación pendiente: “Tienes 12 días disponibles. Para la próxima semana, el equipo tiene disponibilidad alta. Puedes solicitar esos días. ¿Quieres que tramite la solicitud ahora?”

Fíjate: el LLM no envía la solicitud automáticamente — pide confirmación primero. Las consultas de solo lectura pueden configurarse con menos fricción; las acciones con efectos reales deben requerir confirmación humana explícita según su riesgo. MCP hace posible que el modelo proponga solicitar_vacaciones, pero que el host la ejecute sin preguntar es una decisión de diseño separada — y una mala idea en la mayoría de los casos.

Paso 5 — Ejecución, tras confirmación:

{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"solicitar_vacaciones","arguments":{"empleado_id":"emp_12345","fecha_inicio":"2026-09-01","fecha_fin":"2026-09-07"}}}

El servidor responde con el estado enviada, el número de solicitud VAC-2026-8473 y la fecha de envío.

MCP vs. RAG

	RAG (Capítulo 5)	MCP (este capítulo)
Tipo de respuesta	“¿Cuántos días corresponden por antigüedad?” (regla general)	“¿Cuántos días me quedan a MÍ?” (dato personal, en vivo)
Origen del dato	Documento vectorizado de antemano	Sistema consultado en tiempo real
Puede actuar	No por sí solo — recupera contexto	Puede exponer herramientas que ejecutan acciones
Actualización	Requiere reindexar cuando cambia el documento	Cada consulta puede obtener el estado vigente

MCP no reemplaza a RAG — normalmente conviven. RAG implementa la recuperación sobre políticas generales; MCP puede estandarizar el acceso a ese recuperador y también a datos específicos del usuario o acciones.

Seguridad en MCP

Consentimiento del usuario: nunca se asume para una acción sensible — “¿Quieres que tramite la solicitud?” [Sí] [No], nunca “He tramitado tu solicitud” sin haberlo preguntado. El grado de confirmación debe corresponder al impacto y reversibilidad de cada herramienta.

Privacidad de datos — autorización en el servidor:

def consultar_saldo_vacaciones(empleado_id_solicitado, usuario_autenticado):
    if empleado_id_solicitado != usuario_autenticado.id:
        return {"error": "No autorizado para consultar el saldo de otro empleado"}

    return db.execute(
        "SELECT * FROM vacaciones WHERE empleado_id = ?",
        (empleado_id_solicitado,),
    ).fetchone()

El identificador confiable debería derivarse de la sesión autenticada siempre que sea posible, no de texto generado por el modelo.

Seguridad de servidores y herramientas: el host no debe confiar automáticamente en un servidor MCP desconocido. Mitigaciones: registro o lista permitida de servidores, revisión de procedencia, versiones fijadas, credenciales de mínimo privilegio y sandboxing cuando el servidor corre localmente.

Seguridad de la cadena de suministro: si el sistema al que se conecta el servidor tiene una vulnerabilidad, esa vulnerabilidad puede quedar accesible también a través del asistente. El servidor nunca debe pasar consultas dinámicas generadas por el LLM directamente a la base de datos. Las herramientas deben ser operaciones acotadas con parámetros tipados, validados y consultas parametrizadas.

Prompt injection y exfiltración: los resultados de herramientas son datos no confiables; pueden contener instrucciones maliciosas. El host debe separar datos de instrucciones, limitar qué herramientas pueden encadenarse y pedir aprobación antes de compartir información sensible con otro servidor.

Auditoría: cada acción relevante debe registrar usuario, servidor, herramienta, argumentos permitidos, resultado, aprobación y timestamp, aplicando minimización y retención apropiadas. En entornos regulados, estos controles suelen ser necesarios para demostrar trazabilidad.

Local vs. remoto, administrado vs. autoalojado

Servidor MCP	Sensibilidad del dato	Punto de partida
Saldo de vacaciones (RR.HH.)	Muy alta	Autoalojado o servicio administrado privado con controles contractuales y técnicos
Calendario de equipo	Media	Interno o proveedor aprobado con OAuth y mínimo privilegio
Políticas generales (RAG)	Baja	Remoto administrado puede ser razonable
Días feriados oficiales	Pública	Remoto administrado de terceros

La sensibilidad no obliga automáticamente a ejecutar todo de forma local: una plataforma remota puede ser válida si satisface residencia, cifrado, aislamiento, auditoría y obligaciones contractuales. Lo que no debe ocurrir es enviar datos sensibles a un tercero no evaluado o conceder permisos más amplios que los necesarios.

MCP no es memoria

Es fácil confundir MCP con “memoria” porque ambos conectan al LLM con información externa — pero son conceptos de distinto nivel. La memoria responde “¿qué sabe o recuerda el sistema?”; RAG es una implementación habitual de memoria semántica.

MCP responde “¿cómo intercambia capacidades y contexto esta aplicación con un sistema externo?”. Puede transportar acceso a herramientas, recursos y prompts. Consultar un saldo de vacaciones es una herramienta sobre un dato vivo; exponer una colección de políticas puede ser un recurso o una herramienta de búsqueda. Por eso MCP no es un tipo de memoria: es una interfaz estandarizada que también puede conectar al agente con una memoria.

Implementación práctica

(Nota: los SDKs de MCP evolucionan rápido — verifica la sintaxis exacta contra la documentación oficial vigente antes de usar este código en producción; la estructura general se mantiene estable.)

El ejemplo usa la API del SDK Python 2.x documentada en agosto de 2026.

Servidor MCP básico (Python):

from mcp.server import MCPServer

server = MCPServer("mcp-rrhh-server")

@server.tool()
async def consultar_saldo_vacaciones(empleado_id: str) -> dict:
    """Obtiene el saldo disponible de un empleado autorizado."""
    # En producción: obtener identidad autenticada y autorizar en el servidor.
    return {
        "empleado": "Ana García",
        "asignados_anio": 18,
        "usados": 6,
        "disponibles": 12,
    }

@server.tool()
async def solicitar_vacaciones(
    empleado_id: str,
    fecha_inicio: str,
    fecha_fin: str,
) -> dict:
    """Envía una solicitud después de que el host confirme la acción."""
    return {
        "estado": "enviada",
        "numero_solicitud": "VAC-2026-8473",
    }

if __name__ == "__main__":
    server.run()  # stdio por defecto

Cliente MCP (invocación desde el host):

import asyncio

from mcp import Client, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main() -> None:
    params = StdioServerParameters(
        command="python",
        args=["servidor_mcp.py"],
    )

    async with Client(stdio_client(params)) as client:
        tools = await client.list_tools()
        print([tool.name for tool in tools.tools])

        result = await client.call_tool(
            "consultar_saldo_vacaciones",
            {"empleado_id": "emp_12345"},
        )
        print(result)

if __name__ == "__main__":
    asyncio.run(main())

Para un servidor remoto nuevo, la alternativa estándar es server.run(transport="streamable-http", port=3001), acompañada de autenticación y autorización adecuadas.

MCP en el ecosistema actual (2026)

MCP pasó de ser una propuesta de un laboratorio a un proyecto con gobernanza compartida y adopción entre proveedores en poco más de un año:

Noviembre de 2024: Anthropic publica MCP como estándar abierto.
Marzo de 2025: OpenAI anuncia adopción en sus productos. El soporte estaba disponible ese mes en Agents SDK; Responses API y ChatGPT se anunciaron entonces como próximos, no como ya disponibles.
Mayo de 2025: OpenAI agrega servidores MCP remotos a la Responses API. Microsoft lleva la integración de MCP en Copilot Studio a disponibilidad general.
Durante 2025: Gemini, Cursor, Microsoft Copilot, Visual Studio Code y otros productos incorporan MCP. En septiembre, ChatGPT habilita soporte completo de herramientas MCP de lectura y escritura mediante Developer Mode.
9 de diciembre de 2025: Anthropic dona MCP a la Agentic AI Foundation, un fondo dirigido bajo la Linux Foundation, cofundado por Anthropic, Block y OpenAI, con apoyo de Google, Microsoft, AWS, Cloudflare y Bloomberg.
Diciembre de 2025: en ese mismo anuncio oficial, Anthropic reporta más de 97 millones de descargas mensuales combinadas de los SDKs de Python y TypeScript. La fuente primaria no sitúa por primera vez esa cifra en marzo de 2026; para entonces ya se había publicado.
26 de agosto de 2026: OpenAI retira la Assistants API y dirige la migración a Responses API y Conversations API. Responses incluye MCP entre sus herramientas, pero la migración no es exclusivamente “hacia MCP”.
Frameworks como LangChain, LlamaIndex, LangGraph, CrewAI y AutoGen ofrecen integraciones MCP, aunque su configuración y grado de soporte varían; no existe una única capa “por defecto” universal para todos.

La promesa original de MCP —un estándar abierto para conectar aplicaciones de IA con herramientas y fuentes de contexto sin crear una integración distinta para cada combinación— se convirtió en una opción ampliamente adoptada. Eso no elimina la necesidad de verificar compatibilidad de versiones, seguridad ni capacidades concretas de cada cliente.

Resumen del capítulo

MCP es un protocolo basado en JSON-RPC 2.0 para conectar aplicaciones de IA con herramientas, recursos y prompts externos.
Arquitectura de tres actores: Host (contiene al LLM), Cliente MCP (dentro del host) y Servidor MCP (conectado a sistemas externos).
MCP y RAG conviven: RAG implementa recuperación; MCP puede estandarizar cómo se expone esa recuperación y otras capacidades.
La seguridad es crítica: consentimiento proporcional al riesgo, autorización en servidor, validación, mínimo privilegio y auditoría.
MCP no es un tipo de memoria — es una interfaz que puede conectar herramientas, datos y también sistemas de memoria.
Desde diciembre de 2025, MCP forma parte de la Agentic AI Foundation bajo la Linux Foundation, con gobernanza compartida.

En el próximo capítulo (6) veremos los flujos agénticos completos — cómo memoria, herramientas y grados de autonomía se combinan en un solo agente funcional.