Desde que los modelos de lenguaje grandes (LLMs) demostraron ser capaces de razonar sobre problemas complejos, la pregunta inevitable fue: ¿cómo los conectamos con datos reales y acciones concretas? No basta con que ChatGPT escriba código; queremos que ejecute queries, lea archivos, llame APIs y modifique bases de datos.

El problema hasta ahora era la falta de un estándar. Cada implementación de tool calling —OpenAI Function Calling, el sistema de herramientas de Claude, los plugins de LangChain— usaba su propio protocolo, su propia forma de definir herramientas y sus propios mecanismos de autenticación. Integrar un nuevo modelo requería reescribir adaptadores, y cada proveedor reinventaba la rueda.

Anthropic lanzó el Model Context Protocol (MCP) para resolver exactamente eso: un protocolo abierto y estandarizado que permite a cualquier LLM interactuar con cualquier herramienta externa sin necesidad de código personalizado por cada integración.

“MCP es para la IA lo que HTTP fue para la web: un protocolo universal que separa al cliente del servidor y permite que ecosistemas enteros crezcan sobre un estándar común.”

¿Qué es exactamente el Model Context Protocol?

MCP es un protocolo de comunicación cliente-servidor diseñado específicamente para el intercambio de contexto entre LLMs y sistemas externos. Define cómo un modelo puede:

  • Descubrir herramientas disponibles en un servidor remoto o local
  • Invocar herramientas con argumentos tipados y recibir resultados estructurados
  • Acceder a recursos como archivos, bases de datos o documentos
  • Mantener contexto a través de múltiples interacciones

La especificación utiliza JSON-RPC 2.0 como protocolo de transporte subyacente, lo que lo hace ligero, fácil de implementar y compatible con cualquier lenguaje que pueda enviar mensajes JSON.

Arquitectura en tres capas

MCP define tres roles principales:

  1. Host MCP: el cliente (un chat, un agente autónomo, un IDE). Por ejemplo, Claude Desktop, Cline, o cualquier aplicación que quiera conectar LLMs con herramientas.

  2. Cliente MCP: el componente dentro del host que maneja la conexión con los servidores. Mantiene el estado de la sesión, gestiona la autenticación y enruta las peticiones.

  3. Servidor MCP: expone recursos, herramientas y prompts. Un servidor puede ser local (conexión por stdio) o remoto (HTTP+SSE o WebSockets).

La comunicación fluye así:

Host (LLM) → Cliente MCP → Servidor MCP [herramienta/API/DB]
                        ← Resultado

Cómo funciona en la práctica

Supongamos que queremos que un agente de código pueda leer archivos, hacer queries a una base de datos y ejecutar comandos del sistema. Con MCP, implementamos esto con servidores especializados:

Servidor MCP de archivos

# Ejemplo conceptual de un servidor MCP simple
@mcp.tool()
async def read_file(path: str) -> str:
    """Lee el contenido de un archivo en el sistema"""
    with open(path, 'r') as f:
        return f.read()

@mcp.tool()
async def search_files(pattern: str, directory: str = ".") -> list[str]:
    """Busca archivos por patrón glob"""
    import glob
    return glob.glob(f"{directory}/{pattern}")

Servidor MCP de base de datos

@mcp.tool()
async def query_database(sql: str) -> list[dict]:
    """Ejecuta una query SQL y devuelve resultados"""
    import sqlite3
    conn = sqlite3.connect("produccion.db")
    cursor = conn.execute(sql)
    columns = [desc[0] for desc in cursor.description]
    return [dict(zip(columns, row)) for row in cursor.fetchall()]

Lo revolucionario aquí no es que existan estas funciones, sino que el LLM descubre automáticamente qué herramientas están disponibles a través del protocolo. El host solicita la lista de herramientas al servidor MCP, se las pasa al modelo como parte del contexto, y el modelo decide cuándo y cómo invocarlas.

Por qué MCP es diferente a lo que existía antes

1. Es un estándar abierto, no un vendor lock-in

OpenAI Function Calling funciona solo con modelos de OpenAI. Las herramientas de Anthropic funcionan solo con Claude. LangChain abstrae ambas, pero te ata a su ecosistema. MCP es un protocolo independiente del modelo: cualquier LLM que entienda la definición de herramientas puede usarlo.

