{"id":981,"date":"2026-09-08T00:18:34","date_gmt":"2026-09-08T03:18:34","guid":{"rendered":"https:\/\/www.linuxpro.com.br\/2026\/09\/alternativas-claude-mem-go-rust-c\/"},"modified":"2026-10-15T08:44:21","modified_gmt":"2026-10-15T11:44:21","slug":"alternativas-claude-mem-go-rust-c","status":"publish","type":"post","link":"https:\/\/www.linuxpro.com.br\/es\/2026\/09\/alternativas-claude-mem-go-rust-c\/","title":{"rendered":"Alternativas a Claude-Mem en Go, Rust y C"},"content":{"rendered":"<p><img loading=\"lazy\" decoding=\"async\" alt=\"Mascote do LinuxPro encaixando um cartucho de mem\u00f3ria no SQLite, com o gopher do Go, o Ferris e o cubo do C\" src=\"\/wp-content\/uploads\/2026\/09\/alternativas-claude-mem-go-rust-c-v3.webp\" width=\"1486\" height=\"856\" \/><\/p>\n<p class=\"translation-block\">El agente de terminal es genial hasta que termina la sesi\u00f3n. En la siguiente, redescubre el mismo bug, vuelve a leer el mismo README y pregunta otra vez si la API usa JWT. <a href=\"https:\/\/github.com\/thedotmack\/claude-mem\">claude-mem<\/a> 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\u00e1quina ya vive de un \u00fanico binario en <a href=\"\/es\/2026\/09\/a-historia-da-linguagem-go\/\">Go<\/a>, <a href=\"\/es\/2026\/09\/a-historia-da-linguagem-rust\/\">Rust<\/a> o C, puedes tener la misma idea sin la pila JS.<\/p>\n<p><!-- more --><\/p>\n<div style=\"background:#eff6ff;border-left:4px solid #2563eb;padding:.8em 1em;margin:1em 0\"><strong>Actualizaci\u00f3n \u2014 15\/10\/2026:<\/strong> incluimos Deja Vu, que busca historiales ya existentes de diferentes agentes. La secci\u00f3n sobre Deja Vu considera la release estable 0.22.1. La URL, la fecha original y la portada de este art\u00edculo se han conservado.<\/div>\n<p>Este post mapea las alternativas nativas que realmente existen hoy: memoria de sesi\u00f3n (decisiones, bugs, convenciones), b\u00fasqueda retroactiva en los historiales de los agentes y memoria del c\u00f3digo (qui\u00e9n llama a qui\u00e9n). No son clones. Algunos usan MCP por stdio, otros usan HTTP, instalan hooks o se convierten en una extensi\u00f3n de SQLite. El mapa de los agentes en el terminal contin\u00faa en <a href=\"\/es\/2026\/09\/assistentes-de-ia-no-terminal-linux\/\">Asistentes de IA en el terminal Linux<\/a>; el encaje de claude-mem en el flujo de vibe coding est\u00e1 en <a href=\"\/es\/2026\/09\/vibe-coding-linux-skills-ia-cli\/\">Vibe coding en Linux<\/a>.<\/p>\n<h2>Qu\u00e9 hace Claude-Mem \u2014 y qu\u00e9 intentan copiar las alternativas<\/h2>\n<p>El repositorio de referencia es <a href=\"https:\/\/github.com\/thedotmack\/claude-mem\">thedotmack\/claude-mem<\/a>, presentado por el proyecto como Claude-Mem, bajo licencia Apache 2.0. El punto de comparaci\u00f3n es el flujo de memoria, no solo el lenguaje de implementaci\u00f3n:<\/p>\n<ul>\n<li>hooks de ciclo de vida (<code data-no-translation=\"\">SessionStart<\/code>, <code data-no-translation=\"\">PostToolUse<\/code>, <code data-no-translation=\"\">PreCompact<\/code>, <code data-no-translation=\"\">Stop<\/code>);<\/li>\n<li>SQLite + b\u00fasqueda (FTS5 y vector);<\/li>\n<li>MCP para que el agente consulte la memoria bajo demanda;<\/li>\n<li>inyecci\u00f3n de contexto al comienzo de la sesi\u00f3n, sin que pidas \u201crecuerda lo que acordamos\u201d.<\/li>\n<\/ul>\n<p>Quien cambia el stack quiere, en el fondo, esas capacidades con menos piezas que operar. El almacenamiento puede ser SQLite, una wiki o un \u00edndice propio. Los embeddings pueden usar <a href=\"\/es\/2026\/09\/rodando-ia-local-no-linux-com-ollama\/\">Ollama<\/a> u otro endpoint; comprobar el destino es esencial. Incluso con b\u00fasqueda local, los fragmentos recuperados por un agente en la nube pueden entrar en el contexto enviado al proveedor.<\/p>\n<h2>Tabla r\u00e1pida<\/h2>\n<table>\n<thead>\n<tr>\n<th>Proyecto<\/th>\n<th>Lenguaje<\/th>\n<th>Almacenamiento<\/th>\n<th>MCP<\/th>\n<th>Perfil<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><a href=\"https:\/\/github.com\/vshulcz\/deja-vu\">Deja Vu<\/a><\/td>\n<td>Go<\/td>\n<td>\u00cdndice binario propio; embeddings opcionales<\/td>\n<td>stdio<\/td>\n<td>B\u00fasqueda retrospectiva en historiales de m\u00faltiples agentes, CLI\/TUI y handoff<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/kyungw00k\/mnemo\">mnemo<\/a><\/td>\n<td>Go<\/td>\n<td>SQLite (pgvector opcional)<\/td>\n<td>stdio \/ SSE<\/td>\n<td>Lo m\u00e1s parecido a Claude-Mem en Go<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/Gentleman-Programming\/engram\">Engram<\/a><\/td>\n<td>Go<\/td>\n<td>SQLite + FTS5<\/td>\n<td>sim<\/td>\n<td>Memoria multi-agente, CLI, TUI, HTTP<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/srfrog\/goldie-mcp\">Goldie<\/a><\/td>\n<td>Go<\/td>\n<td>SQLite + vector<\/td>\n<td>sim<\/td>\n<td>Pool compartido entre agentes<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/akitaonrails\/ai-memory\">ai-memory<\/a><\/td>\n<td>Rust<\/td>\n<td>Wiki Markdown + SQLite<\/td>\n<td>s\u00ed (HTTP)<\/td>\n<td>Servidor local, hooks y handoff entre agentes<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/asanabrial\/leteo\">Leteo<\/a><\/td>\n<td>Rust<\/td>\n<td>SQLite<\/td>\n<td>22 tools<\/td>\n<td>Binario \u00fanico + hooks, derivado de Engram<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/zircote\/subcog\">Subcog<\/a><\/td>\n<td>Rust<\/td>\n<td>SQLite + FTS5 + HNSW<\/td>\n<td>sim<\/td>\n<td>B\u00fasqueda h\u00edbrida + knowledge graph<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/corporatepiyush\/mcp-memory\">mcp-memory<\/a><\/td>\n<td>Rust<\/td>\n<td>SQLite<\/td>\n<td>sim<\/td>\n<td>Grafo + vector + indexaci\u00f3n de c\u00f3digo<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/DioNanos\/mcp-memory-rs\">mcp-memory-rs<\/a><\/td>\n<td>Rust<\/td>\n<td>JSON + SQLite FTS5<\/td>\n<td>sim<\/td>\n<td>Local-first, versionado, sin embedding<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/tokarix\/memory-server\">memory-server<\/a><\/td>\n<td>Rust<\/td>\n<td>PostgreSQL + pgvector<\/td>\n<td>sim<\/td>\n<td>Servicio centralizado + Ollama<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/sqliteai\/sqlite-memory\">sqlite-memory<\/a><\/td>\n<td>C<\/td>\n<td>SQLite<\/td>\n<td>v\u00eda sqlmem \/ sqlite-mcp<\/td>\n<td>Extensi\u00f3n, Markdown + b\u00fasqueda h\u00edbrida<\/td>\n<\/tr>\n<tr>\n<td><a href=\"https:\/\/github.com\/DeusData\/codebase-memory-mcp\">codebase-memory-mcp<\/a><\/td>\n<td>C<\/td>\n<td>SQLite<\/td>\n<td>sim<\/td>\n<td>Grafo del c\u00f3digo, no de la conversaci\u00f3n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Go: cuatro binarios, diferentes formas de recordar<\/h2>\n<h3>Deja Vu: los historiales que ya tienes se convierten en memoria<\/h3>\n<p><a href=\"https:\/\/github.com\/vshulcz\/deja-vu\">Deja Vu<\/a> (MIT, Go) forma parte de una diferencia importante: Claude Code, Cursor y otros agentes ya dejan historiales en disco. El comando <code data-no-translation=\"\">deja<\/code> lee esas fuentes y crea b\u00fasqueda retrospectiva, incluso para sesiones anteriores a la instalaci\u00f3n. No necesitas esperar a que nuevos hooks acumulen semanas de trabajo para empezar.<\/p>\n<p>El \u00edndice por defecto, <code data-no-translation=\"\">~\/.cache\/deja\/index.db<\/code>, es un <strong>directorio de archivos binarios propios, no una base de datos SQLite<\/strong>. Hay b\u00fasqueda l\u00e9xica, filtros, CLI, TUI, servidor MCP por stdio e integraci\u00f3n autom\u00e1tica opcional. Fuentes que guardan sesiones en SQLite se leen con el ejecutable local <code data-no-translation=\"\">sqlite3<\/code>; el hecho de que el programa principal sea un binario Go no elimina esa dependencia para todos los agentes.<\/p>\n<figure><img decoding=\"async\" src=\"\/wp-content\/uploads\/2026\/10\/deja-vu-local-memory-flow.webp\" alt=\"Arquitetura do Deja Vu: hist\u00f3ricos locais dos agentes, sanitiza\u00e7\u00e3o, \u00edndice bin\u00e1rio e recupera\u00e7\u00e3o por CLI, TUI, MCP e hooks opcionais.\" width=\"1200\" height=\"770\" loading=\"lazy\" \/><figcaption>Deja Vu recupera el pasado ya guardado; la integraci\u00f3n autom\u00e1tica es una etapa aparte.<\/figcaption><\/figure>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\"># Instalador oficial: baixe e inspecione antes de executar.\n# Esta URL fixa o script; ele baixa a release est\u00e1vel mais recente.\nmkdir -p \"$HOME\/.cache\/deja-installer\"\ncurl -fsSL \\\n  https:\/\/raw.githubusercontent.com\/vshulcz\/deja-vu\/v0.22.1\/install.sh \\\n  -o \"$HOME\/.cache\/deja-installer\/install.sh\"\nless \"$HOME\/.cache\/deja-installer\/install.sh\"\nsh \"$HOME\/.cache\/deja-installer\/install.sh\"\nexport PATH=\"$HOME\/.local\/bin:$PATH\"\n\ndeja index\ndeja search \"connection pool exhausted\"\ndeja doctor\n\n# Opcional: ap\u00f3s backup das configura\u00e7\u00f5es, integre somente estes clientes.\ndeja install claude-code codex<\/code><\/pre>\n<p>Para quien ya tiene Go compatible, <code data-no-translation=\"\">go install github.com\/vshulcz\/deja-vu\/cmd\/deja@v0.22.1<\/code> fija la etiqueta de compilaci\u00f3n; el m\u00f3dulo declara Go 1.25. <code data-no-translation=\"\">deja install --auto<\/code> es la v\u00eda amplia para configurar agentes detectados con sus hooks\/plugins autom\u00e1ticos. No es obligatorio: empezar solo por la CLI permite evaluar la b\u00fasqueda sin alterar las integraciones existentes.<\/p>\n<p>Facilidades \u00fatiles: <code data-no-translation=\"\">deja ctx<\/code> prepara contexto, <code data-no-translation=\"\">deja blame<\/code> encuentra sesiones relacionadas con archivos, <code data-no-translation=\"\">deja how<\/code> muestra invocaciones anteriores, <code data-no-translation=\"\">deja fix<\/code> consulta intentos tras errores y <code data-no-translation=\"\">deja handoff --to codex<\/code> prepara la continuaci\u00f3n en otro agente. El historial es evidencia a revisar, no una orden para ejecutar comandos antiguos.<\/p>\n<p><strong>Madurez:<\/strong> la release <a href=\"https:\/\/github.com\/vshulcz\/deja-vu\/releases\/tag\/v0.22.1\">0.22.1, de 12\/10\/2026<\/a>, ofrece una base extensa de pruebas, CI y documentaci\u00f3n de seguridad. En nuestro laboratorio, funcionaron la compilaci\u00f3n, el an\u00e1lisis est\u00e1tico, la b\u00fasqueda entre dos historiales sint\u00e9ticos y MCP. Tambi\u00e9n reproducimos un fallo de prueba relacionado con la zona horaria de S\u00e3o Paulo, sin evidencia de p\u00e9rdida de notas. Es prometedor para un piloto serio en el escritorio, pero a\u00fan es un proyecto joven en la l\u00ednea 0.x, no una garant\u00eda de estabilidad para todos los clientes.<\/p>\n<p><strong>Privacidad:<\/strong> la b\u00fasqueda por defecto no exige modelo; los embeddings son opcionales y env\u00edan material al endpoint configurado. La sanitizaci\u00f3n reduce la exposici\u00f3n de credenciales, pero no garantiza eliminar todo secreto y no cifra el \u00edndice. Adem\u00e1s, borrar la conversaci\u00f3n en el agente no necesariamente borra la copia ya retenida en Deja Vu. Lea el <a href=\"https:\/\/github.com\/vshulcz\/deja-vu\/blob\/v0.22.1\/docs\/SECURITY-MODEL.md\">modelo de seguridad<\/a> antes de activar la captura amplia.<\/p>\n<p>La instalaci\u00f3n detallada, las pruebas, los l\u00edmites y la evaluaci\u00f3n de madurez est\u00e1n en <a href=\"\/es\/2026\/10\/deja-vu-memoria-dos-agentes-no-linux\/\">Deja Vu: memoria de los agentes en Linux<\/a>.<\/p>\n<h3>mnemo \u2014 el clon m\u00e1s directo<\/h3>\n<p><a href=\"https:\/\/github.com\/kyungw00k\/mnemo\">mnemo<\/a> (MIT, Go 1.23+) es un servidor MCP de memoria con un \u00fanico binario. Base de datos por defecto en <code data-no-translation=\"\">~\/.mnemo\/memory.db<\/code>. Detecta Claude Code, OpenCode y Codex en la primera ejecuci\u00f3n y se registra solo. Tiene panel en <code data-no-translation=\"\">http:\/\/localhost:8765<\/code>.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\">go install github.com\/kyungw00k\/mnemo\/cmd\/mnemo@latest\n\n# hooks do Claude Code (ou deixe o auto-install)\nmnemo hook install --dry-run\nmnemo hook install\n\nmnemo dashboard<\/code><\/pre>\n<p>Los hooks cubren el ciclo que populariz\u00f3 Claude-Mem: <code data-no-translation=\"\">SessionStart<\/code> inyecta decisiones recientes, <code data-no-translation=\"\">PreCompact<\/code> guarda una snapshot, <code data-no-translation=\"\">PostToolUse<\/code> anota el resultado de <code data-no-translation=\"\">Bash<\/code>, <code data-no-translation=\"\">Stop<\/code> cierra la sesi\u00f3n. Los embeddings se comunican con cualquier endpoint compatible con OpenAI \u2014 Ollama por defecto (<code data-no-translation=\"\">nomic-embed-text<\/code>, 768 dimensiones). PostgreSQL + pgvector entran si cambias el <code data-no-translation=\"\">DB_URL<\/code>.<\/p>\n<p>Es la opci\u00f3n m\u00e1s parecida al original en Go. El proyecto a\u00fan es nuevo; tr\u00e1telo como una herramienta \u00fatil, no como un producto maduro de a\u00f1os.<\/p>\n<h3>Engram \u2014 un cerebro para varios agentes<\/h3>\n<p><a href=\"https:\/\/github.com\/Gentleman-Programming\/engram\">Engram<\/a> (MIT) naci\u00f3 inspirado en claude-mem, pero es agent-agnostic: un binario Go, un SQLite con FTS5 en <code data-no-translation=\"\">~\/.engram\/engram.db<\/code>, MCP, HTTP, CLI y TUI. Sin Node, sin Python, sin Docker para ejecutar.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\"># Claude Code\nclaude plugin marketplace add Gentleman-Programming\/engram\nclaude plugin install engram\n\n# Codex, OpenCode, Antigravity, Cursor\u2026\nengram setup codex\nengram setup opencode\nengram setup antigravity-cli\n\nengram tui<\/code><\/pre>\n<p>El contrato con el agente es expl\u00edcito: ori\u00e9ntese con <code data-no-translation=\"\">mem_context<\/code> \/ <code data-no-translation=\"\">mem_search<\/code> antes de repetir trabajo; guarde solo lo que dura (<code data-no-translation=\"\">mem_save<\/code>); cierre la sesi\u00f3n con <code data-no-translation=\"\">mem_session_summary<\/code>. No es un vertedero de transcripts. El README de producci\u00f3n pide el binario de las <a href=\"https:\/\/github.com\/Gentleman-Programming\/engram\/releases\">GitHub Releases<\/a>; Homebrew cubre la l\u00ednea estable.<\/p>\n<p>Si Claude Code, Codex y la CLI de Google necesitan recordar la <em>misma<\/em> decisi\u00f3n, empiece por aqu\u00ed. El paso a paso de instalaci\u00f3n, MCP, nombre de proyecto y systemd est\u00e1 en <a href=\"\/es\/2026\/09\/engram-memoria-persistente-para-agentes-no-linux\/\">Engram: memoria persistente para agentes en Linux<\/a>.<\/p>\n<h3>Goldie: un pool, varios agentes<\/h3>\n<p class=\"translation-block\"><a href=\"https:\/\/github.com\/srfrog\/goldie-mcp\">Goldie<\/a> (MIT) cambia el <code>MEMORY.md<\/code> por un archivo SQLite compartido. Herramientas en el vocabulario adecuado: <code>remember<\/code>, <code>recall<\/code>, <code>update_memory<\/code>, <code>forget<\/code>. Memorias tipadas (<code>user<\/code>, <code>feedback<\/code>, <code>project<\/code>, <code>reference<\/code>\u2026), grafo de conceptos, embeddings locales mediante MiniLM (ONNX Runtime) u Ollama.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\"># Linux amd64 \u2014 pegue o bin\u00e1rio da release\ncurl -LO https:\/\/github.com\/srfrog\/goldie-mcp\/releases\/latest\/download\/goldie-mcp-linux-amd64\nchmod +x goldie-mcp-linux-amd64\nmv goldie-mcp-linux-amd64 ~\/.local\/bin\/goldie-mcp\n\n# MiniLM precisa do ONNX Runtime\nsudo apt install libonnxruntime-dev   # Debian\/Ubuntu\n\n# ou pule o ONNX e use Ollama\nollama pull nomic-embed-text\nclaude mcp add -s user -e GOLDIE_DB_PATH=~\/.local\/share\/goldie\/index.db goldie goldie-mcp -- -b ollama<\/code><\/pre>\n<p>El \u201calcance\u201d es el archivo. Dos agentes en el mismo <code data-no-translation=\"\">GOLDIE_DB_PATH<\/code> comparten la memoria. No escriba desde dos m\u00e1quinas a la vez si <code data-no-translation=\"\">.db<\/code> est\u00e1 en Syncthing \u2014 el README es honesto al respecto.<\/p>\n<h2>Rust: del binario \u00fanico al servidor de memoria<\/h2>\n<h3>ai-memory: wiki versionada y pase de relevo<\/h3>\n<p><a href=\"https:\/\/github.com\/akitaonrails\/ai-memory\">ai-memory<\/a> (MIT, Rust) es la opci\u00f3n m\u00e1s estructurada de esta parte de la lista. En lugar de que cada agente escriba directamente en la base de datos, un servidor es el \u00fanico escritor: recibe observaciones saneadas por los hooks, mantiene un wiki Markdown versionado en Git como fuente de verdad y usa SQLite como \u00edndice derivado (FTS5, entidades y vectores opcionales).<\/p>\n<p>El flujo es <em>capturar \u2192 consolidar \u2192 recuperar \u2192 entregar<\/em>. Al final de la sesi\u00f3n, las observaciones pueden convertirse en p\u00e1ginas legibles del wiki; en la siguiente, el agente recibe un handoff limitado y puede buscar en el historial. Captura, b\u00fasqueda y handoff funcionan sin clave ni llamada a un LLM; configurar un proveedor solo a\u00f1ade consolidaci\u00f3n y b\u00fasqueda sem\u00e1ntica. Es una diferencia importante respecto a Engram y Leteo: ai-memory es un servicio local v\u00eda HTTP\/MCP, no solo un proceso que abre un SQLite.<\/p>\n<p>La ruta documentada para Linux es Docker o Podman. Quien ya use <code data-no-translation=\"\">mise<\/code> puede descargar el binario de release con checksum, sin instalar Rust:<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\">mise use -g github:akitaonrails\/ai-memory\n\n# uma vez: cria o estado local; depois sobe MCP + API + hooks HTTP\nai-memory init\nai-memory serve --transport http --bind 127.0.0.1:49374\n\n# em outro terminal, registre MCP e hooks para o cliente escolhido\nai-memory install-mcp --client claude-code --apply\nai-memory install-hooks --agent claude-code --apply\n\n# para o Codex, troque claude-code por codex nos dois comandos<\/code><\/pre>\n<p>Claude Code, Codex, OpenCode, Gemini CLI, Grok Build y varios otros clientes tienen integraci\u00f3n de primera parte. En una sola m\u00e1quina, el servidor escucha en el loopback; para un equipo o homelab, puede estar en un host compartido con autenticaci\u00f3n y HTTPS. Elija ai-memory cuando la prioridad sea la transici\u00f3n expl\u00edcita entre Claude, Codex y otros agentes \u2014 o cuando quiera inspeccionar y versionar la memoria como Markdown. Para un SQLite directo y una configuraci\u00f3n m\u00e1s peque\u00f1a, Engram y Leteo siguen siendo m\u00e1s sencillos.<\/p>\n<h3>Leteo: el Engram en Rust<\/h3>\n<p><a href=\"https:\/\/github.com\/asanabrial\/leteo\">Leteo<\/a> (MIT) es un producto independiente en Rust derivado del flujo y la implementaci\u00f3n MIT de Engram. Un binario, SQLite en <code data-no-translation=\"\">~\/.leteo\/leteo.db<\/code>, sin API key, sin servidor. Importa la base de datos de Engram con <code data-no-translation=\"\">leteo import --from-engram<\/code>.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\">curl -fsSL https:\/\/raw.githubusercontent.com\/asanabrial\/leteo\/main\/scripts\/install.sh | sh\nleteo tui\nleteo setup claude-code --hooks\nleteo setup codex<\/code><\/pre>\n<p>Los archivos de las releases de Linux requieren glibc 2.34 \u2014 Debian 12, Ubuntu 22.04, RHEL 9 o m\u00e1s reciente. Plugin de Claude Code: <code data-no-translation=\"\">\/plugin marketplace add asanabrial\/leteo<\/code> e <code data-no-translation=\"\">\/plugin install leteo@leteo<\/code>. No registre plugin <em>e<\/em> <code data-no-translation=\"\">leteo setup --hooks<\/code> al mismo tiempo: cada evento se dispara dos veces.<\/p>\n<h3>Subcog: b\u00fasqueda h\u00edbrida de verdad<\/h3>\n<p><a href=\"https:\/\/github.com\/zircote\/subcog\">Subcog<\/a> (MIT, Rust 1.88+) apila tres capas: SQLite como fuente de verdad, FTS5 (BM25) y vectores HNSW mediante usearch. Embeddings con <code data-no-translation=\"\">all-MiniLM-L6-v2<\/code> mediante fastembed, 384 dimensiones, sin llamar a la API. Fusi\u00f3n RRF. Knowledge graph con entidades y relaciones.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\">cargo install subcog\n# ou: brew install zircote\/tap\/subcog\n\nsubcog capture --namespace decisions \"Use PostgreSQL por causa do ACID\"\nsubcog recall \"decis\u00e3o de banco\"\nsubcog serve<\/code><\/pre>\n<p>Hooks de Claude Code: <code data-no-translation=\"\">SessionStart<\/code>, <code data-no-translation=\"\">UserPromptSubmit<\/code>, <code data-no-translation=\"\">PostToolUse<\/code>, <code data-no-translation=\"\">PreCompact<\/code>, <code data-no-translation=\"\">Stop<\/code>. Es la opci\u00f3n si \u201crecordar\u201d necesita ser b\u00fasqueda sem\u00e1ntica, no solo grep en SQLite.<\/p>\n<h3>mcp-memory: grafo + c\u00f3digo en el mismo binario<\/h3>\n<p><a href=\"https:\/\/github.com\/corporatepiyush\/mcp-memory\">mcp-memory<\/a> (Apache-2.0) re\u00fane knowledge graph, FTS5, vector (usearch HNSW) e indexaci\u00f3n tree-sitter en Rust, Python, JS\/TS, Go, Java, C, C++, Ruby y PHP. Las tools entran por categor\u00eda: nada se expone hasta que pases <code data-no-translation=\"\">--enable-graph-read<\/code> \/ <code data-no-translation=\"\">--enable-code<\/code> \/ <code data-no-translation=\"\">--enable-all<\/code>.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\">cargo install mcp-memory\nmcp-memory --transport stdio --enable-all<\/code><\/pre>\n<p>\u00datil cuando quieres <em>un<\/em> proceso recordando entidades del proyecto <em>e<\/em> el mapa de s\u00edmbolos. No sustituye a codebase-memory-mcp a escala de kernel, pero cabe en un port\u00e1til sin daemon extra.<\/p>\n<h3>mcp-memory-rs: cuaderno local, sin ML<\/h3>\n<p><a href=\"https:\/\/github.com\/DioNanos\/mcp-memory-rs\">mcp-memory-rs<\/a> (Apache-2.0) guarda el estado del agente en JSON por categor\u00eda, con \u00edndice SQLite FTS5. Cada escritura est\u00e1 versionada. Sin descarga de modelo, sin embedding. La sincronizaci\u00f3n entre m\u00e1quinas es un paso expl\u00edcito (manifest Merkle + HTTP), nunca una dependencia oculta.<\/p>\n<p>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\u00f1ala el companion <code data-no-translation=\"\">mcp-vl-msa-rs<\/code> \u2014 este es el cuaderno, no la biblioteca.<\/p>\n<h3>memory-server: cuando la memoria es un servicio<\/h3>\n<p><a href=\"https:\/\/github.com\/tokarix\/memory-server\">memory-server<\/a> separa las piezas: el agente habla MCP con <code data-no-translation=\"\">memory-mcp<\/code>, que llama <code data-no-translation=\"\">memoryd<\/code> por HTTP, que escribe en PostgreSQL + pgvector y solicita embedding a Ollama (<code data-no-translation=\"\">bge-m3<\/code> por defecto).<\/p>\n<pre data-no-translation=\"\"><code class=\"language-text\" data-no-translation=\"\">agent  --stdio--&gt;  memory-mcp  --HTTP--&gt;  memoryd\n                                           |-- PostgreSQL + pgvector\n                                           +-- Ollama<\/code><\/pre>\n<p>Categor\u00edas fijas: <code data-no-translation=\"\">context<\/code>, <code data-no-translation=\"\">decision<\/code>, <code data-no-translation=\"\">error_fix<\/code>, <code data-no-translation=\"\">plan<\/code>, <code data-no-translation=\"\">rule<\/code>. Tiene sentido cuando port\u00e1til y servidor necesitan el mismo almac\u00e9n \u2014 y aceptas operar Postgres 17 con pgvector. Para un \u00fanico usuario en el port\u00e1til, es matar moscas a ca\u00f1onazos.<\/p>\n<h2>C: extensi\u00f3n SQLite y grafo del repositorio<\/h2>\n<h3>sqlite-memory: memoria como SQL<\/h3>\n<p><a href=\"https:\/\/github.com\/sqliteai\/sqlite-memory\">sqlite-memory<\/a> (MIT) es una extensi\u00f3n en C: Markdown como fuente de verdad, fragmentaci\u00f3n consciente del encabezado, b\u00fasqueda h\u00edbrida (vectorial + FTS5), embeddings locales con <a href=\"\/es\/2026\/09\/llama-cpp-primeiros-passos\/\">llama.cpp<\/a>. Forma parte de la familia SQLite AI (<code data-no-translation=\"\">sqlite-vector<\/code>, <code data-no-translation=\"\">sqlite-sync<\/code>, <code data-no-translation=\"\">sqlite-mcp<\/code>\u2026).<\/p>\n<pre data-no-translation=\"\"><code class=\"language-sql\" data-no-translation=\"\">.load .\/vector\n.load .\/memory\nSELECT memory_set_model('local', '\/path\/to\/nomic-embed-text-v1.5.Q8_0.gguf');\nSELECT memory_add_directory('\/path\/to\/docs', 'project-docs');\nSELECT path, snippet, ranking FROM memory_search\n WHERE query = 'como o agente persiste contexto';<\/code><\/pre>\n<p>El CLI en Go, <code data-no-translation=\"\">sqlmem<\/code>, envuelve esto en un proyecto (<code data-no-translation=\"\">sqlmem init<\/code>, <code data-no-translation=\"\">add<\/code>, <code data-no-translation=\"\">search<\/code>) y expone las tools v\u00eda MCP. Es el camino si quieres construir tu propia capa, no instalar un producto listo. La sincronizaci\u00f3n entre agentes usa CRDT de <code data-no-translation=\"\">sqlite-sync<\/code> \u2014 cada uno trabaja offline y fusiona despu\u00e9s.<\/p>\n<h3>codebase-memory-mcp: la otra memoria<\/h3>\n<p class=\"translation-block\"><a href=\"https:\/\/github.com\/DeusData\/codebase-memory-mcp\">codebase-memory-mcp<\/a> (MIT, C puro) <strong>no<\/strong> es una alternativa a Claude-Mem. Indexa el repositorio en un knowledge graph: funciones, clases, rutas HTTP, qui\u00e9n llama a qui\u00e9n. Tree-sitter, 15 tools MCP, binario nativo. El preprint est\u00e1 en arXiv <a href=\"https:\/\/arxiv.org\/abs\/2603.27277\">2603.27277<\/a>.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-bash\" data-no-translation=\"\">curl -fsSL https:\/\/raw.githubusercontent.com\/DeusData\/codebase-memory-mcp\/main\/install.sh | bash\n# reinicie o agente e pe\u00e7a: index this project<\/code><\/pre>\n<p>Preguntas que responde y el grep no: \u201c\u00bfqui\u00e9n llama a esta funci\u00f3n?\u201d, \u201c\u00bfcu\u00e1l es el radio de explosi\u00f3n de este diff?\u201d, \u201c\u00bfd\u00f3nde se implementa esta interfaz?\u201d. Detalles de uso en el post de <a href=\"\/es\/2026\/09\/vibe-coding-linux-skills-ia-cli\/\">skills de IA en la CLI<\/a>. El caso feliz es <em>los dos<\/em> en el mismo agente: uno recuerda la conversaci\u00f3n, el otro recuerda el c\u00f3digo.<\/p>\n<h2>C++: a\u00fan no hay un clon listo<\/h2>\n<p>Entre los proyectos de esta lista, no aparece un equivalente maduro a Claude-Mem cuya implementaci\u00f3n principal sea C++. Lo que existe en C++ entra como pieza \u2014 <code data-no-translation=\"\">llama.cpp<\/code> para embedding, SQLite, \u00edndices vectoriales \u2014 no como producto de memoria de sesi\u00f3n. El codebase-memory-mcp analiza C\/C++ muy bien; sin embargo, su binario es C.<\/p>\n<h2>Por d\u00f3nde probar en Linux<\/h2>\n<p>Orden pr\u00e1ctico para Claude Code + Codex + lo que est\u00e9 en <code data-no-translation=\"\">PATH<\/code>:<\/p>\n<ol>\n<li><strong>D\u00e9j\u00e0 Vu (Go)<\/strong> \u2014 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\u00fasqueda bajo demanda; habilite la automatizaci\u00f3n despu\u00e9s de evaluar el alcance y la privacidad.<\/li>\n<li><strong>ai-memory (Rust)<\/strong> \u2014 cuando el punto principal es el handoff autom\u00e1tico entre Claude, Codex y otros agentes, con wiki en Markdown versionada y un servidor local.<\/li>\n<li><strong>Engram (Go)<\/strong> \u2014 un banco, varios agentes, TUI para inspeccionar lo que se ha grabado.<\/li>\n<li><strong>mnemo (Go)<\/strong> \u2014 si lo que quieres es el ciclo de hooks de Claude-Mem, sin cambiar de filosof\u00eda.<\/li>\n<li><strong>Leteo (Rust)<\/strong> \u2014 el mismo flujo que Engram, binario Rust, importa el <code data-no-translation=\"\">.db<\/code> de \u00e9l.<\/li>\n<li><strong>Subcog (Rust)<\/strong> \u2014 cuando la b\u00fasqueda necesita vector + BM25 de verdad.<\/li>\n<li><strong>mcp-memory (Rust)<\/strong> \u2014 si quieres grafo + \u00edndice de c\u00f3digo en el mismo proceso.<\/li>\n<li><strong>Goldie (Go)<\/strong> \u2014 pool compartido, vocabulario <code data-no-translation=\"\">remember<\/code>\/<code data-no-translation=\"\">recall<\/code>.<\/li>\n<li><strong>sqlite-memory (C)<\/strong> \u2014 si la idea es montar tu propia capa encima de SQLite.<\/li>\n<\/ol>\n<p>Y, en paralelo, no en su lugar: <strong>codebase-memory-mcp<\/strong>.<\/p>\n<pre data-no-translation=\"\"><code class=\"language-text\" data-no-translation=\"\">          Claude Code \/ Codex \/ OpenCode\n                       |\n              +--------+--------+\n              |                 |\n              v                 v\n     mem\u00f3ria de sess\u00e3o    mem\u00f3ria do c\u00f3digo\n     Engram \/ mnemo \/     codebase-memory-mcp\n     Leteo \/ Subcog              |\n              |                  v\n              v            knowledge graph\n         SQLite + FTS5         (tree-sitter)\n              |\n              +--------+--------+\n                       v\n              contexto persistente<\/code><\/pre>\n<p>As\u00ed, el agente de la ma\u00f1ana siguiente ya sabe que la autenticaci\u00f3n es JWT con refresh, <em>e<\/em> lograr se\u00f1alar el <code data-no-translation=\"\">handler.go<\/code> sin releer el repo.<\/p>\n<h2>Qu\u00e9 no externalizar<\/h2>\n<p>La memoria persistente no es una copia de seguridad de la verdad. Git sigue siendo el registro; la historia est\u00e1 en <a href=\"\/es\/2026\/09\/a-historia-do-git\/\">La historia de Git<\/a>. Lo que va a SQLite es decisi\u00f3n, convenci\u00f3n, bug costoso \u2014 no contrase\u00f1a, no token, no dump de <code data-no-translation=\"\">journalctl<\/code>. Los proyectos serios tienen etiqueta <code data-no-translation=\"\">&lt;private&gt;<\/code> o filtro de secretos; si lo que elegiste no lo tiene, no guardes lo que no puede filtrarse.<\/p>\n<p>Evite instalar varios mecanismos de auto-recall en el mismo agente \u201cpara garantizar\u201d: pueden duplicar contexto y decisiones. Una combinaci\u00f3n m\u00e1s controlable es una fuente principal de memoria duradera, el grafo del c\u00f3digo y, cuando tenga sentido, Deja Vu como consulta retroactiva bajo demanda. Active m\u00e1s automatizaci\u00f3n solo si la ganancia justifica el coste de contexto.<\/p>\n<h2>Cerrando<\/h2>\n<p>Claude-Mem mostr\u00f3 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\u00f1ade b\u00fasqueda retroactiva en transcripciones existentes, con su propio \u00edndice; Rust tambi\u00e9n tiene la ruta de servidor + wiki versionada de ai-memory. C entrega la extensi\u00f3n y el grafo del c\u00f3digo. C++ sigue siendo pieza, no producto. Elija por la pregunta que duele hoy \u2014 \u201cel agente olvid\u00f3 la decisi\u00f3n\u201d, \u201cnecesito pasar el trabajo a otro agente\u201d o \u201cel agente no encuentra la funci\u00f3n\u201d \u2014 y coloque solo la herramienta que responde a esa pregunta.<\/p>\n<p>Repositorios: <a href=\"https:\/\/github.com\/thedotmack\/claude-mem\">claude-mem<\/a> \u00b7 <a href=\"https:\/\/github.com\/vshulcz\/deja-vu\">Deja Vu<\/a> \u00b7 <a href=\"https:\/\/github.com\/kyungw00k\/mnemo\">mnemo<\/a> \u00b7 <a href=\"https:\/\/github.com\/Gentleman-Programming\/engram\">Engram<\/a> \u00b7 <a href=\"https:\/\/github.com\/akitaonrails\/ai-memory\">ai-memory<\/a> \u00b7 <a href=\"https:\/\/github.com\/srfrog\/goldie-mcp\">Goldie<\/a> \u00b7 <a href=\"https:\/\/github.com\/asanabrial\/leteo\">Leteo<\/a> \u00b7 <a href=\"https:\/\/github.com\/zircote\/subcog\">Subcog<\/a> \u00b7 <a href=\"https:\/\/github.com\/corporatepiyush\/mcp-memory\">mcp-memory<\/a> \u00b7 <a href=\"https:\/\/github.com\/DioNanos\/mcp-memory-rs\">mcp-memory-rs<\/a> \u00b7 <a href=\"https:\/\/github.com\/tokarix\/memory-server\">memory-server<\/a> \u00b7 <a href=\"https:\/\/github.com\/sqliteai\/sqlite-memory\">sqlite-memory<\/a> \u00b7 <a href=\"https:\/\/github.com\/DeusData\/codebase-memory-mcp\">codebase-memory-mcp<\/a>. Documentaci\u00f3n: <a href=\"https:\/\/docs.claude-mem.ai\/\">docs.claude-mem.ai<\/a> \u00b7 <a href=\"https:\/\/engram.gentlemanprogramming.com\/\">engram.gentlemanprogramming.com<\/a>.<\/p>\n<p style=\"font-size:.9em;opacity:.75\">Gopher de Go dibujado por Ren\u00e9e French (CC BY 3.0). Ferris, la mascota no oficial de Rust, por Karen Rustad T\u00f6lva.<\/p>","protected":false},"excerpt":{"rendered":"<p>Compara alternativas a Claude-Mem en Go, Rust y C: Deja Vu para buscar historiales ya guardados, Engram, ai-memory, mnemo, Leteo, Subcog y otras opciones.<\/p>","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[45,115,2],"tags":[394,408,544,31,116,311,427,158,407],"class_list":["post-981","post","type-post","status-publish","format-standard","hentry","category-desenv","category-ia","category-linux","tag-agentes","tag-claude-mem","tag-deja-vu","tag-golang","tag-ia","tag-mcp","tag-memoria-persistente","tag-rust","tag-sqlite"],"_links":{"self":[{"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/posts\/981","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/comments?post=981"}],"version-history":[{"count":5,"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/posts\/981\/revisions"}],"predecessor-version":[{"id":1865,"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/posts\/981\/revisions\/1865"}],"wp:attachment":[{"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/media?parent=981"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/categories?post=981"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.linuxpro.com.br\/es\/wp-json\/wp\/v2\/tags?post=981"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}