MCP (Model Context Protocol): Guía Completa 2026

¿Qué es el Model Context Protocol (MCP)?

El Model Context Protocol (MCP) es un estándar abierto creado por Anthropic que define cómo las aplicaciones de inteligencia artificial se conectan con herramientas externas, fuentes de datos y servicios. Piensa en MCP como el "USB-C de la IA": una interfaz universal que permite que cualquier modelo de lenguaje interactúe con el mundo exterior de forma estandarizada.

Antes de MCP, cada integración entre un LLM y una herramienta externa requería código personalizado. Si querías que Claude accediera a tu base de datos, necesitabas escribir un plugin específico. Si luego querías conectar GPT-4 al mismo recurso, tenías que reescribir todo desde cero. MCP resuelve esto con un protocolo único que cualquier cliente y servidor pueden implementar.

Arquitectura de MCP: Host, Client y Server

La arquitectura de MCP se basa en tres componentes principales que siguen un patrón cliente-servidor bien definido:

• Host: La aplicación que el usuario utiliza directamente (Claude Desktop, un IDE, un chatbot). El host orquesta las conexiones y gestiona la seguridad.
• Client: Un componente dentro del host que mantiene una conexión 1:1 con un servidor MCP específico. Cada client gestiona el ciclo de vida de su conexión.
• Server: Un proceso ligero que expone capacidades específicas (herramientas, recursos, prompts) a través del protocolo MCP. Puede ser local o remoto.

1┌─────────────────────────────────────┐
2│           HOST (Claude Desktop)      │
3│                                     │
4│  ┌──────────┐    ┌──────────┐      │
5│  │ Client A │    │ Client B │      │
6│  └────┬─────┘    └────┬─────┘      │
7│       │               │            │
8└───────┼───────────────┼────────────┘
9        │               │
10   ┌────▼─────┐    ┌────▼─────┐
11   │ Server A │    │ Server B │
12   │ (GitHub) │    │ (DB SQL) │
13   └──────────┘    └──────────┘

Esta arquitectura permite que un solo host se conecte a múltiples servidores MCP simultáneamente. Por ejemplo, Claude Desktop puede tener conectados al mismo tiempo un servidor para GitHub, otro para tu base de datos PostgreSQL y otro para Slack.

Capacidades principales de MCP

Un servidor MCP puede exponer tres tipos de capacidades:

1. Tools (Herramientas)

Las herramientas son funciones que el modelo puede invocar. Son el equivalente a function calling, pero estandarizado. Ejemplos: ejecutar una query SQL, crear un archivo, enviar un mensaje en Slack, hacer un deployment.

2. Resources (Recursos)

Los recursos son datos que el modelo puede leer. Son similares a endpoints GET de una API REST. Ejemplos: el contenido de un archivo, el esquema de una base de datos, los últimos commits de un repositorio.

3. Prompts (Plantillas)

Son plantillas de prompts reutilizables que el servidor ofrece al cliente. Útiles para estandarizar flujos de trabajo comunes como "analizar código", "generar documentación" o "revisar un PR".

Protocolos de transporte

MCP soporta varios mecanismos de transporte para la comunicación entre cliente y servidor:

• stdio: Comunicación por entrada/salida estándar. Ideal para servidores locales que el host lanza como procesos hijos. Es el más simple y el más usado en desarrollo local.
• Streamable HTTP: El transporte recomendado para servidores remotos en 2026. Usa HTTP estándar con streaming opcional vía Server-Sent Events (SSE). Compatible con infraestructura web existente (load balancers, proxies, CDN).
• SSE (legacy): El transporte HTTP original de MCP. Usa dos endpoints: uno POST para enviar mensajes y uno GET con SSE para recibirlos. Está siendo reemplazado por Streamable HTTP.

1// Ejemplo: Configuración de transporte en Claude Desktop
2// Archivo: claude_desktop_config.json
3{
4  "mcpServers": {
5    "mi-servidor-local": {
6      "command": "node",
7      "args": ["./dist/server.js"],
8      "transport": "stdio"
9    },
10    "mi-servidor-remoto": {
11      "url": "https://mcp.miempresa.com/api",
12      "transport": "streamable-http",
13      "headers": {
14        "Authorization": "Bearer token-aqui"
15      }
16    }
17  }
18}

Construir un servidor MCP en TypeScript

