chat-recall

chatrecall.dev · Como funciona · Ferramentas MCP · Preços · Self-host · Segurança

Transforme o que suas ferramentas de codificação com IA já escrevem em conhecimento compartilhado para o time, alertas de segredos vazados, descobertas de código ranqueadas e tarefas rastreadas.

Seus agentes anotaram tudo. Ninguém leu.

Cada agente de codificação que você executa mantém uma transcrição completa do seu trabalho: as decisões, o raciocínio, as chaves que alguém colou, os problemas que encontrou e nunca registrou. Cada um escreve no seu próprio diretório, no seu próprio formato, nenhum consegue ler o do outro, e nada lê nenhum deles. O chat-recall lê, através de 63 ferramentas MCP.

	O que faz	Ferramentas
Conhecimento compartilhado de IA	Decisões, convenções e fatos do projeto que um agente aprendeu, disponíveis para todos os outros agentes e colegas de time. Ciente do tempo, então uma decisão substituída é lida como substituída	16
Descobertas de segurança	Credenciais coladas em conversas passadas, sinalizadas por sessão, verificadas se ainda funcionam e rastreadas até serem rotacionadas ou descartadas	4
Melhorias de código automatizadas	Ranqueia o que realmente vale a pena corrigir em um repositório e aplica ou descarta cada recomendação, com inteligência de código sobre o próprio repositório	9
Rastreamento de tarefas	Um quadro compartilhado alimentado por essas descobertas, com regras por repositório, para que uma descoberta vire trabalho em vez de um relatório	5

Por baixo de todos os quatro há um único índice de cada sessão que suas ferramentas já escreveram, e mais 28 ferramentas para buscar, reproduzir e comparar. Esse índice é o mecanismo. Não é o argumento de venda, e não é por isso que alguém compra isso.

A parte entre ferramentas é o que faz funcionar. O histórico embutido de uma única ferramenta para na sua própria fronteira. Isso não para, e seu time também não.

Veja funcionando

Cada tela abaixo é saída real contra um servidor real, capturada da conta demo. Nada é simulado, reproduzido ou re-temporizado.

Um índice, todas as ferramentas. A busca encontra uma sessão pelo que foi discutido nela, não pelo nome do arquivo, e o memory status mostra cada tipo de fonte em um só lugar — sessões ao lado das skills, MCPs, comandos, subagentes e hooks que as produziram.

Ou apenas pergunte em inglês simples — sem nomes de ferramentas, sem IDs de sessão. O agente escolhe a chamada sozinho:

Também encontra as credenciais que você colou e verifica quais ainda funcionam. Uma chave morta é higiene. Uma viva é um incidente, e apenas as vivas geram alerta.

Instalação

npx chat-recall init

Isso indexa as transcrições já no seu disco, detecta quais ferramentas de IA você tem e registra o servidor MCP em cada uma das suas configurações:

Ferramenta	Arquivo que escreve
Claude Code	~/.mcp.json
Codex	~/.codex/config.toml
OpenCode	~/.config/opencode/opencode.json
Cursor	~/.cursor/mcp.json

Ele só toca em uma configuração cuja ferramenta está nesta máquina, nunca sobrescreve uma entrada que você editou manualmente, e o chat-recall doctor imprime uma linha por ferramenta para que um registro ausente fique visível. Dentro do Claude Code, você pode instalar as skills e o servidor MCP juntos:

/plugin marketplace add munhq/chat-recall
/plugin install chat-recall@chat-recall

Qualquer outro cliente MCP (Claude Desktop, Windsurf, Zed, Cline ou uma ferramenta que o init não conhece) usa o mesmo servidor como uma entrada JSON. O binário é chat-recall-mcp, por isso o nome do pacote sozinho não é suficiente — o npx -y chat-recall inicia a CLI, não o servidor:

{
  "mcpServers": {
    "chat-recall": {
      "command": "npx",
      "args": ["-y", "-p", "chat-recall", "chat-recall-mcp"]
    }
  }
}

