Una IA que ajusta el tamaño de tu clúster — y una plataforma que no dejará que rompa prod

El problema: «dejar que una IA toque nuestra infraestructura» es una gran manera de conseguir que un modelo con demasiada confianza escale prod a una réplica a las 3 de la madrugada. La ingeniería interesante en las operaciones agénticas no es el modelo, sino las salvaguardas. La solución: dale a la IA una interfaz tipada y acotada a tu clúster a través de MCP, y pon la lógica de seguridad en el servidor, donde el modelo no puede sortearla. La IA decide qué cambiar; la plataforma decide qué se le permite hacer — y rechaza el resto, incluso cuando se le pide directamente.

Un servidor Model Context Protocol (MCP) expone cinco herramientas de FinOps sobre un clúster de Kubernetes en vivo. Claude (o cualquier cliente MCP — Claude Desktop, etc.) las usa para encontrar cargas de trabajo sobreaprovisionadas y proponer un ajuste de tamaño. Toda llamada mutadora se comprueba contra una política antes de que ocurra nada y, por defecto, es un dry-run; los cambios inseguros — un espacio de nombres prod protegido, un límite mínimo de recursos, un recorte demasiado agresivo — son rechazados por el servidor y se registran en un registro de auditoría.

Se ejecuta enteramente en un portátil: un clúster kind precargado con cargas de trabajo deliberadamente derrochadoras, un servidor MCP de ~120 líneas y un controlador copiloto que funciona sin conexión por defecto (un mock determinista, de modo que funciona sin clave de API y en CI) o con Claude real cuando se define ANTHROPIC_API_KEY.

Qué hace

   Claude / MCP client
          │  calls typed tools
          ▼
   ┌─────────────── MCP server (finops-copilot) ───────────────┐
   │  list_namespaces  list_workloads  estimate_cost           │
   │  recommend_rightsizing        get_audit_log               │
   │                                                           │
   │  apply_rightsizing(…, dry_run=True)                       │
   │        │                                                  │
   │        ▼   ┌─────────── policy.py (guardrails) ────────┐  │
   │     every  │ protected namespaces? resource floors?    │  │
   │     apply ─┤ max single-step cut?  → REFUSE + audit    │  │
   │            └───────────────────────────────────────────┘  │
   └────────────────────────┬──────────────────────────────────┘
                            │ kubectl (read specs / patch)
                            ▼
                  kind cluster: staging (waste) · prod (protected)

Ejecútalo

make up            # kind cluster seeded with waste + Python env (MCP deps)
make demo          # the copilot finds & cuts waste — OFFLINE, no API key needed
make demo-claude   # real Claude drives the same MCP tools (needs ANTHROPIC_API_KEY)
make test          # unit-test the guardrail policy (no cluster needed)
make down          # delete the cluster

make demo ejecuta un copiloto mock determinista sobre el servidor MCP real — las mismas herramientas, las mismas salvaguardas que en la ruta de Claude —, de modo que funciona sin clave y en CI. make demo-claude cambia el mock por Claude conduciendo las herramientas de forma agéntica (SDK oficial de Anthropic + su ejecutor de herramientas MCP).

Qué demuestra la demo (salida real)

Contra un espacio de nombres staging precargado con cuatro cargas de trabajo (tres extremadamente sobreaprovisionadas, una sana) y un prod protegido:

1. Encuentra el desperdicio. staging cuesta ~$138/mes con las solicitudes actuales; la herramienta marca las tres cargas de trabajo que se sitúan entre el 1 y el 4% de uso de CPU y propone recortes de CPU y de réplicas — ~$102/mes (73%) de ahorro proyectado.

2. Primero, los dry-runs. Cada cambio es un dry-run que muestra el diff exacto y su ahorro mensual. Nada se aplica sin una llamada explícita que no sea de dry-run.

3. La plataforma rechaza prod. Al pedirle que recorte también prod, el servidor se niega — namespace 'prod' is protected. La IA lo pidió; la salvaguarda dijo no. Ningún cambio, ni siquiera un dry-run.

4. La plataforma rechaza un recorte demasiado agresivo. Al pedirle que reduzca una solicitud de CPU a 10m, el servidor se niega — por debajo del límite mínimo y un recorte de un solo paso superior al 90%.

5. Toda acción queda registrada. El rastro de auditoría muestra los cinco intentos — tres dry-runs, dos rechazos — con sus motivos.

La IA encontró el desperdicio y propuso los recortes. La plataforma decidió lo que se le permitía hacer. Esa división del trabajo es el punto clave.

Úsalo desde Claude Desktop (MCP real)

Este es un servidor MCP real — apunta cualquier cliente MCP a él. Para Claude Desktop, añade a claude_desktop_config.json:

{
  "mcpServers": {
    "finops": {
      "command": "/path/to/mcp-finops-copilot/.venv/bin/python",
      "args": ["-m", "finops.server"],
      "env": { "FINOPS_CTX": "kind-mcp-finops" }
    }
  }
}

Luego pregúntale a Claude: «¿Cuánto me cuesta mi espacio de nombres staging y qué puedo ajustar de tamaño de forma segura?»

Cómo se traslada a producción

Estructura

finops/policy.py     the guardrail layer — pure, unit-tested (make test)
finops/cost.py       cost model + right-sizing heuristic
finops/kube.py       kubectl read/patch helpers
finops/server.py     the MCP server: 5 tools, dry-run-by-default, audited
copilot/mock_agent.py   deterministic offline copilot (CI-safe)
copilot/llm_agent.py    real Claude via the Anthropic SDK's MCP tool-runner
copilot/driver.py       picks mock vs Claude by ANTHROPIC_API_KEY
k8s/                 staging (seeded waste) + prod (protected)

Con licencia MIT. Una demo pequeña, ejecutable en portátil y segura para NDA que demuestra una idea contundente: las operaciones agénticas son un problema de salvaguardas. Dale a la IA acciones reales, pero haz que la plataforma sea la que diga que no.