context-mem

Otimização de contexto para assistentes de codificação de IA — 99% de economia de tokens via 14 sumarizadores sensíveis ao conteúdo, busca em 3 camadas e divulgação progressiva. Sem dependência de LLM.

GitHub

Experimente este MCPPatrocinado

Documentação

Context Mem

Infraestrutura de memória + contexto para agentes de IA. Lembra de tudo. Comprime tudo. Totalmente local.

O Problema

Dois problemas com as ferramentas de IA atuais que ninguém resolveu juntos em um único pacote.

Sua IA esquece. Cada nova sessão começa do zero. As decisões de arquitetura que você definiu na quinta-feira passada, o bug que você passou quatro horas rastreando até uma variável de ambiente mal configurada, as preferências que você declarou três vezes — nada disso é levado adiante. Você gasta os primeiros dez minutos de cada sessão reexplicando contexto que já existia. Multiplique isso por cada desenvolvedor da sua equipe, cada projeto, cada dia.

Seu contexto explode. Sessões de codificação longas estouram a janela de contexto. Uma sessão típica com 50 saídas de ferramentas acumula 365 KB de texto bruto — stack traces, saída de testes, leituras de arquivos, comandos de shell. Cada token custa dinheiro ou torna o modelo mais lento. A truncagem ingênua descarta exatamente a evidência que o modelo precisa. Manter tudo torna as respostas mais lentas e o custo de inferência sobe rapidamente.

Esses dois problemas se agravam mutuamente. A solução para o esquecimento (manter tudo) é o oposto da solução para a explosão de contexto (descartar tudo). O resultado é um falso trade-off que a maioria das ferramentas impõe a você: ou sua IA esquece tudo, ou seus custos inflam. O context-mem resolve ambos simultaneamente ao construir um armazenamento de memória indexado, comprimido e recuperável, em vez de despejar histórico bruto na janela de contexto.

A Solução — uma ferramenta, dois pilares

Pilar 1: Memória (LLM Wiki)

Cada chamada de ferramenta é automaticamente ingerida, resumida e gravada em um cofre markdown navegável — uma wiki viva que sua IA mantém sobre seu projeto. Entidades ganham suas próprias páginas com backlinks. Tópicos ganham páginas de síntese. Sessões se tornam documentos-fonte navegáveis. Decisões se acumulam em um rastro reconstruível.

O cofre vive em .context-mem/vault/ e sincroniza continuamente a partir do armazenamento SQLite subjacente. Leia-o no Obsidian, use grep no terminal ou consulte-o por meio de 45+ ferramentas MCP usando busca híbrida BM25 + vetorial + avaliador LLM opcional. O armazenamento SQLite bruto é o registro autoritativo; o cofre markdown é a camada derivada e legível por humanos.

Esta é uma implementação de referência do padrão LLM Wiki de Andrej Karpathy — três camadas (fontes brutas / wiki / schema), com ingestão automática de chamadas de ferramentas que nenhum outro sistema fornece.

Pilar 2: Compressão (14 sumarizadores)

Cada observação passa por um sumarizador ciente do conteúdo antes do armazenamento. Um stack trace não é tratado da mesma forma que um arquivo de configuração JSON. A saída de shell de um build é comprimida de forma diferente dos erros do compilador TypeScript. O sistema aplica a compressão certa para o tipo de conteúdo.

O resultado: uma sessão de codificação completa com 50 saídas de ferramentas vai de 365 KB para 3,2 KB — economia de 99,1% em tokens, verificado. A compressão é adaptativa: observações recentes de alta importância permanecem verbatim; as mais antigas e de baixa importância comprimem progressivamente. Entradas fixadas nunca comprimem, independentemente da idade.

Um Comando

npm i context-mem && npx context-mem init

init detecta automaticamente seu editor e grava os arquivos de configuração corretos:

Editor	Configuração gravada
Claude Code	`.mcp.json` + 8 hooks + CLAUDE.md
Cursor	`.cursor/mcp.json` + `.cursor/rules/context-mem.mdc`
Windsurf	`.windsurf/mcp.json` + `.windsurf/rules/context-mem.md`
VS Code / Copilot	`.vscode/mcp.json` + `.github/copilot-instructions.md`
Cline	`.cline/mcp_settings.json` + `.clinerules/context-mem.md`
Roo Code	`.roo-code/mcp_settings.json` + `.roo/rules/context-mem.md`
Aider	`.aider.conf.yml` (bloco MCP)
Continue	`.continue/config.json` (bloco MCP)
JetBrains AI	`.idea/mcp.json`

