Memorix

Ponte de memória entre agentes com grafo de conhecimento, sincronização de workspace e hooks automáticos de memória. Suporta Windsurf, Cursor, Claude Code, Codex e VS Code Copilot.

GitHub

822

Experimente este MCPPatrocinado

Documentação

Memorix

Camada de memória compartilhada local-first para agentes de codificação de IA.
Um sistema de memória de projeto para Claude Code, Codex, CodeBuddy Code, Cursor, Windsurf, Copilot, Gemini CLI, OpenCode, Grok Build, OpenClaw, Hermes Agent, Oh-my-Pi, Pi, Kiro, Antigravity, Trae, DeepSeek Harness, WorkBuddy e qualquer agente compatível com MCP.

Listado no Registro Oficial de MCP

O status do mantenedor e o limite público do trabalho atual estão em ACTIVE_WORK.md. É o único rastreador de trabalho vivo do repositório.

O Memorix dá aos agentes de codificação de IA que você já usa uma memória de projeto compartilhada e pesquisável que sobrevive a novos chats, trocas de IDE, sessões de terminal e transferências. A memória vive sob o projeto Git, não dentro de uma janela de chat ou de uma ferramenta.

Use Claude Code hoje, Codex amanhã e Cursor à tarde. O agente pode mudar; a memória do projeto permanece a mesma.

Use o Memorix quando você fica reexplicando o mesmo projeto para uma nova sessão de agente: a última sessão já descobriu algo, outra IDE não consegue ver, ou uma decisão de design está enterrada em um chat que você não consegue mais encontrar.

Problema	O que o Memorix adiciona
A próxima sessão esquece o que a última sessão aprendeu	Memória com escopo de projeto, resumos de sessão, linhas do tempo e recuperação de detalhes
Agentes diferentes sabem coisas diferentes	Um único pool de memória local disponível via MCP, hooks, CLI, SDK e o agente de terminal integrado
O Git registra o que mudou, mas os agentes não conseguem recordar bem	A Memória Git transforma commits em fatos de engenharia pesquisáveis
Decisões de arquitetura desaparecem em chats antigos	A Memória de Raciocínio armazena por que as escolhas foram feitas, com alternativas e trade-offs
Arquivos de regras estáticos se desatualizam	Gotchas, correções e habilidades de projeto evoluem a partir do trabalho real
O trabalho paralelo de agentes fica bagunçado	`memorix orchestrate` coordena contexto de tarefas, transferências, bloqueios, verificação e loops de revisão

O Memorix é local-first. SQLite é o armazenamento canônico. Projetos pequenos usam o caminho Orama em processo; projetos maiores usam um índice de candidatos SQLite FTS5 persistente e, quando disponível, um índice de sombra semântico LanceDB local opcional. Ambos os índices são reconstruíveis e nunca são um limite para quantas memórias duráveis você pode manter. A formação e a incorporação baseadas em LLM permanecem opcionais.

Recursos

O Memorix é mais do que um armazenamento de memória. Ele também instala integrações de agentes, mantém eventos de trabalho úteis, transforma commits em fatos de projeto, expõe um plano de controle local e pode coordenar trabalho multiagente quando uma tarefa precisa.

