Compartment

Compartment

Listado em: PyPI · Glama · LobeHub · MCP Toplist · mcpservers.org · TensorBlock · Libraries.io · Snyk Advisor · deps.dev

Memória agêntica durável, criptografada em repouso.

Seu agente de IA esquece de você no momento em que a sessão termina. Compartment acaba com isso. Com Compartment, seu agente de IA melhora com a experiência: ele percebe e armazena permanentemente cada decisão, preferência e detalhe offline, criptografado, no seu próprio computador. Hermes, Claude, OpenClaw e outros Agentes de IA podem instalar com um único comando. Um armazenamento de memória totalmente transferível é compartilhado simultaneamente por todos os agentes no computador. 100% offline: sem rede, sem chave de API, sem conta na nuvem, sem telemetria. O modelo de incorporação vem incluso no pacote, e uma busca completa retorna em cerca de 12 ms, superando a ida e volta que uma memória hospedada cobra de você. Cada byte em repouso é criptografado com AEAD, incluindo os vetores de incorporação, e apenas sua frase secreta o abre.

Diferente de outras memórias agênticas, oferecemos uma opção para começar com memória - 6.718 fatos selecionados instalados na instalação: as constantes físicas e conversões de unidades, mais de 800 fatos de hardware com especificações reais (Apple silicon, PCs, CPUs e GPUs, celulares, consoles de jogos, Raspberry Pi, armazenamento, monitores, conectores) para fornecer um mapa da geografia do computador, versões de sistemas operacionais e nomes de lançamentos, portas de rede e HTTP, assinaturas de arquivos, codificações de caracteres, internals de shell e Unix, git, regex, SQL e hashing, códigos ISO de países, moedas e fusos horários, e mais. Permite que um agente offline opere melhor sem internet, e um agente online opere mais rápido e com mais precisão.

Mais seguro, por construção. Cada byte em repouso é criptografado com autenticação, incluindo os vetores de incorporação (a maioria das ferramentas deixa esses em claro, e vetores podem ser invertidos de volta para texto). A exclusão é criptográfica: destrua a chave do registro e ele desaparece, irrecuperável. A adulteração é detectada, o histórico é encadeado por hash, e o cofre se bloqueia ao reiniciar ou em caso de queda de energia. Funciona totalmente offline: um guarda de tempo de execução aborta qualquer tentativa de rede, e CI prova isso em três sistemas operacionais.

Nem um passo mais difícil. Um comando instala, cria o cofre e conecta seu agente. Sem chave de API, sem conta na nuvem, sem daemon. Desbloqueie quando quiser usar; bloqueie quando quiser fechado. Por padrão, um desbloqueio permanece aberto por semanas (até reiniciar ou você bloquear), como qualquer aplicativo que você deixa em execução. A segurança é gratuita no ponto de uso porque surge da arquitetura, não da sua paciência: manter texto simples fora do disco força o índice para a RAM, e um índice residente em RAM também é o mais rápido que existe. Seguro e rápido são a mesma escolha aqui, e nenhum custa um passo de configuração.

Instalação

Instalação em uma linha, funciona em todos os sistemas operacionais.

pip install compartment && compartment init

Depois conecte ao agente que você usa:

compartment integrate claude

claude, hermes e openclaw são os três alvos de conexão automática. Cada um também recebe a habilidade /compartmentalize instalada em seu próprio diretório de habilidades.

/compartmentalize salva a conversa antes que ela seja descartada. Todo agente eventualmente compacta ou resume uma sessão longa, e o resumo é escrito por uma passagem que não tem ferramentas, então nada pode ser armazenado de dentro dela: o que o modelo não pensou em salvar simplesmente desaparece. Digite /compartmentalize e toda a conversa é varrida para o cofre primeiro - pessoas e contatos, credenciais e onde elas vivem, URLs e hosts, decisões e o raciocínio por trás delas, e uma narrativa da própria sessão. Depois compacte, e nada se perde. Também funciona sozinho a qualquer momento.

Instalação em um clique (para quem não é bom com linha de comando). Baixe Compartment.pkg do último lançamento e abra. Python, o modelo de incorporação e todas as dependências estão dentro dele. Apenas macOS.

Após a instalação, tudo é gerenciado pelo aplicativo: a barra de menus no macOS, a área de notificação no Windows e uma janela no menu de aplicativos no Linux.

Compartment é um servidor MCP, então funciona com toda IA agêntica compatível com MCP pronta para uso. Cada opção está em Configuração.

O que o diferencia

Instale em um passo

• Um comando instala, cria o cofre e conecta seu agente. Sem chave de API, sem conta na nuvem, sem daemon.
• No Mac, abra um .pkg e pronto. Python, o modelo de incorporação e todas as dependências estão dentro dele.
• Um aplicativo executa tudo sem terminal nos três sistemas: estado do cofre, desbloqueio, bloqueio e as últimas cinco memórias que salvou. A barra de menus do macOS, a área de notificação do Windows, uma janela no Linux.
• Cada recurso é alternado nesse painel em vez de um arquivo de configuração: captura independente de modelo, fatos iniciais na busca, bloqueio automático.
• /compartmentalize é instalado em cada agente ao qual se conecta, então um comando guarda uma conversa inteira antes que a compactação a descarte.
• Seu cofre já vem cheio. Os 6.718 fatos iniciais são memórias comuns, editáveis e esquecíveis, e um interruptor os mantém fora da busca.
• Funciona com o que você já usa: Hermes ("sem configuração necessária"), Claude Code e Desktop via MCP, OpenClaw, todo cliente MCP, além de uma CLI para scripts e cron.

