Alternativas ao Claude-Mem em Go, Rust e C

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), busca retroativa nos históricos dos agentes e memória do código (quem chama quem). Não são clones. Alguns falam MCP por stdio, outros usam HTTP, instalam hooks ou viram 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 de referência é thedotmack/claude-mem, apresentado pelo projeto como Claude-Mem, sob licença Apache-2.0. O ponto de comparação é o fluxo de memória, não apenas a linguagem de implementação:

• 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 capacidades com menos peças para operar. O armazenamento pode ser SQLite, uma wiki ou um índice próprio. Embeddings podem usar Ollama ou outro endpoint; conferir o destino é essencial. Mesmo com busca local, trechos recuperados por um agente em nuvem podem entrar no contexto enviado ao provedor.

Tabela rápida

Go: quatro binários, diferentes jeitos de lembrar

Deja Vu — os históricos que você já tem viram memória

Deja Vu (MIT, Go) parte de uma diferença importante: Claude Code, Codex, Cursor e outros agentes já deixam históricos no disco. O comando deja lê essas fontes e cria busca retroativa, mesmo para sessões anteriores à instalação. Você não precisa esperar que novos hooks acumulem semanas de trabalho para começar.

O índice padrão, ~/.cache/deja/index.db, é um diretório de arquivos binários próprios, não um banco SQLite. Há busca lexical, filtros, CLI, TUI, servidor MCP por stdio e integração automática opcional. Fontes que guardam sessões em SQLite são lidas com o executável local sqlite3; o fato de o programa principal ser um binário Go não elimina essa dependência para todos os 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 quem já tem Go compatível, go install github.com/vshulcz/deja-vu/cmd/deja@v0.22.1 fixa a tag de compilação; o módulo declara Go 1.25. deja install --auto é o caminho amplo para configurar agentes detectados com seus hooks/plugins automáticos. Não é obrigatório: começar apenas pela CLI permite avaliar a busca sem alterar as integrações existentes.

Facilidades úteis: deja ctx prepara contexto, deja blame encontra sessões relacionadas a arquivos, deja how mostra invocações anteriores, deja fix consulta tentativas após erros e deja handoff --to codex prepara a continuação em outro agente. O histórico é evidência a revisar, não uma ordem para executar comandos antigos.

Maturidade: a release 0.22.1, de 12/10/2026, traz uma base extensa de testes, CI e documentação de segurança. No nosso laboratório, build, análise estática, busca entre dois históricos sintéticos e MCP funcionaram. Também reproduzimos uma falha de teste relacionada ao fuso de São Paulo, sem evidência de perda de notas. É promissor para um piloto sério no desktop, mas ainda é um projeto jovem na linha 0.x, não uma garantia de estabilidade para todos os clientes.

Privacidade: a busca padrão não exige modelo; embeddings são opcionais e enviam material ao endpoint configurado. A sanitização reduz exposição de credenciais, mas não garante retirar todo segredo e não criptografa o índice. Além disso, apagar a conversa no agente não necessariamente apaga sua cópia já retida no Deja Vu. Leia o modelo de segurança antes de ativar captura ampla.

Instalação detalhada, testes, limites e avaliação de maturidade estão em Deja Vu: memória dos agentes no Linux.

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 dashboard

Os 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 tui

O 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: memória persistente para agentes no Linux.

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 ollama

O “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 servidor de memória

ai-memory — wiki versionada e passagem de bastão

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 comandos

Claude 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 — 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 codex

Os 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 serve

Hooks 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
                                           +-- Ollama

Categorias 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 project

Perguntas 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:

1. Deja Vu (Go) — se o problema é encontrar soluções e decisões nos históricos que Claude Code, Codex e outros agentes já salvaram. Comece pela busca sob demanda; habilite automação depois de avaliar escopo e privacidade.
2. ai-memory (Rust) — quando o ponto principal é handoff automático entre Claude, Codex e outros agentes, com wiki Markdown versionada e um servidor local.
3. Engram (Go) — um banco, vários agentes, TUI para inspecionar o que foi gravado.
4. mnemo (Go) — se o que você quer é o ciclo de hooks do Claude-Mem, sem trocar de filosofia.
5. Leteo (Rust) — o mesmo fluxo do Engram, binário Rust, importa o .db dele.
6. Subcog (Rust) — quando a busca precisa de vetor + BM25 de verdade.
7. mcp-memory (Rust) — se quiser grafo + índice de código no mesmo processo.
8. Goldie (Go) — pool compartilhado, vocabulário remember/recall.
9. 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 persistente

Assim 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.

Evite instalar vários mecanismos de auto-recall no mesmo agente “para garantir”: eles podem duplicar contexto e decisões. Uma combinação mais controlável é uma fonte principal de memória durável, o grafo do código e, quando fizer sentido, Deja Vu como consulta retroativa sob demanda. Ative mais automação apenas se o ganho justificar o custo de contexto.

Fechando

O Claude-Mem mostrou o formato: hook no ciclo de vida, estado local e MCP na consulta. Go e Rust já entregam diferentes partes desse fluxo em binários nativos. O Deja Vu acrescenta busca retroativa em transcripts existentes, com índice próprio; 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 · Deja Vu · 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.