Alternativas a Claude-Mem en Go, Rust y C

El agente de terminal es genial hasta que termina la sesión. En la siguiente, redescubre el mismo bug, vuelve a leer el mismo README y pregunta otra vez si la API usa JWT. claude-mem lo soluciona: captura lo que hizo el agente, lo comprime y devuelve el fragmento adecuado en SessionStart. Pero es TypeScript, Node, Bun y un worker aparte. Si tu máquina ya vive de un único binario en Go, Rust o C, puedes tener la misma idea sin la pila JS.

Este post mapea las alternativas nativas que realmente existen hoy: memoria de sesión (decisiones, bugs, convenciones), búsqueda retroactiva en los historiales de los agentes y memoria del código (quién llama a quién). No son clones. Algunos usan MCP por stdio, otros usan HTTP, instalan hooks o se convierten en una extensión de SQLite. El mapa de los agentes en el terminal continúa en Asistentes de IA en el terminal Linux; el encaje de claude-mem en el flujo de vibe coding está en Vibe coding en Linux.

Qué hace Claude-Mem — y qué intentan copiar las alternativas

El repositorio de referencia es thedotmack/claude-mem, presentado por el proyecto como Claude-Mem, bajo licencia Apache 2.0. El punto de comparación es el flujo de memoria, no solo el lenguaje de implementación:

• hooks de ciclo de vida (SessionStart, PostToolUse, PreCompact, Stop);
• SQLite + búsqueda (FTS5 y vector);
• MCP para que el agente consulte la memoria bajo demanda;
• inyección de contexto al comienzo de la sesión, sin que pidas “recuerda lo que acordamos”.

Quien cambia el stack quiere, en el fondo, esas capacidades con menos piezas que operar. El almacenamiento puede ser SQLite, una wiki o un índice propio. Los embeddings pueden usar Ollama u otro endpoint; comprobar el destino es esencial. Incluso con búsqueda local, los fragmentos recuperados por un agente en la nube pueden entrar en el contexto enviado al proveedor.

Tabla rápida

Go: cuatro binarios, diferentes formas de recordar

Deja Vu: los historiales que ya tienes se convierten en memoria

Deja Vu (MIT, Go) forma parte de una diferencia importante: Claude Code, Cursor y otros agentes ya dejan historiales en disco. El comando deja lee esas fuentes y crea búsqueda retrospectiva, incluso para sesiones anteriores a la instalación. No necesitas esperar a que nuevos hooks acumulen semanas de trabajo para empezar.

El índice por defecto, ~/.cache/deja/index.db, es un directorio de archivos binarios propios, no una base de datos SQLite. Hay búsqueda léxica, filtros, CLI, TUI, servidor MCP por stdio e integración automática opcional. Fuentes que guardan sesiones en SQLite se leen con el ejecutable local sqlite3; el hecho de que el programa principal sea un binario Go no elimina esa dependencia para todos los agentes.

# Instalador oficial: baixe e inspecione antes de executar.
# Esta URL fixa o script; ele baixa a release estável mais recente.
mkdir -p "$HOME/.cache/deja-installer"
curl -fsSL \
  https://raw.githubusercontent.com/vshulcz/deja-vu/v0.22.1/install.sh \
  -o "$HOME/.cache/deja-installer/install.sh"
less "$HOME/.cache/deja-installer/install.sh"
sh "$HOME/.cache/deja-installer/install.sh"
export PATH="$HOME/.local/bin:$PATH"

deja index
deja search "connection pool exhausted"
deja doctor

# Opcional: após backup das configurações, integre somente estes clientes.
deja install claude-code codex

Para quien ya tiene Go compatible, go install github.com/vshulcz/deja-vu/cmd/deja@v0.22.1 fija la etiqueta de compilación; el módulo declara Go 1.25. deja install --auto es la vía amplia para configurar agentes detectados con sus hooks/plugins automáticos. No es obligatorio: empezar solo por la CLI permite evaluar la búsqueda sin alterar las integraciones existentes.

