The terminal agent is great until the session ends. In the next one, it rediscovers the same bug, rereads the same README, and asks again if the API uses JWT. The claude-mem solve this one — captures what the agent did, compresses it, and returns the right chunk at SessionStart. Only it's TypeScript, Node, Bun, and a separate worker. If your machine already runs on a single binary in Go, Rust or C, you can have the same idea without the JS stack.
This post maps the native alternatives that actually exist today: session memory (decisions, bugs, conventions) and code memory (who calls who). They're not clones. Some speak MCP over stdio, others use HTTP, install hooks, or become SQLite extensions. The map of terminal agents continues at AI assistants on the Linux terminal; the fit of claude-mem into the vibe coding flow is at Vibe coding on Linux.
What Claude-Mem does — and what the alternatives try to copy
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.
Quick table
| 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 |
| ai-memory | Rust | Wiki Markdown + SQLite | sim (HTTP) | Servidor local, hooks e handoff 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: three binaries, three ways to remember
mnemo — the most direct clone
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 — one brain for multiple agents
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. O passo a passo de instalação, MCP, nome de projeto e systemd está em Engram: persistent memory for agents on Linux.
Goldie — one pool, multiple agents
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: from single binary to memory server
ai-memory — versioned wiki and handoff
ai-memory (MIT, Rust) é a opção mais estruturada desta parte da lista. Em vez de cada agente escrever direto no banco, um servidor é o único escritor: ele recebe observações sanitizadas pelos hooks, mantém uma wiki Markdown versionada em Git como fonte da verdade e usa SQLite como índice derivado (FTS5, entidades e vetores opcionais).
O fluxo é capturar → consolidar → recuperar → entregar. No fim da sessão, as observações podem virar páginas legíveis da wiki; na próxima, o agente recebe um handoff limitado e pode buscar o histórico. Captura, busca e handoff funcionam sem chave nem chamada de LLM; configurar um provedor apenas acrescenta consolidação e busca semântica. É uma diferença importante em relação ao Engram e ao Leteo: ai-memory é um serviço local via HTTP/MCP, não só um processo que abre um SQLite.
O caminho documentado para Linux é Docker ou Podman. Quem já usa mise pode baixar o binário de release com checksum, sem 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 e vários outros clientes têm integração de primeira parte. Em uma máquina só, o servidor escuta no loopback; para uma equipe ou homelab, ele pode ficar num host compartilhado com autenticação e HTTPS. Escolha ai-memory quando a prioridade for a transição explícita entre Claude, Codex e outros agentes — ou quando quiser inspecionar e versionar a memória como Markdown. Para um SQLite direto e um setup menor, Engram e Leteo continuam mais simples.
Leteo — the Engram in 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 and /plugin install leteo@leteo. Não registre plugin and leteo setup --hooks ao mesmo tempo: cada evento dispara duas vezes.
Subcog — true hybrid search
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 — graph + code in the same binary
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 a processo lembrando entidades do projeto and 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 — local notebook, no 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 — when memory is a service
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: SQLite extension and repository graph
sqlite-memory — memory as 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 — the other memory
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 AI skills in the CLI. O caso feliz é os dois no mesmo agente: um lembra a conversa, o outro lembra o código.
C++: the clone isn't ready yet
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:
- ai-memory (Rust) — quando o ponto principal é handoff automático entre Claude, Codex e outros agentes, com wiki Markdown versionada e um servidor local.
- 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, and 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.
Closing
O Claude-Mem mostrou o formato: hook no ciclo de vida, estado local e MCP na consulta. Go e Rust já entregam isso em binário único; Rust também tem o caminho de servidor + wiki versionada do ai-memory. 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”, “preciso passar o trabalho para outro agente” ou “o agente não acha a função” — e coloque só a ferramenta que responde essa pergunta.
Repositórios: claude-mem · mnemo · Engram · ai-memory · Goldie · Leteo · Subcog · mcp-memory · mcp-memory-rs · memory-server · sqlite-memory · codebase-memory-mcp. Docs: docs.claude-mem.ai · engram.gentlemanprogramming.com.
Gopher do Go desenhado por Renée French (CC BY 3.0). Ferris, mascote extraoficial do Rust, por Karen Rustad Tölva.