O mesmo comando em uma linha, para um cliente estilo claude mcp add: npx -y -p chat-recall chat-recall-mcp.

Então:

chat-recall search "that auth bug"      # search everything you have ever done
chat-recall recent                      # what was I working on

Por padrão, isso sincroniza com o servidor hospedado em chatrecall.dev, que começa com um teste de 7 dias sem necessidade de cartão e é uma assinatura paga depois disso — veja preços. Para manter tudo na sua própria máquina, execute o servidor você mesmo: isso é gratuito para uma pessoa, para sempre, com todos os recursos e sem chave de licença — o quadro de tarefas e o Toolkit incluídos — e uma licença só compra colaboração: um segundo membro, histórico compartilhado, atribuição de trabalho. Veja Self-host abaixo. De qualquer forma, a CLI é o mesmo binário e os mesmos comandos; apenas a URL do servidor difere.

Nenhuma chave de API é necessária. A busca é busca de texto completo do Postgres. Resumos de IA são uma atualização opcional, não um pré-requisito.

O que nunca sai da sua máquina

Ele indexa cada sessão de IA neste disco, então o init mostra o que seria enviado — contagem, ferramentas e os projetos por nome — e espera um "sim" antes da primeira sincronização. (--yes, ou sem TTY, imprime o mesmo resumo e prossegue; --skip-sync segura o envio completamente.) Segredos são mascarados no lado do cliente e caminhos de projeto são enviados como hashes; além disso, você escolhe o que está no escopo:

chat-recall exclude project ~/work/client   # a path, and everything under it, never syncs
chat-recall exclude tool cursor             # one AI tool never syncs
chat-recall sync-only add git:github.com/me/app   # invert it: ship ONLY what you list
chat-recall sources decline ~/.claude-work  # a whole transcript profile stays out
                                            #   (--delete-remote purges what it already sent)
chat-recall exclude list                    # every rule in force
chat-recall delete <session-id>             # purge one session on every server, tombstoned
chat-recall retention                       # how long the server keeps what you sent
chat-recall retention set 90                # delete anything older, on a timer (0 = keep everything)

Algumas ferramentas arquivam transcrições sob um hash em vez de uma pasta de projeto, então essas sessões não têm caminho para uma regra de caminho corresponder; exclude tool é o controle que as cobre, e init imprime essa contagem. Uma janela de retenção exclui do servidor em um temporizador. retention set imprime quantas sessões removeria e faz você confirmar o número. Só é desfeito onde a transcrição original ainda está em uma máquina que você tem — amplie a janela e o chat-recall sync --full reenvia o que admite. Para um laptop que você não possui mais, histórico que sua ferramenta de IA rotacionou ou arquivos que você excluiu, nossa cópia é a única cópia. Exporte primeiro se quiser uma.

Exclusões vivem na máquina que contém os dados, então a CLI as possui; elas se aplicam a partir da próxima sincronização, e linhas já sincronizadas permanecem até serem excluídas. O painel Regras de sincronização do dashboard adiciona regras em todos os dispositivos — unidas às locais, então só pode adicionar proteção. Modelo completo, limites incluídos: Segurança.

Quatro coisas que ele realmente faz

1. Memória unificada entre ferramentas. Um índice, uma busca, uma interface sobre Claude Code (~/.claude/projects/), Codex (~/.codex/), OpenCode (~/.local/share/opencode/), Antigravity (~/.gemini/antigravity-cli/), Cursor (~/.cursor/ para a CLI, ~/.config/Cursor/ para a IDE) e Hermes Agent (~/.hermes/). Sessões, planos, tarefas, arquivos CLAUDE.md, cache de colagem, histórico de shell e diários de agente compartilham uma interface MemorySource plugável.
2. O agente se lembra sozinho. 63 ferramentas MCP, para que o Claude Code possa recall_smart_resume, recall_search (com like_session para encontrar trabalho semelhante), recall_edits_timeline, recall_subagent_search e recall_redundant_files em vez de perguntar o que aconteceu da última vez. Ele também escreve de volta, via recall_decision_record, recall_kg_add e recall_set.
3. Avisa antes de você refazer trabalho. Um hook UserPromptSubmit busca sessões passadas semelhantes a cada prompt e injeta uma nota curta "você já fez isso antes, na sessão X" no contexto do agente.
4. Grafo de conhecimento temporal. Decisões e menções a ferramentas viram triplas de entidade-relacionamento com janelas valid_from/valid_to, para que você possa perguntar o que foi decidido em março e se ainda vale.