Facilidades útiles: deja ctx prepara contexto, deja blame encuentra sesiones relacionadas con archivos, deja how muestra invocaciones anteriores, deja fix consulta intentos tras errores y deja handoff --to codex prepara la continuación en otro agente. El historial es evidencia a revisar, no una orden para ejecutar comandos antiguos.

Madurez: la release 0.22.1, de 12/10/2026, ofrece una base extensa de pruebas, CI y documentación de seguridad. En nuestro laboratorio, funcionaron la compilación, el análisis estático, la búsqueda entre dos historiales sintéticos y MCP. También reproducimos un fallo de prueba relacionado con la zona horaria de São Paulo, sin evidencia de pérdida de notas. Es prometedor para un piloto serio en el escritorio, pero aún es un proyecto joven en la línea 0.x, no una garantía de estabilidad para todos los clientes.

Privacidad: la búsqueda por defecto no exige modelo; los embeddings son opcionales y envían material al endpoint configurado. La sanitización reduce la exposición de credenciales, pero no garantiza eliminar todo secreto y no cifra el índice. Además, borrar la conversación en el agente no necesariamente borra la copia ya retenida en Deja Vu. Lea el modelo de seguridad antes de activar la captura amplia.

La instalación detallada, las pruebas, los límites y la evaluación de madurez están en Deja Vu: memoria de los agentes en Linux.

mnemo — el clon más directo

mnemo (MIT, Go 1.23+) es un servidor MCP de memoria con un único binario. Base de datos por defecto en ~/.mnemo/memory.db. Detecta Claude Code, OpenCode y Codex en la primera ejecución y se registra solo. Tiene panel en http://localhost:8765.

go install github.com/kyungw00k/mnemo/cmd/mnemo@latest

# hooks do Claude Code (ou deixe o auto-install)
mnemo hook install --dry-run
mnemo hook install

mnemo dashboard

Los hooks cubren el ciclo que popularizó Claude-Mem: SessionStart inyecta decisiones recientes, PreCompact guarda una snapshot, PostToolUse anota el resultado de Bash, Stop cierra la sesión. Los embeddings se comunican con cualquier endpoint compatible con OpenAI — Ollama por defecto (nomic-embed-text, 768 dimensiones). PostgreSQL + pgvector entran si cambias el DB_URL.

Es la opción más parecida al original en Go. El proyecto aún es nuevo; trátelo como una herramienta útil, no como un producto maduro de años.

Engram — un cerebro para varios agentes

Engram (MIT) nació inspirado en claude-mem, pero es agent-agnostic: un binario Go, un SQLite con FTS5 en ~/.engram/engram.db, MCP, HTTP, CLI y TUI. Sin Node, sin Python, sin Docker para ejecutar.

# Claude Code
claude plugin marketplace add Gentleman-Programming/engram
claude plugin install engram

# Codex, OpenCode, Antigravity, Cursor…
engram setup codex
engram setup opencode
engram setup antigravity-cli

engram tui

El contrato con el agente es explícito: oriéntese con mem_context / mem_search antes de repetir trabajo; guarde solo lo que dura (mem_save); cierre la sesión con mem_session_summary. No es un vertedero de transcripts. El README de producción pide el binario de las GitHub Releases; Homebrew cubre la línea estable.

Si Claude Code, Codex y la CLI de Google necesitan recordar la misma decisión, empiece por aquí. El paso a paso de instalación, MCP, nombre de proyecto y systemd está en Engram: memoria persistente para agentes en Linux.

Goldie: un pool, varios agentes

Goldie (MIT) cambia el MEMORY.md por un archivo SQLite compartido. Herramientas en el vocabulario adecuado: remember, recall, update_memory, forget. Memorias tipadas (user, feedback, project, reference…), grafo de conceptos, embeddings locales mediante MiniLM (ONNX Runtime) u Ollama.

# Linux amd64 — pegue o binário da release
curl -LO https://github.com/srfrog/goldie-mcp/releases/latest/download/goldie-mcp-linux-amd64
chmod +x goldie-mcp-linux-amd64
mv goldie-mcp-linux-amd64 ~/.local/bin/goldie-mcp

