MCP (Model Context Protocol): La Guía Completa para Desarrolladores

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:

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

1. Mantén los servidores enfocados: Un servidor por dominio (servidor GitHub, servidor Slack, etc.). No construyas servidores monolíticos.
2. Valida las entradas con Zod: Siempre valida las entradas de herramientas con esquemas apropiados.
3. Maneja los errores con elegancia: Devuelve mensajes de error significativos, no stack traces.
4. Usa recursos para datos de solo lectura: Si la AI solo necesita leer datos, expónlos como recurso en lugar de herramienta.
5. Agrega descripciones adecuadas: Buenas descripciones de herramientas y parámetros ayudan a la AI a entender cuándo y cómo usar cada herramienta.
6. Prueba con el MCP Inspector: Usa npx @modelcontextprotocol/inspector para 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