Recurso	O que faz	Ponto de entrada
Autopiloto de Memória	Um Workset de tarefas limitado com arquivos iniciais, memória atual, conhecimento com fonte, inícios de fluxo de trabalho, advertências e verificação. Receitas JSON compactas mantêm o uso de CLI de fallback limitado também.	`memorix context "..." --brief-json`, `memorix resume "..." --brief-json`, `memorix_project_context`
Memória de Observação	Fatos pesquisáveis, correções, gotchas, resumos de sessão e notas de implementação com escopo no projeto Git atual	`memorix memory`, ferramentas de memória MCP
Memória de Longo Prazo Curada	Memória episódica, semântica e processual deliberadamente revisada com evidência de fonte. Apenas um item de usuário explicitamente portátil pode cruzar projetos locais	`memorix memory long-term`
Estado de Código e Memória de Código	Snapshots de código local versionados, símbolos e relações TypeScript/JavaScript com fonte, links de arquivo/símbolo e verificações de atualização. Outras linguagens mantêm o fallback Lite honesto; um CodeGraph local já indexado ou resultado SCIP pode adicionar um esboço externo limitado sem assumir o índice local.	`memorix codegraph status\|refresh\|init\|sync`, atualização automática de contexto
Memória Git	Fatos de engenharia derivados de commits que respondem o que mudou, onde e por que importa	`memorix ingest commit`, hook do git
Memória de Raciocínio	Racional de design, alternativas, trade-offs e riscos que devem sobreviver além de um chat	`memorix reasoning`, formação de memória
Workspace de Conhecimento	Afirmações com fonte e revisão-gated, páginas Markdown e fluxos de trabalho canônicos de projeto; propostas nunca sobrescrevem páginas revisadas silenciosamente	`memorix knowledge`, `memorix knowledge workflow`
Configuração de agente	Um caminho de configuração para MCP, regras, hooks, habilidades, plugins, bundles ou extensões dependendo do agente	`memorix setup --agent <agent>`
Doctor de agente	Verifica se a configuração MCP e as orientações do agente estão atualizadas e repara entradas de propriedade do Memorix quando necessário	`memorix doctor agents`, `memorix repair agents`
Hooks e habilidades	Captura opcional de agentes suportados, além de habilidades de projeto reutilizáveis promovidas de conhecimento durável	`memorix hooks`, `memorix skills`
Dashboard e HTTP	Uma interface web local e endpoint MCP compartilhado para navegar memória, estado do projeto, equipes, diagnósticos e ações de limpeza, consolidação, deduplicação e retenção com pré-visualização	`memorix dashboard`, `memorix background start`
Orquestração e trabalho em equipe	Planejamento de tarefas, transferências de trabalhadores, bloqueios de arquivos, mensagens, portões de verificação e loops de revisão	`memorix orchestrate`, `memorix team`, `memorix lock`
memcode	Um agente de codificação de terminal integrado que já lê e escreve a mesma memória de projeto	`memorix`, `memcode`
CLI e SDK	Acesso via script para automação, importações/exportações, diagnósticos e integrações personalizadas	`memorix ...`, `createMemoryClient()`
Sincronização multi-dispositivo opcional	Eventos de observação com filtro de privacidade com SQLite local mantido canônico; escopo de projeto padrão, `--scope user` opcional para cada projeto local; relay GitHub JSONL, filesystem, S3 ou Postgres	`memorix sync store status\|push\|pull`

O Memorix conecta-se através das interfaces que cada agente já suporta: pacotes de plugin, MCP, regras de projeto, hooks, habilidades ou o agente de terminal integrado. memorix setup escolhe a configuração certa para cada agente e mantém o MCP stdio como transporte padrão.

Claude Code _{plugin oficial + MCP + hooks + habilidades}	Codex CLI _{plugin oficial + MCP + AGENTS.md}	GitHub Copilot CLI _{plugin + MCP + hooks + habilidades}	Cursor _{MCP + regras + habilidades}	Windsurf _{MCP + regras + hooks}	Gemini CLI _{extensão + MCP + hooks + habilidades}
OpenCode _{plugin local + MCP + habilidades + AGENTS.md}	agente de codificação pi _{pacote + extensão + habilidade}	Kiro _{MCP + direcionamento + hooks}	Antigravity _{plugin + MCP + hooks + habilidades}	Trae _{MCP + regras de projeto}	memcode _{agente de terminal integrado}
OpenClaw _{bundle + MCP + hooks + habilidades}	Hermes Agent _{plugin + MCP + hooks + habilidades}	Oh-my-Pi _{pacote + MCP + hooks + habilidades}	DeepSeek Harness _{patch MCP + AGENTS.md + habilidades}	Qualquer Cliente MCP _{MCP stdio ou HTTP}	Grok Build _{hooks nativos + AGENTS.md}

_{Funciona com agentes que falam MCP, expõem hooks/regras ou suportam entradas de plugin/pacote. Uma camada de memória local-first compartilhada entre todos eles.}

Superfícies de integração:

Superfície	O que faz	Entrada do Memorix
Comando de configuração	Instala a integração recomendada do Memorix em nível de usuário, uma única vez	`memorix setup --agent <agent> --global`
MCP	Dá ao agente ferramentas compactas do Memorix para contexto de projeto, busca, recuperação de detalhes, armazenamento e resolução	incluído nos pacotes de configuração ou `memorix serve`
Orientação de uso	Ensina ao agente quando e como usar o Memorix sem forçar consulta de memória a cada prompt	incluído ou gerado por `memorix setup`
Hooks	Captura opcional de prompts, eventos de ferramentas, edições de arquivos, eventos de ciclo de vida de sessão e checkpoints nativos de compactação onde o agente os expõe	incluído ou gerado por `memorix setup`
Pacote de plugin ou bundle	Instala arquivos de plugin, bundle compatível ou pacote onde o agente os suporta	Claude Code, Codex, CodeBuddy Code, GitHub Copilot CLI, Antigravity, OpenClaw, Hermes Agent, Oh-my-Pi, Pi
Extensão	Instala arquivos de extensão onde o agente os suporta	Gemini CLI
Plugin local	Instala arquivos de plugin local onde o agente os carrega diretamente	OpenCode
Config de MCP/regras	Escreve configuração de MCP, regras, direcionamento, orientação ou hooks para IDEs e agentes que expõem essas superfícies	Cursor, Windsurf, Kiro, Trae, DeepSeek Harness, WorkBuddy
Skills	Transforma conhecimento durável de projeto em orientação de tarefa reutilizável	`memorix skills` e `memorix_promote`
memcode	Abre o agente de terminal incluído que já usa a memória do Memorix	`memorix` ou `memcode`

Consulte Superfícies de Integração para a matriz de suporte atual e o que cada arquivo gerado significa.

Use o mesmo comando de configuração sem --global apenas quando você intencionalmente quiser orientação, regras ou hooks locais ao repositório no projeto Git atual.

CLI, MCP e HTTP são pontos de entrada diferentes:

memorix CLI é a superfície de comando direta para configuração, busca/armazenamento de memória, Git Memory, importação/exportação, dashboard, orquestração, diagnósticos e automação.
memorix serve é a ponte MCP stdio usada por IDEs e agentes de codificação. Seu perfil de ferramentas padrão é micro, então os agentes veem apenas o conjunto de ferramentas principais compacto.
memorix background start / memorix serve-http executam o serviço HTTP para um endpoint compartilhado, dashboard, implantação Docker em VPS ou múltiplos clientes.

A sincronização de armazenamento multi-dispositivo é opcional e separada do compartilhamento HTTP. Ela nunca envia o banco de dados SQLite ativo ou arquivos WAL. Por padrão, ela apenas retransmite observações qualificadas visíveis ao projeto para o projeto Git atual; registros pessoais, direcionados a agentes, candidatos e efêmeros permanecem locais. Passe --scope user para incluir todos os projetos locais. Defina MEMORIX_SYNC_PROVIDER e inspecione memorix sync store status --json antes do primeiro envio.

Requisitos:

Node.js >=22.18.0
Git, porque a identidade do projeto é derivada da raiz Git real

Instale e inicialize:

npm install -g memorix
memorix init --global                   # optional defaults
memorix setup --agent claude --global   # or codex, copilot, cursor, pi, gemini-cli, opencode,
                                       # codebuddy, windsurf, kiro, antigravity, trae, openclaw, hermes, omp

memorix init é opcional. Ele cria ou atualiza a configuração TOML:

~/.memorix/config.toml para padrões globais
<git-root>/memorix.toml para sobrescritas opcionais de projeto

Os legados memorix.yml, .env e ~/.memorix/config.json ainda são lidos para compatibilidade, mas novos fluxos de configuração usam TOML.

Se você quiser orientação ou hooks locais ao repositório para um repositório específico, execute o mesmo comando de configuração de dentro desse repositório sem --global. Codex é a exceção: seu caminho suportado é a instalação de plugin em nível de usuário, então o Memorix deixa a configuração de .codex do projeto intacta.

Conectar um agente existente

Use o comando de configuração primeiro. A forma global é a instalação normal de uma única vez:

memorix setup --agent claude --global
memorix setup --agent codex --global
memorix setup --agent copilot --global
memorix setup --agent cursor --global
memorix setup --agent pi --global
memorix setup --agent gemini-cli --global
memorix setup --agent opencode --global
memorix setup --agent windsurf --global
memorix setup --agent kiro --global
memorix setup --agent antigravity --global
memorix setup --agent trae --global
memorix setup --agent openclaw --global
memorix setup --agent hermes --global
memorix setup --agent codebuddy --global
memorix setup --agent omp --global
memorix setup --agent dsh --global
memorix setup --agent workbuddy --global
memorix setup --agent grok --global

O que ele instala depende do agente alvo, mas o objetivo é o mesmo: tornar o Memorix disponível onde quer que você abra esse agente, sem pedir que você configure cada repositório manualmente.

Claude Code: instala o pacote de plugin do Memorix, adiciona orientação CLAUDE.md e habilita a captura de hooks quando você não passa --noHooks.
Codex: instala um plugin do Memorix em nível de usuário com MCP stdio incluído, skills e hooks de ciclo de vida. Ele não escreve configuração .codex local ao projeto nem altera suas configurações de modelo, aprovação ou sandbox. Quando o Codex perguntar, revise a definição do hook do plugin uma vez com /hooks; --noHooks pula a captura automática.
GitHub Copilot CLI: instala o pacote de plugin do Copilot e as skills oficiais do Memorix.
Pi: instala o pacote Pi em nível de usuário e as skills oficiais.
Cursor: escreve entradas de MCP/regras/config do Cursor no escopo escolhido.
Gemini CLI: instala o pacote de extensão, contexto GEMINI.md, hooks e skills. O Antigravity CLI tem um caminho oficial de migração do Gemini CLI, mas o Gemini CLI continua sendo um alvo autônomo ativo.
OpenCode: instala o arquivo de plugin local, opencode.json, skills e orientação AGENTS.md.
Windsurf, Kiro, Trae: escrevem os arquivos de MCP/regras/hooks que o alvo suporta.
Antigravity: instala o pacote de plugin oficial com plugin.json, mcp_config.json, hooks.json, regras e skills sob ~/.gemini/config/plugins/memorix ou .agents/plugins/memorix.
OpenClaw: instala um bundle compatível com OpenClaw com .mcp.json, skills oficiais e um pacote de hooks HOOK.md/handler.ts do OpenClaw.
Hermes Agent: instala no diretório home do Hermes (%LOCALAPPDATA%\hermes no Windows nativo, ~/.hermes em outros lugares, ou HERMES_HOME), habilita o plugin em config.yaml, registra hooks de plugin, comandos de barra/CLI, skills e escreve configuração MCP.
CodeBuddy Code: instala um plugin de marketplace local em escopo de usuário sob ~/.codebuddy/memorix-local com MCP, skills e hooks. Ele não altera arquivos existentes de modelo, permissão ou configurações do CodeBuddy; o CodeBuddy mantém a aprovação de hooks de terceiros em seu próprio fluxo /hooks.
Oh-my-Pi: instala um pacote omp.extensions com eventos de hook de extensão, um comando memorix, skills oficiais e escreve configuração MCP.
DeepSeek Harness: escreve uma linha @deepseek-ai/dsh-mcp-client do Memorix em $DSH_HOME/cordis.patch.yml (padrão ~/.dsh/cordis.patch.yml), anexa orientação ao AGENTS.md do harness e instala skills oficiais sob $DSH_HOME/skills. A linha segue a referência do Memorix fornecida pelo próprio DSH, então as ferramentas aparecem como mcp__memorix__*.
WorkBuddy: escreve uma linha de servidor MCP do Memorix em ~/.workbuddy/mcp.json (ou <project>/.workbuddy/mcp.json para instalações de projeto) e anexa orientação a AGENTS.md. As ferramentas aparecem como mcp__memorix__*; não há superfície de hooks.
Grok Build: instala hooks de ciclo de vida nativos sob ~/.grok/hooks/memorix.json e orientação em ~/.grok/AGENTS.md. O MCP permanece de propriedade do host por padrão; passe --mcp http para escrever [mcp_servers.memorix] com url = "http://localhost:3211/mcp". Hooks locais ao projeto exigem Grok /hooks-trust, enquanto hooks globais são confiáveis. Defina GROK_HOME para usar um diretório home Grok personalizado.