Lembra das coisas certas

• "OK" é uma decisão, e Compartment a arquiva como tal, com a pergunta que respondeu. Esse é o registro que você precisa depois.
• Decisões superam preferências, preferências superam detalhes de máquina, detalhes de máquina superam conversa fiada. Uma classificação fixa, não o humor de um modelo.
• Não esquece nada. Conversa fiada é mantida e classificada por último.
• Substitui a memória embutida do seu host em vez de lutar contra ela: importa o que Claude Code já escreveu e depois a supera.
• Captura mesmo quando o modelo não coopera. Um hook escreve o fato independentemente de o modelo chamar a ferramenta.
• Um grafo, não uma pilha. Relações explícitas com janelas de validade respondem quem trabalhou onde e quando.

Busca que supera uma chamada de rede

• Busca vetorial de 0,68 ms. Cerca de 12 ms para o pipeline híbrido completo. Uma memória na nuvem gasta mais que isso só para dizer olá.
• Exata abaixo de 20 mil registros: recall = 1,0 por construção, não uma aproximação.
• Híbrida sempre: significado e palavras-chave, fundidos.
• Um espaço vetorial fixo, aplicado toda vez que o cofre abre, para que suas comparações permaneçam válidas para sempre.

Criptografado, offline e seu

• Cada byte em repouso é criptografado com AEAD, incluindo vetores de incorporação. A maioria das ferramentas deixa vetores em claro, e vetores invertem de volta para texto.
• Apenas sua frase secreta o abre. Compartment não gera senha, semente, frase de recuperação e não guarda nenhuma credencial que você não tenha.
• Adicione um arquivo de chave e o desbloqueio exige dois fatores. Ambos alimentam Argon2id juntos, então é aritmética, não uma verificação de política.
• forget --shred destrói a chave do registro. O conteúdo é matematicamente irrecuperável, não marcado como excluído.
• Reiniciar ou queda de energia o bloqueia, e o agente tem um bloqueio de pânico que limpa toda credencial instantaneamente.
• 100% offline. Um guarda de tempo de execução aborta qualquer tentativa de rede, e CI prova isso no Linux, macOS e Windows. Zero portas abertas. Sem telemetria, nunca.
• Sem LLM interno. As incorporações rodam localmente em menos de 300 MB, e o julgamento permanece com o modelo que você já paga.
• À prova de adulteração: log de auditoria encadeado por hash, diário selado, recuperação de falha kill-9 verificada.
• Um arquivo portátil. Mova um cofre bloqueado para qualquer lugar, e lock --sign o sela com um manifesto Ed25519 que qualquer um pode verificar sem credencial.
• compartment dash coloca todo o cofre em uma página local: apenas 127.0.0.1, token aleatório, somente leitura.

A lógica da memória

Caminho de escrita completo, matemática de decisão e comparações em docs/MEMORY.md. As ideias centrais:

Quase tudo é armazenado; nada importante é enterrado. Apenas turnos vazios são descartados. Um "OK" puro não é ruído, é uma decisão: quando o agente pergunta "Quer que eu envie esta resposta ao cliente agora?" e o usuário responde "OK", Compartment resolve a pergunta a partir da conversa e armazena [decisão 2026-07-20] Aprovado (respondeu "OK"): Quer que eu envie esta resposta ao cliente agora? no nível de importância mais alto. Perguntar "o usuário disse para enviar um e-mail ao cliente?" mais tarde recupera exatamente esse registro.

Níveis de importância determinísticos classificam a recuperação: decisões/consentimento 0,90, fatos pessoais e preferências 0,80, a máquina e configuração do usuário 0,75, outras declarações substantivas 0,55, gentilezas 0,20 (mantidas, classificadas por último). A importância multiplica uma correspondência em vez de somar a ela, então resolve quase-empates a favor do que importa e nunca pode trazer à tona uma memória para uma pergunta com a qual não tem relação. Todo o modelo de pontuação, e os números contra os quais foi escolhido, estão em A matemática. O agente aprende o usuário e o computador primeiro, o mundo em segundo, e não esquece nada.

Uma memória, não duas. Hosts de agentes cada vez mais têm uma memória própria - Claude Code mantém arquivos Markdown por projeto com um índice carregado automaticamente. Duas memórias significam que fatos caem naquela em que o modelo pensou por acaso, e nenhuma está completa. Compartment assume na instalação: importa o que a memória de arquivo já contém, e tanto o handshake MCP quanto o bloco gerenciado CLAUDE.md dizem ao modelo que Compartment a supera - escreva toda nova memória aqui, trate os arquivos como um arquivo somente leitura. Um cofre, criptografado, compartilhado por todos os agentes e projetos na máquina. Nada é excluído; os arquivos permanecem exatamente onde estavam.