Sem chaves de API. Sem conta na nuvem. Nenhum dado sai da sua máquina.

Dois pilares em 60 segundos

[ placeholder: GIF ou vídeo — sessão do Claude Code com visualização dividida mostrando o gráfico do Obsidian atualizando em tempo real junto com o gráfico de economia de tokens do dashboard do context-mem ]

Arquitetura (implementação de referência do padrão LLM Wiki de Karpathy)

                    ┌─────────────────────────────────────────┐
                    │            Raw Sources (immutable)       │
                    │  tool calls · observations · file reads  │
                    └──────────────────┬──────────────────────┘
                                       │
                                       ▼
                    ┌─────────────────────────────────────────┐
                    │           Observation Pipeline           │
                    │                                          │
                    │  PrivacyEngine (9 detectors)             │
                    │    → 14 content-aware summarizers        │
                    │    → entity extraction (100+ aliases)    │
                    │    → topic detection                     │
                    │    → importance scoring (0.0–1.0)        │
                    │    → adaptive compression tier           │
                    └────────────────┬────────────────────────┘
                                     │
                   ┌─────────────────┴───────────────────┐
                   │                                     │
                   ▼                                     ▼
    ┌──────────────────────────┐       ┌─────────────────────────────┐
    │    SQLite (primary)      │       │   Markdown Vault (derived)  │
    │                          │       │                             │
    │  observations            │──────▶│  .context-mem/vault/        │
    │  entities + graph        │  sync │    index.md                 │
    │  knowledge               │       │    log.md                   │
    │  events                  │       │    sources/<session>.md     │
    │  FTS5 index              │       │    entities/<name>.md       │
    │  vector embeddings       │       │    topics/<name>.md         │
    └──────────────────────────┘       │    knowledge/<id>.md        │
                   │                   └─────────────────────────────┘
                   │
                   ▼
    ┌──────────────────────────────────────────────────────────────┐
    │              Hybrid Retrieval                                │
    │                                                              │
    │  BM25 (8 strategies + synonym expansion)                     │
    │  + Vector (nomic-embed-text-v1.5, 768-dim)                   │
    │  + Trigram + Levenshtein                                     │
    │  → Fusion (intent-adaptive weights, IDF reranker)            │
    │  → Optional LLM judge (Haiku, 50/50 blend, 100% R@5)        │
    └──────────────────────────────────────────────────────────────┘

Três camadas (segundo Karpathy):

Fontes brutas — suas saídas de chamadas de ferramentas, leituras de arquivos, comandos de shell, observações. Gravadas uma vez, nunca modificadas. O registro permanente.
A wiki — cofre markdown mantido por LLM (.context-mem/vault/). Sincronizado automaticamente do SQLite. Legível por humanos, compatível com Obsidian, amigável a grep. Páginas de entidades, páginas de tópicos, páginas de sessões, páginas de conhecimento, índice, log de eventos.
Schema — docs/llm-wiki-schema.md governa a estrutura das páginas, convenções de vinculação, receitas de fluxo de trabalho do agente e o contrato de interoperabilidade. Especificação pública — outras ferramentas podem emitir wikis conformes.

A distinção da maioria dos sistemas de memória: o context-mem não substitui SQLite por markdown. O SQLite é autoritativo — é onde as observações são armazenadas, buscadas e indexadas. O cofre é a superfície navegável, vinculável e diferenciável sobre ele — a camada que um humano ou LLM pode navegar sem um cliente de banco de dados. Se você excluir o diretório do cofre, não perde nada que importe. Se editar uma página do cofre manualmente, essas edições são preservadas e não sobrescritas na próxima sincronização.

Este é o modelo de três camadas de Karpathy aplicado a um ambiente de desenvolvimento de IA em execução: entradas imutáveis, uma camada de síntese mantida e um schema público que governa a síntese. O cofre pode ser usado independentemente das ferramentas MCP — é apenas um diretório de arquivos markdown. Abra-o em qualquer editor. Coloque-o no git. Faça diff entre commits. Use-o como contexto de formato longo copiando e colando páginas em uma nova conversa. As ferramentas MCP são o caminho automatizado; o cofre markdown é o caminho portátil, durável e legível por humanos.