Precisa de uma instalação mais silenciosa? Adicione --noHooks para alvos onde a configuração pode controlar a captura de hooks separadamente da entrada oficial do pacote do host. Ele mantém MCP e orientação, mas pula a captura de hooks do Memorix.

Se você intencionalmente quiser orientação ou hooks locais ao repositório, execute o mesmo comando dentro desse repositório sem --global.

Se o seu agente precisar apenas de uma entrada MCP manual, use stdio:

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

Para um cliente MCP baseado em npm ou testador de registro, use o comando completo npx -y memorix serve. O argumento serve importa: memorix sem argumentos abre o agente de terminal memcode incluído quando executado por um humano, enquanto clientes MCP devem iniciar o servidor stdio explicitamente.

Para uma entrada Claude Code gerenciada manualmente, adicione "alwaysLoad": true dentro do objeto de servidor memorix. Isso permite que o Claude Code exponha as ferramentas do Memorix durante a inicialização em modo de impressão; memorix doctor agents --agent claude pode detectar e reparar uma configuração ausente.

HTTP não é necessário para configuração normal. Use-o apenas quando você intencionalmente quiser um serviço de fundo compartilhado, dashboard, implantação Docker em VPS ou múltiplos clientes usando o mesmo endpoint. O desenvolvimento local usa o serviço Node diretamente e não requer Docker:

memorix background start

Em seguida, aponte o cliente para:

http://localhost:3211/mcp

No modo HTTP, os agentes devem vincular o repositório ativo explicitamente com memorix_session_start(projectRoot=...) quando o cliente puder fornecer o caminho do workspace. O Git permanece a fonte final de verdade para a identidade do projeto.

Desinstalar

Pré-visualize o que será removido:

memorix uninstall --dry-run

Pare o serviço de fundo e remova os hooks:

memorix uninstall --background --hooks

Limpeza completa:

memorix uninstall --yes --background --hooks --purge-data
npm uninstall -g memorix

memorix uninstall relata entradas de configuração MCP para limpeza manual em vez de editar silenciosamente todos os arquivos MCP que encontrar.

Trabalhar pela CLI

memorix --cwd /path/to/repo resume "continue release blocker"
memorix checkpoint list
memorix memory search --query "release blocker"
memorix memory --help

# Optional: activate one local agent identity for personal/team records and coordination.
memorix identity join --agent-type codex --name codex-main
memorix memory store --text "private investigation note" --visibility personal
memorix task create --description "verify the release package"

# Deliberate durable memory: create a candidate, then review it before it can enter a Workset.
memorix memory long-term add --kind procedural --scope user --portability portable --title "Release verification preference" --text "Run focused tests and a packed-package smoke before publishing." --applicability "When publishing an npm package."
memorix memory long-term qualify --id <id> --reason "The user explicitly confirmed this preference."
memorix memory long-term approve --id <id> --reason "Reviewed for future local projects."

memorix transfer export --format json --out ./.memorix-export.json
memorix transfer import --file ./.memorix-export.json
memorix reasoning search --query "why sqlite"
memorix git-hook --force
memorix ingest log --count 20
memorix workbench

A CLI é direta e não depende de uma sessão MCP. Ela se vincula ao projeto Git atual, ou ao projeto fornecido com --cwd. Sem uma identidade ativa, ela lê, escreve e exporta apenas memória visível ao projeto. Use memorix identity join ou memorix identity use --agent-id <id> apenas quando você intencionalmente precisar de memória pessoal/da equipe ou ações de tarefa coordenadas; memorix identity clear retorna o terminal ao escopo do projeto. --as <active-agent-id> é a alternativa de comando único para scripts. Flags em camelCase e kebab-case são aceitas.

Gerenciar mídia controlada

A mídia é opcional. Uma importação local explícita é copiada para o diretório de dados local do Memorix, com hash aplicado e mantida fora da árvore de trabalho do Git. Ela se torna memória normal apenas quando você a anexa. O Memorix nunca captura cada captura de tela ou saída de ferramenta. Um ativo pode ter até o limite de mídia configurado (100 MiB por padrão). A análise automática de visão é deliberadamente limitada a 20 MiB; uma imagem maior ainda é mantida e pode ser anexada, mas o Memorix registra um fallback de texto claro em vez de enviar um payload superdimensionado a um provedor de modelo.

