IA & Machine LearningIntermedio

MCP (Model Context Protocol)

Protocolo abierto, presentado por Anthropic en 2024, que estandariza cómo las aplicaciones de AI se conectan a herramientas, datos y servicios externos.

Pronunciación

/ɛm siː piː/
"em-si-pi"
Escuchar en:Forvo

Qué es

MCP (Model Context Protocol) es un protocolo abierto que define cómo las aplicaciones de AI (asistentes como Claude o ChatGPT, IDEs como Cursor o VS Code, agentes propios) se conectan a herramientas, fuentes de datos y servicios externos.

Anthropic lo presentó en noviembre de 2024 y en diciembre de 2025 lo donó a la Agentic AI Foundation (AAIF), un fondo de la Linux Foundation, para que su evolución tenga gobernanza neutral entre proveedores.

La documentación oficial lo compara con un puerto USB-C para aplicaciones de AI: un conector estándar para que cualquier aplicación compatible use cualquier servidor MCP sin integraciones a medida.

Errores comunes de pronunciación

  • ❌ “mcpé” (no es una palabra, son iniciales)
  • ❌ “eme-ce-pe” (en contextos técnicos se usa la pronunciación inglesa de las siglas)

Por qué existe MCP

El problema antes de MCP

┌─────────────────────────────────────────────────────────┐
│                   SIN ESTÁNDAR (Antes)                  │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   App AI A ───→ Integración propia A ──→ Tu App         │
│                                                          │
│   App AI B ───→ Integración propia B ──→ Tu App         │
│                (diferente formato)                       │
│                                                          │
│   App AI C ───→ Integración propia C ──→ Tu App         │
│                (otro formato más)                        │
│                                                          │
│   = 3 integraciones diferentes para lo mismo            │
│                                                          │
└─────────────────────────────────────────────────────────┘

La solución con MCP

┌─────────────────────────────────────────────────────────┐
│                   CON MCP (Ahora)                        │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   App AI A ─┐                                            │
│             │                                            │
│   App AI B ─┼────→ MCP Server ────→ Tu App              │
│             │      (un formato)                          │
│   App AI C ─┘                                            │
│                                                          │
│   = 1 integración sirve para todas las apps compatibles │
│                                                          │
└─────────────────────────────────────────────────────────┘

Arquitectura MCP

MCP define tres participantes:

Componente Rol Ejemplo
Host La aplicación de AI con la que interactúa el usuario Claude Desktop, Cursor, VS Code
Client Componente dentro del host que mantiene una conexión 1:1 con un servidor Uno por cada servidor conectado
Server Programa que expone herramientas, recursos y prompts Tu backend, un servidor de GitHub o de archivos

Flujo de comunicación

┌──────────┐      ┌──────────┐      ┌──────────┐
│   Host   │      │  Client  │      │  Server  │
│ (Claude) │ ←──→ │  (MCP)   │ ←──→ │ (Tu API) │
└──────────┘      └──────────┘      └──────────┘
     │                 │                  │
     │   "Lista mis    │                  │
     │    tareas"      │                  │
     │ ───────────────→│                  │
     │                 │  tools/list      │
     │                 │ ────────────────→│
     │                 │                  │
     │                 │  [getTasks,      │
     │                 │   createTask]    │
     │                 │ ←────────────────│
     │                 │                  │
     │                 │  tools/call      │
     │                 │  getTasks()      │
     │                 │ ────────────────→│
     │                 │                  │
     │                 │  [{id:1, ...}]   │
     │                 │ ←────────────────│
     │   "Tienes 5     │                  │
     │    tareas..."   │                  │
     │ ←───────────────│                  │

Los mensajes viajan como JSON-RPC 2.0, ya sea por stdio (servidores locales) o por HTTP (servidores remotos).

Ejemplo práctico: Servidor MCP básico

Con el SDK oficial de TypeScript (v2, paquete @modelcontextprotocol/server):