Captura que não depende do modelo. Instruções são um pedido, e um host que declara sua própria memória no prompt do sistema supera qualquer coisa que uma ferramenta diga. Então compartment integrate claude também instala um hook PostToolUse: quando Claude Code escreve um arquivo de memória, o fato cai no cofre independentemente de o modelo ter pensado em Compartment. O hook é aditivo e idempotente (seus outros hooks não são tocados, settings.json é copiado primeiro), sai com sucesso não importa o que aconteça - uma ferramenta de memória nunca deve quebrar seu editor - e fica quieto quando o cofre está bloqueado. compartment hook status | install | uninstall, ou integrate claude --no-hooks.

Um aplicativo nos três sistemas, a partir da mesma instalação. pip install compartment && compartment init configura no macOS, Windows e Linux. Não há pacote separado, nada extra para lembrar e nenhum segundo comando. No Mac você pode, em vez disso, abrir Compartment.pkg do último lançamento, que carrega Python e todas as dependências dentro dele, então não há nada para instalar primeiro. compartment init --no-app pula o aplicativo para caixas headless e CI.

O mesmo painel, no lugar onde cada sistema guarda coisas assim: a barra de menus no macOS, a área de notificação no Windows e, no Linux, uma janela comum, com Compartment no menu de aplicativos. O Linux recebe uma janela em vez de um ícone deliberadamente. Se um ícone de bandeja aparece lá depende do ambiente de desktop, e no GNOME ou Wayland ele pode simplesmente nunca aparecer sem aviso, que é a pior forma de o controle que desbloqueia suas memórias falhar.

O painel mostra se o cofre está aberto, quanto ele aprendeu, as três configurações que valem a pena mudar no dia a dia (hook de captura, se fatos iniciais entram nas buscas, bloqueio automático), quais agentes estão conectados e botões para conectá-los, e as últimas cinco coisas que lembrou. Desbloqueie, bloqueie e mude sua frase secreta também lá, sem abrir um terminal. Ele não mantém cofre em memória - o estado vem da CLI, então um aplicativo ocioso não custa nada. Veja o que ele acabou de aprender. compartment recent lista as memórias mais recentes, das mais novas para as mais antigas, ocultando os milhares de fatos iniciais pré-carregados para que a pequena quantidade que o uso real produziu fique realmente visível — e compartment status reporta organic_records ao lado do total, para que um cofre que não aprendeu nada nunca pareça movimentado. A mesma visão via MCP que memory_recent.

Um fato por memória, com data. Uma memória é um ponto de dado atomizado, não um registro de sessão. memory_store_many processa um lote inteiro em uma única chamada, então armazenar seis fatos separadamente custa a mesma única ida e volta que agrupá-los em uma descrição de formato mais longa — que é o que fazia os agentes escreverem descrições de formato mais longas. Cada memória carrega o momento em que foi salva e, separadamente, o dia em que o fato foi descoberto, junto com como foi estabelecido, acrescentado como uma cláusula curta de [web search, 2026-08-01]. São duas datas diferentes: um preço que você verifica na sexta-feira e escreve na segunda-feira mantém a sexta-feira como descoberta e a segunda-feira como salvamento.

A busca retorna o que é relevante, não um número fixo. Quantas memórias respondem a uma pergunta é uma propriedade da pergunta, então o Compartment retorna toda memória cuja evidência se sustenta contra a melhor resposta para essa mesma pergunta, com um limite generoso. O corte precisa ser relativo, porque as pontuações não são comparáveis entre perguntas — em um cofre real, a consulta absurda "como fazer pão de fermentação natural" pontuou mais alto do que a genuína "o que o Max decidiu sobre o Airtable". Pergunte algo que o cofre não conhece e ele não retorna nada, em vez de uma página de irrelevâncias educadas. Passe um top_k explícito quando quiser exatamente essa quantidade.

Tags que permanecem fiéis. Sobre o que uma memória é nunca muda. Para o que ela é relevante muda constantemente, e uma tag escrita uma única vez, no dia em que a memória foi armazenada, não pode saber disso.

Aqui está um exemplo da falha que isso resolve. Trabalhando em um projeto chamado Northwind, você descobre que seu cliente quer números antes de conclusões: nunca abra com a recomendação, abra com os números. Esse é um fato durável sobre uma pessoa. O agente armazena isso e o marca com northwind, reporting, porque Northwind era o que estava à frente dele naquele dia.

Northwind termina. Dois anos depois, o mesmo cliente, agora usando o nome Harbour, contrata você novamente. Seu agente restringe a recuperação a harbour, da mesma forma que qualquer pessoa restringe uma busca quando um cofre contém milhares de memórias. A única coisa que você mais quer aplicar está arquivada sob um nome que não existe mais. Ela ainda é verdadeira e ainda é exatamente a regra certa, mas uma busca filtrada por tag não pode retorná-la, porque a filtragem por tag é uma correspondência de subconjunto e uma memória sem a tag simplesmente não está no conjunto. A memória não decaiu. Sua entrada de índice decaiu.

O Compartment repara isso automaticamente, offline, em segundo plano, sem usar um LLM. Conforme as memórias do Harbour se acumulam — o cliente pedindo números primeiro novamente, um deck reordenado para começar com eles — elas caem por design ao lado dessa preferência antiga no espaço de embeddings, porque são sobre o mesmo assunto e posicionadas de forma semelhante por lógica ordenada. Uma passada em segundo plano dá a cada memória as tags que seus vizinhos mais próximos carregam, ponderadas por cosseno, e a preferência recebe harbour deles. Dois outros sinais offline rodam junto: tags que quase sempre ocorrem juntas passam a se implicar mutuamente, e qualquer tag existente cuja frase aparece no próprio texto de uma memória é anexada. Nada no Compartment jamais soube o que eram Northwind ou Harbour.

