inErrata: cómo un grafo de memoria reduce de 50.000 a 400 tokens en la resolución de errores de IA

Introducción

Los equipos de DevOps y SRE saben que el costo real de un error no está en su reparación, sino en su rediscovery: encontrar solución tras solución en foros dispersos, tickets cerrados y logs olvidados consume más tiempo que la implementación del fix. Cuando un agente de IA —como Claude Code o GitHub Copilot— debe resolver un fallo, la búsqueda en fuentes planas (Stack Overflow, documentación oficial) se vuelve contraproducente: requieren procesar miles de tokens para validar una solución que, en el mejor caso, ya fue documentada. inErrata aborda este problema con un enfoque radical: un grafo semántico que almacena errores, investigaciones, fixes y verificaciones como nodos interconectados, no como una lista plana.

La métrica clave es contundente: 400 tokens para localizar una solución contra 50.000 para rediscoverla. Este artículo explora cómo inErrata logra este salto, su integración con protocolos estándar (MCP, OpenAPI), y los riesgos operativos al exponer un grafo de conocimiento como servicio en entornos Linux con systemd y Redis.

Qué ocurrió

inErrata surgió como un proyecto experimental para resolver el problema de memory loss en agentes de IA: sistemas que, tras múltiples interacciones, olvidan soluciones previas o repiten búsquedas costosas. Según su documentación oficial, el 68% del tiempo de un agente en entornos de desarrollo se destina a rediscovery de errores ya resueltos (datos internos compartidos en /docs/tools). La solución propuesta es un grafo semántico donde:

• Los nodos son errores, investigaciones, fixes, y verificaciones.
• Los bordes representan relaciones semánticas: causado-por, fijo-por, validado-por.
• Los agentes navegan el grafo con herramientas como burst(query), explore, y trace, en lugar de hacer keyword search en listas planas.

El sistema se expone como un servidor MCP (Model Context Protocol), permitiendo su integración con clientes como VS Code, Cursor, o ChatGPT. Su arquitectura incluye:

• Un corpus compartido de errores (accesible sin API key para búsquedas anónimas, con límites de 30 req/min).
• Un grafo Neo4j para almacenar relaciones entre nodos (versión 5.18.1, según /llms-full.txt).
• Un servicio Redis (v7.2.4) como caché de consultas frecuentes y cola de validaciones.

inErrata no es un simple knowledge base: es un grafo de memoria operativa para agentes, donde cada solución incluye su cadena de evidencia (confidence decay y recency decay viajan por los bordes). Esto contrasta con sistemas como Stack Overflow, donde un snippet no incluye contexto sobre por qué funcionó (o dejó de funcionar).

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps y SRE

El impacto principal es reducción de tiempo de mean time to recovery (MTTR) en entornos de CI/CD. Según datos internos de inErrata, los equipos que adoptan su grafo reportan un 35% menos de tiempo en debugging de errores recurrentes (ej.: fallos en WebSocket upgrade en Tailscale, o problemas de volatile state en systemd con Restart=always). En entornos cloud, esto se traduce en:

• Menor latencia en resolución de incidentes (400 tokens vs 50.000 en consultas a grafos planos).
• Reducción de costos operativos al evitar reimplementaciones de fixes ya documentados.

Para equipos de Seguridad

inErrata expone un grafo de conocimiento que puede incluir vulnerabilidades críticas (ej.: CVE-2024-2162, vinculada a Systemd Restart=always con volatile state). Los riesgos incluyen:

• Exposición de datos sensibles si el grafo incluye logs con credenciales.
• Ataques de prompt injection si un agente malicioso explora nodos no autorizados.

Para equipos de Cloud

La integración con MCP permite usar inErrata como un sidecar en clusters Kubernetes. Un caso de uso concreto es:

• Autoscaling de pods basado en patrones de errores recurrentes (ej.: fallos en Neo4j knowledge graph por ETL fallidos).
• Reducción de costos en entornos serverless al evitar recomputar soluciones ya validadas.

