MCP: El Protocolo que Conecta los Modelos de IA con el Mundo Real

Uno de los mayores desafíos al trabajar con modelos de lenguaje grande (LLMs) es su aislamiento: por defecto, solo saben lo que está en su entrenamiento. No pueden leer tu base de datos, consultar una API en tiempo real ni acceder a los archivos de tu sistema. El Model Context Protocol (MCP), introducido por Anthropic en noviembre de 2024, es la respuesta a ese problema: un estándar abierto que define cómo los modelos de IA se conectan con el mundo exterior de forma estructurada, segura y reutilizable.

¿Qué es MCP?

MCP (Model Context Protocol) es un protocolo de comunicación abierto que estandariza la forma en que las aplicaciones proporcionan contexto a los LLMs. En lugar de que cada desarrollador construya su propia integración ad-hoc para conectar un modelo con una herramienta o fuente de datos, MCP ofrece una capa común que cualquier cliente (un IDE, un asistente, un agente) puede usar para hablar con cualquier servidor MCP.

La analogía más clara: MCP es para los LLMs lo que el protocolo HTTP es para la web. Define las reglas de comunicación para que cualquier cliente pueda conectarse a cualquier servidor sin necesidad de implementaciones a medida.

El Problema que Resuelve

Antes de MCP, integrar un LLM con herramientas externas implicaba:

• Implementar integraciones personalizadas para cada combinación de modelo y herramienta.
• Gestionar manualmente el contexto, los errores y los formatos de respuesta.
• Duplicar código entre proyectos que necesitaban las mismas integraciones.
• Ausencia de un modelo de seguridad estándar para controlar qué puede hacer el modelo.

Con MCP, se construye un servidor una vez y cualquier cliente compatible puede usarlo. Un servidor MCP para PostgreSQL, por ejemplo, puede ser utilizado por Claude Desktop, Cursor, un agente personalizado o cualquier otra aplicación que implemente el protocolo cliente.

Arquitectura de MCP

MCP define tres componentes principales que interactúan entre sí:

1. MCP Host

Es la aplicación que el usuario utiliza directamente: Claude Desktop, un IDE como Cursor o VS Code con extensión MCP, o una aplicación de agente personalizada. El Host aloja el cliente MCP y gestiona las conexiones con los servidores.

2. MCP Client

Componente embebido en el Host que mantiene una conexión 1:1 con cada servidor MCP. Es responsable de descubrir las capacidades del servidor, enviar solicitudes y devolver los resultados al modelo.

3. MCP Server

Programa independiente que expone capacidades específicas: acceso a una base de datos, llamadas a una API, lectura de archivos, ejecución de comandos. Cada servidor declara qué puede ofrecer mediante tres primitivas fundamentales.

Las Tres Primitivas de MCP

Resources (Recursos)

Datos que el servidor expone para que el modelo los lea: archivos, registros de base de datos, respuestas de APIs, logs. Son análogos a los endpoints GET de una API REST: proveen información sin efectos secundarios.

{
  "uri": "file:///home/usuario/proyecto/README.md",
  "name": "README del proyecto",
  "description": "Documentación principal del proyecto",
  "mimeType": "text/markdown"
}

Tools (Herramientas)

Acciones que el modelo puede invocar para producir efectos: crear un registro en una base de datos, enviar un email, ejecutar un script, hacer una búsqueda web. El modelo decide cuándo y cómo llamar a cada herramienta basándose en el contexto de la conversación.

{
  "name": "ejecutar_query_sql",
  "description": "Ejecuta una consulta SQL de solo lectura en la base de datos",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Consulta SQL a ejecutar"
      }
    },
    "required": ["query"]
  }
}

Prompts (Plantillas)

Plantillas de mensajes predefinidas que el servidor puede ofrecer para casos de uso comunes. Permiten estandarizar cómo se formula una solicitud al modelo para tareas específicas.

Cómo Funciona el Protocolo