Benchmarks de recuperação (metodologia honesta)

Todas as pontuações são de recall de recuperação em nível de sessão: alguma sessão de evidência correta apareceu nos resultados top-k? Isso é diferente da precisão de QA ponta a ponta (recuperar + gerar + avaliar), que é mais difícil e menor para todos os sistemas. Ambas as medições são publicadas aqui.

Puramente local (zero chamadas de API, totalmente gratuito)

Benchmark	Recall de Recuperação	Precisão QA E2E	Perguntas	Sessões
LongMemEval	97,8% R@5	publicado pós-v3.4	500	~53/conv
LoCoMo	98,1% R@10	publicado pós-v3.4	1.977	19-35/conv
MemBench	98,0% R@5	—	500	—
ConvoMem	97,7% R@10	—	250	—

Com reranking LLM opcional (~US$ 1 por 500 consultas)

Benchmark	Recall de Recuperação
LongMemEval	100,0% R@5 (500/500)

O avaliador LLM (Claude Haiku) pontua os candidatos top-N de BM25+vetorial de 0 a 10 e combina 50/50 com a pontuação de recuperação. Ativa quando ai_curation.enabled = true. Adiciona ~US$ 0,002 por consulta no preço do Haiku.

Notas de metodologia:

Um "acerto" é pontuado se qualquer sessão de evidência correta aparecer no top-k. Não é QA ponta a ponta.
O benchmark LoCoMo anexa metadados fornecidos pelo conjunto de dados (session_summary, observation, event_summary) aos documentos de sessão — o sistema de produção aplica enriquecimento equivalente via sumarizadores e extração de entidades.
Expansões de sinônimos: o construtor de consultas principal inclui sinônimos de vocabulário geral (movie → film, sibling → brother). Resultados sem qualquer expansão de sinônimos são ~1-2% menores.
Todo o código de benchmark é aberto e executável: npm run bench. Veja benchmarks/.

Metodologia completa: docs/benchmarks/methodology.md (publicada com a v3.4).

Benchmarks de compressão (verificados)

Cenário	Bruto	Comprimido	Economia
Sessão de codificação típica (50 saídas de ferramentas)	365 KB	3,2 KB	99,1%

Detalhamento por sumarizador:

Sumarizador	Taxa de compressão
Saída de log	97%
Erros	95%
Shell / CLI	~95%
Código	92%
JSON	89%
Erros do compilador TS	~88%
Testes	~85%
Saída de build	~94%
Logs do git	~90%
HTML	~92%
Markdown	~75%
CSV	~80%
Respostas de rede	~88%
Binário (dumps hex)	~98%

A compressão é sem perdas no nível semântico para observações de alta importância (flags DECISION, MILESTONE, PROBLEM) — essas permanecem verbatim independentemente da idade. A compressão se aplica à saída rotineira de ferramentas.

Recursos principais

Memória

Substrato LLM Wiki — cofre markdown em .context-mem/vault/, sincronizado automaticamente do SQLite. Páginas de entidades, páginas de tópicos, páginas-fonte de sessões, páginas de conhecimento, index.md, log.md. Compatível com Obsidian, amigável a grep.
14 sumarizadores cientes de conteúdo — JSON, shell, código, logs, erros, erros TS, testes, builds, logs do git, HTML, markdown, CSV, binário, rede. Cada um ajustado para seu tipo de conteúdo.
Compressão adaptativa em 4 níveis — verbatim (0–7 dias) → leve (7–30 dias) → média (30–90 dias) → destilada (90 dias+). Entradas fixadas permanecem verbatim para sempre.
Grafo de conhecimento — modelo de relacionamento entidade-tipo: arquivos, módulos, padrões, decisões, bugs, pessoas, bibliotecas, serviços, APIs, configurações. Atravessável via graph_query, graph_neighbors, add_relationship.
Fatos temporais — valid_from/valid_to em todas as entradas de conhecimento. Cadeias de substituição. temporal_query responde "o que era verdade sobre X no tempo T?"
Reconstrução de trilha de decisões — explain_decision percorre a cadeia de evidências para trás: leituras de arquivos → erros → buscas → a decisão. Proveniência completa.
Inteligência de entidades — detecta automaticamente tecnologias, pessoas, caminhos de arquivos, identificadores CamelCase, constantes ALL_CAPS. Mais de 100 aliases canônicos (React.js → React, Node → Node.js, etc.).
Narrativas de sessão — 4 modelos prontos: descrição de PR, atualização de standup, ADR, guia de integração. context-mem story --format pr.
Primer de despertar — injeção de contexto com orçamento de tokens no início da sessão. 4 camadas: perfil do projeto (15%), conhecimento crítico (40%), decisões recentes (30%), principais entidades (15%).
Injeção por prompt — o hook UserPromptSubmit injeta automaticamente memórias relevantes em cada mensagem. Com limite de taxa, deduplicação por tópico. Zero comandos manuais.