memorix media import --path ./architecture.png --json
memorix media attach --asset <asset-id> --title "Architecture diagram" --json
memorix media list --kind image --json
memorix media show --asset <asset-id> --json
memorix media remove --asset <asset-id> --force --json

# Controlled derivations: explicit, bounded, and attachable to memory.
memorix media derive-pdf --asset <asset-id> --attach --json
memorix media derive-audio --asset <asset-id> --attach --json

# Legacy image analysis now uses the same controlled asset lifecycle.
memorix ingest image --path ./architecture.png --json

A geração de imagem MiniMax é uma operação CLI deliberada. A geração de vídeo retorna um job durável imediatamente; inspecione ou cancele esse job em vez de esperar em uma solicitação de agente.

# Configure MINIMAX_API_KEY in your user environment or .env, never in Git.
memorix media generate image --prompt "A clean system architecture diagram" --json
# Image-to-image with a reference image (MiniMax image-01 / image-01-live):
memorix media generate image --prompt "Keep the subject, change the background" --image ./reference.png --json
memorix media generate video --prompt "A short product walkthrough" --json
memorix media status --job <media-job-id> --json
memorix media cancel --job <media-job-id> --json

memorix_media é o companheiro MCP compacto em todos os perfis, incluindo micro. Ele suporta importação, anexo, listagem, exibição, derivações de PDF/áudio, geração e status de job. A geração de imagem e vídeo via MCP está desabilitada por padrão porque pode incorrer em custos de provedor. Defina MEMORIX_MCP_MEDIA_GENERATION=1 apenas depois que você deliberadamente quiser que um agente solicite saída MiniMax cobrada. O caminho normal de embedding de texto OpenRouter ainda é somente texto; vetores de mídia são criados apenas por um provedor que declara explicitamente suporte para essa modalidade. Descrições de texto e anexos permanecem um fallback útil de recuperação comum.

Usar o agente de terminal incluído

memorix
# or
memcode

Isso abre o memcode, um agente de codificação de terminal que usa a mesma memória de projeto do Memorix que seus agentes conectados via MCP.

Camada	Armazena	Melhor para
Memória de Observação	fatos, pegadinhas, correções, notas de implementação	"Como isso funciona?"
Memória de Raciocínio	justificativa, alternativas, restrições, riscos	"Por que escolhemos isso?"
Git Memory	fatos de engenharia derivados de commits	"O que mudou e onde?"
Memória de Código	arquivos, símbolos, arestas de importação e frescor memória-para-código	"Qual código atual devo inspecionar primeiro?"
Memória de Longo Prazo Curada	eventos episódicos revisados, fatos estáveis ou procedimentos reutilizáveis com evidência	"O que este agente ainda deve saber ou fazer depois?"
Continuidade Compacta	resumos compactos recentes nativos do host ou marcadores de ciclo de vida	"O que sobreviveu à última compactação de contexto?"

A busca é limitada ao projeto por padrão. scope="global" busca entre projetos. A busca impulsiona Git Memory para perguntas de "o que mudou" e registros de raciocínio para perguntas de "por quê". A memória de longo prazo não é, deliberadamente, um despejo automático de todas as notas. Uma observação de origem, uma Claim, um fluxo de trabalho, uma sessão e um snapshot de código mantêm seus papéis existentes. Um agente pode solicitar memorix_store para criar um registro adicional de longo prazo; uma solicitação explícita se qualifica automaticamente e entra nos briefs de tarefa como uma âncora durável, enquanto candidatos capturados por hooks ou derivados do Git permanecem pendentes até serem qualificados. A aprovação continua sendo uma revisão explícita do operador. Use memorix memory long-term approve|archive|supersede para registrar o ciclo de vida com base em evidências. Apenas um item user + portable criado manualmente ou confirmado pelo usuário pode ser considerado em outro projeto local; código de projeto, fatos do Git, testes, fluxos de trabalho, sessões e observações não podem ser promovidos para a memória portátil do usuário.