Adicione sua própria ferramenta de IA

Um novo backend é um arquivo e uma linha — sem mudanças no motor. Se uma ferramenta que você usa escreve transcrições em disco, ela pode ser indexada aqui, e um pull request é o caminho mais rápido para isso acontecer.

Opcional: dashboard web

O dashboard React faz parte do servidor (SaaS ou docker compose self-host) — a CLI em si não tem interface. Para desenvolvimento do dashboard:

npm run web:install                 # install web deps
npm run web:dev                     # API on :5000, UI on :5174

Self-host do servidor (docker compose)

Tudo na sua própria máquina, sem conta, nada enviado a lugar nenhum:

git clone https://github.com/munhq/chat-recall && cd chat-recall
echo "ADMIN_KEY=$(openssl rand -hex 24)"         >> .env
echo "POSTGRES_PASSWORD=$(openssl rand -hex 24)" >> .env
docker compose up -d --build          # FIRST RUN BUILDS FROM SOURCE (minutes)

Depois, crie um token de dispositivo e conecte uma máquina — a sequência completa, com solução de problemas, está em docs/SELF_HOSTING.md.

Dois contêineres: o servidor mais um Postgres pgvector/pgvector incluído, então um docker compose up simples é autocontido. Traga seu próprio Postgres também é suportado (é assim que o serviço hospedado roda): defina DATABASE_URL para um Postgres 16+ externo.

Mantenha o índice ativo (+ sincronização opcional com servidor)

Você não precisa de um daemon. O Claude Code inicia o servidor MCP, e esse processo sincroniza a cada 3 minutos sozinho — o binário é o daemon. Para uma máquina headless sem assistente rodando, opte por um serviço em segundo plano:

chat-recall watch                    # foreground daemon: watches every tool, summaries, precompute
chat-recall watch --install-service  # systemd user unit (Linux) · launchd (macOS) · Scheduled Task (Windows)

O init não o instala, de propósito. Ambos os caminhos passam pelo mesmo syncIncremental() sob o mesmo bloqueio de índice entre plataformas, então um escritor toca o registro por vez — veja docs/SYNC.md antes de mudar qualquer coisa. Segredos são mascarados no lado do cliente antes de qualquer coisa sair da máquina. O chat-recall sync faz o mesmo envio uma vez, sob demanda.

Conecte ao Claude Code

O chat-recall init faz isso por você. Equivalente manual em ~/.mcp.json:

{
  "mcpServers": {
    "chat-recall": {
      "command": "chat-recall-mcp"
    }
  }
}

O chat-recall-mcp é um relé, não o servidor. Ele encontra o daemon em segundo plano para seu perfil de ferramenta, inicia um se não houver e passa bytes para ele. Cada sessão em uma máquina, portanto, compartilha um motor carregado em vez de carregar o seu próprio: uma sessão custa cerca de 50 MB em vez de 87 MB, contra um único daemon compartilhado, e a sincronização em segundo plano roda em um processo em vez de disputar um bloqueio em todos eles. O daemon sai 15 minutos após a última sessão fechar.

Dois controles, ambos opcionais:

CHAT_RECALL_NO_DAEMON=1          # load the whole server in each session instead
CHAT_RECALL_DAEMON_IDLE_SECS=0   # keep the daemon resident (default 900)

