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) y memoria del código (quién llama a quién). No son clones. Algunas hablan MCP por stdio, otras usan HTTP, instalan hooks o se convierten en 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 sigue siendo thedotmack/claude-mem, licencia Apache-2.0. En 2026 el producto también se llama Grok Mem; el paquete npm sigue claude-mem. La pieza que importa para comparar:
- 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 cuatro cosas en un binario local, con la base de datos en un archivo que tú controlas. Los embeddings, cuando existen, apuntan a Ollama o a un modelo integrado — no hace falta que nada salga de la máquina.
Tabla rápida
| Proyecto | Lenguaje | Base de datos | MCP | Perfil |
|---|---|---|---|---|
| mnemo | Go | SQLite (pgvector opcional) | stdio / SSE | Lo más parecido a Claude-Mem en Go |
| Engram | Go | SQLite + FTS5 | sim | Memoria multi-agente, CLI, TUI, HTTP |
| Goldie | Go | SQLite + vector | sim | Pool compartido entre agentes |
| ai-memory | Rust | Wiki Markdown + SQLite | sí (HTTP) | Servidor local, hooks y handoff entre agentes |
| Leteo | Rust | SQLite | 22 tools | Binario único + hooks, derivado de Engram |
| Subcog | Rust | SQLite + FTS5 + HNSW | sim | Búsqueda híbrida + knowledge graph |
| mcp-memory | Rust | SQLite | sim | Grafo + vector + indexación de código |
| mcp-memory-rs | Rust | JSON + SQLite FTS5 | sim | Local-first, versionado, sin embedding |
| memory-server | Rust | PostgreSQL + pgvector | sim | Servicio centralizado + Ollama |
| sqlite-memory | C | SQLite | vía sqlmem / sqlite-mcp | Extensión, Markdown + búsqueda híbrida |
| codebase-memory-mcp | C | SQLite | sim | Grafo del código, no de la conversación |
Go: tres binarios, tres formas de recordar
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 dashboardLos 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 tuiEl 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 ollamaEl “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 comandosClaude 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 codexLos 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 serveHooks 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
+-- OllamaCategorí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 projectPreguntas 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:
- 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.
- Engram (Go) — un banco, varios agentes, TUI para inspeccionar lo que se ha grabado.
- mnemo (Go) — si lo que quieres es el ciclo de hooks de Claude-Mem, sin cambiar de filosofía.
- Leteo (Rust) — el mismo flujo que Engram, binario Rust, importa el
.dbde él. - Subcog (Rust) — cuando la búsqueda necesita vector + BM25 de verdad.
- mcp-memory (Rust) — si quieres grafo + índice de código en el mismo proceso.
- Goldie (Go) — pool compartido, vocabulario
remember/recall. - 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 persistenteAsí, 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.
Y no instales tres servidores de memoria en el mismo agente “para asegurarte”. Compiten por el contexto. Uno de sesión + el grafo del código ya es el techo útil.
Cerrando
Claude-Mem mostró el formato: hook en el ciclo de vida, estado local y MCP en la consulta. Go y Rust ya lo entregan en un único binario; 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 una pieza, no un producto. Elige 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 coloca solo la herramienta que responde esa pregunta.
Repositorios: claude-mem · 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.