memorix context "..." é a entrada padrão do Memory Autopilot. Ele cria um brief compacto com foco na tarefa para agentes: tarefas de correção de bugs tendem a priorizar testes e reproduções, tarefas de release tendem a priorizar verificações de pacote/changelog/build, tarefas de onboarding tendem a priorizar documentação e pontos de entrada, e memórias desatualizadas ou não relacionadas permanecem em faixas de aviso em vez de inundar o prompt. Use --fallback --brief-json quando o MCP não estiver disponível e um fallback de CLI precisar do mesmo brief limitado, além de um recibo do que foi selecionado ou omitido; --json permanece como a forma detalhada de diagnóstico. Uma nova tarefa normal não recebe um despejo de sessão antiga. Para uma continuação explícita, memorix resume "..." adiciona apenas o resumo de sessão mais recente e útil, até três âncoras duráveis legíveis e, no máximo, um checkpoint compacto recente do host com rótulo de origem. Uma âncora durável carrega uma referência durable:<id>, para que um agente possa expandir o registro completo revisado por meio de memorix_detail somente quando necessário. Correspondências por palavra-chave continuam sendo primárias; quando nenhum item durável revisado corresponde e um provedor de embeddings está configurado, o Memorix faz um fallback semântico de 1,8 segundo, sem tentativas, para paráfrases ou tarefas multilíngues. Um provedor lento ou indisponível simplesmente deixa o Workset normal apenas por palavra-chave intacto. Um checkpoint é evidência do ciclo de vida, não memória durável ou backup de transcrição. Os agentes devem ler os arquivos sugeridos antes de confiar na memória armazenada.

Você quer	Execute
Instalar um pacote de integração de agente	`memorix setup --agent <agent> --global`
Verificar ou reparar uma integração de agente	`memorix doctor agents --agent <agent>`, `memorix repair agents --agent <agent>`
Expor manualmente o MCP via stdio	`memorix serve`
Executar MCP HTTP compartilhado mais dashboard	`memorix background start`
Depurar o MCP HTTP em primeiro plano	`memorix serve-http --port 3211`
Inspecionar ou gerenciar memória diretamente	`memorix memory`, `memorix reasoning`, `memorix session`, `memorix ingest`, `memorix media`
Gerenciar memória de longo prazo revisada	`memorix memory long-term list
Aposentar memórias da recuperação	`memorix purge` (projeto atual), `memorix purge --all --yes` (tudo)
Inspecionar a continuidade nativa de compactação	`memorix checkpoint list
Usar o plano de controle de memória interativo do terminal	`memorix workbench`
Usar o agente de terminal incluído	`memorix` ou `memcode`
Executar trabalho orquestrado de subagentes	`memorix orchestrate --goal "..."`

memorix serve usa como padrão --mode micro (9 ferramentas) para manter os schemas de ferramentas MCP pequenos para agentes. memorix setup grava --mode lite (21 ferramentas) na configuração MCP instalada para que a superfície normal de memória, continuidade e sessão fique acessível. Use --mode team (29 ferramentas) para ferramentas de coordenação, ou --mode full (48 ferramentas) para ferramentas avançadas e de compatibilidade, como inspeção de checkpoints.

Atalhos e aliases: memorix search / remember / recent são atalhos diretos de consulta, bg/bs iniciam o serviço em segundo plano, hook executa o lançador de hooks, e memorix config get|path|migrate inspeciona ou migra arquivos de configuração.

memorix orchestrate usa o checkout atual para execuções de worker único. Ao executar vários workers, ele cria worktrees de tarefa em .worktrees/ e mescla os branches de tarefa bem-sucedidos de volta. Use --isolated para forçar o isolamento de worktree para um worker, --no-worktree para desativá-lo, --allow-dirty para executar com alterações não commitadas, e --no-auto-merge para preservar worktrees de tarefa para revisão manual.

memcode é o agente de codificação de terminal incluído no Memorix. Ele pode ler, editar, executar comandos, retomar sessões, trocar de modelo e usar comandos /memory — tudo apoiado pela mesma memória de projeto dos seus agentes conectados via MCP.

Use-o quando quiser um agente de terminal com memória já integrada.

one Git project -> one shared Memorix memory pool

Consulte docs/MEMCODE.md para o guia específico do memcode.

~/.memorix/config.toml mínimo:

[agent]
provider = "openai"
model = "gpt-4o"
api_key = "..."

