El Model Context Protocol (MCP) es un estándar abierto creado por Anthropic que define cómo los modelos de AI se comunican con herramientas externas, fuentes de datos y servicios. Piénsalo como el "USB-C de la AI" - un conector universal que permite a cualquier agente de AI comunicarse con cualquier herramienta a través de una interfaz estandarizada.
Desde su lanzamiento, MCP ha superado los 97 millones de descargas mensuales del SDK y ha sido adoptado por todos los principales proveedores de AI: Anthropic, OpenAI, Google, Microsoft y Amazon. En esta guía, exploraremos todo lo que necesitas saber para construir con MCP.
Por Qué Existe MCP
Antes de MCP, cada aplicación de AI tenía que construir integraciones personalizadas para cada herramienta que quería utilizar. ¿Quieres que tu AI lea archivos? Escribe código personalizado. ¿Consultar una base de datos? Más código personalizado. ¿Publicar en Slack? Otra integración más.
Esto creaba un problema N×M: N aplicaciones de AI, cada una necesitando M integraciones personalizadas, lo que llevaba a esfuerzos duplicados y ecosistemas fragmentados.
MCP resuelve esto con un único protocolo que cualquier cliente de AI puede usar para comunicarse con cualquier servidor MCP:
Conceptos Fundamentales
MCP tiene tres primitivas fundamentales:
1. Herramientas (Tools)
Las herramientas son funciones que la AI puede llamar. Representan acciones como "crear un archivo", "consultar una base de datos" o "enviar un mensaje". Cada herramienta tiene un nombre, una descripción y un JSON Schema para sus parámetros.
{ name: "create_issue", description: "Create a new GitHub issue", inputSchema: { type: "object", properties: { title: { type: "string", description: "Issue title" }, body: { type: "string", description: "Issue body" }, repo: { type: "string", description: "Repository name" } }, required: ["title", "repo"] } }
2. Recursos (Resources)
Los recursos son datos que la AI puede leer. Representan archivos, registros de bases de datos, respuestas de API o cualquier otra fuente de datos. Los recursos se identifican mediante URIs.
{ uri: "file:///Users/dev/project/README.md", name: "Project README", mimeType: "text/markdown" }
3. Prompts
Los prompts son plantillas reutilizables que ayudan a estructurar las interacciones. Pueden incluir parámetros dinámicos y son útiles para estandarizar flujos de trabajo comunes.
{ name: "code_review", description: "Review code changes for quality and security", arguments: [ { name: "diff", description: "The code diff to review", required: true } ] }
Arquitectura
MCP sigue una arquitectura cliente-servidor:
- Host: La aplicación de AI (Claude Desktop, Cursor, tu aplicación personalizada)
- Client: Mantiene una conexión 1:1 con un servidor MCP
- Server: Expone herramientas, recursos y prompts al cliente
- Transport: La comunicación se realiza a través de JSON-RPC 2.0 sobre stdio (local) o Server-Sent Events (remoto)
Construir un Servidor MCP
Construyamos un servidor MCP práctico que interactúa con una lista de tareas almacenada en un archivo JSON.
Configuración Inicial
mkdir mcp-todo-server && cd mcp-todo-server npm init -y npm install @modelcontextprotocol/sdk zod
Implementación del Servidor
// src/index.ts import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; import { z } from "zod"; import fs from "fs"; const TODO_FILE = "./todos.json"; function readTodos(): { id: number; text: string; done: boolean }[] { if (!fs.existsSync(TODO_FILE)) return []; return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8")); } function writeTodos(todos: { id: number; text: string; done: boolean }[]) { fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2)); } const server = new McpServer({ name: "todo-server", version: "1.0.0", }); // Tool: Add a todo server.tool( "add_todo", "Add a new todo item", { text: z.string().describe("The todo text") }, async ({ text }) => { const todos = readTodos(); const newTodo = { id: Date.now(), text, done: false }; todos.push(newTodo); writeTodos(todos); return { content: [{ type: "text", text: `Added: "${text}"` }] }; } ); // Tool: List todos server.tool( "list_todos", "List all todo items", {}, async () => { const todos = readTodos(); const list = todos .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`) .join("\n"); return { content: [{ type: "text", text: list || "No todos yet." }] }; } ); // Tool: Complete a todo server.tool( "complete_todo", "Mark a todo as completed", { id: z.number().describe("The todo ID to complete") }, async ({ id }) => { const todos = readTodos(); const todo = todos.find((t) => t.id === id); if (!todo) return { content: [{ type: "text", text: "Todo not found." }] }; todo.done = true; writeTodos(todos); return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] }; } ); // Resource: Current todos as a readable resource server.resource( "todos://list", "Current todo list", async () => ({ contents: [{ uri: "todos://list", mimeType: "application/json", text: JSON.stringify(readTodos(), null, 2), }], }) ); // Start the server const transport = new StdioServerTransport(); await server.connect(transport);
Configuración
Para usar este servidor con Claude Desktop, agrégalo a tu configuración:
{ "mcpServers": { "todo": { "command": "npx", "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"] } } }
Construir un Cliente MCP
También puedes construir un cliente personalizado que se conecte a cualquier servidor MCP:
import { Client } from "@modelcontextprotocol/sdk/client/index.js"; import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"; const transport = new StdioClientTransport({ command: "npx", args: ["tsx", "./src/index.ts"], }); const client = new Client({ name: "my-client", version: "1.0.0" }); await client.connect(transport); // List available tools const { tools } = await client.listTools(); console.log("Available tools:", tools.map((t) => t.name)); // Call a tool const result = await client.callTool({ name: "add_todo", arguments: { text: "Write MCP blog post" }, }); console.log(result);
Servidores MCP Populares
El ecosistema MCP ha crecido rápidamente. Aquí hay algunos de los servidores más populares:
| Servidor | Descripción | Caso de Uso |
|---|---|---|
| GitHub | Crear issues, PRs, gestionar repos | Flujos de trabajo de desarrollo |
| Slack | Enviar mensajes, gestionar canales | Comunicación del equipo |
| PostgreSQL | Consultar y gestionar bases de datos | Acceso a datos |
| Filesystem | Leer, escribir y buscar archivos | Desarrollo local |
| Puppeteer | Automatización del navegador y scraping | Pruebas web |
| Sentry | Monitoreo de errores y depuración | Soporte en producción |
| Supabase | Base de datos, auth, almacenamiento | Operaciones backend |
MCP vs A2A (Agent-to-Agent)
Mientras que MCP maneja la comunicación agente-herramienta, el protocolo A2A (Agent-to-Agent) de Google maneja la comunicación agente-agente. Son complementarios:
- MCP: Cómo un agente de AI usa herramientas (integración vertical)
- A2A: Cómo los agentes de AI colaboran entre sí (integración horizontal)
Buenas Prácticas
- Mantén los servidores enfocados: Un servidor por dominio (servidor GitHub, servidor Slack, etc.). No construyas servidores monolíticos.
- Valida las entradas con Zod: Siempre valida las entradas de herramientas con esquemas apropiados.
- Maneja los errores con elegancia: Devuelve mensajes de error significativos, no stack traces.
- Usa recursos para datos de solo lectura: Si la AI solo necesita leer datos, expónlos como recurso en lugar de herramienta.
- Agrega descripciones adecuadas: Buenas descripciones de herramientas y parámetros ayudan a la AI a entender cuándo y cómo usar cada herramienta.
- Prueba con el MCP Inspector: Usa
npx @modelcontextprotocol/inspectorpara probar tu servidor de forma interactiva.
Primeros Pasos
# Create a new MCP server from template npx @modelcontextprotocol/create-server my-server # Test with the MCP Inspector npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
Conclusión
MCP se ha convertido en el estándar de facto para el uso de herramientas AI en 2026. Ya sea que estés construyendo agentes AI personalizados, extendiendo Claude Code o creando integraciones para plataformas existentes, entender MCP es esencial. El protocolo es lo suficientemente simple para aprenderlo en una tarde pero lo suficientemente potente para construir flujos de trabajo AI de nivel producción.
Próximos pasos:
- Explora la Especificación MCP
- Navega por los servidores MCP existentes en busca de inspiración
- Construye tu primer servidor con el SDK de TypeScript o Python
- Pruébalo con Claude Desktop o el MCP Inspector