MCP está en todos lados. Cada anuncio de herramientas de IA a principios de 2026 lo menciona. Cada artículo de "stack moderno de IA" lo incluye. Pero cuando le preguntas a la gente qué es realmente MCP, te sueltan o una tesis doctoral o un pitch de marketing.
Aquí va la versión de una sola frase: MCP es un puerto USB para agentes de IA.
Esa es toda la explicación. OK va, aquí está el resto. 😼
El mundo antes del estándar
Imagina tu setup a finales de 2024. Estás construyendo un agente de IA — un programa que usa un modelo de lenguaje grande (LLM — el cerebro detrás de ChatGPT, Claude, Gemini) para tomar decisiones y ejecutar acciones por su cuenta. Tu agente necesita consultar una base de datos PostgreSQL, buscar en la web, gestionar issues de GitHub y leer archivos locales.
Para cada herramienta, escribes código de integración personalizado:
# Cada herramienta necesita su propio código pegamento
from custom_postgres import query_db
from custom_github import create_issue
from custom_search import web_search
from custom_files import read_file
# Cada integración tiene diferentes:
# - Métodos de autenticación
# - Formatos de respuesta
# - Manejo de errores
# - Gestión de conexiones
Cada proveedor de IA construía su propio sistema de integración. Claude tenía "tool use." OpenAI tenía "function calling." LangChain tenía "tools." Todos hacían lo mismo de formas incompatibles. Construir una integración para uno significaba reconstruirla para otro.
Esta es la era del puerto serial, puerto paralelo y cargador propietario de las herramientas de IA. ¿Te acuerdas de eso? Antes del USB, cada dispositivo tenía su propio cable. Un desmadre total. 😹
El vacío que necesitaba llenarse
El problema no era que las integraciones fueran difíciles. El problema era que eran difíciles cada maldita vez. Sale una herramienta nueva — escribes otras 200 líneas de integración custom. Multiplica eso por cada cliente de IA en el mercado. Las cuentas son brutales.
Alguien tenía que definir un conector universal.
Entra MCP
Anthropic presentó MCP (Model Context Protocol) a finales de 2024 como un estándar abierto — un estándar de conexión universal para herramientas de IA, como USB pero para datos. Para marzo de 2026, se convirtió en la forma predeterminada en que los agentes de IA se conectan al mundo exterior.
Así se ve conectar cuatro herramientas con MCP:
{
"mcpServers": {
"postgres": { "command": "npx", "args": ["-y", "@mcp/server-postgres", "..."] },
"github": { "command": "npx", "args": ["-y", "@mcp/server-github"] },
"search": { "command": "npx", "args": ["-y", "@mcp/server-brave-search"] },
"files": { "command": "npx", "args": ["-y", "@mcp/server-filesystem", "/home"] }
}
}
Cuatro herramientas. Cuatro líneas de config. Cero código custom. Cada servidor habla el mismo protocolo — un conjunto de reglas sobre cómo se comunican los programas — y cada cliente lo entiende.
La arquitectura: tres actores, cero magia
MCP tiene exactamente tres partes móviles:
┌──────────────────┐
│ HOST │ (Claude Code, Cursor, tu app)
│ │
│ ┌────────────┐ │
│ │ CLIENT │──── MCP Protocol ──── SERVER (Postgres, GitHub)
│ └────────────┘ │
│ │
│ ┌────────────┐ │
│ │ CLIENT │──── MCP Protocol ──── SERVER (Search, Files)
│ └────────────┘ │
└──────────────────┘
Host — la aplicación de IA con la que interactúas. Claude Code, Claude Desktop, Cursor, Windsurf, o tu propia app personalizada.
Client — vive dentro del host. Gestiona la conexión con un servidor. Un host puede correr muchos clientes conectados a muchos servidores a la vez.
Server — provee herramientas y datos. Corre como un proceso separado — un programa independiente — ya sea en tu máquina o en un servidor remoto.
Sin capa de orquestación. Sin cola de mensajes. Sin service mesh. Solo un cliente hablando con un servidor a través de un protocolo estándar. Eso es todo. 😸
Qué viaja por el tubo
Los servidores MCP pueden proveer tres tipos de cosas:
1. Tools — acciones que la IA puede ejecutar
Las tools son funciones — operaciones autocontenidas — que la IA puede llamar. Como "ejecutar una consulta SQL" o "crear un issue en GitHub."
{
"name": "query",
"description": "Run a read-only SQL query against the database",
"inputSchema": {
"type": "object",
"properties": {
"sql": { "type": "string", "description": "The SQL query to execute" }
},
"required": ["sql"]
}
}
Cuando el servidor arranca, le dice al cliente: "Estas son las herramientas que ofrezco, esto hace cada una, estos son los parámetros." El modelo de IA lee estas descripciones y decide cuándo usarlas — de la misma manera en que tú decides qué app abrir en tu teléfono.
2. Resources — datos que la IA puede leer
Los resources son piezas de datos que el servidor expone. El contenido de un archivo, un schema de base de datos (la estructura de tus tablas), una configuración.
La distinción importa: las tools hacen cosas, los resources dan contexto. La IA lee los resources para entender el entorno antes de actuar. Piensa en esto como leer el menú del restaurante antes de ordenar.
3. Prompts — plantillas predefinidas
Plantillas preescritas que el servidor ofrece, como "analiza esta tabla" o "revisa este pull request." Son atajos de conveniencia que saben cómo usar las herramientas del servidor de manera efectiva.
La mayoría de la gente ignora los prompts y simplemente le habla a su IA de forma normal. Y está bien. Son opcionales.
Siguiendo una solicitud real
Veamos qué pasa cuando escribes "Muéstrame todos los usuarios que se registraron hoy" en Claude Code con un servidor MCP de Postgres conectado:
1. TÚ escribes: "Muéstrame todos los usuarios que se registraron hoy"
2. CLAUDE ve que las tools de MCP de Postgres están disponibles
(query, list_tables, describe_table)
3. CLAUDE llama primero a 'describe_table' para entender
la estructura de la tabla users
4. CLIENT envía al SERVER:
{ "method": "tools/call",
"params": { "name": "describe_table",
"arguments": { "table": "users" } } }
5. SERVER consulta PostgreSQL, devuelve el schema
6. CLAUDE escribe una consulta SQL basada en el schema:
SELECT * FROM users WHERE created_at >= CURRENT_DATE
7. CLIENT envía la consulta al SERVER, SERVER la ejecuta
8. CLAUDE formatea los resultados y te los muestra
Todo el proceso toma 1-2 segundos. Preguntaste en español, la IA armó el SQL, el servidor MCP lo ejecutó, y obtuviste resultados. Sin escribir queries a mano. Este es el momento "ajá" para la mayoría de la gente. 😻
La capa de transporte — cómo viajan los bits
MCP funciona sobre dos métodos de transporte:
STDIO (servidores locales) — el servidor corre como un proceso hijo en tu máquina. La comunicación ocurre sobre stdin/stdout — los mismos pipes de texto que usa tu terminal. Esta es la configuración más común:
{
"mcpServers": {
"my-server": {
"command": "node",
"args": ["server.js"],
"env": { "DB_URL": "..." }
}
}
}
Simple, rápido, sin red de por medio.
Streamable HTTP (servidores remotos) — para servidores en otras máquinas. Alojados en la nube, compartidos con un equipo, o servicios de terceros:
{
"mcpServers": {
"remote-server": {
"url": "https://mcp.example.com/sse",
"headers": { "Authorization": "Bearer your-token" }
}
}
}
Las solicitudes van como HTTP POST normal. Las respuestas regresan en streaming en tiempo real. Así funcionan los deployments empresariales — servidores centralizados a los que se conectan múltiples desarrolladores.
Construye el tuyo en 20 líneas
Este es el servidor MCP más simple que puedes escribir usando el SDK oficial de TypeScript:
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
const server = new McpServer({
name: "my-tool",
version: "1.0.0"
});
server.tool(
"hello",
"Says hello to someone",
{ name: { type: "string", description: "Person to greet" } },
async ({ name }) => ({
content: [{ type: "text", text: `Hello, ${name}!` }]
})
);
const transport = new StdioServerTransport();
await server.connect(transport);
Instala el SDK (npm install @modelcontextprotocol/sdk), define tus tools, conecta el transporte. El SDK se encarga de la negociación del protocolo — el handshake donde cliente y servidor acuerdan qué soportan ambos — el parseo de mensajes y el manejo de errores.
Un ejemplo práctico — API del clima
server.tool(
"get_weather",
"Get current weather for a city",
{
city: { type: "string", description: "City name" },
units: { type: "string", description: "celsius or fahrenheit", default: "celsius" }
},
async ({ city, units }) => {
const response = await fetch(
`https://wttr.in/${encodeURIComponent(city)}?format=j1`
);
const data = await response.json();
const current = data.current_condition[0];
const temp = units === "fahrenheit"
? current.temp_F + "°F"
: current.temp_C + "°C";
return {
content: [{ type: "text", text: `${city}: ${temp}, ${current.weatherDesc[0].value}` }]
};
}
);
Ahora tu agente de IA puede revisar el clima. Más importante aún, observa el patrón: trae datos de cualquier API (interfaz de programación de aplicaciones — la forma en que los programas hablan entre sí), envuélvelos en una tool MCP, y cada cliente compatible con MCP en el planeta puede usarla.
El handshake de capacidades
Cuando un cliente se conecta por primera vez a un servidor, negocian:
Cliente: "Soporto tools, resources y prompts. ¿Qué tienes?"
Servidor: "Ofrezco 3 tools y 2 resources. Aquí están."
Cliente: "Entendido. Listo."
Esto significa que los clientes no necesitan saber de antemano qué ofrece un servidor. Los servidores pueden agregar o quitar funcionalidades sin romper nada. Diferentes clientes pueden usar el mismo servidor de formas distintas. Es evolución elegante, no acoplamiento frágil.
Lo que no es perfecto
No vamos a pretender que esto es impecable. A marzo de 2026:
La seguridad sigue siendo tu problema. Un servidor MCP puede hacer cualquier cosa para la que le des permiso. Un servidor malicioso podría exfiltrar datos a través de llamadas a tools. No hay sandboxing integrado — sin aislamiento automático del resto de tu sistema. Confías en cada servidor de la misma forma en que confías en cualquier paquete de npm que instalas. Piénsalo un segundo.
El descubrimiento es un desorden. Encontrar el servidor MCP correcto para tu caso de uso significa navegar registros como mcpservers.org o glama.ai/mcp/servers. Todavía no hay un marketplace centralizado y verificado. La calidad varía brutalmente.
El debugging es doloroso. Cuando una llamada a una tool falla, los mensajes de error suelen pasar por múltiples capas — cliente, protocolo, servidor, API subyacente — y salen del otro lado como papilla. Va mejorando, pero sigue siendo un dolor.
Existe overhead de rendimiento. Cada llamada a una tool es un round trip de JSON-RPC — un mensaje de solicitud-respuesta en formato JSON. Para servidores locales STDIO, esto es despreciable. Para servidores remotos sobre HTTP, la latencia se acumula cuando la IA encadena múltiples llamadas.
Qué significa esto para ti
Si usas herramientas de IA para programar como Claude Code o Cursor: MCP significa que tu IA sigue ganando nuevas habilidades sin actualizaciones de software. ¿Aparece un nuevo servidor MCP para Jira? Instálalo, y tu IA gestiona tus tickets. ¿Un nuevo servidor para AWS? Tu IA gestiona tu infraestructura. No esperas a que el proveedor de la herramienta construya integraciones — la comunidad las construye.
Si construyes herramientas o APIs: MCP significa que escribes una sola integración y funciona con Claude, Cursor, Windsurf, Cline, y cada futuro cliente compatible con MCP. Un servidor, docenas de clientes. Esas son las cuentas del USB.
Si eres founder: construir un servidor MCP para tu producto se está volviendo el mínimo indispensable, como construir una REST API lo fue hace 10 años. Si tu herramienta para desarrolladores no tiene un servidor MCP, tus usuarios van a preguntar por qué.
El ecosistema a marzo de 2026
- Servidores oficiales de Anthropic: PostgreSQL, GitHub, Filesystem, Brave Search, Puppeteer, Google Maps, Slack, y más — ve el repositorio de servidores MCP
- Servidores enterprise de AWS, Cloudflare, Sentry
- Servidores de la comunidad para Docker, Kubernetes, Notion, Linear, Figma, Stripe — cientos y contando
- El roadmap de 2026 se enfoca en comunicación agente-a-agente, escalamiento horizontal, y un mecanismo de descubrimiento
.well-knownpara que los servidores se anuncien automáticamente
USB mató al cargador propietario. MCP mata las integraciones custom.
MCP es lo más importante que le ha pasado a las herramientas de IA desde que las ventanas de contexto — la memoria de trabajo de la IA — se hicieron lo suficientemente grandes para meter un codebase real. No es sexy. Es un protocolo JSON-RPC sobre stdio. Pero USB tampoco era sexy, y mató a cada conector propietario en su camino.
Lo más inteligente que puedes hacer ahora mismo: deja de leer documentos de especificación. Instala un servidor MCP de Postgres, conéctalo a Claude Code, y pregúntale sobre tu base de datos. Vas a entender MCP en 30 segundos.
La especificación es para la gente que construye el protocolo. Tú lo estás usando. 😹