A passada só pode escrever a coluna de tags, nunca o texto, as datas ou os embeddings. Ela é aditiva, a menos que você passe --prune, tags_origin mantém as tags com as quais uma memória nasceu para sempre, e compartment retag --dry-run mostra exatamente o que mudaria antes que qualquer coisa mude.

Um único espaço de embeddings fixado. O SHA-256 do modelo é registrado no cofre e aplicado na abertura; comparações de cosseno permanecem matematicamente válidas para sempre, em vez de degradarem silenciosamente quando um modelo muda. A migração é explícita: compartment reindex --re-embed.

Nenhum LLM interno. Os embeddings rodam localmente (modelo ONNX int8 de 384 dimensões incluído, <300 MB de RAM). O julgamento pertence ao modelo host que você já executa, via memory_store / memory_forget; o Compartment contribui com captura determinística, criptografia e recuperação total. Essa divisão é o que torna a garantia offline absoluta e cada decisão reproduzível. Combine o Compartment com um LLM offline e toda a pilha do agente pode rodar de forma útil sem nenhuma rede.

A matemática

Tudo abaixo vive em um único arquivo, src/compartment/ranking.py, que o cofre, o painel e o benchmark importam. Uma pontuação de benchmark é, portanto, uma medição do produto e não de uma cópia dele que se desviou.

Armazenamento: uma memória é incorporada em janelas, não truncada

O codificador lê 512 tokens. Texto além disso não é ponderado menos — não é visto de forma alguma, então uma memória longa costumava ser pesquisável apenas pela sua abertura. Em um cofre real de 6.705 memórias, 40% dos registros ultrapassavam a janela e 57,6% de todo o corpus era invisível para a busca semântica.

Então um registro é incorporado como janelas sobrepostas de W = 448 tokens com um passo de S = 384, dando 64 tokens de sobreposição para que nenhum fato seja cortado ao meio por uma fronteira, e o registro é pontuado pela sua melhor janela:

windows(d) = ceil( max(0, tokens(d) - W) / S ) + 1        capped at 64

s_vec(d)   = max over windows w of d :  cos(q, w)

Max-pooling, não média: uma memória é relevante se qualquer parte dela for, e uma média puniria uma memória longa pelas partes que são sobre outra coisa. Com uma janela por registro, isso se reduz exatamente ao comportamento antigo, então nunca pode ser pior para uma memória curta. O custo é pequeno porque a maioria das memórias é curta: naquele cofre, 6.705 registros produziram 6.785 janelas.

As janelas são medidas em tokens do modelo, nunca em caracteres. Um orçamento de caracteres erra por um fator de três entre prosa e um digest hex, e errar aqui significa descartar silenciosamente o final de uma memória.

Recuperação: dois canais, combinados como evidência em vez de somados

Dois índices procuram uma memória e respondem perguntas diferentes. O índice vetorial responde o que isso significa. O índice de palavras-chave responde o que isso diz. Suas pontuações não são denominadas na mesma coisa, e combiná-los é toda a dificuldade.

O movimento óbvio, e o que o Compartment enviou até agora, é somá-los. Somar é a operação errada: permite que uma correspondência semântica apenas boa supere evidência literal conclusiva. Buscar em um cofre real por um sha de commit que ocorre em exatamente uma memória entre 6.705 retornou essa memória abaixo de dez paráfrases dela — o índice de palavras-chave a classificou em primeiro lugar e a soma a enterrou.

Os dois canais não são adendos, são alternativas: qualquer um deles sozinho pode estabelecer relevância. Isso é um OR suave sobre evidência independente,

P(relevant) = 1 - (1 - p_vec)(1 - p_lex)

e a pontuação é seu logaritmo, que classifica de forma idêntica enquanto continua a espalhar os resultados perto do topo em vez de saturar em 1:

score(d) = - w_vec · log(1 - p_vec(d))  -  w_lex · log(1 - p_lex(d))

w_vec = 0.75      w_lex = 0.25

Qualquer canal se aproximando da certeza carrega a memória sozinho, e nenhum pode vetar o outro.

Lendo um cosseno como probabilidade. Um codificador normalizado por L2 dá cossenos que são comparáveis entre consultas, então eles mapeiam através de limites fixos. A normalização min-max por consulta é a alternativa óbvia e é uma armadilha: ela reescala o melhor resultado de uma consulta sem esperança para 1.0 e joga fora essa calibração.

p_vec(d) = clamp( (cos(q, d) - 0.25) / (0.85 - 0.25),  0,  0.88 )

Esse teto de 0.88 está fazendo trabalho real. Um cosseno é uma similaridade, nunca uma identidade: um codificador pode dizer isso é sobre a mesma coisa, mas nunca pode dizer este é o registro que você nomeou. Uma correspondência literal em uma string única para uma memória pode dizer exatamente isso. Então o canal semântico é limitado abaixo da certeza que o canal literal pode alcançar, e o limite é forçado em vez de escolhido — o canal literal atinge o máximo em 0.25 · -log(1 - 0.999) = 1.727, então o limite deve satisfazer 0.75 · -log(1 - cap) < 1.727, dando cap < 0.90.