Compressão

14 sumarizadores cientes de conteúdo — não é um tamanho único. Um stack trace recebe tratamento diferente de uma resposta JSON.
Preservação verbatim fixada — decisões, marcos e observações fixadas manualmente nunca comprimem.
Cascata de truncagem por prioridade — se o orçamento de contexto for excedido, itens de menor importância são comprimidos primeiro. Itens de alta importância sobrevivem.
Orçamento de tokens configurável — três estratégias de estouro: comprimir os mais antigos, comprimir os de menor importância ou truncar de forma rígida.
365 KB → 3,2 KB — verificado em uma sessão típica de codificação com 50 saídas de ferramentas.

Ambos

Busca híbrida — BM25 (8 estratégias + expansão de sinônimos) + vetorial (nomic-embed-text-v1.5, 768-dim) + trigrama + Levenshtein executados em paralelo, fundidos via pesos adaptativos de intenção com reranking de conteúdo ponderado por IDF. Reranker LLM opcional.
Resolvedor temporal — análise determinística para consultas de datas relativas ("3 dias atrás", "sábado passado", "semana passada"). Custo zero de LLM. Retorna intervalo de datas absoluto com nível de confiança.
45+ ferramentas MCP — observar, buscar, recordar, perguntar, linha do tempo, grafo de conhecimento, detecção de entidades, consulta temporal, handoff de sessão, coordenação multiagente, orçamento de tokens, dashboard, diagnósticos e mais.
Totalmente local, zero nuvem — SQLite na sua máquina. Sem telemetria. Sem chaves de API necessárias para a funcionalidade principal.
Mecanismo de privacidade com 9 detectores — remove tags <private>, aplica redações de regex personalizadas, detecta chaves de API, tokens, senhas, padrões de PII. Nada sensível sai da sua máquina.
Operações em submilissegundos — classificação de importância a 556K ops/s, extração de entidades a 179K ops/s, busca BM25 a 3,3K ops/s, tudo local.

Como se compara

O espaço de memória tem vários players estabelecidos. O espaço de compressão de contexto tem mais alguns. Nenhuma outra ferramenta aborda ambos os eixos juntos.

	context-mem v4	Mem0	Graphiti	Zep	Letta
Wiki LLM / cofre markdown	✅	❌	❌	❌	❌
Ingestão automática de chamadas de ferramentas	✅	❌	❌	❌	❌
Recall de recuperação (local)	97,8–98,1% R@k	não publicado	não publicado	não publicado	não publicado
Compressão de tokens	99,1%	❌	❌	❌	parcial
Grafo de conhecimento tipado	✅	✅	✅	parcial	parcial
Consultas temporais em grafo	✅	✅	✅	❌	❌
Híbrido BM25 + vetorial + rerank por LLM	✅	parcial	❌	parcial	❌
Totalmente local (sem nuvem necessária)	✅	❌	❌	❌	❌
Reconstrução de trilha de decisões	✅	❌	❌	❌	❌
Saída compatível com Obsidian	✅	❌	❌	❌	❌
Ferramentas MCP	45+	algumas	algumas	algumas	algumas
Licença	MIT	Apache/nuvem	Apache	Apache	Apache

