O agente de terminal é ótimo até a sessão acabar. Na seguinte, ele redescobre o mesmo bug, relê o mesmo README e pergunta de novo se a API usa JWT. O claude-mem resolve isso — captura o que o agente fez, comprime e devolve o pedaço certo no SessionStart. Só que ele é TypeScript, Node, Bun e um worker à parte. Se a sua máquina já vive de binário único em Go, Rust ou C, dá para ter a mesma ideia sem a pilha JS.
Este post mapeia as alternativas nativas que realmente existem hoje: memória de sessão (decisões, bugs, convenções) e memória do código (quem chama quem). Não são clones. Alguns falam MCP, outros instalam hooks, um é extensão do SQLite. O mapa dos agentes no terminal continua em Assistentes de IA no terminal Linux; o encaixe do claude-mem no fluxo de vibe coding está em Vibe coding no Linux.
O que o Claude-Mem faz — e o que as alternativas tentam copiar
O repositório ainda é thedotmack/claude-mem, licença Apache-2.0. Em 2026 o produto também se chama Grok Mem; o pacote npm continua claude-mem. A peça que importa para comparar:
- hooks de ciclo de vida (
SessionStart,PostToolUse,PreCompact,Stop); - SQLite + busca (FTS5 e vetor);
- MCP para o agente consultar a memória sob demanda;
- injeção de contexto no começo da sessão, sem você pedir “lembra o que combinamos”.
Quem troca o stack quer, no fundo, essas quatro coisas num binário local, com o banco num arquivo que você controla. Embeddings, quando existem, apontam para Ollama ou para um modelo embutido — nada precisa sair da máquina.
Tabela rápida
| Projeto | Linguagem | Banco | MCP | Perfil |
|---|---|---|---|---|
| mnemo | Go | SQLite (pgvector opcional) | stdio / SSE | O mais próximo do Claude-Mem em Go |
| Engram | Go | SQLite + FTS5 | sim | Memória multi-agente, CLI, TUI, HTTP |
| Goldie | Go | SQLite + vetor | sim | Pool compartilhado entre agentes |
| Leteo | Rust | SQLite | 22 tools | Binário único + hooks, derivado do Engram |
| Subcog | Rust | SQLite + FTS5 + HNSW | sim | Busca híbrida + knowledge graph |
| mcp-memory | Rust | SQLite | sim | Grafo + vetor + indexação de código |
| mcp-memory-rs | Rust | JSON + SQLite FTS5 | sim | Local-first, versionado, sem embedding |
| memory-server | Rust | PostgreSQL + pgvector | sim | Serviço centralizado + Ollama |
| sqlite-memory | C | SQLite | via sqlmem / sqlite-mcp | Extensão, Markdown + busca híbrida |
| codebase-memory-mcp | C | SQLite | sim | Grafo do código, não da conversa |
Go: três binários, três jeitos de lembrar
mnemo — o clone mais direto
mnemo (MIT, Go 1.23+) é um servidor MCP de memória com um único binário. Banco padrão em ~/.mnemo/memory.db. Detecta Claude Code, OpenCode e Codex na primeira execução e se registra sozinho. Tem dashboard em 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 dashboardOs hooks cobrem o ciclo que o Claude-Mem popularizou: SessionStart injeta decisões recentes, PreCompact grava um snapshot, PostToolUse anota resultado de Bash, Stop fecha a sessão. Embeddings falam com qualquer endpoint OpenAI-compatible — Ollama no default (nomic-embed-text, 768 dimensões). PostgreSQL + pgvector entram se você trocar o DB_URL.
É a opção mais parecida com o original em Go. O projeto ainda é novo; trate como ferramenta útil, não como produto maduro de anos.
Engram — um cérebro para vários agentes
Engram (MIT) nasceu inspirado no claude-mem, mas é agent-agnostic: um binário Go, um SQLite com FTS5 em ~/.engram/engram.db, MCP, HTTP, CLI e TUI. Sem Node, sem Python, sem Docker para rodar.
# 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 tuiO contrato com o agente é explícito: oriente-se com mem_context / mem_search antes de repetir trabalho; grave só o que dura (mem_save); feche a sessão com mem_session_summary. Não é lixeira de transcript. O README de produção pede o binário das GitHub Releases; o Homebrew cobre a linha estável.
Se Claude Code, Codex e o CLI do Google precisam lembrar a mesma decisão, comece por aqui.
Goldie — um pool, vários agentes
Goldie (MIT) troca o MEMORY.md por arquivo de um SQLite compartilhado. Ferramentas no vocabulário certo: remember, recall, update_memory, forget. Memórias tipadas (user, feedback, project, reference…), grafo de conceitos, embeddings locais via MiniLM (ONNX Runtime) ou 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 ollamaO “escopo” é o arquivo. Dois agentes no mesmo GOLDIE_DB_PATH compartilham a memória. Não escreva de duas máquinas ao mesmo tempo se o .db estiver no Syncthing — o README é honesto sobre isso.
Rust: do binário único ao serviço com Postgres
Leteo — o Engram em Rust
Leteo (MIT) é um produto independente em Rust derivado do fluxo e da implementação MIT do Engram. Um binário, SQLite em ~/.leteo/leteo.db, sem API key, sem servidor. Importa o banco do Engram com 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 codexOs arquivos das releases Linux pedem glibc 2.34 — Debian 12, Ubuntu 22.04, RHEL 9 ou mais novo. Plugin do Claude Code: /plugin marketplace add asanabrial/leteo e /plugin install leteo@leteo. Não registre plugin e leteo setup --hooks ao mesmo tempo: cada evento dispara duas vezes.
Subcog — busca híbrida de verdade
Subcog (MIT, Rust 1.88+) empilha três camadas: SQLite como fonte da verdade, FTS5 (BM25) e vetores HNSW via usearch. Embeddings com all-MiniLM-L6-v2 pelo fastembed, 384 dimensões, sem chamar API. Fusão RRF. Knowledge graph com entidades e relações.
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 do Claude Code: SessionStart, UserPromptSubmit, PostToolUse, PreCompact, Stop. É a opção se “lembrar” precisa ser busca semântica, não só grep no SQLite.
mcp-memory — grafo + código no mesmo binário
mcp-memory (Apache-2.0) junta knowledge graph, FTS5, vetor (usearch HNSW) e indexação tree-sitter em Rust, Python, JS/TS, Go, Java, C, C++, Ruby e PHP. Tools entram por categoria: nada é exposto até você passar --enable-graph-read / --enable-code / --enable-all.
cargo install mcp-memory
mcp-memory --transport stdio --enable-allÚtil quando você quer um processo lembrando entidades do projeto e o mapa de símbolos. Não substitui o codebase-memory-mcp em escala de kernel, mas cabe num laptop sem daemon extra.
mcp-memory-rs — caderno local, sem ML
mcp-memory-rs (Apache-2.0) guarda estado do agente em JSON por categoria, com índice SQLite FTS5. Cada escrita é versionada. Sem download de modelo, sem embedding. Sync entre máquinas é passo explícito (manifest Merkle + HTTP), nunca dependência escondida.
O default offline é o ponto: Claude Code e Codex apontam para o mesmo binário e o estado sobrevive à troca de modelo. Para corpus (documentos chunkados) o autor aponta o companion mcp-vl-msa-rs — este aqui é o caderno, não a biblioteca.
memory-server — quando a memória é um serviço
memory-server separa as peças: o agente fala MCP com memory-mcp, que chama memoryd por HTTP, que grava em PostgreSQL + pgvector e pede embedding ao Ollama (bge-m3 no default).
agent --stdio--> memory-mcp --HTTP--> memoryd
|-- PostgreSQL + pgvector
+-- OllamaCategorias fixas: context, decision, error_fix, plan, rule. Faz sentido quando laptop e servidor precisam do mesmo store — e você aceita operar Postgres 17 com pgvector. Para um único usuário no notebook, é tiro de canhão.
C: extensão SQLite e grafo do repositório
sqlite-memory — memória como SQL
sqlite-memory (MIT) é extensão C: Markdown como fonte da verdade, chunking consciente de heading, busca híbrida (vetor + FTS5), embeddings locais com llama.cpp. Faz parte da família 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';O CLI em Go, sqlmem, embrulha isso em projeto (sqlmem init, add, search) e expõe as tools via MCP. É o caminho se você quer construir a sua camada, não instalar um produto pronto. Sync entre agentes usa CRDT do sqlite-sync — cada um trabalha offline e mescla depois.
codebase-memory-mcp — a outra memória
codebase-memory-mcp (MIT, C puro) não é alternativa ao Claude-Mem. Indexa o repositório num knowledge graph: funções, classes, rotas HTTP, quem chama quem. Tree-sitter, 15 tools MCP, binário nativo. O preprint está no 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 projectPerguntas que ele responde e o grep não: “quem chama esta função?”, “qual o raio de explosão deste diff?”, “onde esta interface é implementada?”. Detalhes de uso no post de skills de IA no CLI. O caso feliz é os dois no mesmo agente: um lembra a conversa, o outro lembra o código.
C++: ainda não há o clone pronto
Entre os projetos desta lista, não aparece um equivalente maduro ao Claude-Mem cuja implementação principal seja C++. O que existe em C++ entra como peça — llama.cpp para embedding, SQLite, índices vetoriais — não como produto de memória de sessão. O codebase-memory-mcp analisa C/C++ muito bem; o binário dele, porém, é C.
Por onde testar no Linux
Ordem prática para Claude Code + Codex + o que mais estiver no PATH:
- Engram (Go) — um banco, vários agentes, TUI para inspecionar o que foi gravado.
- mnemo (Go) — se o que você quer é o ciclo de hooks do Claude-Mem, sem trocar de filosofia.
- Leteo (Rust) — o mesmo fluxo do Engram, binário Rust, importa o
.dbdele. - Subcog (Rust) — quando a busca precisa de vetor + BM25 de verdade.
- mcp-memory (Rust) — se quiser grafo + índice de código no mesmo processo.
- Goldie (Go) — pool compartilhado, vocabulário
remember/recall. - sqlite-memory (C) — se a ideia é montar a sua camada em cima do SQLite.
E, em paralelo, não no 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 persistenteAssim o agente da manhã seguinte já sabe que a autenticação é JWT com refresh, e consegue apontar o handler.go sem reler o repo.
O que não terceirizar
Memória persistente não é backup da verdade. O git continua sendo o registro; a história está em A história do Git. O que vai para o SQLite é decisão, convenção, bug caro — não senha, não token, não dump de journalctl. Projetos sérios têm tag <private> ou filtro de segredo; se o que você escolheu não tiver, não grave o que não pode vazar.
E não instale três servidores de memória no mesmo agente “para garantir”. Eles competem pelo contexto. Um de sessão + o grafo do código já é o teto útil.
Fechando
O Claude-Mem mostrou o formato: hook no ciclo de vida, SQLite no disco, MCP na consulta. Go e Rust já entregam isso em binário único; C entrega a extensão e o grafo do código. C++ ainda é peça, não produto. Escolha pela pergunta que dói hoje — “o agente esqueceu a decisão” ou “o agente não acha a função” — e coloque só a ferramenta que responde essa pergunta.
Repositórios: claude-mem · mnemo · Engram · Goldie · Leteo · Subcog · mcp-memory · mcp-memory-rs · memory-server · sqlite-memory · codebase-memory-mcp. Docs: docs.claude-mem.ai · engram.gentlemanprogramming.com.