Protocolo de Contexto del Modelo (MCP): Cómo Conecta la IA a Tus Herramientas

Última actualización: June 28, 2026

MCP — el Model Context Protocol — es un estándar abierto lanzado por Anthropic a finales de 2024 para conectar asistentes y agentes de IA con fuentes de datos y herramientas externas. En lugar de escribir una integración personalizada (bespoke) para cada modelo y cada herramienta, expones un único servidor MCP y cualquier cliente compatible con MCP puede usarlo. La semana pasada conecté un servidor de sistema de archivos y un servidor de GitHub a Claude Code y la diferencia en lo que el agente podía hacer fue inmediata. Esta publicación cubre qué es MCP, cómo funciona el modelo cliente-servidor, los tipos centrales de capacidades y cómo ejecutar servidores en tu propio entorno.

Respuesta rápida: ¿qué es MCP?

MCP es un protocolo basado en JSON-RPC 2.0 que estandariza la conexión entre una aplicación anfitriona (el cliente MCP, como Claude Desktop o Claude Code) y servidores externos que exponen datos y acciones. Un único servidor MCP puede anunciar tres tipos de capacidades a los clientes:

• Tools — funciones que el modelo puede llamar (consultar una base de datos, enviar un mensaje, buscar en un repositorio).
• Resources — datos estructurados que el modelo puede leer (contenido de archivos, respuestas de API, registros).
• Prompts — plantillas de prompts reutilizables y parametrizadas que el usuario puede invocar.

El objetivo es un "USB-C para integraciones de IA": un servidor, muchos clientes, sin adhesivo por modelo. La especificación y los SDK son de código abierto y se mantienen en modelcontextprotocol en GitHub, con la documentación canónica en modelcontextprotocol.io.

¿Por qué existe MCP?

Antes de MCP, cada integración de herramientas era un evento aislado. Si querías que un asistente leyera tus issues de GitHub y también consultara Postgres, escribías dos conectores personalizados, y luego los reescribías cuando cambiabas de modelo o anfitrión. La motivación declarada de Anthropic es poner fin a esa duplicación con un protocolo compartido: la documentación oficial lo describe como darle a los modelos "acceso estandarizado" a archivos locales, bases de datos y APIs.

Ese marco es importante para flujos de trabajo agenticos en particular. Un agente que solo puede chatear es un chatbot; un agente que puede leer tu repositorio, ejecutar una consulta y llamar a una herramienta en un bucle es un trabajador real. MCP es la infraestructura que hace que el segundo sea portátil. Si quieres ver el panorama más amplio de dónde encaja esto en el diseño de agentes, consulta nuestra publicación sobre automatización de agentes de IA.

¿Cómo funciona el modelo cliente-servidor?

MCP sigue una topología anfitrión-cliente-servidor:

• Host — la aplicación que ejecuta el usuario (Claude Desktop, Claude Code, una extensión de IDE).
• Client — vive dentro del host, mantiene una sesión 1:1 con un servidor.
• Server — un proceso que expone capacidades a través de un transporte.

Un anfitrión puede ejecutar muchos clientes, cada uno hablando con un servidor. El protocolo es JSON-RPC 2.0, y hay tres fases del ciclo de vida que pruebo cada vez que agrego un nuevo servidor:

1. Initialize — el cliente envía la versión del protocolo, las capacidades e información del cliente; el servidor responde con la suya propia.
2. Capability negotiation — ambos lados declaran lo que soportan (herramientas, recursos, prompts, muestreo, raíces).
3. Operation — el cliente solicita listas de herramientas, invoca herramientas, lee recursos y el servidor transmite los resultados.

Opciones de transporte

stdio es el predeterminado para configuraciones locales y lo que usa claude mcp add a menos que pases una URL HTTP. Para un recorrido más profundo de claude mcp add y la decisión stdio vs. HTTP, consulta nuestra guía de integración MCP de Claude Code.

¿Cuáles son los tres tipos de capacidades, en la práctica?

La mayor parte del valor de MCP reside en los tres tipos de capacidades. Así es como se comporta cada uno cuando un modelo lo utiliza.

Tools (invocadas por el modelo)

Las herramientas son el motor. El modelo decide llamarlas basándose en la conversación. Ejecuté un servidor que exponía una herramienta search_logs y el modelo la llamó sin ser solicitado en el momento en que pregunté "¿por qué falló el despliegue a las 2 am?". Las definiciones de herramientas incluyen un JSON Schema para argumentos, por lo que el modelo recibe entradas tipadas y validadas.

Resources (controlados por la aplicación)

Los recursos se dirigen mediante URI y son típicamente seleccionados por el usuario, no por el modelo; el usuario adjunta un recurso como un archivo o registro, y el host lo inyecta en el contexto. Esto es importante para el control del alcance: el modelo solo puede ver lo que tú le entregas explícitamente.