Notas sobre esta tabela: Os números de recall de recuperação para Mem0, Graphiti, Zep e Letta não são publicados com base nos mesmos benchmarks (LongMemEval, LoCoMo, MemBench, ConvoMem) em nível de sessão, usando metodologia comparável à nossa. Se existirem números publicados em suas documentações, eles se referem a conjuntos de dados diferentes, granularidade diferente (nível de chunk vs. nível de sessão) ou infraestrutura não divulgada. Não os compare diretamente. Os números de QA E2E para context-mem serão publicados com a v3.4. Todas as outras comparações são baseadas em documentação pública de abril de 2026.

A linha "compressão de tokens" merece uma nota: Mem0, Graphiti e Zep são principalmente sistemas de recuperação — eles não afirmam resolver o problema de custo da janela de contexto. Letta tem compressão parcial via sumarização. O número de 99,1% do context-mem foi medido em uma sessão real de codificação (50 saídas de ferramentas, 365 KB → 3,2 KB). A medição é reproduzível: você pode executá-la você mesmo no seu próprio projeto comparando context-mem stats --raw vs context-mem stats --compressed.

Exemplos do mundo real

You: "Why did we choose Postgres over MySQL?"
→ recall returns the exact verbatim quote from March 15 (importance 0.95)
  with the full evidence chain: error → file_read → search → decision

You: "What did Sarah work on last sprint?"
→ browse by person shows 14 observations mentioning Sarah,
  grouped by topic (auth, database, deployment)

You: "What are we about to forget?"
→ predict_loss shows 8 entries at risk: low importance, 45+ days old,
  never accessed. Pin the critical ones before they decay.

You: "Generate a PR description for this branch"
→ context-mem story --format pr assembles changes, decisions,
  resolved issues, and test plan from the current session

You: "What was our database schema in January?"
→ temporal_query returns what was true about the schema at that point
  in time, including since-superseded knowledge

Comece agora

1. Instalação

npm i context-mem && npx context-mem init

init cria a configuração MCP correta para o seu editor. Não é necessário reiniciar a IDE para Claude Code. Para Cursor, Windsurf e VS Code, reinicie a IDE após o init.

2. Configurar MCP (opção manual)

Se preferir configurar manualmente, adicione à sua configuração MCP:

{
  "mcpServers": {
    "context-mem": {
      "command": "npx",
      "args": ["context-mem", "serve"],
      "env": {}
    }
  }
}

Especificamente para Claude Code, init também grava 8 hooks em .claude/settings.json que injetam automaticamente memórias relevantes a cada envio de prompt — sem necessidade de chamadas manuais de observe durante o desenvolvimento normal.

3. Ativar o cofre LLM Wiki (opt-in na v3.4+)

Adicione à sua configuração context-mem (.context-mem/config.json):

{
  "vault": {
    "enabled": true,
    "vaultDir": ".context-mem/vault"
  }
}

O diretório do cofre será populado automaticamente na próxima ingestão de observação. Abra .context-mem/vault/ no Obsidian para navegar pela visualização em grafo do conhecimento do seu projeto.

O cofre é opt-in na v3.4 e será ativado por padrão na v4.0.

4. Painel

context-mem dashboard

Abre uma interface web local em http://localhost:3141 com 6 páginas: Visão Geral de Inteligência, Grafo de Conhecimento, Tópicos, Linha do Tempo, Entidades e Diagnóstico.

5. Benchmarks (execute você mesmo)

npm run bench          # quick mode (all 4 benchmarks, sample sizes)
npm run bench:full     # full benchmarks
npm run bench:e2e-qa   # E2E QA: retrieve → Haiku answer → Haiku judge

Todo o código dos benchmarks é aberto. Sem adaptadores ocultos que inflam números. Veja benchmarks/ e docs/benchmarks/methodology.md.

Referência de ferramentas MCP (45+)

context-mem expõe toda a sua superfície como ferramentas MCP — sem SDK proprietário, sem biblioteca wrapper, sem lock-in. Qualquer host compatível com MCP (Claude Code, Cursor, Windsurf, VS Code, Cline, Roo Code, Aider, Continue, JetBrains AI, CrewAI, LangChain, AutoGen) pode usar essas ferramentas diretamente. Não há ferramentas "premium" atrás de paywall e nenhum recurso que exija assinatura em nuvem. Cada capacidade listada neste README está disponível via interface MCP aberta.

Ferramentas principais de memória:

Ferramenta	Finalidade
`observe`	Armazenar observação com auto-sumarização, pontuação de importância, extração de entidades, detecção de tópicos
`recall`	Recuperar conteúdo verbatim por filtro (importância, tipo, flag, tempo)
`search`	Busca híbrida (BM25 + vetorial + juiz LLM opcional)
`ask`	Perguntas e respostas em linguagem natural sobre todo o armazenamento de memória
`timeline`	Observações em ordem cronológica reversa com selos de importância e flags
`stats`	Economia de tokens para a sessão atual (bruto vs. comprimido)

Ferramentas de grafo de conhecimento:

Ferramenta	Finalidade
`save_knowledge`	Salvar uma entrada de conhecimento com detecção de contradição + janelas de validade temporal
`search_knowledge`	Buscar (entradas substituídas são filtradas por padrão)
`promote_knowledge`	Promover para o armazenamento global entre projetos
`global_search`	Buscar em todos os projetos simultaneamente
`resolve_contradiction`	Resolver conflitos de conhecimento (substituir / mesclar / manter / arquivar)
`merge_suggestions`	Visualizar sugestões de duplicatas entre projetos
`graph_query`	Percorrer relacionamentos entre entidades
`add_relationship`	Vincular entidades com relacionamentos tipados
`graph_neighbors`	Encontrar entidades conectadas (profundidade configurável)

Ferramentas temporais e de inteligência:

Ferramenta	Finalidade
`temporal_query`	Consultar o que era verdade em um ponto específico no tempo
`time_travel`	Comparar o estado do projeto em dois timestamps arbitrários
`explain_decision`	Percorrer a cadeia de evidências para reconstruir por que uma decisão foi tomada
`predict_loss`	Identificar observações em risco de compressão/exclusão
`generate_story`	Gerar descrição de PR, atualização de standup, ADR ou guia de onboarding
`entity_detect`	Detectar entidades em texto arbitrário
`find_tunnels`	Encontrar conexões de tópicos entre projetos

Ferramentas de sessão e agentes:

Ferramenta	Finalidade
`wake_up`	Primer de contexto com orçamento de tokens para início de sessão
`restore_session`	Restaurar sessão a partir de checkpoint
`handoff_session`	Pacote de continuidade entre sessões
`agent_register`	Registrar um agente com papel e capacidades
`agent_status`	Verificar todos os agentes ativos e seus recursos reivindicados
`claim_files`	Reivindicar arquivos para evitar conflitos entre agentes paralelos
`agent_broadcast`	Transmitir uma descoberta para todos os agentes do projeto

Ferramentas de sistema:

Ferramenta	Finalidade
`configure`	Atualizar configuração em tempo de execução
`budget_status` / `budget_configure`	Gerenciamento de orçamento de tokens
`summarize`	Sumarizar conteúdo sem armazenar (one-shot)
`execute`	Executar código (JS, TS, Python, Shell, Ruby, Go, Rust, PHP, Perl, R, Elixir)
`index_content`	Indexar com chunking ciente de código
`search_content`	Buscar chunks indexados
`list_people` / `list_topics`	Navegar por entidades e tópicos
`import_conversations`	Importar histórico de conversas
`browse`	Recuperar observações por pessoa, entidade ou tópico
`diagnostics`	Log de erros, estatísticas de pipeline, saúde do armazenamento

API de diagnóstico

Se você precisar inspecionar o que o sistema está fazendo:

# MCP tool
mcp__context-mem__diagnostics

# HTTP (when dashboard is running)
curl http://localhost:3141/api/diagnostics

Retorna log de erros, estatísticas de pipeline, sessão ativa, saúde do armazenamento, estado do índice de busca.

Suporte a múltiplos agentes

context-mem suporta agentes de IA paralelos trabalhando no mesmo projeto sem colisões:

// Agent A registers and claims a file
mcp__context-mem__agent_register({ agent_id: "agent-a", role: "backend" })
mcp__context-mem__claim_files({ files: ["src/api.ts"] })

// Agent B sees Agent A's claim and avoids the conflict
mcp__context-mem__agent_status({})
// → { "agent-a": { files: ["src/api.ts"], status: "active" } }

// Broadcast a finding to all agents
mcp__context-mem__agent_broadcast({ message: "auth module has a race condition on token refresh" })