// server.ts - Un servidor MCP mínimo
import { McpServer } from "@modelcontextprotocol/server";
import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
import * as z from "zod/v4";

const server = new McpServer({ name: "mi-servidor-tareas", version: "1.0.0" });

// Registrar una herramienta: el SDK la anuncia en tools/list
// y valida los argumentos con el schema antes de llamar al handler
server.registerTool(
  "obtener_tareas",
  {
    description: "Obtiene la lista de tareas",
    inputSchema: z.object({
      estado: z.enum(["pendiente", "completada", "todas"]),
    }),
  },
  async ({ estado }) => {
    const tareas = await fetchTareasFromDB(estado);
    return { content: [{ type: "text", text: JSON.stringify(tareas) }] };
  }
);

// Iniciar servidor por stdio
const transport = new StdioServerTransport();
await server.connect(transport);

Capacidades de MCP

Un servidor MCP puede exponer tres tipos de capacidades:

1. Tools (Herramientas)

Funciones que la AI puede ejecutar:

{
  "name": "enviar_email",
  "description": "Envía un email a un destinatario",
  "inputSchema": {
    "type": "object",
    "properties": {
      "to": { "type": "string" },
      "subject": { "type": "string" },
      "body": { "type": "string" }
    },
    "required": ["to", "subject", "body"]
  }
}

2. Resources (Recursos)

Datos que la AI puede leer:

{
  "uri": "file:///config/settings.json",
  "name": "Configuración del sistema",
  "mimeType": "application/json"
}

3. Prompts (Plantillas)

Instrucciones reutilizables:

{
  "name": "revisar_codigo",
  "description": "Template para code review",
  "arguments": [
    { "name": "archivo", "required": true }
  ]
}

Servidores MCP populares

Servidor Función Mantenedor
filesystem Acceso a archivos locales con control de acceso Proyecto MCP (servidor de referencia)
git Leer, buscar y manipular repositorios Git Proyecto MCP (servidor de referencia)
fetch Obtener contenido web y convertirlo para el LLM Proyecto MCP (servidor de referencia)
GitHub MCP Server Issues, PRs y repos de GitHub GitHub (servidor oficial)

Varios servidores de referencia antiguos (PostgreSQL, Slack, Google Drive, entre otros) fueron archivados en el repositorio servers-archived; hoy conviene buscar el servidor oficial de cada proveedor.

Configuración en Claude Desktop

// ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
{
  "mcpServers": {
    "mi-servidor": {
      "command": "node",
      "args": ["/path/to/server.js"],
      "env": {
        "API_KEY": "tu-api-key"
      }
    }
  }
}

Seguridad en MCP

Principios de seguridad

  1. Menor privilegio: Exponer solo lo necesario
  2. Validación: Verificar todos los inputs
  3. Autenticación: Usar tokens para acceso (la especificación define autorización basada en OAuth para servidores HTTP)
  4. Auditoría: Registrar todas las operaciones
  5. Desconfiar del contenido externo: lo que devuelve una herramienta puede traer prompt injection

Ejemplo de validación

server.registerTool(
  "borrar_tarea",
  {
    description: "Borra una tarea del usuario actual",
    // El schema rechaza argumentos inválidos antes de ejecutar
    inputSchema: z.object({ id: z.string().uuid() }),
  },
  async ({ id }) => {
    // Verificar permisos en el servidor, no confiar en el modelo
    if (!(await usuarioPuedeBorrar(id))) {
      return { isError: true, content: [{ type: "text", text: "Operación no permitida" }] };
    }
    await borrarTarea(id);
    return { content: [{ type: "text", text: `Tarea ${id} borrada` }] };
  }
);

Términos relacionados

  • Agentic AI - AI que actúa de forma autónoma usando herramientas
  • API - Interfaz de programación de aplicaciones
  • Webhook - Callback HTTP para eventos

Recursos oficiales:

Artículos relacionados

Todos los términos