# MiniLM precisa do ONNX Runtime
sudo apt install libonnxruntime-dev   # Debian/Ubuntu

# ou pule o ONNX e use Ollama
ollama pull nomic-embed-text
claude mcp add -s user -e GOLDIE_DB_PATH=~/.local/share/goldie/index.db goldie goldie-mcp -- -b ollama

El “alcance” es el archivo. Dos agentes en el mismo GOLDIE_DB_PATH comparten la memoria. No escriba desde dos máquinas a la vez si .db está en Syncthing — el README es honesto al respecto.

Rust: del binario único al servidor de memoria

ai-memory: wiki versionada y pase de relevo

ai-memory (MIT, Rust) es la opción más estructurada de esta parte de la lista. En lugar de que cada agente escriba directamente en la base de datos, un servidor es el único escritor: recibe observaciones saneadas por los hooks, mantiene un wiki Markdown versionado en Git como fuente de verdad y usa SQLite como índice derivado (FTS5, entidades y vectores opcionales).

El flujo es capturar → consolidar → recuperar → entregar. Al final de la sesión, las observaciones pueden convertirse en páginas legibles del wiki; en la siguiente, el agente recibe un handoff limitado y puede buscar en el historial. Captura, búsqueda y handoff funcionan sin clave ni llamada a un LLM; configurar un proveedor solo añade consolidación y búsqueda semántica. Es una diferencia importante respecto a Engram y Leteo: ai-memory es un servicio local vía HTTP/MCP, no solo un proceso que abre un SQLite.

La ruta documentada para Linux es Docker o Podman. Quien ya use mise puede descargar el binario de release con checksum, sin instalar Rust:

mise use -g github:akitaonrails/ai-memory

# uma vez: cria o estado local; depois sobe MCP + API + hooks HTTP
ai-memory init
ai-memory serve --transport http --bind 127.0.0.1:49374

# em outro terminal, registre MCP e hooks para o cliente escolhido
ai-memory install-mcp --client claude-code --apply
ai-memory install-hooks --agent claude-code --apply

# para o Codex, troque claude-code por codex nos dois comandos

Claude Code, Codex, OpenCode, Gemini CLI, Grok Build y varios otros clientes tienen integración de primera parte. En una sola máquina, el servidor escucha en el loopback; para un equipo o homelab, puede estar en un host compartido con autenticación y HTTPS. Elija ai-memory cuando la prioridad sea la transición explícita entre Claude, Codex y otros agentes — o cuando quiera inspeccionar y versionar la memoria como Markdown. Para un SQLite directo y una configuración más pequeña, Engram y Leteo siguen siendo más sencillos.

Leteo: el Engram en Rust

Leteo (MIT) es un producto independiente en Rust derivado del flujo y la implementación MIT de Engram. Un binario, SQLite en ~/.leteo/leteo.db, sin API key, sin servidor. Importa la base de datos de Engram con leteo import --from-engram.

curl -fsSL https://raw.githubusercontent.com/asanabrial/leteo/main/scripts/install.sh | sh
leteo tui
leteo setup claude-code --hooks
leteo setup codex

Los archivos de las releases de Linux requieren glibc 2.34 — Debian 12, Ubuntu 22.04, RHEL 9 o más reciente. Plugin de Claude Code: /plugin marketplace add asanabrial/leteo e /plugin install leteo@leteo. No registre plugin e leteo setup --hooks al mismo tiempo: cada evento se dispara dos veces.

Subcog: búsqueda híbrida de verdad

Subcog (MIT, Rust 1.88+) apila tres capas: SQLite como fuente de verdad, FTS5 (BM25) y vectores HNSW mediante usearch. Embeddings con all-MiniLM-L6-v2 mediante fastembed, 384 dimensiones, sin llamar a la API. Fusión RRF. Knowledge graph con entidades y relaciones.

cargo install subcog
# ou: brew install zircote/tap/subcog

