Recall

Sem um servidor de memória, toda conversa com Claude / Copilot / Cursor começa do zero. Você reexplica o código, as convenções, as decisões, os detalhes — toda vez. O Recall resolve isso.

Comece aqui: o que o Recall faz para um desenvolvedor, uma IA

Instale uma vez, aponte seu cliente MCP para ele, e sua IA agora:

• Lembra entre sessões — "o que decidimos sobre o fluxo de autenticação na semana passada?" retorna a decisão real, não uma alucinação
• Indexa seu código e documentação — index_file + recall = RAG semântico local sobre seu repositório
• Cita a origem da resposta — answer retorna o texto e os trechos de onde extraiu
• Constrói conhecimento do projeto — cada checkpoint, reflect e anti_pattern torna-se pesquisável posteriormente
• Sobrevive a reinicializações — artefatos somente anexados em disco, armazenamento vetorial reconstruível a partir deles

Um pip install, um bloco de configuração, pronto. Sem chave de API. Sem serviço externo. Sem cobrança por token. Licença MIT. É para isso que 95% dos usuários usarão o Recall.

---

Como isso é diferente do mem0 / Letta / Zep?

O Recall faz o mesmo trabalho que eles — memória persistente entre sessões de IA, recall semântico, "lembrar o que o usuário disse na semana passada." A diferença é onde e como:

	mem0 / Letta / Zep	Recall
Onde a memória vive	A nuvem deles	Seu ~/.recall/
Chave de API necessária	Sim	Não
Custo	Por token / SaaS mensal	Gratuito
Embeddings	Serviço deles	ONNX local (offline)
Chamadas de rede	A cada recall	Zero
Compatível com air-gap	Não	Sim
Nativo MCP	Wrapper ou SDK	Construído sobre MCP
Coordenação multiagente	Nenhuma	6 primitivas

Se você está satisfeito em pagar um provedor de memória hospedado por token, esses são ótimos produtos e você não precisa do Recall. Se você prefere que a memória da sua IA viva no seu laptop ou no seu próprio servidor, gratuita e offline, é para isso que o Recall serve.

---

Escalando: coordenação quando você executa mais de um agente

A mesma instalação que dá a um desenvolvedor uma memória de IA pessoal também funciona como um cérebro compartilhado quando mais de um agente fala com ele. Duas janelas do Copilot. Um par planejador + executor. Três instâncias do Claude dividindo um refactor. Um agente pre-commit e um agente code-review no mesmo PR. Todos eles remember e recall do mesmo armazenamento.

Isso introduz um novo problema que nenhum dos serviços de memória hospedados tentou resolver: agentes pisando uns nos outros. O Agente A começa a refatorar src/auth.py. O Agente B, em outra janela, reescreve o mesmo arquivo sem saber que A está no meio da edição. Quem salvar por último vence. O trabalho do outro agente desaparece.

O Recall oferece seis primitivas MCP que transformam agentes paralelos de uma bagunça em um time coordenado:

Ferramenta	O que faz
claim(resource, agent)	Bloqueio suave de um arquivo/tabela/URL com TTL de expiração automática
release(resource, agent)	Remover o bloqueio (arquivamento suave — o trilho de auditoria sobrevive)
who_has(resource)	"Alguém está editando src/foo.py agora?"
claims()	Todos os bloqueios ativos em todos os agentes
handoff(to_agent, ...)	Transferência explícita de trabalho com intenção + arquivos + contexto
pulse_others(self_agent)	Os N checkpoints mais recentes de agentes diferentes de você

As reivindicações são consultivas (como bloqueios do git) — o Recall não impede fisicamente um segundo agente de escrever, mas todo cliente bem-comportado verifica primeiro. Os TTLs impedem que um agente travado congele um recurso para sempre. As liberações fazem arquivamento suave (de acordo com a regra delete=archive do projeto) para que o trilho de auditoria de quem segurou o quê e quando sobreviva.