Lendo um resultado de palavra-chave como probabilidade, e deliberadamente não com BM25. O BM25 responde quão bem isso corresponde, que não é o que decide um confronto contra um resultado semântico. O que decide é quão improvável a correspondência foi por acaso. Então cada termo de consulta carrega sua autoinformação sobre o cofre, e uma memória pontua a fração da informação da consulta que ela explica:

I(t)     = log( N / (1 + df(t)) )                     N = records in the vault

p_lex(d) = ( Σ I(t) for query terms t present in d ) / ( Σ I(t) for all t )

Um termo único para uma memória é evidência quase conclusiva. Um termo que aparece em um décimo do cofre é quase nada, seja qual for seu BM25. Esta é a peça que torna um resultado literal e um resultado semântico comparáveis.

O índice de palavras-chave é consultado com AND primeiro, já que uma correspondência de frase exata é o sinal mais forte disponível. O AND implícito do FTS5 significa que uma pergunta de nove palavras tem que aparecer palavra por palavra, então quando o AND não encontra nada, ele cai para OR apenas sobre os termos que carregam informação — qualquer coisa que apareça em mais de 10% dos registros é descartada. Esse teto é medido do cofre em vez de tirado de uma lista de stopwords em inglês, então ele se comporta da mesma forma para um cofre cheio de código, nomes ou outro idioma.

Um pequeno resíduo de concordância de classificação é adicionado, a única coisa em que a fusão de rank recíproco é genuinamente boa, dimensionado para desempatar em vez de decidir:

+ w_rrf · k · [ 1/(k + rank_vec) + 1/(k + rank_lex) ]      w_rrf = 0.10, k = 20

Classificação de importância: prioris multiplicam, nunca somam

final(d) = score(d) · ( 1 + w_imp · (2·importance(d) - 1)
                          + w_rec · 2^( -age_days(d) / 180 ) )

w_imp = 0.15      w_rec = 0.10

Multiplicativo, então uma priori só pode reordenar uma memória que já correspondeu. Uma priori aditiva permite que uma memória muito importante apareça para uma pergunta com a qual não tem nada a ver, que é como um sistema de memória começa a parecer assombrado. Uma memória que não correspondeu a nada pontua zero, e nada pode levantá-la do zero.

Centrado no padrão 0.5, que é por que 2·importance - 1 aparece em vez de importance. Cada memória sem peso carrega 0.5, incluindo os milhares de fatos iniciais com os quais um cofre vem. Sem centralizar, todos coletam o mesmo impulso silencioso, que é outra forma de dizer que a importância não fez nada. Centralizado, uma memória sem peso é exatamente neutra e um peso deliberado é a única coisa que move.

Os níveis que o caminho de captura escreve: decisões e consentimento 0.90, fatos pessoais e preferências 0.80, a máquina e configuração do usuário 0.75, outras declarações substantivas 0.55, gentilezas 0.20. A recência reduz pela metade a cada 180 dias.

Ordem de recuperação, e por que o pool é amplo

Filtros de namespace, tag, data e fatos iniciais rodam depois da classificação, então um pool de candidatos dimensionado para o número de resultados solicitados pode ser esvaziado por eles enquanto memórias correspondentes ficam logo além do corte. O pool começa em 200 por canal e alarga até três vezes quando a filtragem deixa poucos.

Medido

Contra o pontuador anterior, de ponta a ponta através de Vault.search, em um cofre real de 6.705 memórias com 44 consultas em quatro famílias:

	antes	depois
Recall@1	0.523	0.773
Recall@5	0.705	0.977
MRR@10	0.601	0.845
nDCG@10	0.627	0.878
identificadores exatos encontrados no top 5	4/10	10/10
fatos além da janela do codificador	0/6	5/6
paráfrases	16/16	16/16
latência mediana de busca	4.4 ms	11.6 ms

Nada regrediu em nenhuma família. Os pesos foram escolhidos a partir de uma varredura de sensibilidade e são deliberadamente redondos: o resultado é plano ao redor deles, porque um classificador que só funciona em w_lex = 0.37 é um classificador que não funciona.

Conectando cada agente

Um comando por plataforma. Cada um instala o pacote, cria seu cofre criptografado e conecta o agente.

Cada um desses também é um botão no aplicativo. Clique no ícone do Compartment na sua barra de menus ou área de notificação e, em CONNECT AN AGENT, pressione Claude, Hermes ou OpenClaw. O botão executa o mesmo comando compartment integrate para você, então ninguém precisa abrir um terminal uma segunda vez. Claude (Code + Desktop) - macOS / Linux:

pip install compartment && compartment init && compartment integrate claude

Windows (PowerShell):

py -m pip install compartment; compartment init; compartment integrate claude

Registra o servidor MCP na CLI do Claude Code (escopo do usuário, todos os projetos), importa quaisquer memórias que o Claude Code já tenha escrito em sua própria memória baseada em arquivos (somente cópia - os arquivos Markdown nunca são modificados; --no-import opta por não fazer isso, compartment import-claude faz isso mais tarde), e imprime o bloco de configuração do Claude Desktop. O servidor se descreve por meio do handshake MCP - ele diz ao modelo para recordar antes de responder e para armazenar fatos duráveis, credenciais, nomes e decisões - então o Claude trata o Compartment como sua memória sem instrução escrita manualmente; integrate claude também escreve um bloco gerenciado e idempotente no seu CLAUDE.md como backup.