subcog capture --namespace decisions "Use PostgreSQL por causa do ACID"
subcog recall "decisão de banco"
subcog serve

Hooks de Claude Code: SessionStart, UserPromptSubmit, PostToolUse, PreCompact, Stop. Es la opción si “recordar” necesita ser búsqueda semántica, no solo grep en SQLite.

mcp-memory: grafo + código en el mismo binario

mcp-memory (Apache-2.0) reúne knowledge graph, FTS5, vector (usearch HNSW) e indexación tree-sitter en Rust, Python, JS/TS, Go, Java, C, C++, Ruby y PHP. Las tools entran por categoría: nada se expone hasta que pases --enable-graph-read / --enable-code / --enable-all.

cargo install mcp-memory
mcp-memory --transport stdio --enable-all

Útil cuando quieres un proceso recordando entidades del proyecto e el mapa de símbolos. No sustituye a codebase-memory-mcp a escala de kernel, pero cabe en un portátil sin daemon extra.

mcp-memory-rs: cuaderno local, sin ML

mcp-memory-rs (Apache-2.0) guarda el estado del agente en JSON por categoría, con índice SQLite FTS5. Cada escritura está versionada. Sin descarga de modelo, sin embedding. La sincronización entre máquinas es un paso explícito (manifest Merkle + HTTP), nunca una dependencia oculta.

El valor por defecto offline es el punto: Claude Code y Codex apuntan al mismo binario y el estado sobrevive al cambio de modelo. Para corpus (documentos fragmentados) el autor señala el companion mcp-vl-msa-rs — este es el cuaderno, no la biblioteca.

memory-server: cuando la memoria es un servicio

memory-server separa las piezas: el agente habla MCP con memory-mcp, que llama memoryd por HTTP, que escribe en PostgreSQL + pgvector y solicita embedding a Ollama (bge-m3 por defecto).

agent  --stdio-->  memory-mcp  --HTTP-->  memoryd
                                           |-- PostgreSQL + pgvector
                                           +-- Ollama

Categorías fijas: context, decision, error_fix, plan, rule. Tiene sentido cuando portátil y servidor necesitan el mismo almacén — y aceptas operar Postgres 17 con pgvector. Para un único usuario en el portátil, es matar moscas a cañonazos.

C: extensión SQLite y grafo del repositorio

sqlite-memory: memoria como SQL

sqlite-memory (MIT) es una extensión en C: Markdown como fuente de verdad, fragmentación consciente del encabezado, búsqueda híbrida (vectorial + FTS5), embeddings locales con llama.cpp. Forma parte de la familia SQLite AI (sqlite-vector, sqlite-sync, sqlite-mcp…).

.load ./vector
.load ./memory
SELECT memory_set_model('local', '/path/to/nomic-embed-text-v1.5.Q8_0.gguf');
SELECT memory_add_directory('/path/to/docs', 'project-docs');
SELECT path, snippet, ranking FROM memory_search
 WHERE query = 'como o agente persiste contexto';

El CLI en Go, sqlmem, envuelve esto en un proyecto (sqlmem init, add, search) y expone las tools vía MCP. Es el camino si quieres construir tu propia capa, no instalar un producto listo. La sincronización entre agentes usa CRDT de sqlite-sync — cada uno trabaja offline y fusiona después.

codebase-memory-mcp: la otra memoria

codebase-memory-mcp (MIT, C puro) no es una alternativa a Claude-Mem. Indexa el repositorio en un knowledge graph: funciones, clases, rutas HTTP, quién llama a quién. Tree-sitter, 15 tools MCP, binario nativo. El preprint está en arXiv 2603.27277.

curl -fsSL https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh | bash
# reinicie o agente e peça: index this project

Preguntas que responde y el grep no: “¿quién llama a esta función?”, “¿cuál es el radio de explosión de este diff?”, “¿dónde se implementa esta interfaz?”. Detalles de uso en el post de skills de IA en la CLI. El caso feliz es los dos en el mismo agente: uno recuerda la conversación, el otro recuerda el código.