Se você é um usuário único, essas ferramentas ficam lá sem uso. Se você escalar para múltiplos agentes, elas já estão lá.

   ┌──────────────┐                           ┌──────────────┐
   │  Agent a3f7  │      claim(file, ttl)     │  Agent b1c4  │
   │  Claude #1   │ ───────────┐  ┌─────────► │  Claude #2   │
   └──────┬───────┘            ▼  │           └──────┬───────┘
          │              ┌────────┴───────┐          │
          │   remember   │     Recall     │   pulse  │
          ├────────────► │ • shared memory│ ◄────────┤
          │              │ • claims/locks │          │
          │   handoff    │ • handoffs     │  handoff │
          ├────────────► │ • who_has      │ ◄────────┤
          │              └────────────────┘          │
          ▼                                          ▼
       22 MCP tools — Copilot, Claude, Cursor, custom

22 ferramentas MCP no total — 16 ferramentas de memória que todo usuário recebe, mais as 6 primitivas de coordenação que ativam quando você escala.

---

Instalação em uma linha (Claude Desktop, VS Code, Cursor)

O Recall é distribuído como um servidor MCP stdio. Zero configuração — sem chaves de API, sem Docker, sem portas. A memória vive em ~/.recall/.

pip install "ai-recallworks[mcp]"

Em seguida, adicione o Recall à configuração do seu cliente MCP:

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json no macOS, %APPDATA%\Claude\claude_desktop_config.json no Windows):

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

VS Code (mcp.json nas configurações do seu workspace ou do usuário):

{
  "servers": {
    "recall": {
      "command": "recall-mcp"
    }
  }
}

Reinicie o cliente. Seu agente agora tem memória persistente entre sessões. Os embeddings rodam totalmente offline (all-MiniLM-L6-v2 incluído do Chroma). Atualize para embeddings Ollama / OpenAI / Voyage via variáveis de ambiente quando quiser.

---

Instalação em cinco minutos (HTTP / multi-usuário / equipe)

1. Execute o servidor:

docker run -d --name recall \
  -p 8787:8787 \
  -e API_KEY=changeme \
  -v recall-data:/data \
  ghcr.io/recallworks/recall:latest

2. Fale com ele — escolha sua stack:

# Raw HTTP (any language)
curl -H "X-API-Key: changeme" \
     -H "Content-Type: application/json" \
     -d '{"content":"first memory","tags":"hello"}' \
     http://localhost:8787/tool/remember

# Python (use requests/httpx — no SDK pkg needed)
import requests
h = {"X-API-Key": "changeme", "Content-Type": "application/json"}
requests.post("http://localhost:8787/tool/remember", headers=h,
              json={"content": "first memory", "tags": "hello"})
print(requests.post("http://localhost:8787/tool/recall", headers=h,
                    json={"query": "memory"}).json()["result"])

// TypeScript / JavaScript (Node 18+, Bun, Deno, browser)
npm install @recallworks/recall-client

import { RecallClient } from "@recallworks/recall-client";
const c = new RecallClient({ baseUrl: "http://localhost:8787", apiKey: "changeme" });
await c.remember("first memory", { tags: "hello" });
console.log((await c.recall("memory")).result);

Passo a passo completo: docs/quickstart.md.

---

O que você obtém

• 13 ferramentas — remember, recall, reflect, anti_pattern, checkpoint, pulse, session_close, index_file, reindex, snapshot_index, memory_stats, forget, maintenance.
• Dois transportes — HTTP simples (POST /tool/{name}) e MCP sobre SSE. Integre-se ao Copilot, Claude Code, Cursor ou qualquer cliente MCP.
• Traga seus próprios modelos — embedder plugável (padrão / OpenAI / Ollama) e sumarizador (noop / OpenAI / Ollama). Execute totalmente offline, totalmente on-prem, ou contra seu próprio tenant Azure-OpenAI. Veja docs/byo-models.md.
• Durável por padrão — armazenamento ao vivo efêmero com snapshot automático em disco; reinicializações de contêiner sobem inteiras.
• Artefatos somente anexados — cada escrita também vira um arquivo .md. Se o armazenamento vetorial algum dia queimar, reindex o reconstrói a partir dos artefatos.
• forget é arquivamento suave — proteção embutida no próprio código OSS, não adicionada como política. Memória que você exclui pode ser recuperada.

---

Como é diferente

	Recall	Mem0 / Letta / Zep