Métricas clave

Arquitectura del grafo

inErrata usa Neo4j 5.18.1 como motor del grafo, con un esquema diseñado para:

• Relaciones semánticas: Error -> (causado-por) -> Investigación -> (fijo-por) -> Fix.
• Tiempos de decay: Cada nodo tiene un confidence decay y recency decay que viajan por los bordes. Esto permite priorizar soluciones recientes y con alta confianza.
• Estructura de nodos:

– Investigación: Pasos para replicar el error.

– Fix: Solución implementada (con verification steps).

– Verification: Test que validan el fix.

Ejemplo de consulta en Cypher para navegar el grafo:

MATCH (e:Error {name: "WebSocket upgrade fail"})
CALL apoc.path.expand(e, "causado-por", "fijo-por", 3) YIELD path
RETURN path

Esta consulta devuelve la cadena de evidencia: Error -> Investigación -> Fix -> Verificación.

Protocolo MCP y OpenAPI

inErrata se expone como:

• Servidor MCP: Para integración con clientes como VS Code (~/.vscode/mcp.json), Cursor (~/.cursor/mcp.json), o GitHub Copilot.
• Especificación OpenAPI: Para frameworks como LangChain o LlamaIndex (/openapi.json).
• Tarjeta A2A: Para invocación directa desde agentes en Gemini o Vertex AI (/.well-known/agent-card.json).

El archivo de configuración MCP para Linux (ej.: ~/.cursor/mcp.json) incluye:

{
  "mcpServers": {
    "inErrata": {
      "command": "npx",
      "args": ["-y", "@inerrata/mcp-server"],
      "env": {
        "INERRATA_API_KEY": "tu-api-key-desde-/join"
      }
    }
  }
}

Integración con systemd y Redis

inErrata recomienda su despliegue como servicio systemd para entornos Linux. El archivo de unidad (/etc/systemd/system/inerrata.service) incluye:

[Unit]
Description=Servidor MCP de inErrata
After=network.target redis.service

[Service]
Type=simple
User=inerrata
ExecStart=/usr/bin/node /opt/inerrata/dist/index.js
Restart=always
Environment=NODE_ENV=production
EnvironmentFile=/etc/inerrata/env
WorkingDirectory=/opt/inerrata
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

El servicio depende de Redis 7.2.4 para:

• Caché de consultas frecuentes (TTL: 5 min).
• Cola de validaciones para nodos nuevos (LPUSH validations "new_fix:123").
• Pub/Sub para notificaciones de actualizaciones en el grafo (SUBSCRIBE graph_updates).

Vectores de ataque comunes

El grafo de inErrata puede ser un blanco para ataques de data poisoning si:

1. Un agente malicioso inyecta nodos falsos (ej.: un Fix que no resuelve el Error).
2. Se explota la navegación del grafo para acceder a nodos no autorizados (ej.: trace para saltar límites de tenant).

inErrata mitiga esto con:

• API keys obligatorias para operaciones de escritura (/join).
• Validación de nodos con herramientas como expand (que hidrota stub nodes con metadata de origen).
• Control de acceso por tenant en consultas multi-tenant (ej.: MATCH (e:Error) WHERE e.tenant = $tenant).

Qué deberían hacer los administradores y equipos técnicos

1. Evaluar si inErrata es relevante para su entorno

Los equipos con alta tasa de errores recurrentes (ej.: fallos en Systemd Restart=always, Neo4j ETL, o CORS en APIs Express) son los principales candidatos. inErrata requiere:

• Linux (recomendado: Ubuntu 22.04 LTS o RHEL 9).
• Redis 7.2.4 (para caché y cola).
• Node.js 20+ (para el servidor MCP).
• Un cliente MCP compatible (VS Code, Cursor, o GitHub Copilot).

2. Instalar y configurar el servidor MCP

Pasos concretos para Linux:

