En el enorme repositorio de ClickHouse, el agente Claude Code con memoria compartida conectada falla menos al buscar archivos y gasta bastante menos dinero en el modelo, pero solo cuando el contexto deja de vivir en sesiones desechables y se vincula directo al código. Justo para eso el equipo de ClickHouse abrió ClickHouse Loom (v1.2.0, licencia Apache-2.0): un servidor de memoria a largo plazo, búsqueda en documentos y análisis de código para agentes de programación.
Por qué los agentes de código sufren amnesia y cómo Loom ancla la memoria al código
Escena conocida. Ayer pasaste dos horas explicándole a Claude Code, Codex o Cursor por qué en el módulo de autenticación no se puede tocar la caché antigua y dónde se esconde la lógica de reintentos. Hoy abres una sesión nueva y vuelta a la hoja en blanco. El agente revisa otra vez decenas de archivos, quema tokens y propone alegremente romper esa misma caché. Archivos de reglas como CLAUDE.md salvan hasta el primer refactor grande, y en equipo pronto se vuelven un cajón de contradicciones.
ClickHouse atacó el problema desde la infraestructura y sacó la memoria a un servicio self-hosted (desplegable en tu máquina o servidor de empresa, sin filtrar historial a una nube ajena) bajo el protocolo MCP (Model Context Protocol), el estándar abierto para conectar herramientas y bases de conocimiento a agentes de IA. Todo se guarda en ClickHouse: búsqueda vectorial y de texto, grafo de relaciones y auditoría. Si prefieres, el estado operativo de la memoria puede ir en Postgres al primer arranque mediante LOOM_STORAGE_AUTHORITY=postgres.
El punto fuerte es la memoria ligada al código. Las notas y decisiones se fijan a archivos y símbolos concretos. Si un método se mueve en un refactor, la nota se mueve con él. Si cambian líneas relacionadas, el hecho queda marcado para revisión. Cuando el agente abre esa zona mañana, el contexto necesario aparece solo. Cada registro tiene autor, historial de versiones y resolución de conflictos, y cualquier namespace (espacio de nombres aislado de memoria, por defecto dev/local) puede revertirse a cualquier momento anterior.
Al lado trabaja un índice de código tipo compilador: no una búsqueda por cadenas, sino un mapa estructural del proyecto con definiciones, funciones llamantes (callers), impacto de cambios y tests necesarios enlazados con commits, PRs y tareas. La imagen ya incluye indexadores para Python, TypeScript y Go, y en amd64 también para C++. Además suma RAG con citas (búsqueda sobre notas, conversaciones y documentos PDF, .docx, .pptx mediante el servicio extractor con enlaces a fuentes y rechazo de respuesta si la confianza es baja) y colas de tareas (task inboxes con leases y reintentos) para pasar trabajo entre agentes.
Benchmarks sin ilusiones: de dónde sale el ahorro y qué quedó fuera
El equipo de ClickHouse publicó mediciones reproducibles sobre su propia base de código con Claude Code (claude-sonnet-5):
| Tarea / benchmark | Con Loom | Sin Loom | Efecto en recursos | Alcance de la prueba |
|---|---|---|---|---|
| Calidad de respuestas del agente | 0.84 | 0.78 | -20% en factura del modelo | 24 preguntas × 3 ejecuciones emparejadas |
| Localización de archivos (top-3) | 96.4% | 91.4% | -21% en factura del modelo | 36 preguntas × 10 ejecuciones emparejadas |
Memoria vs historial completo (LongMemEval-S, lector gpt-5) | 94% | 90% | -91% de tokens en el prompt | 100 preguntas emparejadas |
| SWE-bench Verified (archivo en top-10) | 82% | 57% (BM25) | 76.5% en top-5 | 200 tareas (solo búsqueda de archivo) |
Los números lucen bien, pero los autores enumeraron con honestidad todas las salvedades en la documentación, y conviene saberlas de antemano.
Primero, el ahorro de las dos primeras filas cuenta únicamente la factura del modelo del propio agente de código. Quedan fuera las llamadas de servidor al LLM dentro de Loom, el cálculo de embeddings (vectores numéricos para búsqueda semántica), la indexación del repositorio y el alojamiento de ClickHouse. En la práctica, trasladas parte del gasto del contexto caro del agente a un servicio en segundo plano.
Segundo, en la prueba LongMemEval-S la compresión del prompt no incluye el costo de escribir y recuperar memoria, y los propios autores califican la leve ventaja en precisión como descriptiva, no estadísticamente demostrada. Tercero, SWE-bench aquí evalúa solo encontrar el archivo, no resolver la tarea completa.
La cuenta es clara: en un monorrepo enorme, donde el agente pierde tiempo cada vez buscando el módulo correcto, Loom se amortiza rápido. En un servicio pequeño, el costo operativo y mantener la base se comerán todo el beneficio.
Cómo levantar Loom en Docker y conectarlo a Claude Code o Codex
Para arrancar en local según el Quickstart necesitas Docker con Compose 2.20+ (en Windows, WSL 2 con Docker Desktop o Docker Engine dentro de WSL) y el puerto 7777 libre. El modo personal corre en localhost sin login, crea dev/local y no tiene funciones recortadas: si el equipo crece, puedes pasarlo a modo multiusuario sin perder datos.
Ejecuta el instalador desde tu carpeta personal:
# Ejecuta desde tu carpeta home: los ajustes y Compose quedarán en ~/.loom
curl -fsSL \
https://github.com/ClickHouse/loom/releases/latest/download/install.sh \
-o loom-install.sh \
&& sh loom-install.sh \
&& rm loom-install.sh
El script guarda el archivo Compose y .env en ~/.loom (la ruta cambia con LOOM_INSTALL_DIR), levanta ClickHouse y Loom, aplica migraciones, verifica lectura/escritura y abre el panel web http://localhost:7777/. Si lo ejecutas otra vez, actualiza el stack conservando tu configuración.
De fábrica el stack arranca sin claves ni internet, pero busca por significado con el modelo local débil bge-small (384 dimensiones en CPU) y en lugar de un LLM usa el simulador fake-echo-1: la extracción de hechos, resúmenes de sesión y memory.ask quedan mudos. La suscripción o el login CLI de tu agente no pasan las claves API dentro de Loom: debes configurarlas aparte.
Los proveedores se eligen fácil desde el panel (Settings → Models & keys → Test & apply, sin reiniciar el contenedor) o en ~/.loom/.env siguiendo Models & keys. Una sola clave de OpenAI cubre ambos roles:
# Activamos modelos reales en lugar de bge-small local y fake-echo-1
LOOM_LLM_PROVIDER=openai
LOOM_LLM_MODEL=gpt-6-luna
OPENAI_API_KEY=<tu_clave_OpenAI>
LOOM_EMBEDDING_PROVIDER=openai
LOOM_EMBEDDING_MODEL=text-embedding-3-large
LOOM_EMBEDDING_DIM=3072
# Evitamos que el servidor vuelva en silencio al simulador
LOOM_REQUIRE_REAL_PROVIDERS=true
Si eliges Anthropic (claude-haiku-4-5) para el LLM, para los embeddings necesitarás un segundo proveedor: OpenAI, Gemini (gemini-embedding-001) o un endpoint compatible con OpenAI. Ojo: poner solo la clave sin LOOM_*_PROVIDER y LOOM_*_MODEL no desactiva los simuladores, y los ajustes del panel siempre sobrescriben el .env. Tras editar el archivo, recrea el contenedor:
# Recreamos el contenedor para tomar los cambios de ~/.loom/.env
docker compose --project-directory "$HOME/.loom" \
up -d --force-recreate loom
Ahora conectamos los propios agentes. Si el instalador no lo hizo ya, en localhost no hace falta token y bastan un par de comandos:
# Conectamos el plugin para Claude Code (en localhost no requiere token)
claude plugin marketplace add ClickHouse/loom
claude plugin install loom@loom
# Conectamos el plugin para Codex
codex plugin marketplace add ClickHouse/loom
codex plugin add loom@loom
Abre una sesión nueva y el agente se conectará solo a http://localhost:7777. En Codex, tras instalar, debes ejecutar codex una vez de forma interactiva y aprobar los hooks, o solo funcionarán las herramientas sin captura automática de sesión. Cursor y el modo agente de VS Code en local también se conectan por MCP sin token (el plugin de equipo para Cursor Teams/Enterprise figura como untested in Cursor). Para tus propios agentes hay API HTTP, SDK en Python 3.11+ y TypeScript (Node 20+), e integraciones opcionales con Langfuse y ClickStack / HyperDX para observabilidad.
Quién necesita Loom ya y dónde conviene prescindir de él
Incluso en local, Loom es una arquitectura cliente-servidor completa donde el servidor web y ClickHouse comparten CPU y RAM. Según la guía de despliegue, en la versión standalone el número de workers web (LOOM_WEB_WORKERS) viene limitado a dos por defecto (no más de uno por núcleo y por gigabyte de memoria, con tope de ocho) para no ahogar la base, y los archivos temporales viven en tmpfs bajo /run/loom.
Un conjunto así tiene sentido en un repositorio grande donde trabajan varios agentes o ingenieros, las tareas se repiten y hace falta mantener el historial de decisiones y búsqueda documental dentro de tu propia red. En el resto de los casos ayuda la honesta lista When it does not fit de los propios autores: siete situaciones donde Loom sobra.
Si tienes un solo agente en un único proceso y memoria corta para un par de horas, montar ClickHouse para eso no tiene sentido: mejor usa una librería en memoria. Tampoco sirve para lecturas de submilisegundos en ruta crítica: cada consulta pasa por SQL (con FINAL sobre filas versionadas), así que no reemplaza una caché. Para análisis profundo de grafos también choca con un límite de cuatro saltos (hops): las relaciones largas conviene exportarlas con loom entity-export a una base de grafos.
Y no confundas roles: Loom no es un framework agéntico, no ejecuta prompts ni el bucle del agente; solo guarda memoria y pasa tareas. La auditoría y el borrado verificado (erasure saga) no sustituyen una certificación de cumplimiento normativo. Los autores tampoco recomiendan producción en un solo nodo de ClickHouse OSS sin copias de seguridad por falta de replicación y recuperación a un punto en el tiempo (PITR): para producción sugieren ClickHouse Cloud. Por último, la API sigue cambiando entre versiones, así que conviene fijar la versión y consultar ops.capabilities.