[memory.llm]
provider = "openai"
model = "gpt-4o-mini"
api_key = "..."

[embedding]
provider = "auto"

[memory]
inject = "minimal"
formation = "active"

Use [memory.llm] e [embedding] para qualidade e recuperação de memória do Memorix. Use [agent] para o modelo com o qual o memcode conversa enquanto codifica. Mantenha credenciais na configuração global ou em variáveis de ambiente, e não faça commit de segredos.

Para o preset opcional de memória Atlas Cloud, execute memorix init e escolha Atlas Cloud, ou defina provider = "atlascloud" em [memory.llm]. Ele usa o endpoint compatível com OpenAI https://api.atlascloud.ai/v1 e lê ATLASCLOUD_API_KEY ou o MEMORIX_LLM_API_KEY explícito.

Para embeddings do OpenRouter, use provider = "api", base_url = "https://openrouter.ai/api/v1" e model = "qwen/qwen3-embedding-8b". O Memorix aceita OPENROUTER_API_KEY para esse endpoint de embeddings; MEMORIX_EMBEDDING_API_KEY permanece como a substituição explícita.

Para geração controlada de mídia MiniMax, defina MINIMAX_API_KEY (global) ou MINIMAX_CN_API_KEY (região China) no seu ambiente ou em .env. A biblioteca de mídia nunca armazena essa chave, uma URL de saída assinada ou payloads base64. A geração via CLI é explícita; a geração via MCP também exige MEMORIX_MCP_MEDIA_GENERATION=1.

Docker é uma opção de implantação HTTP em VPS/hospedado, não um requisito para desenvolvimento local ou MCP via stdio:

docker compose up --build -d

Depois abra:

dashboard: http://localhost:3211
MCP: http://localhost:3211/mcp
health: http://localhost:3211/health

O contêiner deve conseguir acessar o caminho do repositório passado como projectRoot para o comportamento de Git e configuração com escopo de projeto.

Use o Memorix diretamente do TypeScript:

import { createMemoryClient } from 'memorix/sdk';

const client = await createMemoryClient({ projectRoot: '/path/to/repo' });

await client.store({
  entityName: 'auth-module',
  type: 'decision',
  title: 'Use JWT for API auth',
  narrative: 'Chose JWT because the API is stateless and used by multiple clients.',
});

const results = await client.search({ query: 'auth decision' });
await client.close();

Comece aqui	Use quando
Mapa de Documentação	Você quer o caminho mais curto para o guia certo
Guia de Configuração	Instalando, usando `memorix setup`, escolhendo entre stdio e HTTP
Superfícies de Integração	Pacotes de plugin, MCP, regras de projeto, hooks e suporte a skills
Configuração	Configuração TOML, faixas de modelo, arquivos de compatibilidade
Referência da API	Ferramentas MCP e comandos CLI
Memória Git	Ingestão de commits e verdade de engenharia pesquisável
Docker	Serviço HTTP conteinerizado
memcode	Usando o agente de terminal incluído
Playbook do Agente	Guia de execução voltado a IA para instalação, vinculação, hooks e solução de problemas
Desenvolvimento	Contribuindo, testando, verificações de release
Changelog	O que mudou em cada release

Resumos amigáveis para LLMs: llms.txt e llms-full.txt.

git clone https://github.com/AVIDS2/memorix.git
cd memorix
npm install
npm run lint
npm test
npm run build

Comunidade

Integrações de desktop e shell construídas sobre o Memorix:

omarchy-memorix — um widget nativo da barra de shell do Omarchy: estatísticas do pool, busca global ao vivo, detalhamento por projeto, memórias recentes e um lançador de workbench. Somente leitura via ~/.memorix/data; sem daemons, sem telemetria.

Construiu algo sobre o Memorix? Abra um PR para listá-lo aqui.

O Memorix se inspira no ecossistema MCP e em projetos anteriores de memória, como mcp-memory-service, MemCP, claude-mem e Mem0. O memcode é baseado no código do agente de codificação Pi e adapta seu modelo de agente de terminal para o ecossistema Memorix.

Apache 2.0

Histórico de Estrelas

_{Atualizado automaticamente pela API de histórico de estrelas do GitHub, segura quanto à privacidade. Sem PRs gerados.}