Hermes - macOS / Linux:

pip install compartment && compartment init && compartment integrate hermes

Windows (PowerShell):

py -m pip install compartment; compartment init; compartment integrate hermes

Instala o plugin do provedor, conecta o venv do Hermes e executa hermes memory setup compartment. O Compartment então aparece no seletor hermes memory setup ao lado de hindsight e mem0, a única entrada marcada como "sem necessidade de configuração": sem chave de API, sem conta na nuvem, sem daemon. Verifique com hermes memory status. Veja tudo o que o Hermes lembra a qualquer momento com compartment dash - um comando, e o cofre abre no seu navegador (memórias por tipo, crescimento, o grafo de relações, busca ao vivo); Ctrl-C o fecha.

O Hermes também lê o formato portátil Agent Plugins, e este repositório é um deles. Essa rota instala o servidor MCP e a habilidade /compartmentalize diretamente do GitHub, e requer Hermes 0.20.0 ou mais recente, que é onde o carregador de plugins portátil chegou:

pip install compartment && compartment init
hermes plugins install MaxFreedomPollard/Compartment
hermes plugins enable compartment

O provedor acima continua sendo a integração mais completa, porque a recordação e a persistência rodam automaticamente a cada turno, enquanto o pacote portátil é invocado por ferramenta. No macOS e no Windows, os dois resolvem para o mesmo nome de diretório de plugin, então instale um ou outro.

OpenClaw - macOS / Linux:

pip install compartment && compartment init && compartment integrate openclaw

Windows (PowerShell):

py -m pip install compartment; compartment init; compartment integrate openclaw

Escreve a entrada mcpServers em ~/.openclaw/openclaw.json (com um backup), então: openclaw gateway restart e confirme com openclaw mcp list.

Qualquer cliente MCP - macOS / Linux / Windows:

pip install compartment && compartment init

compartment integrate --list nomeia os vinte e oito clientes MCP que conhece - Cursor, VS Code, Cline, Roo Code, Zed, OpenCode, Codex CLI, Gemini CLI, Oh My Pi, LM Studio, AnythingLLM, BoltAI e os demais - e compartment integrate --all escreve o bloco abaixo em cada um deles que estiver instalado aqui.

Em seguida, adicione o servidor à configuração MCP do seu cliente (transporte stdio, sem chave de API, sem variáveis de ambiente):

{
  "mcpServers": {
    "compartment": {
      "command": "compartment",
      "args": ["serve"]
    }
  }
}

--vault e --caller são opcionais (compartment --vault PATH --caller NAME serve); the defaults use ~/.compartment/memory.vault with caller user. Guias passo a passo por cliente em docs/INTEGRATIONS.md.

Medido, em um laptop básico de 8 GB

Cada número abaixo é reproduzível na sua máquina com compartment selftest e compartment bench.

Métrica	Medido
Instalação limpa → abrir cofre, offline	segundos, zero rede
Busca vetorial, 20 mil registros (HNSW)	p95 0,68 ms
Busca híbrida completa (embed + janelas + BM25 + fusão de evidências)	mediana 11,6 ms, p95 14,7 ms
RSS de pico, modelo + cofre + índice residentes	319 MB
Armazenar uma memória (embed + criptografar + fsync do diário)	~40 ms
Tamanho da wheel, modelo incluído	~30 MB
Suíte de testes (cripto, adulteração, crash, offline, concorrência, 2FA, grafo, painel, ranking)	566 testes, ~110 s

Uma única ida e volta de rede para uma API de memória na nuvem custa mais do que todo esse pipeline. A propriedade que torna o Compartment seguro (nenhum índice em texto puro no disco, então toda a busca fica residente em RAM) é a mesma propriedade que o torna rápido: abaixo de 20 mil registros, a busca é matemática exata de matriz SIMD, recordação = 1,0 por construção; acima disso, HNSW com SIMD com ~99% de recordação.

Nativo para agentes por design

O Compartment foi feito para ficar sob agentes que você já usa, não como um aplicativo separado que você precisa monitorar.

• Provedor nativo do Hermes - aparece em hermes memory setup com "sem necessidade de configuração". Ativa a sincronização automaticamente; a busca injeta apenas o que é relevante, marcado como dados, não instruções.
• Claude via MCP - um passo de integrate claude registra o servidor e fornece o bloco de configuração do Desktop além de um bloco gerenciado no CLAUDE.md, para que a memória faça parte do trabalho normal.
• OpenClaw e qualquer cliente MCP - o mesmo servidor stdio, zero portas abertas, as mesmas ferramentas (memory_search, memory_store, memory_forget, lock).
• Um grafo de memória, não apenas uma pilha de memórias - memory_link registra relações explícitas (quem trabalha onde, o que pertence a quê), com janelas de validade opcionais; memory_relations responde a consultas de entidade, predicado e as-of. Armazenamento determinístico, julgamento do modelo hospedeiro - a mesma divisão de tudo o mais no Compartment.
• CLI para todo o resto - scripts, cron, outros agentes: compartment store, compartment search, compartment recent, compartment forget, compartment link, compartment relations, compartment import-claude, compartment lock.
• Veja o cofre: compartment dash - um comando abre uma página local com tudo de relance: quantas memórias de cada tipo, crescimento ao longo do tempo, o grafo de relações, tags, contagens por agente, busca ao vivo. Servido a partir da RAM, somente em 127.0.0.1 atrás de um token de URL aleatório, somente leitura, zero requisições de saída, zero configuração.
• Bloqueio de pânico pelo agente - memory_lock / compartment lock limpa credenciais armazenadas instantaneamente quando você precisa fechar o cofre agora.
• Um cofre, muitos hosts - Hermes, Claude e a CLI podem compartilhar um cofre ao mesmo tempo; cada chamador tem sua própria identidade e ACLs de namespace.
• Uma memória, sem seções - as memórias iniciais semeadas em init vivem em main como registros comuns, editáveis e esquecíveis como qualquer coisa que o agente armazena; cofres mais antigos se reorganizam automaticamente.

