Saltar al contenido principal

Protocolo MCP (Model Context Protocol)

En la sesión anterior exploramos cómo extender el razonamiento del agente mediante Skills (memoria procedimental bajo demanda). Sin embargo, un modelo de lenguaje por sí solo no tiene acceso al mundo real: no puede consultar tu base de datos en Supabase, no puede interactuar con repositorios remotos en GitHub ni puede manipular un navegador web para probar una pantalla en vivo.

Para resolver la fragmentación entre los LLMs y las fuentes de datos del mundo real, la industria adoptó un estándar abierto fundamental: el Model Context Protocol (MCP).

1. ¿Qué es MCP?​

El Model Context Protocol (MCP) es un protocolo abierto y bidireccional desarrollado por Anthropic que estandariza la forma en que las aplicaciones con IA (Hosts) se conectan de manera segura con herramientas, fuentes de datos y servicios externos (Servers).

Antes de MCP, si una herramienta quería conectar un agente con una base de datos PostgreSQL, un repositorio de GitHub y el sistema de archivos local, debía programar conectores propietarios independientes para cada uno. Con MCP, cualquier servicio que implemente la especificación se vuelve accesible de forma universal e instantánea para cualquier cliente compatible (agy, Claude Desktop, Cursor, VS Code).

Comparativa: API Tradicional vs Skill vs Servidor MCP

2. La Tríada Conceptual: API vs. Skill vs. MCP​

Es común que los desarrolladores confundan estos tres conceptos en el ecosistema agéntico. Comprender su diferencia es esencial para diseñar arquitecturas de software modernas:

CaracterísticaAPI Tradicional (REST / GraphQL)Skill de AgenteServidor MCP (Model Context Protocol)
¿Qué es?Interfaz de programación para comunicación entre sistemas.Módulo de memoria procedimental, heurísticas y reglas de razonamiento.Protocolo cliente-servidor que expone herramientas y recursos ejecutables en tiempo real.
Público objetivoDesarrolladores humanos y código compilado tradicional.El modelo de lenguaje (se inyecta en su ventana de contexto).El agente inteligente y su runtime de ejecución de herramientas (Tool Calling).
AutodescubrimientoNinguno. Requiere que un humano lea la documentación de Swagger/OpenAPI y programe el cliente.Por metadatos YAML frontmatter o comando directo (/skill).Totalmente dinámico. El servidor expone sus herramientas (tools/list) con esquemas JSON Schema en vivo.
Analogía del mundo realUn enchufe eléctrico de pared con voltaje fijo.El manual de taller con instrucciones paso a paso sobre cómo armar un motor.La caja de herramientas mecánicas conectada al brazo robótico del operario.

3. ¿Por qué un LLM no puede consumir directamente una API REST?​

Podrías preguntarte: "Si ya tenemos APIs REST con endpoints como /api/v1/contacts, ¿por qué necesitamos MCP?".

Las APIs REST tradicionales presentan tres limitaciones graves cuando interactúan con modelos de lenguaje:

  1. Falta de introspección semántica: Una API HTTP entrega un código de estado (como 400 Bad Request o 404 Not Found) pero no explica al agente qué parámetros esperaba o qué alternativas existen para resolver el error.
  2. Sobrecarga de tokens innecesaria: Si intentas inyectar una especificación Swagger completa (OpenAPI) con cientos de endpoints en el prompt del LLM, agotarás la ventana de contexto antes de comenzar a trabajar.
  3. Seguridad y permisos en runtime: Una API REST tradicional concede acceso global a través de un token API estático. MCP implementa un protocolo de consentimiento donde el usuario puede autorizar individualmente cada llamada a herramienta (Human-in-the-Loop).

4. Arquitectura de MCP: Host, Client y Server​

La especificación MCP opera bajo una arquitectura de tres capas:

  1. MCP Host: La aplicación principal donde el usuario interactúa con la IA (por ejemplo, el CLI de desarrollo o tu editor de código).
  2. MCP Client: El módulo dentro del host que gestiona las conexiones activas, envía las solicitudes del modelo y recibe los resultados.
  3. MCP Server: Un proceso independiente y ligero que expone tres tipos primitivos de capacidades:
    • Tools (Herramientas): Funciones ejecutables con efectos secundarios (ej. create_table, git_commit, send_slack_message).
    • Resources (Recursos): Datos de solo lectura contextuales (ej. esquemas de bases de datos, archivos de logs, documentación técnica).
    • Prompts: Plantillas preconfiguradas para guiar al modelo en tareas específicas del servidor.

Canales de Transporte (Transports)​

MCP se comunica mediante mensajes JSON-RPC 2.0 a través de dos mecanismos de transporte:

  • stdio (Entrada/Salida Estándar): El host inicia el servidor MCP como un subproceso local en la misma máquina (ideal para CLI tools, emuladores y manipulación de archivos locales).
  • SSE (Server-Sent Events sobre HTTP): El servidor MCP corre en un host remoto en la nube (ideal para servicios compartidos como Supabase, Jira corporativo o clusters de Docker).

5. Ejemplos Prácticos de Servidores MCP en Ingeniería​

A continuación se presentan los servidores MCP más utilizados en proyectos de software contemporáneos:

Permite que el agente inspeccione la estructura real de la base de datos antes de escribir consultas o modelos en Dart:

tools/list (Respuesta del servidor MCP Postgres)
{
  "tools": [
    {
      "name": "describe_table",
      "description": "Devuelve las columnas, tipos de datos y llaves foráneas de una tabla en Postgres.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "table_name": { "type": "string" }
        },
        "required": ["table_name"]
      }
    }
  ]
}
  • Beneficio para el estudiante: El agente consulta describe_table(table_name: "contactos") y genera el modelo inmutable en Dart con los nombres de campos y tipos exactos de la base de datos sin alucinar.

6. Configuración de un Servidor MCP en tu Entorno​

Para habilitar un servidor MCP en tu CLI de desarrollo (agy), se define un archivo de configuración JSON en tu espacio de trabajo o directorio global:

mcp_servers.json
{
  "mcpServers": {
    "supabase-db": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://postgres:pass@db.supabase.co:5432/postgres"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxx"
      }
    }
  }
}

Al iniciar la sesión, el agente detecta automáticamente estos servidores mediante el handshake de MCP, listando las nuevas herramientas disponibles para asistir en la construcción y auditoría de tu aplicación.

Cuestionario de Autoevaluación​

Cargando cuestionario...