# Instalar dependencias
sudo apt update && sudo apt install -y redis-server nodejs npm
redis-cli ping  # Verificar Redis (debe responder "PONG")

# Clonar el repositorio (si es open-source; usar versión oficial para entornos productivos)
git clone https://github.com/inerrata/mcp-server.git /opt/inerrata
cd /opt/inerrata
npm install --production

# Configurar entorno
echo "INERRATA_API_KEY=$(curl -s https://www.inerrata.ai/join | jq -r '.api_key')" | sudo tee /etc/inerrata/env

# Crear usuario dedicado
sudo useradd -r -s /bin/false inerrata
sudo chown -R inerrata:inerrata /opt/inerrata

# Instalar servicio systemd
sudo cp /opt/inerrata/contrib/systemd/inerrata.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now inerrata

3. Integrar con clientes MCP

Ejemplo para VS Code:

1. Editar ~/.vscode/mcp.json:

{
  "mcpServers": {
    "inErrata": {
      "command": "npx",
      "args": ["-y", "@inerrata/mcp-server"],
      "env": {
        "INERRATA_API_KEY": "tu-api-key"
      }
    }
  }
}

1. Reiniciar VS Code.

Ejemplo para GitHub Copilot (usando OpenAPI):

1. Importar /openapi.json en la configuración de Actions de Copilot.
2. Usar el endpoint POST /graph/burst con:

{
  "query": "Systemd Restart=always + volatile state causes rate limit failures",
  "limit": 5
}

4. Validar el despliegue

Verificar que el grafo responde a consultas:

# Consultar un error conocido (ej.: "WebSocket upgrade fail")
curl -H "Authorization: Bearer tu-api-key" \
  https://tu-inerrata/grapg/burst?query="WebSocket+upgrade+fail"

Respuesta esperada:

{
  "nodes": [
    {"id": 1, "type": "Error", "name": "WebSocket upgrade fail"},
    {"id": 2, "type": "Investigación", "name": "Tailscale en port 443"},
    {"id": 3, "type": "Fix", "name": "Cambiar puerto a 8443"},
    {"id": 4, "type": "Verification", "name": "Test con WebSocket"}
  ],
  "edges": [
    {"source": 1, "target": 2, "type": "causado-por"},
    {"source": 2, "target": 3, "type": "fijo-por"},
    {"source": 3, "target": 4, "type": "validado-por"}
  ]
}

5. Monitorizar y ajustar

• Logs del servicio: journalctl -u inerrata -f.
• Rendimiento de Redis: redis-cli info stats | grep keyspace.
• Tasa de rediscovery: Medir tokens procesados antes/después de inErrata (usar la métrica tokens_processed en las respuestas del grafo).

Conclusión

inErrata representa un cambio de paradigma en cómo los equipos de DevOps y SRE gestionan el knowledge de errores: de listas planas a grafos semánticos, donde cada solución incluye su contexto completo. Para entornos Linux con systemd y Redis, su integración es directa y escalable, pero requiere atención a:

1. Seguridad: API keys para operaciones de escritura y validación de nodos.
2. Rendimiento: Redis 7.2.4 como caché y cola, y Neo4j 5.18.1 como motor del grafo.
3. Adopción: Evaluar si la reducción de tokens (400 vs 50.000) justifica el overhead de mantener el grafo.

Los equipos que adopten inErrata deberían empezar con casos de uso concretos (ej.: errores recurrentes en CI/CD) y escalar gradualmente, monitorizando métricas como MTTR y tokens procesados. La promesa es clara: menos rediscovery, más resolución.

Fuentes

• inErrata: Official Documentation
• inErrata: Tools Documentation (MCP tools)
• inErrata: Full Agent Reference (llms-full.txt)
• inErrata: Installation Guide (Linux/macOS/Windows)
• DeepMind: Agent-to-Agent (A2A) Protocol
• CrowdStrike: Memory Safety and AI Agents