Back-end13 min de lectura
Qué es MCP (Model Context Protocol) y cómo funciona
Qué es el Model Context Protocol, explicado con dos servidores MCP que uso a diario: host, client y server, tools, transportes y un servidor mínimo en TypeScript.

Si usas Claude Code, Cursor o cualquier IA dentro del editor, ya te topaste con la sigla MCP. Aparece en la configuración, en listas de "conectores", en todo post sobre agentes. Y casi siempre en inglés.
Yo uso MCP todos los días. Tengo un servidor propio que dibuja personajes para una app mía, y uso una versión extendida de Talk to Figma para dibujar en Figma directo desde la terminal. Las ilustraciones de este post salieron de ahí.
Así que este es el post que me hubiera gustado leer cuando empecé: qué es MCP, cómo se comunican las piezas y cómo es un servidor de verdad por dentro.
TL;DR#
- MCP es un estándar abierto para conectar apps de IA a sistemas externos: archivos, bases de datos, APIs, Figma.
- Tres piezas: el host (la app que usas), un client por conexión y el server (quien ofrece las herramientas).
- El servidor ofrece tools, resources y prompts. Las tools son las más usadas: acciones que el modelo decide llamar.
- Por debajo es JSON-RPC 2.0, por
stdio(proceso local) o Streamable HTTP (servidor remoto). - La spec cambió el 2026-07-28: pasó a no tener estado, sin el apretón de manos
initialize, y marcó sampling y roots como obsoletos. Un tutorial de 2025 ya está desactualizado. - Una tool es código que corre con tus permisos. Instala un servidor MCP con el mismo cuidado que una dependencia.
El problema que resuelve MCP#
Imagina tres apps de IA (Claude Code, Cursor y la app que estás construyendo) y cuatro herramientas que quieres usar con ellas: GitHub, Figma, Postgres y Slack.
Sin un estándar, cada app necesita su propia integración con cada herramienta. Son 3 × 4 = 12 integraciones, cada una con su formato, su autenticación y sus bugs. ¿Llega una app nueva? Cuatro más. ¿Llega una herramienta nueva? Tres más.
Con MCP, la cuenta se vuelve una suma: cada app implementa un client MCP y cada herramienta tiene un servidor MCP. Son 3 + 4 piezas, y cualquier app habla con cualquier herramienta.
Un puerto USB-C para las IA#
La documentación oficial define MCP como un estándar de código abierto para conectar aplicaciones de IA a sistemas externos. Y usa una imagen que ayuda mucho: piensa en MCP como un puerto USB-C para aplicaciones de IA.
Antes del USB-C, cada aparato tenía su propio cable. Hoy un solo cable sirve para el cargador, el monitor y el disco externo. MCP hace eso entre la IA y las herramientas: la app no necesita saber nada de Figma, solo necesita hablar MCP.
Un poco de historia: Anthropic lanzó MCP en noviembre de 2024 y, en diciembre de 2025, donó el protocolo a la Agentic AI Foundation, vinculada a la Linux Foundation. En el anuncio de la donación, Anthropic hablaba de más de 10 mil servidores MCP públicos activos.
Las tres piezas: host, client y server#
Esta es la parte que más confunde, así que voy a usar mi setup como ejemplo.
- Host es la app de IA que usas. En mi caso, Claude Code. Guarda la conversación, habla con el modelo y te pide permiso antes de ejecutar una tool (a menos que la hayas liberado).
- Client es la pieza dentro del host que mantiene una conexión con un servidor. El host crea un client para cada servidor configurado.
- Server es el programa que ofrece las herramientas. Puede correr en tu máquina o en otro lugar.
Mis dos servidores locales son muy diferentes por dentro:
- el servidor de personajes arma personajes en SVG a partir de las piezas de un brandbook y devuelve la imagen lista;
- TalkToFigma no dibuja nada por sí solo: reenvía los comandos, por un WebSocket local, a un plugin abierto en Figma. Quien toca las capas es el plugin.
Para Claude Code, los dos son iguales: un servidor MCP con una lista de tools.
Lo que ofrece un servidor#
Un servidor puede ofrecer tres tipos de cosas, que la spec llama primitivas. La diferencia entre ellas es quién decide usarlas.
Tools: decide el modelo#
Las tools son acciones. Buscar algo, crear un archivo, mandar un mensaje, generar un personaje. El servidor lista las tools con nombre, descripción y el formato de los parámetros, y es el modelo el que decide cuándo llamar a cada una. Es por lejos la primitiva más usada: mis dos servidores solo tienen tools.
Resources: decide la app#
Los resources son datos para dar contexto: el contenido de un archivo, el esquema de una base de datos, el historial de git. Cada uno tiene una URI, y es la app la que decide qué adjuntar a la conversación.
Prompts: decides tú#
Los prompts son plantillas de mensaje listas que eliges en el momento, como un comando con barra. Talk to Figma trae algunos, como design_strategy, con buenas prácticas para trabajar en Figma.
¿Y del lado del client?#
El camino inverso también existe: el servidor puede pedirle cosas al client. Aquí la spec del 2026-07-28 cambió bastante:
- Elicitation se mantiene: el servidor te pide un dato en medio de la tarea (un login, una confirmación).
- Sampling (el servidor pidiéndole una respuesta al modelo del host) y Roots (el client diciéndole al servidor qué carpetas puede ver) fueron marcados como obsoletos. Todavía funcionan, pero una implementación nueva no debería usarlos.
Si estás leyendo un tutorial de 2025, es aquí donde más te va a engañar.
Por debajo: JSON-RPC#
Toda conversación entre client y server es JSON-RPC 2.0: mensajes JSON con method, params y un id para emparejar la pregunta con la respuesta. Para llamar a una tool, el client manda un tools/call:
{ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { "name": "greet", "arguments": { "name": "Yasmin" } } }Y el servidor responde con el resultado. Esta respuesta es real: salió del servidor mínimo que muestro más abajo.
{
"jsonrpc": "2.0",
"id": 2,
"result": {
"content": [{ "type": "text", "text": "Hello, Yasmin!" }],
"resultType": "complete"
}
}En la versión actual, cada solicitud también lleva la versión del protocolo y las capacidades del client en un campo _meta. La spec omite ese campo en los ejemplos para acortarlos, y yo hice lo mismo.
Los transportes#
El JSON tiene que viajar de alguna forma, y la spec define dos transportes:
- stdio: el host abre el servidor como un proceso hijo y se comunica por la entrada y salida estándar, un mensaje por línea. Es lo que usan mis dos servidores.
- Streamable HTTP: cada mensaje es un
POSTa un único endpoint, y la respuesta vuelve como JSON o como un stream SSE. Es la forma de correr un servidor remoto, que atiende a varios clients.
El antiguo transporte HTTP+SSE, que aparece en muchos tutoriales, está obsoleto desde la versión 2025-03-26.
Una llamada a una tool, paso a paso#
Juntando todo, esto es lo que pasa cuando le pido un personaje a Claude Code:
- El client descubre el servidor. En la spec actual, con
server/discover, que devuelve las versiones y capacidades. En las versiones de 2025, era el apretón de manosinitialize. - El client pide la lista de tools (
tools/list). Mi servidor devuelve 11, cada una con nombre, descripción y el schema de los parámetros. - Tú pides, en lenguaje natural: "dibuja una persona de 70 años".
- El modelo elige la tool leyendo las descripciones, y arma los argumentos:
{ anos: 70 }. - El host te pide permiso. Puedes negarlo.
- El modelo le pasa la llamada al client.
- El client manda el
tools/cally el servidor ejecuta el código. - Vuelve el resultado: en mi caso, una imagen PNG y un JSON con la seed y los rasgos.
- El modelo responde con el personaje.
Fíjate que el modelo nunca habla con el servidor. Solo elige la tool y los argumentos. Quien habla con el servidor es el client, dentro del host, y solo después de tu ok.
Un servidor mínimo en TypeScript#
La forma más rápida de entenderlo es escribir uno. El SDK oficial de TypeScript está en la versión 2, con paquetes separados para el servidor y el client:
npm install @modelcontextprotocol/server zodY este es un servidor completo, con una tool:
import { McpServer } from "@modelcontextprotocol/server";
import { serveStdio } from "@modelcontextprotocol/server/stdio";
import { z } from "zod";
// serveStdio calls this for every instance it needs
function createServer() {
const server = new McpServer({ name: "hello-mcp", version: "1.0.0" });
server.registerTool(
"greet",
{
description: "Greets someone by name. Use it when the user asks to say hi to someone.",
inputSchema: z.object({ name: z.string().describe("Who to greet") }),
},
async ({ name }) => ({
content: [{ type: "text", text: `Hello, ${name}!` }],
}),
);
return server;
}
serveStdio(createServer, {
onerror: (error) => console.error("hello-mcp error:", error),
});
console.error("hello-mcp running on stdio"); // stderr: stdout belongs to the protocolTres detalles que importan:
- La descripción es lo que lee el modelo para decidir si llama a la tool. Escríbela como si fuera para alguien de tu equipo.
- El schema en zod se convierte en JSON Schema en el
tools/list. Así el modelo sabe qué argumentos mandar. - Nada de
console.log. En stdio, la salida estándar es del protocolo: cualquier texto suelto ahí rompe los mensajes. Los logs van aconsole.error.
serveStdio atiende tanto a clients nuevos como a clients que todavía abren con el initialize de 2025. Probé los dos mandando los mensajes a mano, y el servidor respondió bien en cada versión.
Para conectarlo a Claude Code, después de compilar:
claude mcp add hello-mcp -- node build/index.jsY para probarlo sin ninguna IA, el Inspector lista las tools desde la línea de comandos:
npx @modelcontextprotocol/inspector --cli node build/index.js --protocol-era modern --method tools/listCómo es en mi servidor de verdad#
El servidor de personajes tiene 11 tools. Esta es la principal, con los nombres traducidos al inglés (en el servidor se llama gerar_personagem, que es el nombre que aparece en los diagramas):
server.registerTool(
"generate_character",
{
title: "Generate character",
description:
"Generates a character from a seed (the same seed always gives the same character). " +
"Without a seed, draws a new one. Traits in 'locked' are kept. 'age' shows the same person in another phase of life. " +
"Returns the image and the traits.",
inputSchema: { seed: z.string().optional(), locked: partialTraits.optional(), ...visual },
annotations: { readOnlyHint: true },
},
async ({ seed, locked, ...v }) => {
const s = seed ?? newSeed();
return respond(draw(s, locked), s, v);
},
);Y la respuesta devuelve dos cosas: la imagen, para que la veas, y un JSON, para que el modelo pueda seguir con el trabajo:
return {
content: [
{ type: "image", data: png.toString("base64"), mimeType: "image/png" },
{ type: "text", text: JSON.stringify(info, null, 2) }, // seed, age and traits
],
};Así salió el personaje de la animación: pedí una persona de 70 años, feliz, y el servidor devolvió la imagen con la seed 0d2kajwu. Con la misma seed, otra tool muestra a la misma persona en otra etapa de la vida.
Este servidor todavía está en el SDK v1 (@modelcontextprotocol/sdk), conectado con server.connect(new StdioServerTransport()). Funciona con el Claude Code que uso hoy, pero la documentación nueva avisa que esa forma solo atiende a clients de la era 2025. Un servidor nuevo yo ya lo empezaría en la v2, con serveStdio.
Lo que aprendí#
La descripción es el prompt. El modelo no lee tu código, lee la descripción de la tool y de los parámetros. En mi servidor, cada uno de los estilos de dibujo tiene una frase que explica qué cambia, porque eso es lo único que ve el modelo a la hora de elegir.
Dale al modelo una forma de descubrir los valores válidos. Creé una tool listar_opcoes que solo lista los ids de las piezas y de los colores. La descripción de la tool que arma personajes le indica consultarla, y el error de rasgo inválido también apunta a ella. Así el modelo tiene dónde buscar, en vez de inventarse un id que no existe.
Devuelve lo que el modelo va a necesitar en el siguiente paso. La seed en el JSON parece un detalle, pero es lo que permite pedir "ahora esta misma persona con 10 años".
No todo tiene que pasar por MCP. Las ilustraciones de este post se dibujaron en Figma desde la terminal, pero los comandos que agregué al plugin de Talk to Figma los llamo con un script que habla directo con el relay, en un lote de más de 200 pasos. MCP es la puerta para que la IA hable con la herramienta. Cuando quien maneja es un script, un cliente simple alcanza.
Cuidados de seguridad#
La propia spec es directa: las tools representan ejecución arbitraria de código. Entonces:
- Ten claro quién ejecuta qué. Un servidor por
stdioes un proceso en tu máquina, con tus permisos: lee tus archivos y accede a tu red. Un servidor remoto corre en la máquina de otra persona, y todo lo que le mandas sale de tu computadora. - Instala un servidor MCP como instalas una dependencia. Lee el código, fija la versión, desconfía de servidores sin un dueño claro. En Talk to Figma, hice que el relay acepte solo conexiones de
127.0.0.1y le quité Google Analytics al plugin antes de usarlo. - No apruebes todo en automático. La spec pide que el host tenga tu consentimiento antes de llamar a cualquier tool, y que siempre puedas negarte. Liberarlo todo es renunciar a eso.
- Las anotaciones son pistas, no garantías.
readOnlyHint: truedice que la tool solo lee, pero la spec pide tratar las anotaciones como no confiables, a menos que el servidor sea de confianza. - Cuidado con lo que vuelve. El resultado de una tool entra en el contexto del modelo. Una página web o un issue pueden traer instrucciones escondidas, y el modelo puede intentar seguirlas.
Referencias#
Sigue leyendo

Back-end19 min de lectura
Qué es RAG: indexación, búsqueda híbrida y un caso real

Front-end17 min de lectura
SEO multilingüe en React: hreflang, prerender y sitemap

Front-end15 min de lectura
Cómo creo videos con IA usando Remotion: un caso real