Vamos a crear un servidor MCP funcional en TypeScript que expone una herramienta para consultar una API de clima. Usaremos el SDK oficial @modelcontextprotocol/sdk.

1import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
2import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
3import { z } from "zod";
4
5// 1. Crear el servidor
6const server = new McpServer({
7  name: "weather-server",
8  version: "1.0.0",
9  description: "Servidor MCP para consultar clima"
10});
11
12// 2. Definir una herramienta con validación Zod
13server.tool(
14  "get-weather",
15  "Obtiene el clima actual de una ciudad",
16  {
17    city: z.string().describe("Nombre de la ciudad"),
18    units: z.enum(["celsius", "fahrenheit"]).default("celsius")
19  },
20  async ({ city, units }) => {
21    const response = await fetch(
22      `https://api.weatherapi.com/v1/current.json?key=API_KEY&q=${city}`
23    );
24    const data = await response.json();
25    const temp = units === "celsius"
26      ? data.current.temp_c
27      : data.current.temp_f;
28
29    return {
30      content: [{
31        type: "text",
32        text: `El clima en ${city}: ${temp}° ${units}, ${data.current.condition.text}`
33      }]
34    };
35  }
36);
37
38// 3. Definir un recurso
39server.resource(
40  "supported-cities",
41  "cities://list",
42  async (uri) => ({
43    contents: [{
44      uri: uri.href,
45      mimeType: "application/json",
46      text: JSON.stringify(["Madrid", "CDMX", "Buenos Aires", "Bogotá", "Lima"])
47    }]
48  })
49);
50
51// 4. Conectar con transporte stdio
52const transport = new StdioServerTransport();
53await server.connect(transport);
54console.error("Servidor MCP de clima iniciado");

Para ejecutar este servidor necesitas instalar las dependencias:

1npm init -y
2npm install @modelcontextprotocol/sdk zod
3npx tsc --init
4# Compilar y ejecutar
5npx tsc && node dist/server.js

Construir un servidor MCP en Python

El ecosistema Python también tiene un SDK oficial para MCP. Aquí creamos un servidor que expone herramientas para interactuar con una base de datos SQLite:

1import sqlite3
2from mcp.server.fastmcp import FastMCP
3
4# Crear servidor con FastMCP (API de alto nivel)
5mcp = FastMCP("database-server")
6
7DB_PATH = "mi_base_de_datos.db"
8
9@mcp.tool()
10def query_database(sql: str) -> str:
11    """Ejecuta una consulta SQL SELECT en la base de datos.
12    Solo permite consultas de lectura (SELECT).
13    """
14    if not sql.strip().upper().startswith("SELECT"):
15        return "Error: Solo se permiten consultas SELECT"
16
17    conn = sqlite3.connect(DB_PATH)
18    try:
19        cursor = conn.execute(sql)
20        columns = [desc[0] for desc in cursor.description]
21        rows = cursor.fetchall()
22        result = [dict(zip(columns, row)) for row in rows]
23        return str(result)
24    except Exception as e:
25        return f"Error ejecutando query: {e}"
26    finally:
27        conn.close()
28
29@mcp.tool()
30def list_tables() -> str:
31    """Lista todas las tablas disponibles en la base de datos."""
32    conn = sqlite3.connect(DB_PATH)
33    cursor = conn.execute(
34        "SELECT name FROM sqlite_master WHERE type='table'"
35    )
36    tables = [row[0] for row in cursor.fetchall()]
37    conn.close()
38    return str(tables)
39
40@mcp.resource("schema://tables/{table_name}")
41def get_table_schema(table_name: str) -> str:
42    """Retorna el esquema de una tabla específica."""
43    conn = sqlite3.connect(DB_PATH)
44    cursor = conn.execute(f"PRAGMA table_info({table_name})")
45    columns = cursor.fetchall()
46    conn.close()
47    schema = [{"name": c[1], "type": c[2], "nullable": not c[3]} for c in columns]
48    return str(schema)
49
50# Iniciar el servidor
51if __name__ == "__main__":
52    mcp.run(transport="stdio")

Seguridad y mejores prácticas

MCP introduce una superficie de ataque nueva que debes considerar cuidadosamente:

Principio de mínimo privilegio

Cada servidor MCP debe tener acceso solo a los recursos que necesita. Si tu servidor de GitHub solo necesita leer issues, no le des permisos de escritura en repositorios.

Validación de inputs

Siempre valida los argumentos que reciben tus herramientas. Usa Zod en TypeScript o Pydantic en Python. Nunca confíes en que el modelo enviará datos correctos.

