MCP

Resumen

MCP, Model Context Protocol, es un protocolo abierto creado por Anthropic que estandariza cómo las aplicaciones de IA se conectan con herramientas, fuentes de datos y servicios externos. En vez de que cada agente o asistente integre APIs una por una con código ad hoc, MCP define servidores que exponen capacidades —tools, resources, prompts— y clientes que las descubren y consumen con un contrato común.

Importa porque el ecosistema de herramientas para IA está fragmentado. Cada proveedor de API, cada base de datos, cada servicio tiene su propio SDK, formato y mecanismo de autenticación. MCP ofrece un estándar que reduce esa fragmentación: un servidor MCP puede exponer búsqueda en documentos, acceso a bases de datos, APIs de negocio o cualquier capacidad que un LLM necesite invocar, y cualquier cliente MCP puede consumirlo sin integración personalizada.

Alcance y supuestos

Este paquete cubre MCP a nivel conceptual: servidores, clientes, tools, resources, prompts, transportes y el modelo request/response que orquesta la comunicación entre aplicaciones IA y sistemas externos.

No cubre implementación detallada de transporte, construcción de servidores MCP en producción, tutoriales de SDKs ni comparación exhaustiva de implementaciones. Asume que entiendes LLMs, agentes IA, tool calling y el concepto de herramientas y fuentes de datos externas para aplicaciones de IA.

Modelo mental

Piensa en un puerto USB-C para aplicaciones de IA. Antes de USB-C, cada dispositivo necesitaba su propio cable y adaptador: el monitor con HDMI, el disco duro con Thunderbolt, el teclado con USB-A. USB-C estandarizó la conexión física y el protocolo, permitiendo que cualquier dispositivo compatible se conecte a cualquier puerto.

MCP hace lo mismo para herramientas de IA. Antes de MCP, cada herramienta requería código de integración específico: una función para buscar en Google Drive, otra para consultar PostgreSQL, otra para leer tickets de Jira. Con MCP, el servidor expone capacidades estandarizadas que cualquier cliente MCP entiende. Cambiar de herramienta no requiere reescribir todo el código de integración; solo apuntas a otro servidor.

Un servidor MCP expone tres tipos de capacidades:

• Tools: funciones que el modelo puede invocar, como buscar documentos, crear tickets o consultar datos. Son skills estandarizados por MCP.
• Resources: datos estructurados que el modelo puede leer, como archivos, registros de base de datos o contenido de APIs.
• Prompts: plantillas de prompt predefinidas que el servidor ofrece para tareas comunes.

El cliente MCP descubre qué capacidades ofrece cada servidor y las pone a disposición del modelo. El modelo decide cuándo usarlas, igual que con function calling tradicional, pero sin acoplarse al mecanismo específico de cada proveedor.

Uso práctico

Usa MCP cuando necesitas que agentes o asistentes de IA se conecten a múltiples herramientas y fuentes de datos sin integraciones frágiles:

• ✅ Conectar un asistente a Google Drive, Slack, GitHub, bases de datos y APIs internas sin escribir conectores para cada uno.
• ✅ Estandarizar el catálogo de herramientas disponibles para agentes en una organización o producto.
• ✅ Separar la lógica de herramientas del código del agente: los servidores MCP pueden evolucionar, escalar y asegurarse de forma independiente.
• ✅ Compartir herramientas entre distintos clientes y modelos sin duplicar integraciones.
• ❌ No reemplaza function calling; MCP es una capa de estandarización sobre function calling, no un mecanismo alternativo de invocación.
• ❌ No es necesario para casos simples con una o dos APIs; la complejidad de MCP se justifica cuando hay múltiples herramientas y fuentes de datos.

Ejemplo trabajado: conectar un agente a múltiples fuentes vía MCP

Supón que un agente de soporte necesita buscar políticas en Google Drive, consultar pedidos en PostgreSQL y leer tickets en Jira. Sin MCP, cada fuente requiere su propio código de integración. Con MCP, cada fuente expone un servidor y el agente solo necesita un cliente MCP:

type MCPServer = {
  name: string;
  capabilities: {
    tools: Array<{
      name: string;
      description: string;
      parameters: Record<string, unknown>;
    }>;
  };
};

type MCPClient = {
  listServers(): Promise<MCPServer[]>;
  callTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
  readResource(serverName: string, uri: string): Promise<unknown>;
};

async function setupAgentTools(mcpClient: MCPClient) {
  const servers = await mcpClient.listServers();

  const allTools: Array<{
    server: string;
    name: string;
    description: string;
  }> = [];

  for (const server of servers) {
    for (const tool of server.capabilities.tools) {
      allTools.push({
        server: server.name,
        name: tool.name,
        description: tool.description,
      });
    }
  }

  return allTools;
  // Estas herramientas se pasan al modelo como tool definitions.
  // El modelo elige cuál invocar; el cliente MCP traduce la llamada
  // al servidor correcto sin que el agente sepa los detalles de cada API.
}

Lo que hace valioso este diseño:

1. Un solo cliente MCP reemplaza N integraciones directas a APIs.
2. Agregar una nueva fuente de datos es levantar un servidor MCP, no reescribir el agente.
3. Las herramientas se descubren dinámicamente: no necesitas hardcodear un catálogo fijo.
4. La separación permite que el equipo de infraestructura mantenga los servidores MCP mientras el equipo de producto itera sobre el agente.
5. Los servidores pueden aplicar sus propias políticas de seguridad, rate limiting y logging.

MCP no es magia: sigue habiendo un servidor que implementa la lógica real (leer de PostgreSQL, buscar en Drive). Pero estandariza la interfaz, reduciendo el acoplamiento entre el agente y cada fuente de datos.

Evidencia

• Anthropic, Introducing the Model Context Protocol presenta MCP como un estándar abierto para construir conexiones seguras y bidireccionales entre fuentes de datos y herramientas de IA.
• Model Context Protocol specification define MCP como un protocolo abierto que permite la integración fluida entre aplicaciones LLM y fuentes de datos y herramientas externas.