No dia a dia, o ponto é simples: o agente lembra de você, das suas decisões e da sua máquina - criptografado, offline e rápido - sem uma conta na nuvem.

O modelo de bloqueio

Você bloqueia e desbloqueia o cofre quando quiser. O controle manual está sempre disponível:

• compartment unlock - abra o cofre com SUA frase secreta. Você a escolhe; o Compartment nunca gera automaticamente senha, semente ou frase de recuperação, e não há credencial que ele conheça que você não conheça. (Cofres criados por versões antigas que receberam uma frase de recuperação gerada automaticamente ainda abrem com ela.)
• compartment lock - feche-o novamente e limpe toda credencial armazenada. Os agentes podem fazer o mesmo pela ferramenta de pânico memory_lock.
• compartment 2fa enable - desbloqueio opcional com dois fatores: sua frase secreta (conhecimento) mais um arquivo de chave (posse - mantenha-o em um pendrive). Ambos os fatores alimentam o Argon2id juntos, então exigir ambos é garantido por aritmética, não por uma verificação de política; um arquivo de cofre roubado mais sua frase secreta ainda não abre nada sem o arquivo de chave. Um comando, zero configuração: a localização do arquivo de chave é lembrada, então o desbloqueio diário parece exatamente o mesmo enquanto o arquivo estiver presente.

O modo de desbloqueio padrão é conveniência, não uma gaiola: após um desbloqueio normal, o cofre permanece utilizável entre processos, logoffs e logins - por semanas ou meses se você deixar assim - até a próxima reinicialização ou queda de energia, ou até você bloqueá-lo manualmente. Reinicialização/queda de energia sempre o bloqueia: a credencial armazenada é a chave mestra envolvida sob um segredo aleatório de 32 bytes por inicialização, mantido em um objeto volátil do kernel que nunca é gravado em nenhum sistema de arquivos, então uma reinicialização o destrói e uma nova inicialização nunca pode abrir o antigo invólucro. Uma cópia do arquivo de credencial sozinha é inútil, porque a chave de que ela precisa nunca esteve no disco. Isso é aritmética, não uma verificação de política.

Se você preferir desbloqueio que sobrevive à reinicialização no macOS, isso é um opt-in explícito (compartment unlock --keychain), com a compensação documentada. A qualquer momento você pode bloquear, desbloquear, bloquear de novo - na sua agenda.

Segurança, em um parágrafo

XChaCha20-Poly1305 AEAD em tudo em repouso, incluindo vetores (resistência a inversão de embedding) · slots de chave Argon2id, estilo LUKS, abertos apenas pela própria frase secreta do usuário (sem credenciais geradas automaticamente), opcionalmente com dois fatores com um arquivo de chave · chaves por registro permitindo forget --shred (cripto-destruição: chave destruída, conteúdo matematicamente irrecuperável) · diário selado com fsync, compactação atômica, recuperação verificada de crash kill-9 · log de auditoria à prova de adulteração com encadeamento de hash (compartment audit verify) · ACLs de namespace por chamador, camada de quarentena para conteúdo não confiável, manifestos de cofre assinados · transporte MCP stdio: zero portas abertas · guarda de offline em tempo de execução que aborta em qualquer tentativa de socket; o CI executa toda a suíte com ele ativo no Linux, macOS e Windows · sem telemetria, nunca. Modelo de ameaça completo e honesto, incluindo o que o Compartment não pode proteger, em SECURITY.md.

Um cofre, muitos agentes

Hermes, Claude e a CLI podem compartilhar um único cofre simultaneamente: gravações são serializadas por um bloqueio de arquivo consultivo, cada processo detecta gravações estrangeiras e recarrega, e cada host recebe sua própria identidade de chamador e namespace com concessões rw/ro. Um cofre bloqueado é um único arquivo portátil, seguro para mover por qualquer canal; compartment lock --sign o sela com um manifesto Ed25519 que o destinatário pode verificar sem nenhuma credencial.

compartment lock
scp ~/.compartment/memory.vault other-machine:
compartment --vault memory.vault unlock     # your passphrase (+ keyfile if 2FA)

Configuração

Nada aqui é obrigatório. O Compartment já vem configurado, e esta é toda a superfície se você quiser mudar algo.

No aplicativo

O painel atrás do ícone: Desbloquear e Bloquear, Alterar senha, Criar memórias automaticamente (o gancho de captura), Buscar fatos iniciais, Bloqueio automático (15, 30, 60 minutos ou nunca), os botões CONECTAR UM AGENTE para Claude, Hermes e OpenClaw, Atualizar e Sair.