2. Separación clara entre cliente y servidor

En las implementaciones anteriores, la definición de herramientas estaba acoplada al código del agente. Si querías compartir herramientas entre proyectos, tenías que copiar y pegar código. Con MCP, puedes ejecutar un servidor MCP una vez y conectarlo a múltiples hosts: tu agente de código local, tu chat desktop, tu pipeline CI/CD.

3. Transporte flexible

MCP soporta conexiones locales (stdio para procesos hijos, ideal para herramientas del sistema de archivos) y remotas (HTTP con Server-Sent Events, WebSockets para tiempo real). Esto permite desde un agente que ejecuta comandos en tu máquina hasta un servidor centralizado que expone APIs corporativas.

4. Seguridad por diseño

Cada servidor MCP define explícitamente qué herramientas expone. El host debe autenticarse y el servidor puede implementar autorización granular. No hay llamadas a funciones ocultas ni acceso implícito a recursos del sistema.

Casos de uso reales

Agentes de código en el IDE

Esta es quizás la aplicación más inmediata. Cline, un agente open-source para VS Code, usa MCP para conectar el LLM con el sistema de archivos del proyecto, el terminal integrado y el navegador. El agente puede leer archivos, ejecutar tests, buscar documentación y hasta hacer commits, todo a través de servidores MCP que siguen el estándar.

Automatización de infraestructura

Un servidor MCP que expone la API de AWS, Docker o Kubernetes permite que un LLM despliegue servicios, revise logs y diagnostique incidentes sin intervención humana. El modelo pide las herramientas necesarias y el servidor las ejecuta con los permisos configurados.

Asistentes de datos empresariales

Con servidores MCP que abstraen el acceso a bases de datos SQL y APIs internas, los equipos de negocio pueden hacer preguntas en lenguaje natural que se traducen a queries, cruces de datos y reportes. El protocolo garantiza que el LLM solo acceda a los recursos que el servidor le permite.

Cómo empezar con MCP hoy

Si quieres experimentar, el camino más corto es:

  1. Instalar un cliente MCP: Claude Desktop tiene soporte nativo. También puedes usar Cline en VS Code o construir tu propio host MCP con el SDK oficial de Python o TypeScript.

  2. Explorar servidores MCP existentes: El repositorio oficial de Anthropic lista servidores para archivos locales, SQLite, GitHub, PostgreSQL, Puppeteer y más. Muchos están listos para usar con una línea de configuración.

  3. Construir tu propio servidor: Con el SDK de Python, crear un servidor MCP que exponga una API interna de tu empresa toma menos de 50 líneas. El protocolo maneja la autenticación, el descubrimiento de herramientas y el enrutamiento.

# Ejemplo: conectar Claude Desktop con tu servidor MCP local
# En claude_desktop_config.json
{
  "mcpServers": {
    "mi-api": {
      "command": "python",
      "args": ["-m", "mcp_server_mi_api"]
    }
  }
}

El futuro que MCP habilita

Si el protocolo logra la adopción que está consiguiendo en la comunidad, el ecosistema de herramientas para LLMs podría estandarizarse de la misma forma que HTTP estandarizó la web. Los desarrolladores no escribirán código para conectar un modelo con una API; simplemente conectarán un servidor MCP y el modelo hará el resto.

Ya hay movimientos significativos: varias startups de agentes de código están adoptando MCP como protocolo base, y herramientas open-source como Cline, Continue.dev y Sourcegraph Cody están integrando soporte. El patrón es claro: un estándar único para tool calling es más importante que la competencia entre proveedores de modelos.

La pregunta que vale la pena hacerse como desarrollador no es “¿qué modelo debo usar?”, sino “¿cómo construyo sistemas donde el modelo sea intercambiable y las herramientas sean reutilizables?”. MCP es la respuesta más sólida que tenemos hasta ahora.

En el bootcamp de DojoFullStack ya estamos integrando MCP en nuestros proyectos prácticos de agentes de código, porque creemos que este estándar va a definir cómo se construye software impulsado por IA en los próximos años.

Sigue explorando estos temas en el blog de DojoFullStack, donde cada semana compartimos guías prácticas sobre desarrollo de software moderno, agentes de código y automatización inteligente.