Licença (núcleo)	MIT	mista; primeiro SaaS
Self-host	um docker run	varia, muitas vezes não trivial
BYO embedder	padrão / OpenAI / Ollama (variável de ambiente)	geralmente fixo
BYO LLM	noop / OpenAI / Ollama (variável de ambiente)	geralmente fixo
Modelo de armazenamento	artefatos somente anexados + índice vetorial, reconstruível	apenas banco de dados ao vivo
delete	arquivamento suave por design	exclusão definitiva
Superfície de ferramentas	13 ferramentas opinativas (memória + fluxo de trabalho)	primitivas de embedding + recuperação
Nativo MCP	sim, além de HTTP simples	parcial / via wrapper
Modelo operacional	binário único, contêiner único	stack multi-serviço

Se você quer um serviço gerenciado, veja Recall Cloud abaixo. Se você quer um cérebro totalmente seu, este núcleo OSS é suficiente.

---

Estrutura do repositório

Caminho	O que é
src/recall/	Servidor OSS (MIT)
src/recall/tools/	Um módulo por ferramenta
src/recall/transport/	Adaptadores HTTP + MCP/SSE
docker/single-tenant/	Dockerfile + compose de referência
tests/	Suíte pytest (sem Docker necessário)
docs/	Quickstart, convenções, arquitetura
enterprise/	Multi-tenant, SSO, plano de controle (BSL)

---

Convenções

Estas são as práticas que fazem as ferramentas valerem a pena. Escolha o que se encaixa.

• Ritual de início a frio — protocolo de abertura que toda sessão deve executar.
• Marca — cabeçalhos de edição assinados para você rastrear qual agente tocou em qual arquivo e quando.

---

Status

Alpha. O código em src/recall/ é extraído de um cérebro de produção hospedado que atendeu milhares de sessões, depois higienizado de caminhos específicos da organização, extensões e dados de tenant. Espere mudanças que quebram antes da 1.0; fixe a tag da imagem.

---

Contribuindo

Sim — leia CONTRIBUTING.md primeiro. Aceitamos correções de bugs, novos backends Store, melhorias na documentação e entradas de anti-padrões. Não aceitamos reescritas arquiteturais sem discussão prévia.

Problemas de segurança: veja SECURITY.md.

---

Licença

• src/recall/, clients/, docker/single-tenant/, docs/, examples/ — MIT (LICENSE)
• enterprise/ — BSL 1.1, concessão de uso adicional para 5 assentos, converte para MIT após 3 anos (LICENSE-COMMERCIAL.md)

---

Recall Open Source vs. Recall Pro vs. Hospedado

Capacidade	OSS (este repositório)	Recall Pro	Recall Cloud
Imagem Docker de tenant único	✅	✅	n/a (hospedado)
13 ferramentas de memória, MCP + HTTP	✅	✅	✅
BYO embedder + LLM	✅	✅	✅
Artefatos somente anexados + snapshot automático	✅	✅	✅
Multi-tenant, SSO, RBAC	—	✅	✅
Log de auditoria + política de retenção	—	✅	✅
Grafo de entidades entre sessões	—	✅	✅
Pipeline de sanitização de PII	—	✅	✅
Replicação de snapshot / DR	—	✅	✅
Suporte do fornecedor + SLA	comunidade	horário comercial	24×7
Hospedado em nossa infraestrutura	—	—	✅
Preço	gratuito	a partir de $99/mês por nó	a partir de $0,10 por 1k ferramentas

Recall Pro é distribuído a partir da árvore enterprise/ sob uma Business Source License — código-fonte disponível, concessão gratuita de uso adicional para 5 assentos, converte para MIT após 3 anos. Compre uma licença e os módulos enterprise/ são ativados junto com sua instalação OSS.

Recall Cloud é a versão hospedada multi-tenant. Mesmas ferramentas, sem infraestrutura. Entre em contato para preços de acesso antecipado.

➡️ Fale com vendas: sales@recall.works · Agende uma demonstração de 20 min: https://recall.works/demo

---

Construções verticais alimentadas pelo Recall

O Recall é o motor. Entregamos cérebros verticais prontos para uso sobre ele:

• IceWhisperer — o cérebro de memória + fluxo de trabalho para equipes de ICE Mortgage Technology / Encompass. Índice de SDK pré-carregado, receitas de configuração, auditorias de plugins, detecção de desvios. Planos a partir de $250/mês.

Se você quiser um cérebro vertical para sua indústria, nós o construiremos. Envie um e-mail para partners@recall.works.

---

Mantenedores

Entre em contato com os mantenedores em maintainers@recall.works. Issues e PRs são bem-vindos no GitHub.