1~
2El **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.
3~
4Desde 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.
5~
6## Por Qué Existe MCP
7~
8Antes 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.
9~
10Esto creaba un **problema N×M**: N aplicaciones de AI, cada una necesitando M integraciones personalizadas, lo que llevaba a esfuerzos duplicados y ecosistemas fragmentados.
11~
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23~
24MCP resuelve esto con un **único protocolo** que cualquier cliente de AI puede usar para comunicarse con cualquier servidor MCP:
25~
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36~
37## Conceptos Fundamentales
38~
39MCP tiene tres primitivas fundamentales:
40~
41### 1. Herramientas (Tools)
42Las 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.
43~
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59~
60### 2. Recursos (Resources)
61Los 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.
62~
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70~
71### 3. Prompts
72Los 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.
73~
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83~
84## Arquitectura
85~
86MCP sigue una arquitectura cliente-servidor:
87~
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93~
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100~
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103~
104- **Host**: La aplicación de AI (Claude Desktop, Cursor, tu aplicación personalizada)
105- **Client**: Mantiene una conexión 1:1 con un servidor MCP
106- **Server**: Expone herramientas, recursos y prompts al cliente
107- **Transport**: La comunicación se realiza a través de JSON-RPC 2.0 sobre stdio (local) o Server-Sent Events (remoto)
108~
109## Construir un Servidor MCP
110~
111Construyamos un servidor MCP práctico que interactúa con una lista de tareas almacenada en un archivo JSON.
112~
113### Configuración Inicial
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Implementación del Servidor
122~
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129~
130const TODO_FILE = "./todos.json";
131~
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136~
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140~
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145~
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159~
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173~
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188~
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201~
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206~
207### Configuración
208~
209Para usar este servidor con Claude Desktop, agrégalo a tu configuración:
210~
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221~
222## Construir un Cliente MCP
223~
224También puedes construir un cliente personalizado que se conecte a cualquier servidor MCP:
225~
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229~
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234~
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237~
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241~
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249~
250## Servidores MCP Populares
251~
252El ecosistema MCP ha crecido rápidamente. Aquí hay algunos de los servidores más populares:
253~
254| Servidor | Descripción | Caso de Uso |
255|----------|-------------|-------------|
256| **GitHub** | Crear issues, PRs, gestionar repos | Flujos de trabajo de desarrollo |
257| **Slack** | Enviar mensajes, gestionar canales | Comunicación del equipo |
258| **PostgreSQL** | Consultar y gestionar bases de datos | Acceso a datos |
259| **Filesystem** | Leer, escribir y buscar archivos | Desarrollo local |
260| **Puppeteer** | Automatización del navegador y scraping | Pruebas web |
261| **Sentry** | Monitoreo de errores y depuración | Soporte en producción |
262| **Supabase** | Base de datos, auth, almacenamiento | Operaciones backend |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266Mientras que MCP maneja la comunicación **agente-herramienta**, el protocolo **A2A (Agent-to-Agent)** de Google maneja la comunicación **agente-agente**. Son complementarios:
267~
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274~
275- **MCP**: Cómo un agente de AI usa herramientas (integración vertical)
276- **A2A**: Cómo los agentes de AI colaboran entre sí (integración horizontal)
277~
278## Buenas Prácticas
279~
2801. **Mantén los servidores enfocados**: Un servidor por dominio (servidor GitHub, servidor Slack, etc.). No construyas servidores monolíticos.
2812. **Valida las entradas con Zod**: Siempre valida las entradas de herramientas con esquemas apropiados.
2823. **Maneja los errores con elegancia**: Devuelve mensajes de error significativos, no stack traces.
2834. **Usa recursos para datos de solo lectura**: Si la AI solo necesita leer datos, expónlos como recurso en lugar de herramienta.
2845. **Agrega descripciones adecuadas**: Buenas descripciones de herramientas y parámetros ayudan a la AI a entender cuándo y cómo usar cada herramienta.
2856. **Prueba con el MCP Inspector**: Usa `npx @modelcontextprotocol/inspector` para probar tu servidor de forma interactiva.
286~
287## Primeros Pasos
288~
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292~
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296~
297## Conclusión
298~
299MCP 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.
300~
301**Próximos pasos:**
302- Explora la [Especificación MCP](https://spec.modelcontextprotocol.io/)
303- Navega por los [servidores MCP existentes](https://github.com/modelcontextprotocol/servers) en busca de inspiración
304- Construye tu primer servidor con el SDK de TypeScript o Python
305- Pruébalo con Claude Desktop o el MCP Inspector
306~