Autenticación y autorización

Para servidores remotos, implementa OAuth 2.1 (el flujo recomendado por la especificación MCP). Para servidores locales, el aislamiento de proceso es generalmente suficiente.

Logging y auditoría

Registra todas las invocaciones de herramientas con sus argumentos y resultados. Esto es crítico para debuggear problemas y para cumplir con regulaciones de compliance.

1// Middleware de logging para un servidor MCP
2server.tool(
3  "delete-record",
4  "Elimina un registro de la base de datos",
5  { id: z.string().uuid(), table: z.string() },
6  async ({ id, table }) => {
7    // Log antes de ejecutar
8    console.error(JSON.stringify({
9      timestamp: new Date().toISOString(),
10      tool: "delete-record",
11      args: { id, table },
12      action: "invoked"
13    }));
14
15    // Validación adicional
16    const allowedTables = ["drafts", "temp_files"];
17    if (!allowedTables.includes(table)) {
18      return {
19        content: [{ type: "text", text: "Tabla no permitida para eliminación" }],
20        isError: true
21      };
22    }
23
24    // Ejecutar operación...
25    return {
26      content: [{ type: "text", text: `Registro ${id} eliminado de ${table}` }]
27    };
28  }
29);

Ecosistema y herramientas compatibles

El ecosistema MCP ha crecido enormemente desde su lanzamiento. Estas son las principales plataformas que lo soportan en 2026:

IDEs y editores

• Claude Desktop: El cliente MCP original. Soporta todas las capacidades (tools, resources, prompts) y múltiples transportes.
• VS Code + GitHub Copilot: Soporte nativo de MCP desde la versión 1.99. Permite configurar servidores en settings.json o .vscode/mcp.json.
• Cursor: Integración profunda con MCP. Los servidores se configuran en la sección "MCP" de la configuración del proyecto.
• Windsurf: Soporte completo de MCP con interfaz visual para gestionar servidores.
• Zed: El editor de alto rendimiento también adoptó MCP para sus capacidades de IA.

Servidores MCP populares

• GitHub MCP Server: Acceso completo a repos, issues, PRs, Actions.
• PostgreSQL / MySQL: Consultas, esquemas, migraciones.
• Slack: Enviar mensajes, buscar conversaciones, gestionar canales.
• Filesystem: Leer/escribir archivos con permisos granulares.
• Puppeteer / Playwright: Automatización de navegador web.
• AWS / GCP / Azure: Gestión de recursos cloud.

Casos de uso en el mundo real

MCP no es solo una especificación teórica. Ya está siendo usado en producción por empresas de todos los tamaños:

Desarrollo de software

Equipos de ingeniería conectan Claude o Copilot a sus bases de datos, sistemas de CI/CD y herramientas de monitoreo. Un desarrollador puede preguntar "¿cuáles son los errores más frecuentes en producción esta semana?" y el modelo consulta Datadog o Grafana vía MCP.

Soporte al cliente

Chatbots internos usan MCP para acceder a CRMs, sistemas de tickets y bases de conocimiento. El agente de IA puede buscar el historial de un cliente, crear un ticket en Jira y enviar una respuesta personalizada, todo dentro de una misma conversación.

Análisis de datos

Analistas de negocio conectan modelos de IA a data warehouses via MCP. Pueden hacer preguntas en lenguaje natural que se traducen a queries SQL, sin necesidad de saber SQL ellos mismos.

Conclusión y futuro de MCP

El Model Context Protocol representa un cambio fundamental en cómo construimos aplicaciones de IA. En lugar de integraciones frágiles y propietarias, tenemos un estándar abierto que cualquier modelo, herramienta y plataforma puede adoptar.

En 2026, MCP ya es el estándar de facto para conectar IA con herramientas. La especificación sigue evolucionando: se están añadiendo capacidades como elicitation (pedir input al usuario durante la ejecución), structured output schemas y mejor soporte para agentes multi-paso.

Si estás construyendo cualquier tipo de integración con IA, aprender MCP no es opcional: es una habilidad esencial para el desarrollo de software moderno. Empieza con un servidor simple en TypeScript o Python, conéctalo a Claude Desktop, y experimenta con las posibilidades.

El futuro de la IA no es solo modelos más inteligentes. Es modelos que pueden actuar en el mundo real. Y MCP es el puente que lo hace posible.