Se o daemon não puder ser alcançado por qualquer motivo, a sessão carrega o servidor sozinha e funciona exatamente como antes — mais lenta, nunca quebrada.

Depois, instale os hooks (um comando configura auto-save, backup pré-compactação e a dica de retomada que avisa quando você está prestes a refazer trabalho):

chat-recall install-hooks                 # registers all five events, in every Claude profile
chat-recall install-hooks --no-resume-hint  # skip the resume warning
chat-recall install-hooks --no-wakeup       # skip the session-start wake-up bundle
chat-recall install-hooks --no-escalate     # skip the session-end escalation
chat-recall install-hooks --uninstall     # remove all of ours, leave third-party hooks alone

Hook	Quando dispara	O que faz
SessionStart	Nova sessão (startup / clear)	Injeta o pacote de ativação com escopo de projeto
UserPromptSubmit	Quando você digita um prompt	Busca sessões passadas; se uma semelhante existir, injeta "você já trabalhou nisso antes" no contexto do agente
Stop	Após cada turno do assistente	Auto-salva tópicos, decisões e ferramentas em ~/.chat-recall/memory/
PreCompact	Antes de o Claude Code compactar contexto	Salvamento de emergência para que nada se perca na compactação
SessionEnd	Quando a sessão fecha	Escala os aprendizados da sessão em segundo plano, para que nada atrase

O guardião de decisões

Uma decisão que ninguém lê é uma sugestão. O chat-recall guard roda antes de uma chamada de ferramenta e avisa quando a chamada alcança algo já descartado:

chat-recall: this reaches for something already decided against.
- keycloak was ruled out — BetterAuth is the decision (2026-03-14) · session 8f2c1a4e
Proceed only if this is a deliberate reversal. If it is, record it:
recall_decision_record with the area, so the old decision is closed rather than contradicted.

Ele dispara em instalações, imports e edições de manifesto — npm install auth0, uma nova linha de import, um nome adicionado a package.json. Nunca em prosa: "poderíamos usar Auth0" em uma frase não deve parar nada, ou o guardião vira algo que as pessoas desligam.

Ele avisa; não bloqueia. Um bloqueio errado custa um turno ao usuário e faz o guardião ser desinstalado; um aviso errado custa uma linha de contexto. Defina CHAT_RECALL_GUARD_ENFORCE=1 para bloquear, por máquina. CHAT_RECALL_GUARD=0 o desliga.

O chat-recall install-hooks o registra em todas as cinco ferramentas. Cada uma mantém seu hook de pré-execução em seu próprio arquivo, então o instalador escreve cinco formatos e pula qualquer ferramenta que não esteja na máquina (--no-guard para pular todas):

Ferramenta	Onde	Evento
Claude Code	~/.claude/hooks.json, cada perfil	PreToolUse
Codex	~/.codex/hooks.json	PreToolUse
Antigravity	~/.gemini/antigravity-cli/hooks.json	PreToolUse — a única ferramenta com um veredito real de ask, então pode avisar
Cursor	~/.cursor/hooks.json	beforeShellExecution + afterFileEdit
OpenCode	~/.config/opencode/plugins/chat-recall-guard.js	tool.execute.before