C++: aún no hay un clon listo

Entre los proyectos de esta lista, no aparece un equivalente maduro a Claude-Mem cuya implementación principal sea C++. Lo que existe en C++ entra como pieza — llama.cpp para embedding, SQLite, índices vectoriales — no como producto de memoria de sesión. El codebase-memory-mcp analiza C/C++ muy bien; sin embargo, su binario es C.

Por dónde probar en Linux

Orden práctico para Claude Code + Codex + lo que esté en PATH:

1. Déjà Vu (Go) — si el problema es encontrar soluciones y decisiones en los historiales que Claude Code, Codex y otros agentes ya han guardado. Empiece por la búsqueda bajo demanda; habilite la automatización después de evaluar el alcance y la privacidad.
2. ai-memory (Rust) — cuando el punto principal es el handoff automático entre Claude, Codex y otros agentes, con wiki en Markdown versionada y un servidor local.
3. Engram (Go) — un banco, varios agentes, TUI para inspeccionar lo que se ha grabado.
4. mnemo (Go) — si lo que quieres es el ciclo de hooks de Claude-Mem, sin cambiar de filosofía.
5. Leteo (Rust) — el mismo flujo que Engram, binario Rust, importa el .db de él.
6. Subcog (Rust) — cuando la búsqueda necesita vector + BM25 de verdad.
7. mcp-memory (Rust) — si quieres grafo + índice de código en el mismo proceso.
8. Goldie (Go) — pool compartido, vocabulario remember/recall.
9. sqlite-memory (C) — si la idea es montar tu propia capa encima de SQLite.

Y, en paralelo, no en su lugar: codebase-memory-mcp.

          Claude Code / Codex / OpenCode
                       |
              +--------+--------+
              |                 |
              v                 v
     memória de sessão    memória do código
     Engram / mnemo /     codebase-memory-mcp
     Leteo / Subcog              |
              |                  v
              v            knowledge graph
         SQLite + FTS5         (tree-sitter)
              |
              +--------+--------+
                       v
              contexto persistente

Así, el agente de la mañana siguiente ya sabe que la autenticación es JWT con refresh, e lograr señalar el handler.go sin releer el repo.

Qué no externalizar

La memoria persistente no es una copia de seguridad de la verdad. Git sigue siendo el registro; la historia está en La historia de Git. Lo que va a SQLite es decisión, convención, bug costoso — no contraseña, no token, no dump de journalctl. Los proyectos serios tienen etiqueta <private> o filtro de secretos; si lo que elegiste no lo tiene, no guardes lo que no puede filtrarse.

Evite instalar varios mecanismos de auto-recall en el mismo agente “para garantizar”: pueden duplicar contexto y decisiones. Una combinación más controlable es una fuente principal de memoria duradera, el grafo del código y, cuando tenga sentido, Deja Vu como consulta retroactiva bajo demanda. Active más automatización solo si la ganancia justifica el coste de contexto.

Cerrando

Claude-Mem mostró el formato: hook en el ciclo de vida, estado local y MCP en la consulta. Go y Rust ya entregan diferentes partes de ese flujo en binarios nativos. Deja Vu añade búsqueda retroactiva en transcripciones existentes, con su propio índice; Rust también tiene la ruta de servidor + wiki versionada de ai-memory. C entrega la extensión y el grafo del código. C++ sigue siendo pieza, no producto. Elija por la pregunta que duele hoy — “el agente olvidó la decisión”, “necesito pasar el trabajo a otro agente” o “el agente no encuentra la función” — y coloque solo la herramienta que responde a esa pregunta.

Repositorios: claude-mem · Deja Vu · mnemo · Engram · ai-memory · Goldie · Leteo · Subcog · mcp-memory · mcp-memory-rs · memory-server · sqlite-memory · codebase-memory-mcp. Documentación: docs.claude-mem.ai · engram.gentlemanprogramming.com.

Gopher de Go dibujado por Renée French (CC BY 3.0). Ferris, la mascota no oficial de Rust, por Karen Rustad Tölva.