MCP en acción: integra datos del sistema en tus modelos generativos

En 2025, la velocidad con la que aparecen nuevos conceptos y funcionalidades en el campo de la inteligencia artificial generativa hace que parezca que han pasado décadas desde el lanzamiento de la primera versión de ChatGPT. Sin embargo, han pasado menos de tres años. A fines de 2024, Anthropic, los creadores de Claude, publicaron el Model Context Protocol (MCP) como código abierto. Aunque inicialmente pasó desapercibido, hoy está presente en casi todos los artículos, herramientas o funcionalidades relacionadas con la IA generativa. MCP se menciona en todas partes. ¿Qué es MCP? MCP (Model Context Protocol) es una especificación de código abierto desarrollada por Anthropic. Según su documentación oficial, MCP actúa como el “USB-C para la IA”: una interfaz unificada que permite conectar modelos de lenguaje con herramientas externas de forma estandarizada. La verdadera ventaja de MCP radica en la estandarización. Técnicamente, un LLM que actúa como cliente puede conectarse a un servidor MCP para acceder a datos o funcionalidades externas. Componentes estándar del protocolo MCP El Model Context Protocol (MCP) se basa en tres componentes fundamentales que permiten a los servidores exponer capacidades a los clientes: Recursos: Datos estructurados que proporcionan contexto adicional al modelo. Pueden incluir contenidos de archivos, registros de bases de datos, respuestas de APIs, entre otros. Los recursos son controlados por la aplicación y pueden ser seleccionados explícitamente por el usuario o automáticamente por el cliente. Más Info Prompts: Plantillas reutilizables que definen interacciones comunes con el modelo. Permiten estandarizar y compartir flujos de trabajo, y pueden aceptar argumentos dinámicos, incluir contexto de recursos y guiar procesos específicos. Más Info Herramientas: Funciones ejecutables que el modelo puede invocar para realizar acciones, como interactuar con sistemas externos, realizar cálculos o ejecutar comandos. Las herramientas son controladas por el modelo y pueden ser descubiertas e invocadas automáticamente por este.Más Info “MCP proporciona una estructura modular que organiza claramente la entrada, el conocimiento y la capacidad de acción del modelo.” ¿Por qué es relevante? Gracias a su estructura modular, MCP permite: Separación de responsabilidades: cada bloque tiene un propósito específico. Mayor claridad contextual: el modelo comprende mejor sus objetivos. Agentes más avanzados: habilita el uso de memoria, herramientas y razonamiento intermedio. Escalabilidad: permite construir arquitecturas modulares y sostenibles. No estás escribiendo un solo prompt. Estás diseñando un protocolo. Ejemplo práctico Si le preguntas a un modelo cuál es el uso actual de la CPU de tu computadora, probablemente no lo sepa. No tiene acceso a tu sistema operativo, ya que su función principal es generar texto, no interactuar con hardware. Ahí es donde entra MCP: permite que el modelo acceda a información externa a través de herramientas definidas por el servidor. Cómo construir un servidor MCP en 4 pasos Puedes crear un servidor MCP utilizando Python y la biblioteca fastmcp. 1. Crear server.py from typing import Dict import psutil from mcp.server.fastmcp import FastMCP mcp = FastMCP("sys-monitor") @mcp.tool() def get_system_stats() -> Dict[str, float]: cpu_percent = psutil.cpu_percent(interval=1) virtual_mem = psutil.virtual_memory() return { "cpu_percent": cpu_percent, "memory_total_gb": round(virtual_mem.total / (1024 ** 3), 2), "memory_used_gb": round(virtual_mem.used / (1024 ** 3), 2), "memory_percent": virtual_mem.percent } if __name__ == "__main__": mcp.run() 2. Crear requirements.txt psutil>=5.9.0 fastmcp>=0.1.0 3. Crear el Dockerfile FROM python:3.12-slim WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . EXPOSE 8000 CMD ["python", "server.py"] 4. Construir la imagen de Docker (opcional) Nota: esta configuración reportará el uso de CPU del contenedor, no del sistema anfitrión. A fines educativos, sigue siendo válido. docker build -t cpusage . Conectar el servidor MCP a un modelo Este ejemplo utiliza Claude Desktop, pero también es compatible con Amazon Q CLI u otros LLM que soporten MCP. Sigue la guía oficial para la integración. Si tu archivo claude_desktop_config.json está vacío, agregá lo siguiente: { "mcpServers": { "cpusage": { "command": "docker", "args": [ "run", "-i", "--rm", "cpusage" ] } } } Si deseas ejecutar el servidor directamente con Python: { "mcpServers": { "cpusage": { "command": "python", "args": ["ruta/al/server.py"] } } } También podés reemplazar "python" por uv u otro comando si estás usand

from typing import Dict
import psutil
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("sys-monitor")

@mcp.tool()
def get_system_stats() -> Dict[str, float]:
    cpu_percent = psutil.cpu_percent(interval=1)
    virtual_mem = psutil.virtual_memory()
    return {
        "cpu_percent": cpu_percent,
        "memory_total_gb": round(virtual_mem.total / (1024 ** 3), 2),
        "memory_used_gb": round(virtual_mem.used / (1024 ** 3), 2),
        "memory_percent": virtual_mem.percent
    }

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

psutil>=5.9.0
fastmcp>=0.1.0

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "server.py"]