Prompts (invocados por el usuario)

Los prompts son plantillas con argumentos que aparecen en la interfaz de usuario del host como comandos de barra o elementos de menú. Son la capacidad menos utilizada; los uso para codificar "revisar este PR contra nuestra guía de estilo" para no tener que pegar las mismas instrucciones cada vez.

¿Cómo configuras un servidor MCP?

Configuración concreta, usando Claude Code como el host. La misma configuración del servidor funciona en el archivo JSON de Claude Desktop.

1. Instala Node.js 20+ (o Python 3.10+ con uv).
2. Agrega un servidor de referencia, por ejemplo, el servidor de sistema de archivos: npx -y @modelcontextprotocol/server-filesystem /Users/you/projects
3. Regístralo en Claude Code: claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /Users/you/projects
4. Verifica la conexión: claude mcp list y luego claude mcp get filesystem
5. Reinicia el host y busca las herramientas del servidor en la sesión.

Ese es todo el ciclo. Los servidores de referencia en el org de GitHub cubren sistema de archivos, Git, GitHub, Postgres, SQLite, Slack, Google Drive, Puppeteer y más.

Un servidor personalizado mínimo (Python)

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("status")

@mcp.tool()
def healthcheck(service: str) -> str:
    """Return the current status of a service."""
    return f"{service}: ok"

if __name__ == "__main__":
    mcp.run(transport="stdio")

Probé esto contra un endpoint de staging en unos diez minutos, incluyendo su conexión con Claude Code. Para patrones más amplios sobre la exposición de servicios internos como APIs invocables por agentes, nuestra guía de desarrollo de API de IA profundiza en autenticación y limitación de tasas (rate-limiting).

¿Cómo se ve el ecosistema en 2026?

El ecosistema se ha consolidado en torno al registro oficial y un puñado de servidores de referencia bien mantenidos. Mantengo una lista corta de los que realmente confío en producción:

• filesystem — lectura/escritura local de archivos con restricciones de raíz.
• github — issues, PRs, búsqueda, operaciones de archivos.
• postgres / sqlite — solo lectura por defecto, introspección de esquemas.
• puppeteer / playwright — automatización de navegadores para agentes.
• slack — lecturas de canales y envío de mensajes.

Para orquestar múltiples servidores detrás de subagentes — un subagente posee la base de datos, otro posee el navegador — nuestra publicación sobre subagentes de Claude Code detalla el patrón de equipo.

¿A qué debes tener cuidado?

Esta es la parte que la mayoría de los intros omiten. Los servidores MCP se ejecutan con tus credenciales y tu acceso al sistema de archivos, por lo que el alcance (scope) importa.

• Trata cada servidor como una dependencia. Fija las versiones, audita la fuente antes de ejecutar npx en un repositorio desconocido. Una herramienta maliciosa puede exfiltrar cualquier cosa que vea el modelo.
• Restringe las raíces. El servidor de sistema de archivos solo es tan seguro como el directorio al que lo apuntas; nunca pases /.
• Prefiere configuraciones de base de datos solo lectura hasta que tengas una razón concreta para habilitar escrituras.
• Cuida la inyección de prompts. Si una herramienta devuelve contenido sobre el cual el modelo actúa, la entrada no confiable puede convertirse en instrucciones. Asume que cualquier recurso es hostil.
• Limita los tokens OAuth. Los tokens de Slack y GitHub deben tener el alcance mínimo que necesita el servidor, no tu token personal.

Empiezo cada nuevo servidor en una cuenta aislada (sandboxed) y observo las primeras llamadas a herramientas antes de confiar en él en una sesión real.

Conclusión clave

MCP es un protocolo pequeño que resuelve un problema real: permite que un servidor exponga herramientas, recursos y prompts a cualquier host de IA compatible, eliminando el impuesto de integración N-por-M. La mecánica es simple — inicializar, negociar, operar sobre stdio o HTTP — pero la postura de seguridad es lo que determina si pertenece a tu flujo de trabajo. Ejecuta servidores que puedas auditar, limita estrictamente sus credenciales y asume que la entrada no confiable es hostil. Haz eso y MCP es la forma más limpia de convertir un asistente en un agente que realmente puede tocar tus sistemas.

Créditos de imágenes

• Código fuente mostrado en una pantalla de monitor — foto de Markus Spiske en Pexels
• Un desarrollador tecleando en una laptop mientras configura un servidor en una terminal — foto de Vlada Karpovich en Pexels
• Composición abstracta de placa de circuito simbolizando arquitectura en capas — foto de Christina Morillo en Pexels