MCP usa JSON-RPC 2.0 como formato de mensajes y soporta dos mecanismos de transporte:

• stdio: comunicación por entrada/salida estándar, ideal para servidores locales que el Host lanza como subprocesos.
• HTTP con Server-Sent Events (SSE): para servidores remotos accesibles por red, permite comunicación bidireccional asíncrona.

El flujo típico de una interacción es:

1. El Host inicia el servidor MCP y el cliente establece la conexión.
2. El cliente envía initialize para negociar capacidades.
3. El modelo recibe la lista de tools/resources disponibles y los incluye en su contexto.
4. Durante la conversación, el modelo decide invocar una herramienta enviando una solicitud estructurada.
5. El cliente MCP retransmite la solicitud al servidor, obtiene el resultado y lo devuelve al modelo.
6. El modelo usa el resultado para continuar generando su respuesta.

Implementando un Servidor MCP en Python

El SDK oficial de Python (mcp) simplifica enormemente la creación de servidores:

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
import mcp.types as types

app = Server("mi-servidor-mcp")

@app.list_tools()
async def listar_herramientas() -> list[Tool]:
    return [
        Tool(
            name="obtener_clima",
            description="Obtiene el clima actual de una ciudad",
            inputSchema={
                "type": "object",
                "properties": {
                    "ciudad": {"type": "string", "description": "Nombre de la ciudad"}
                },
                "required": ["ciudad"]
            }
        )
    ]

@app.call_tool()
async def llamar_herramienta(name: str, arguments: dict) -> list[TextContent]:
    if name == "obtener_clima":
        ciudad = arguments["ciudad"]
        # Aquí iría la llamada real a una API de clima
        resultado = f"El clima en {ciudad} es soleado, 22°C."
        return [TextContent(type="text", text=resultado)]
    raise ValueError(f"Herramienta desconocida: {name}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(stdio_server(app))

Configuración en Claude Desktop

Para conectar un servidor MCP local a Claude Desktop, se agrega la configuración en el archivo claude_desktop_config.json:

{
  "mcpServers": {
    "mi-servidor": {
      "command": "python3",
      "args": ["/ruta/al/servidor.py"]
    },
    "servidor-postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_URL": "postgresql://usuario:clave@localhost/midb"
      }
    }
  }
}

Ecosistema y Adopción

Desde su lanzamiento, MCP ha ganado adopción rápida. Existen servidores MCP oficiales y de la comunidad para:

• Bases de datos: PostgreSQL, SQLite, MySQL, MongoDB.
• Sistemas de archivos: acceso local, Google Drive, S3.
• Herramientas de desarrollo: GitHub, GitLab, Jira, Linear.
• Comunicación: Slack, Gmail, Notion.
• Búsqueda: Brave Search, Tavily, Exa.
• Infraestructura: Docker, Kubernetes, Terraform.

IDEs como Cursor y VS Code (via extensiones) ya implementan el cliente MCP, y el protocolo está siendo adoptado por otros proveedores de modelos más allá de Anthropic.

MCP y el Futuro de los Agentes de IA

MCP es especialmente relevante en el contexto de los agentes de IA: sistemas que no solo responden preguntas sino que ejecutan tareas complejas de forma autónoma. Un agente con acceso a servidores MCP puede leer documentación, consultar bases de datos, crear tickets, ejecutar código y comunicarse con APIs externas, todo dentro de una conversación coherente.

La estandarización que ofrece MCP es clave para que los agentes sean componibles: un agente puede orquestar múltiples servidores MCP para completar flujos de trabajo complejos, de la misma forma en que una aplicación web consume múltiples microservicios.

MCP representa un cambio de paradigma en cómo los LLMs interactúan con el mundo. Al definir un lenguaje común entre modelos y herramientas, reduce la fricción de integración y abre la puerta a ecosistemas de agentes más capaces, seguros y reutilizables. Para los desarrolladores que trabajan con IA, entender MCP ya no es opcional: es parte fundamental del stack moderno.