compartment panel --login on | off | status controla a inicialização no login, que no Linux é a entrada do menu de aplicativos.

Comandos

Comando	O que faz
init	cria o cofre. --passphrase, --creator, --keychain, --no-session, --no-app
unlock / lock	abre ou fecha. --passphrase-stdin, --keyfile, --keychain, --once; lock --sign --identity
status / verify / selftest	o que há nele, se está intacto, se funciona
store / get / forget	uma memória. --namespace, --tag, --importance, --quarantined, forget --shred
search / recent	encontra coisas. --namespace, --tag, --top-k, --limit, --all, --json
link / relations / unlink	o grafo de relações, com janelas de validade (--from, --to, --as-of)
panel (menubar, tray)	o aplicativo. --show, --self-check, --render, --login
integrate <agent>	conecta claude, hermes ou openclaw e instala /compartmentalize para ele. --no-import, --no-hooks
hook	gancho de captura: install --pin-vault, uninstall, status, capture
serve	o servidor MCP, via stdio
dash	lê o cofre no navegador: 127.0.0.1, token de uso único, somente GET
export / import	export --plaintext grava sem criptografia; import lê de volta
import-claude	importa o que o Claude Code já escreveu. --dir, --namespace, --dry-run
rekey	altera a frase secreta. --new-passphrase-stdin
2fa	enable, disable, status — um arquivo de chave como segundo fator
audit	verify, repair o histórico encadeado por hash
pack	build, install, remove, list, export pacotes de memória assinados (--trusted-key)
reindex	reconstrói o índice e dá aos registros longos as janelas de incorporação que faltam. --int8, --f32, --re-embed, --model
bench	--records, --longmemeval, --variant, --limit
setup	download-model, download-longmemeval, airgap-bundle
update	atualiza no lugar. --source pega o main do GitHub, --no-app pula a reinicialização
uninstall	remove. O cofre é mantido a menos que você passe --purge

Flags globais, antes do comando: --vault PATH, --caller NAME, --keyfile PATH, --assert-offline, --version.

A skill /compartmentalize

compartment integrate <agent> grava um arquivo no diretório de skills do próprio agente, e compartment uninstall o traz de volta:

Agente	Caminho
Claude Code	~/.claude/skills/compartmentalize/SKILL.md
Hermes	$HERMES_HOME ou ~/.hermes/skills/compartmentalize/SKILL.md
OpenClaw	$OPENCLAW_HOME ou ~/.openclaw/skills/compartmentalize/SKILL.md

Todos os três leem o mesmo layout de Agent Skills, então é um único arquivo empacotado. Ela só é invocada pelo usuário: nenhum agente a executa por conta própria. Edite sua cópia à vontade — uma instalação posterior faz backup de qualquer coisa que difira em vez de sobrescrever, e deixa o backup para trás quando a skill é removida. Invocá-la faz o agente varrer a conversa e gravar no cofre, então espere uma rajada de chamadas memory_store; é esse o objetivo.

Arquivo de configurações

<vault>.config.json, ao lado do cofre, contendo permissões por chamador e:

Configuração	Padrão	Significado
auto_lock_minutes	30	tempo ocioso antes de bloquear. 0 nunca bloqueia
search_starter_facts	true	se os fatos semeados entram nos resultados de busca
include_packs_in_search	true	o mesmo, para pacotes instalados
duplicate_threshold	0.97	similaridade de cosseno na qual um armazenamento é duplicado
index_precision	"f32"	"int8" usa um quarto da RAM
retag_interval_hours	6	com que frequência a passada em segundo plano rederiva tags. 0 desativa
retag_prune	false	se essa passada também pode REMOVER tags que o cofre não suporta mais
unlock_tool_enabled	false	permite que um agente desbloqueie o cofre. Desativado porque a frase secreta cruzaria o contexto do modelo

Ambiente

COMPARTMENT_VAULT qual cofre usar, COMPARTMENT_PASSPHRASE para scripts e CI, COMPARTMENT_SESSION_DIR onde a credencial de desbloqueio fica, COMPARTMENT_UI_SCALE escala do painel, COMPARTMENT_ASSERT_OFFLINE aborta em qualquer tentativa de rede. HERMES_HOME, OPENCLAW_HOME e XDG_DATA_HOME são lidos onde se aplicam. Qualquer coisa exportada como ENGRAM_* ainda funciona.

Ferramentas MCP

memory_search, memory_store, memory_store_many, memory_get, memory_recent, memory_forget, memory_link, memory_relations, memory_unlink, memory_list_namespaces, memory_status, memory_lock, memory_selftest. memory_unlock existe, mas fica desativada a menos que você a ative acima.

Documentação

docs/MEMORY.md	como a memória é armazenada, o que é lembrado, por que a matemática vence
docs/INTEGRATIONS.md	selecionando o Compartment no Hermes, OpenClaw, Claude e tudo mais
SECURITY.md	modelo de ameaças completo, limites honestos
FORMAT.md	especificações .vault e .mpack em nível de byte (independentes de linguagem)
PACKS.md	criação e distribuição de pacotes de memória assinados
RELEASING.md	fazendo um release: cada download, toda vez

---

mcp-name: io.github.MaxFreedomPollard/compartment