O Codex precisa de mais um passo. Ele roda um hook apenas depois que você confia nele — abra o Codex e execute /hooks uma vez. O chat-recall doctor reporta o registro para cada ferramenta. Dois deles não têm cobertura completa, e a documentação diz isso em vez de dar a entender o contrário. Cursor expõe beforeShellExecution, mas apenas afterFileEdit, então uma importação adicionada em uma edição é relatada após a gravação, não impedida. Os hooks de plugin do OpenCode não são acionados para chamadas de ferramentas de subagentes (#5894), então um agente que delega rotas contorna isso.

Companheiro: codeindex (detecção automática)

Existe um servidor MCP separado chamado codeindex (binário Zig, ~56 MB) por munhq que dá ao agente uma busca em nível de código. Os dois se compõem:

• chat-recall = memória de sessão. No que trabalhei? O que decidimos?
• codeindex = memória de código. Onde está este símbolo? Quem o chama? O que quebra se eu mudá-lo?

Juntos, o agente pode responder "já construí isso antes?" e "isso já existe neste código?" antes de refazer o trabalho.

Como o chat-recall lida com isso: chat-recall init detecta se codeindex está no seu PATH (ou em ~/.local/bin/codeindex). Se sim, ele o registra como um servidor MCP em ~/.mcp.json automaticamente — sem download, sem surpresa. Se não, ele imprime uma dica de uma linha sobre como obtê-lo.

chat-recall init                       # default — detect and register if installed
chat-recall init --with-codeindex      # additionally force-download the binary
chat-recall init --skip-codeindex      # don't even check
chat-recall companions install         # download manually (after init)
chat-recall companions status          # show what was detected
chat-recall companions uninstall       # remove the binary + MCP registration

codeindex é open source (MIT) em github.com/munhq/codeindex. A instalação é opcional — o chat-recall funciona totalmente sem ele; você apenas não obtém as ferramentas em nível de código.

O que é indexado

Fonte	Origem	Notas
Sessões (Claude)	~/.claude/projects/<hash>/<uuid>.jsonl	Transcrições completas, tokens, custo, arquivos tocados, modelos usados
Sessões (OpenCode)	~/.local/share/opencode/opencode.db (SQLite)	Custo, tokens, tarefas
Transcrições de subagentes	<session-dir>/<id>/subagents/*.jsonl	Explore, aside, e acompact-* (histórico compactado órfão)
Planos	~/.claude/plans/*.md	Documentos de planejamento do agente, divididos por ##
Tarefas	~/.claude/tasks/<session>/*.json	Vinculadas à sessão pai
CLAUDE.md	Descoberto automaticamente a partir de hashes de projeto	Vinculado a sessões no mesmo projeto
Histórico	~/.claude/history.jsonl	Histórico do shell, opcionalmente vinculado a uma sessão
Colar	~/.claude/paste-cache/*.txt	Grandes blocos colados
Diário	~/.chat-recall/index/diary/<agent>/*.json	O que o agente contou ao seu eu futuro via recall_diary_write

Ferramentas MCP (62, incluindo 4 ferramentas de inteligência de código que se registram quando o binário companheiro está instalado)

Busca e recuperação — recall_search, recall_memory_search, recall_recent, recall_show, recall_context, recall_summary, recall_smart_resume, recall_project_context, recall_weekly_digest, recall_analytics_summary, recall_wake_up.

Detecção de padrões — recall_search com like_session: <id> (encontra trabalho semelhante a uma sessão dada), recall_redundant_files (avisa quando um novo nome de arquivo se sobrepõe a trabalho anterior), recall_diff com files_only: true (quais arquivos a sessão X realmente tocou), recall_edits_timeline com group_by: "session" (quais sessões editaram auth.rs).

Subagentes e filtros — recall_subagent_search (busca dentro de transcrições ocultas Explore/aside/compact), recall_user_prompts (apenas o que o humano digitou, com banners removidos).

Descobertas, classificadas — recall_claude_suggestions (cada descoberta que se torna uma mudança de instrução do agente: as regras do CLAUDE.md e instalações de habilidades, mescladas no escopo da conta e em cada projeto indexado) e recall_improvements (todo o resto, classificado do mais urgente primeiro, com create_tasks: true para abrir uma tarefa de equipe por item). Elas particionam os mesmos mecanismos de recomendação, então um item nunca aparece em ambos.

Grafo de conhecimento — recall_kg_query, recall_kg_add, recall_kg_invalidate, recall_kg_timeline, recall_kg_stats. Além de recall_decision_record para escrever uma decisão como um triplo e uma entrada de diário em uma única chamada.

Estado KV — recall_set, recall_get (sem chave = lista o escopo). Pequenos valores persistentes chaveados por strings com namespace: "URL do PR atual", "branch em que estou trabalhando", preferências do usuário.

Diário e status — recall_diary_write, recall_diary_read, recall_status (inclui detalhamento de memória), recall_index. Planos/tarefas: busca via recall_memory_search(source_types:['plan','task']), leitura via recall_show.

Removendo coisas — recall_forget exclui uma conversa do servidor permanentemente, com tombstone para que nenhuma sincronização posterior a restaure (seu próprio arquivo de transcrição não é tocado); recall_exclude_path interrompe a sincronização de um caminho, nesta máquina e na sua conta. Elas existem como ferramentas porque "esqueça essa conversa" e "pare de sincronizar este repositório" são coisas que as pessoas dizem no meio de uma conversa, não coisas para as quais abrem um painel. Ambas exigem confirm: true, ambas são anotadas como destrutivas, e nenhuma é aprovada automaticamente — seu cliente pergunta toda vez. O limite é unidirecional de propósito: um agente pode restringir o que é armazenado e não há ferramenta que o amplie novamente (sem des-exclusão, sem lista de permissões, sem retenção). Ampliar é seu: chat-recall exclude remove, ou o painel.

Quando o companheiro codeindex está instalado, o agente também obtém 16 ferramentas em nível de código (find_symbol, find_callers, get_imports, plan_change, get_change_impact, analyze, etc.) de um servidor MCP separado. Elas se compõem: chat-recall encontra o que você fez; codeindex diz o que existe atualmente.

Arquitetura de busca

A busca roda no servidor, e é busca de texto completo do Postgres: correspondência de palavras-chave com classificação, além de tolerância a erros de digitação pg_trgm. Não precisa de embedder, chave de API ou serviço extra.

O CLI envia chunks redigidos ao servidor, que os indexa.

Rastreamento de custos

O custo em USD é calculado a partir do uso de tokens quando pelo menos um modelo na sessão tem uma taxa que o servidor conhece. Para qualquer outro modelo — qualquer coisa local, qualquer coisa auto-hospedada, qualquer coisa mais nova que a tabela de taxas — o painel mostra — em vez de fabricar um número. O resumo exibe um contador sessionsWithoutPricing, para que você possa ver quanto do total a figura realmente cobre.

Contexto de ativação

chat-recall memory wake-up

Constrói um pequeno pacote para uma sessão de IA: texto de identidade opcional, os 10 principais chunks que o classificador marcou como decisões/preferências/marcos com importância ≥ 4, e um instantâneo dos fatos do grafo de conhecimento atualmente válidos. Sem compressão mágica — apenas os itens de maior sinal que o indexador já marca.

Locais de dados

O CLI mantém quase nada localmente — apenas o necessário para alcançar o servidor:

Caminho	O quê
~/.chat-recall/credentials.json	Alvo(s) do servidor + token do dispositivo (modo 0600)
~/.chat-recall/sync-ledger.json	Marca d'água de sincronização por servidor (o que já foi enviado)
~/.chat-recall/hooks/	Hooks instalados (após install-hooks)
~/.chat-recall/index/diary/	Diários do agente escritos por recall_diary_write
~/.chat-recall/shadow/	Cópia gzipada da transcrição mais completa vista por sessão, para que uma truncagem --resume a montante não possa destruir o histórico
~/.chat-recall/cache.db	Cache local de resultados/metadados para o painel local. Não é um índice, e não é usado no modo servidor

Todo o conteúdo indexado — chunks, FTS, vetores, grafo de conhecimento, descobertas secretas, diário — vive no servidor (Postgres para auto-hospedagem e SaaS). Redefina-o apagando os dados do Postgres do servidor, não qualquer coisa sob ~/.chat-recall.

Privacidade

Suas sessões sincronizam com um servidor chat-recall — seja um que você auto-hospeda (sua própria máquina, seu próprio Postgres) ou o SaaS. Antes de qualquer coisa sair do CLI, ela é redigida: segredos são mascarados no lado do cliente, então o servidor nunca recebe credenciais brutas. A auto-hospedagem mantém todos os dados na infraestrutura que você controla; o SaaS é a alternativa hospedada.

Sem telemetria. Seus dados vivem no Postgres do seu servidor — faça backup como quiser. No SaaS, eles vivem no Postgres hospedado; auto-hospede se preferir manter tudo inteiramente na sua própria infraestrutura.

Arquitetura

packages/
├── engine/src/
│   ├── core/
│   │   ├── backends/        ToolBackend per AI tool (claude, opencode, codex, agy, cursor)
│   │   ├── tool-backend.ts  Registry interface — single source of truth for tool identity
│   │   ├── tool-paths.ts    Env-overridable default paths for each tool
│   │   ├── generic-engine.ts  Shared turn extraction / edit scan / replay (canonical events)
│   │   └── …                Indexing, storage, embeddings, summaries, KG, classifier
│   └── parsers/             *-source.ts plugins per content type (sessions, plans, tasks, …)
├── cli/
│   ├── src/cli.ts           CLI
│   ├── src/mcp.ts           MCP server
│   ├── auto-indexer/        chokidar-based watcher daemon (systemd-friendly)
│   └── hooks/               Claude Code hooks (install via `chat-recall install-hooks`)
└── server/
    ├── src/                 Express API
    ├── client/              React + Vite UI — the dashboard
    └── cloud/migrations/    Empty by design — pg-schema.ts owns the schema

docker/                  Dockerfile + entrypoint for the server image
e2e/                     Playwright tests for the dashboard

Dois pontos de extensão, ambos orientados a registro:

• Adicionar um novo tipo de conteúdo (por exemplo, outro formato de arquivo para indexar) — implemente MemorySource (discover → parse → extractLinks) e registre-o no SourceRegistry.
• Adicionar uma nova ferramenta de IA (um sétimo backend além de Claude/OpenCode/Codex/Antigravity/Cursor/Hermes) — implemente ToolBackend (caminhos, manipulação de ID, readEvents, fileToolMap, extractEditDelta) e registre-o em packages/engine/src/core/backends/index.ts. Todos os caminhos são substituíveis por env via CHAT_RECALL_{CLAUDE,CODEX,AGY,CURSOR,CURSOR_IDE,HERMES}_HOME / CHAT_RECALL_OPENCODE_DB.

Requisitos

• Node.js 22 ou posterior. A imagem Docker e o CI rodam 24.
• Sessões escritas por uma ferramenta suportada, em sua localização padrão: ~/.claude/, ~/.codex/, ~/.local/share/opencode/, ~/.gemini/antigravity-cli/.

Essa é a lista completa. Nenhuma chave de API é necessária para instalar, indexar ou buscar.

Um recurso é opcional, e precisa de um backend que você escolhe:

Recurso	Backends para os quais você pode apontar
Resumos de IA	Ollama, um CLI no qual você já está logado (SUMMARY_CLI_CMD), um endpoint compatível com OpenAI, ou ANTHROPIC_API_KEY

Sem ele, as sessões não carregam resumo gerado. Todo o resto funciona igual.

Licença

Elastic License 2.0 para todo o repositório.

Em termos simples: use, modifique, execute para você mesmo ou dentro da sua empresa, gratuitamente e sem pedir permissão. A única coisa que você não pode fazer é oferecê-lo a terceiros como um serviço hospedado ou gerenciado — esse é o produto. Você também não pode remover as verificações de chave de licença ou os avisos de direitos autorais.

É código-fonte disponível, não open source OSI, e este README não vai fingir o contrário. Ele substituiu uma divisão onde o CLI e o motor eram MIT e o servidor era BSL 1.1, que respondia "posso usar isso?" de três maneiras diferentes dentro de um único repositório.