A memória compartilhada evita trabalho duplicado. Arquivos reivindicados evitam conflitos de merge. A transmissão mantém todos os agentes sincronizados sobre descobertas.

Referência de arquitetura: pipeline de busca

A pilha de recuperação executa 8 estratégias BM25 em paralelo, cada uma com peso e tradeoff de precisão/recall diferentes:

Estratégia	Peso	Finalidade
Modo AND	2,0	Alta precisão, todos os termos exigidos
Correspondência de frases	1,9	Pares de palavras-chave consecutivas
Foco em entidades	1,8	Substantivos próprios, datas, identificadores
FTS5 sanitizado	1,5	Tokenização padrão
AND relaxado	1,2	Entidade + principais palavras-chave
Modo OR + sinônimos	1,0	Recall amplo com expansão semântica
Palavras-chave individuais	0,5	Captura de cauda longa
Sinônimos individuais	0,2	Ponte de lacuna semântica (irmão → irmão)

Além disso, resolução temporal (peso 1,6): consultas de datas relativas ("sábado passado") são resolvidas deterministicamente para intervalos de datas absolutos antes da busca — custo zero de LLM.

A busca vetorial (nomic-embed-text-v1.5, 768-dim) roda em paralelo com BM25 nos 30 principais candidatos, não em cascata. Os resultados são fundidos via pesos adaptativos por intenção (BM25: 0,45, trigrama: 0,15, Levenshtein: 0,05, vetorial: 0,35) com rerank de conteúdo ponderado por IDF. O juiz LLM opcional combina 50/50 com a pontuação de recuperação no top-N final.

Esquema do LLM Wiki

O cofre segue um esquema documentado em docs/llm-wiki-schema.md. Ele especifica:

Layout de diretórios (sources/, entities/, topics/, knowledge/)
Tipos de página e convenções de frontmatter
Sintaxe de vinculação ([[entity-name]] resolve para entities/entity-name.md)
Operações: ingestão / consulta / lint
Receitas de fluxo de trabalho para agentes em CLAUDE.md / AGENTS.md
Contrato de interoperabilidade — outras ferramentas podem emitir wikis conformes que context-mem pode importar

Esta é uma especificação pública. RFCs da comunidade em github.com/JubaKitiashvili/context-mem/discussions.

Características de desempenho

Todas as operações principais são síncronas e sub-milissegundo. Nenhum LLM é necessário para qualquer operação padrão.

Operação	Throughput	Latência
Classificação de importância	556K ops/s	0,002ms
Extração de entidades	179K ops/s	0,006ms
Detecção de tópicos	162K ops/s	0,006ms
Cálculo de nível de compressão	3M ops/s	<0,001ms
Busca FTS5 verbatim	50K ops/s	0,020ms
Busca híbrida BM25	3,3K ops/s	0,3ms
Montagem de primer de wake-up	9K ops/s	0,111ms
Geração de narrativa	6K ops/s	0,164ms

O embedding vetorial (nomic-embed-text-v1.5) adiciona ~5–15ms por consulta quando a busca vetorial está habilitada — ainda mais rápido que qualquer chamada de rede. O juiz LLM opcional adiciona uma chamada de API Haiku (~100ms) e só é invocado quando ai_curation.enabled = true.

Destaques do changelog

v4.0.0 — Lançamento completo do LLM Wiki. Páginas de síntese, plugin Obsidian, 8 integrações de IDE, RFC do Context Protocol, polimento de compressão. Alvo: 2026-05-22.
v3.4.0 — Prévia do LLM Wiki. Camada de cofre markdown, especificação de esquema v1, benchmark E2E QA, issue #6 fechada (divulgação de metodologia de benchmark).
v3.3.0 — Fundamentos. CI, log de erros, diagnóstico. Patch silencioso.
v3.2.0 — Busca híbrida paralela. BM25 + vetorial em paralelo, fusão adaptativa por intenção.
v2.5.0 — Painel. Interface web em tempo real, visualização de grafo de conhecimento.

Licença: MIT

Construído por Juba Kitiashvili.

Crédito: Andrej Karpathy pelo enquadramento do LLM Wiki (2026-04-04). Vannevar Bush pelo Memex (1945).