StudioMeyer local memory

Parte do StudioMeyer MCP Stack — Feito em Mallorca 🌴 · ⭐ se você usar

local-memory-mcp

**Memória local persistente para Claude, Cursor e Codex. 25 ferramentas. Recuperação híbrida (BM25 + cosseno vetorial, RRF). Consultas bi-temporais asOf + substituição de fatos. Detecção de contradição sem LLM + reflexão. Exportação/importação JSON portátil. Embeddings multilíngues. Sem nuvem. Sem chaves de API.**

Seu assistente de IA esquece tudo quando você fecha o chat. Isso resolve esse problema.

Aprendizados, decisões, pessoas, projetos — armazenados em um único arquivo SQLite na sua máquina que nunca sai do seu computador. Grafo de conhecimento integrado, detecção de duplicatas, busca por palavras-chave FTS5 e (novo na v2) recuperação híbrida que combina BM25 com cosseno vetorial local via Fusão de Rank Recíproco. O modelo de embeddings é multilíngue (DE / EN / ES / 100+ idiomas) e roda localmente — sem chaves de API, sem nuvem.

📄 Mergulho profundo: WHITEPAPER.md — arquitetura, princípios de design, o contrato local-first e uma comparação honesta com outros sistemas de memória.

Não afiliado ao danieleugenewilliams/local-memory-releases — esse é um projeto diferente de "Local Memory" com o mesmo nome descritivo. Este pacote é publicado como @studiomeyer/local-memory-mcp — use sempre o nome com escopo para desambiguar.

Uma nota nossa

Temos construído ferramentas e sistemas para nós mesmos nos últimos dois anos. O fato de este repositório ser pequeno e ter poucas estrelas não é porque é novo. É porque só agora decidimos compartilhar o que construímos. Não é um experimento recente, é uma longa história com um commit recente.

Amamos construir coisas e compartilhá-las. Não amamos táticas de redes sociais, truques de crescimento ou perseguir estrelas e seguidores. Então este repositório é pequeno. O código é real, é usado, as issues são respondidas. Julgue por si mesmo.

Se ajudar você, compartilhar, testar e dar feedback nos ajuda. Se puder ser melhor, uma issue é mais útil. Se você construir algo com isso, fale conosco em hello@studiomeyer.io. Isso genuinamente faz o nosso dia.

De um pequeno estúdio em Palma de Mallorca.

Início Rápido

Claude Code

claude mcp add memory -- npx -y @studiomeyer/local-memory-mcp

Claude Desktop

Mais fácil: pacote MCPB com um clique. A v2.0.0 inclui pacotes .mcpb pré-construídos para cada plataforma desktop principal — baixe o do seu sistema operacional na última versão e clique duas vezes. O Claude Desktop guia você pela instalação — sem edição de JSON, sem npm install, sem terminal.

Plataforma	Pacote
Linux x64	local-memory-mcp-2.2.0-linux-x64.mcpb
macOS Apple Silicon	local-memory-mcp-2.2.0-darwin-arm64.mcpb
macOS Intel	local-memory-mcp-2.2.0-darwin-x64.mcpb
Windows x64	local-memory-mcp-2.2.0-win32-x64.mcpb

Cada pacote é específico da plataforma porque better-sqlite3 é um módulo nativo — o binário .node correspondente é incluído no pacote para que você não precise de uma cadeia de ferramentas de compilação.

Configuração manual (todas as plataformas — adicione ao claude_desktop_config.json, veja Configurações > Desenvolvedor > Editar Config):

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@studiomeyer/local-memory-mcp"]
    }
  }
}

Cursor / VS Code

Adicione ao .cursor/mcp.json ou .vscode/mcp.json:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@studiomeyer/local-memory-mcp"]
    }
  }
}

Codex

# ~/.codex/config.toml
[mcp_servers.memory]
command = "npx"
args = ["-y", "@studiomeyer/local-memory-mcp"]

Rastreamento automático de sessão

Você pode tornar o rastreamento de sessão totalmente automático para nunca precisar pensar nisso.

Claude Code (CLAUDE.md): Adicione esta linha ao CLAUDE.md do seu projeto:

Always call memory_session_start at the beginning of each conversation and memory_session_end when done.

Claude Code (Hook): Para uma configuração em todo o sistema, adicione um hook SessionStart no ~/.claude/settings.json:

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "echo '{\"hookSpecificOutput\":{\"hookEventName\":\"SessionStart\",\"additionalContext\":\"Call memory_session_start now.\"}}'",
        "timeout": 5
      }]
    }]
  }
}

Ambas as abordagens fazem o Claude chamar memory_session_start automaticamente. O caminho via CLAUDE.md é mais simples; o caminho via hook funciona em todos os projetos.

O que faz

Quando você inicia uma conversa, o servidor carrega o contexto das suas últimas sessões para que a IA saiba em que você estava trabalhando.

Durante a conversa, a IA armazena padrões, insights e erros via memory_learn. Ela registra fatos sobre pessoas, projetos e ferramentas via memory_entity_observe — construindo um grafo de conhecimento ao longo do tempo. Cada linha armazenada também é incorporada em um vetor local de 384 dimensões via o modelo multilingual-e5-small.

Quando você pesquisa, o memory_search unificado executa recuperação híbrida: FTS5 com ranqueamento BM25 é combinado com cosseno vetorial via Fusão de Rank Recíproco (RRF, k=60). Isso supera incompatibilidades de vocabulário ("enviar" encontra "publicar"), funciona em DE / EN / ES / 100+ idiomas e corresponde mesmo quando a consulta não tem sobreposição exata de tokens com o conteúdo armazenado. Se a extensão vetorial não puder carregar na sua máquina, a busca cai transparentemente para apenas FTS5 — nada quebra, você apenas perde a metade semântica.

O guardião de duplicatas ainda impede que a mesma informação seja armazenada duas vezes.

Busca Híbrida (v2.0.0+)

memory_search({ query: "...", mode: "hybrid" })   // default
memory_search({ query: "...", mode: "fts" })       // keyword only
memory_search({ query: "...", mode: "vector" })    // cosine only

Arquitetura

• search_fts (FTS5, BM25) — recall por palavras-chave, o caminho da v1.
• embeddings (tabela virtual sqlite-vec vec0, float[384]) — recall vetorial.
• Fusão de Rank Recíproco (k=60) combina os dois quando mode: "hybrid".
• Os embeddings vêm do Xenova/multilingual-e5-small (Apache-2.0) via Transformers.js, quantizados em q8 (~30 MB de cache). O modelo carrega preguiçosamente na primeira chamada de embed; roda inteiramente na CPU.
• Auto-embed-ao-inserir cobre aprendizados, decisões e observações de entidades. As próprias entidades não são incorporadas — suas observações anexadas carregam a superfície semântica.

Multilíngue. O modelo padrão é treinado em 100+ idiomas com forte recuperação em DE/EN/ES. Misturar idiomas nos seus dados armazenados é aceitável — consulte em um idioma e a metade por cosseno ainda traz resultados relevantes em outro.

Substituições de ambiente

• MEMORY_EMBED_DISABLED=1 — força apenas FTS5 (ex.: rede isolada ou com proxy corporativo).
• MEMORY_EMBED_MODEL=... — troque por um modelo diferente de extração de características do Transformers.js.
• MEMORY_EMBED_CACHE_DIR=... — substitua o local do cache do Transformers.js.
• MEMORY_EMBED_DTYPE=fp32|fp16|q8|q4 — quantização do modelo (padrão q8).

Ciclo de vida + Reflexão (v2.1.0+)

A v2.1 fecha a lacuna entre "armazenar um fato" e "gerenciar uma memória ao longo do tempo". O esquema carrega archived, lifecycle_state, valid_from e valid_to desde a v1, mas nenhuma ferramenta os expunha. Agora quatro ferramentas fazem isso.

asOf bi-temporal — "o que eu sabia na data X?"

memory_entity_open({ id: "...", asOf: "2026-04-15" })

Retorna a entidade mais o conjunto de observações cuja janela de validade continha 2026-04-15. O filtro é valid_from <= asOf AND (valid_to IS NULL OR valid_to > asOf). Aceita qualquer formato que o datetime() do SQLite reconheça: ISO 8601 (2026-04-15T00:00:00Z), estilo SQLite (2026-04-15 00:00:00) ou apenas data (2026-04-15). Sem asOf você obtém a visão ao vivo legada (toda observação com valid_to IS NULL).

Escolha de design — apenas tempo de validade, não bi-temporal completo. SQL:2011, XTDB, Datomic oferecem bi-temporal em dois eixos (tempo de validade × tempo de transação). Fazemos apenas tempo de validade; o tempo de transação vive passivamente no created_at mas não é consultável como um eixo separado. Para um produto local de memória de IA, a pergunta é "o que a IA sabia sobre X na data Y" — isso é tempo de validade. Bi-temporal completo importa para trilhas de auditoria reguladas (seguros, bancos) — se você precisar, use XTDB.

Nota de escala. O predicado asOf envolve valid_from no datetime() do SQLite para comparações robustas de formato, o que significa que o planejador não pode usar um índice na coluna diretamente. Para corpora de <1000 observações por entidade (típico), a varredura é submilissegundo. Se você tiver uma entidade com 10k+ observações, adicione um índice de expressão — CREATE INDEX idx_obs_valid_from_dt ON entity_observations(datetime(valid_from)) — e o predicado volta a ser sargable.

Scanner de contradição — sem LLM

memory_contradictions({ minCosine: 0.75, minConfidenceDrift: 0.2 })
memory_contradictions({ entityId: "...", limit: 20 })

Superfícies de pares de observações que são semanticamente muito próximas (similaridade de cosseno acima de minCosine) mas discordam em:

• XOR de marcador de negação — um lado afirma, o outro nega (regex cobre EN / DE / ES / Catalão).
• Deriva de confiança — mesma afirmação de superfície, valores de confidence muito diferentes.

Sem LLM de propósito — a promessa de sem chaves de API é mantida. A heurística é conservadora; o cliente de IA julga. Duplicatas puras (sem negação, sem deriva de confiança) não são sinalizadas. A matemática de cosseno roda em SQL via vec_distance_cosine, então a extensão deve estar carregada; em plataformas onde não está, a ferramenta retorna VECTOR_DISABLED com uma mensagem clara em vez de degradar silenciosamente.

Calibração. O minCosine = 0.75 padrão segue a literatura de ajuste de recuperadores de 2026 (SparseCL em Arguana; orientação de ajuste de limiar do Milvus) que encontra um aumento acentuado de falsos positivos abaixo de 0,7. Reduza para 0,6 para uso focado em recall, aumente para 0,85 para uso focado em precisão. O regex de negação cobre EN / DE / ES / Catalão / Português / Italiano / Francês — os sete idiomas que o multilingual-e5-small lida com mais força.

Substituir — aposentar um fato desatualizado (v2.2)

memory_observation_supersede({ observationId: "..." })
memory_observation_supersede({ observationId: "...", supersededById: "..." })

O scanner encontra um fato desatualizado; memory_observation_supersede age sobre ele. Define o valid_to da observação mais antiga (uma marca de túmulo) para que o fato pare de aparecer em memory_search e memory_entity_open ao vivo — mas a linha permanece no banco de dados, então uma consulta asOf ainda a retorna como a crença que era atual antes do corte. Este é o padrão de substituição de fatos do Zep: invalidar, nunca excluir. Passe supersededById e o corte se torna o valid_from do fato mais novo (o fato antigo era verdadeiro até o novo ser registrado); passe validTo para um instante explícito, ou nenhum para agora. Guardas de mesma-entidade e auto-substituição mantêm a operação sã, e uma segunda chamada é idempotente (already_superseded).

Arquivar + atualizar — ciclo de vida para aprendizados

memory_learn_archive({ learningId: "...", reason: "wrong" })
memory_learn_update({ learningId: "...", content: "…", confidence: 0.9 })

archive é uma exclusão suave: a linha permanece no learnings (com archived = 1, archived_at e lifecycle_state = 'archived' | 'archived:<reason>'), o embedding permanece no vec0 (para que referências cruzadas estilo asOf ainda possam resolver), mas recall / search / a verificação de duplicatas todos o filtram. Idempotente.

update edita um aprendizado ativo (não arquivado). Se content mudar, re-incorporamos no padrão atômico F4 (computar fora da transação, escrever dentro de um db.transaction() síncrono). Se a escrita do embedding falhar ou o vec estiver desabilitado, o embedding antigo agora desatualizado é purgado para que a busca por cosseno não possa superfíciar um vetor que não representa mais o texto ativo. Incrementa usage_count e define last_used para que uma edição conte como um toque.

Trade-off — sem trilha de auditoria. update sobrescreve o conteúdo anterior. O texto antigo não é retido em nenhum lugar. Isso mantém o esquema limpo; uma versão futura pode adicionar memory_learn_history mais uma tabela learnings_history imutável para usuários que precisam de recuperação pontual. Se você precisar de uma trilha de auditoria hoje, memory_learn_archive(reason: "wrong") o aprendizado antigo e memory_learn o novo como uma linha nova — o texto antigo permanece na linha arquivada.

Reflexão — o que é importante agora

memory_reflect({ lookbackDays: 7, staleThresholdDays: 30 })

Passagem de agregação sobre o fluxo de memória recente — o passo de reflexão dos Generative Agents de Stanford, menos o LLM. Retorna um payload estruturado MAIS um resumo em Markdown cobrindo:

• Aprendizados mais usados — top N por usage_count tocados dentro do lookback.
• Aprendizados desatualizados — criados há mais de staleThresholdDays e nunca recuperados. Candidatos a arquivamento.
• Entidades quentes — top N por novas observações dentro do lookback.
• Decisões abertas — mais antigas que o lookback e verified = 0. Candidatas a acompanhamento.

O Markdown é para o LLM ler no início da sessão; os campos estruturados são para automação downstream (Claude Code Hook, fluxo n8n) que quer reagir sem reanalisar. Passe project para escopar a um projeto.

Sleeptime via hooks. Letta / Zep / Mem0 executam reflexão em um loop de "sleeptime" em segundo plano. Nós executamos sob demanda porque somos um daemon stdio sem estado — mas você obtém a semântica de sleeptime gratuitamente ao conectar um hook de SessionStart ou SessionEnd do Claude Code (ou um cron do n8n, ou uma entrada crontab) que chama memory_reflect. O resumo chega no contexto do LLM ao mesmo tempo que seu snapshot memory_session_start. Zero infraestrutura nova.

Ferramentas (25)

Sessões

memory_session_start — Chame primeiro em toda conversa. Carrega contexto das suas últimas 3 sessões (resumos, aprendizados recentes) para que sua IA saiba no que você estava trabalhando. Parâmetro opcional project para escopar sessões por projeto.

memory_session_end — Chame no final para salvar um resumo. Passe uma string summary descrevendo o que foi realizado. A próxima sessão carrega isso automaticamente. Sem argumentos, fecha a sessão ativa.

Aprendizados

memory_learn — A ferramenta principal. Armazena um conhecimento com categoria e conteúdo. Categorias: pattern (sucesso recorrente), mistake (o que deu errado), insight (percepção estratégica), research (conhecimento externo), architecture, infrastructure, tool, workflow, performance, security. O gatekeeper de duplicatas verifica se o conteúdo idêntico já está armazenado. Se estiver, incrementa o contador de uso em vez de criar uma duplicata. Para estender uma entrada existente em vez de adicionar uma nova, use memory_learn_update com o id dela. Opcional: tags, confidence (0-1), project, memoryType (episódico ou semântico, classificado automaticamente se omitido).

memory_recall — Busca rápida apenas em aprendizados. Passe uma string query para busca por palavra-chave, ou omita para obter os aprendizados mais recentes. Bom para perguntas tipo "o que aprendi sobre X". Use limit para controlar quantos resultados retornam (padrão 10).

memory_search — Busca unificada em tudo: aprendizados, decisões, entidades e observações. Usa FTS5 com ranqueamento bm25. Consultas com múltiplas palavras correspondem a qualquer uma das palavras e ranqueiam por relevância. Use o array types para filtrar (ex.: ["learning", "decision"]). Esta é a ferramenta de busca mais ampla.

memory_learn_archive (v2.1+) — Exclusão suave de um aprendizado. A linha permanece no banco (para que consultas asOf que a referenciam ainda resolvam), mas nunca mais reaparece em recall ou busca. reason opcional é armazenado em lifecycle_state como archived:<reason>. Idempotente — chamar duas vezes retorna already_archived.

memory_learn_update (v2.1+) — Edita um aprendizado ativo (content / confidence / tags). Pelo menos um campo é obrigatório. Incrementa usage_count + last_used para que uma edição conte como um toque. Re-embedding atômico quando content muda (padrão F4: calcular fora da transação, escrever dentro de um db.transaction() síncrono). Rejeita edições em aprendizados arquivados com code: 'ARCHIVED'.

memory_learn_bulk (v2.2+) — Inserção em lote de até 500 aprendizados em uma única chamada atômica. Cada item aceita os mesmos campos que memory_learn. Gatekeeper apenas de duplicatas exatas (sem fusão difusa), então o resultado é inserir-ou-pular determinístico; conteúdos duplicados dentro do lote colapsam na primeira ocorrência. Apenas os novos conteúdos são embedded, em uma única passagem direta do modelo. Para restaurar um backup, semear um banco novo ou migrar de outro sistema.

Quando usar recall vs busca: Use recall quando quiser aprendizados especificamente. Use search quando quiser encontrar qualquer coisa em todos os tipos, incluindo entidades e decisões.

Decisões

memory_decide — Registra uma decisão com contexto estruturado. Parâmetros: title (o que foi decidido), decision (a escolha feita), reasoning (porquê), alternatives (o que mais foi considerado). Opcional: confidence, project, tags. Isso é útil para revisitar decisões passadas meses depois e entender por que você escolheu algo.

Grafo de Conhecimento

memory_entity_observe — Registra um fato sobre uma pessoa, projeto, empresa, ferramenta ou qualquer outra entidade. Se a entidade ainda não existir, ela é criada automaticamente. Parâmetros: entityName, entityType (pessoa, projeto, empresa, ferramenta, conceito, etc.), content (o fato). Observações são bitemporais, ou seja, podem ser substituídas ao longo do tempo sem perder histórico.

memory_entity_search — Busca difusa em nomes de entidades e suas observações. Encontra "Claude" mesmo se você buscar "claude ai". Filtro opcional entityType para restringir resultados.

memory_entity_open — Carrega uma visão completa da entidade: a própria entidade, todas as suas observações atuais e todas as suas relações com outras entidades. Busque por name ou id. v2.1: parâmetro opcional asOf para uma visão bitemporal em um ponto no tempo — "o que eu sabia sobre esta entidade na data X?"

memory_entity_relate — Cria uma aresta tipada e direcionada entre duas entidades. Parâmetros: fromEntityId, toEntityId, relationType (ex.: "trabalha_em", "usa", "criou", "depende_de"). Opcional weight (0-1). Construa um grafo de como as coisas se conectam.

memory_contradictions (v2.1+) — Scanner sem LLM que revela pares de observações com alta similaridade de cosseno, mas discordando em marcadores de negação ou confiança. O cliente de IA (Claude / Cursor) julga os candidatos. Escopo opcional: entityId ou entityName + entityType. Controles: minCosine (padrão 0.75), minConfidenceDrift (padrão 0.2), limit (padrão 20). Requer sqlite-vec — retorna VECTOR_DISABLED se não estiver carregado.

memory_observation_supersede (v2.2+) — O braço de execução para memory_contradictions: aposentar uma observação obsoleta definindo valid_to (um tombstone). A linha permanece no banco para que uma consulta asOf ainda a revele, mas ela sai do memory_search e memory_entity_open ativos. Passe supersededById para definir o corte para o valid_from do fato mais novo (substituição de fato do Zep), validTo para um instante explícito, ou nenhum para now(). Proteções de mesma-entidade + auto-substituição; idempotente.

Tipos de entidade recomendados: person, project, company, tool, concept, service, team. Use o que fizer sentido para seu domínio.

Reflexão

memory_reflect (v2.1+) — Passada de agregação sobre o fluxo de memória recente. Retorna dados estruturados mais um resumo em Markdown cobrindo: aprendizados mais usados (top N por usage_count tocados no lookback), aprendizados obsoletos (criados há mais de staleThresholdDays, nunca recuperados), entidades quentes (top N por novas observações no lookback), decisões em aberto (verified = 0, mais antigas que o lookback). Sem LLM — o passo de reflexão dos Stanford Generative Agents sem a chamada de API. Padrões: lookbackDays: 7, staleThresholdDays: 30, limit: 5. Filtro opcional project.

memory_insights — Estatísticas gerais: quantos dias de memória, total de sessões, aprendizados, decisões, entidades. Divisão por categoria e por tipo de entidade. Bom para momentos de "o que o Claude sabe sobre mim". Filtro opcional project.

memory_profile — Armazena informações pessoais localmente. Use set para armazenar campos (nome, função, preferências, idioma, fuso horário), use get para recuperá-los. Sua IA pode ler isso no início da sessão para personalizar o comportamento.

memory_guide — Ajuda integrada. Tópicos: quickstart (como começar), session (fluxo de trabalho de sessão), search (como a busca funciona), entities (grafo de conhecimento explicado), learn (categorias de aprendizado), privacy (onde os dados vivem, o que é coletado).

Portabilidade (v2.2+)

memory_export — Despeja toda a memória — aprendizados, decisões, entidades, observações, relações, sessões, perfil, meta — em um envelope JSON versionado em camelCase (format: "studiomeyer-memory-export", version: 1). Embeddings não são exportados; eles são rederivados na importação, então o arquivo permanece pequeno e agnóstico de modelo. Flags: includeSessions (padrão true), includeArchived (padrão true). Você é dono dos seus dados — já é um único arquivo SQLite, e agora também é um documento portátil.

memory_import — Ingere um envelope memory_export ({ data: <envelope> }). Puramente aditivo e idempotente: cada escrita é INSERT OR IGNORE no id de origem, então reimportar o mesmo arquivo é um no-op e nunca sobrescreve uma linha existente. Ordenação segura para FK com pulos de referências pendentes (um pulo contado, nunca um erro). Re-embedding em tempo real. Não existe modo replace por design — para limpar um armazenamento local, exclua memory.sqlite. O mesmo envelope também importa para o nível hospedado StudioMeyer Memory, então este é seu ponto de entrada quando você superar uma única máquina.

Dicas

• Comece com sessões e aprendizados. Apenas chamar memory_session_start no início e memory_learn quando algo importante surgir já te dá 80% do valor.
• Use entidades para pessoas e projetos. Quando você mencionar um colega, cliente ou projeto repetidamente, crie uma entidade. Com o tempo, você constrói um grafo de conhecimento que sua IA pode percorrer.
• Decisões são subestimadas. Daqui a três meses você não vai lembrar por que escolheu Postgres em vez de SQLite para aquele projeto. memory_decide captura o raciocínio.
• Deixe sua IA dirigir. Uma vez que as ferramentas estão disponíveis, sua IA naturalmente começará a usá-las. Você não precisa chamar ferramentas manualmente. Diga "lembre disso" e ela chama memory_learn. Diga "o que você sabe sobre a Sarah" e ela chama memory_entity_search.
• Faça backup do seu arquivo SQLite. É um único arquivo. Copie para um pendrive, Dropbox, onde quiser. Você também pode abri-lo com qualquer navegador SQLite para inspecionar o que sua IA aprendeu.

Recursos

• Grafo de Conhecimento — não apenas texto plano. Entidades, observações bitemporais, relações tipadas.
• Proteção contra Duplicatas — verificação de similaridade FTS5 impede armazenar a mesma coisa duas vezes. Contador de uso em vez disso.
• Contexto de Sessão — carrega automaticamente as últimas 3 sessões no início. Sua IA retoma de onde parou.
• Rastreamento de Decisões — registra decisões com raciocínio e alternativas. Único entre servidores de memória.
• Busca de Texto Completo — FTS5 com ranqueamento bm25 em aprendizados, decisões, entidades, observações.
• Arquivo SQLite Único — um arquivo, portátil, com backup, deletável. Modo WAL para acesso concorrente.
• Zero Configuração — npx e pronto. Sem Docker, sem Postgres, sem Redis, sem chaves de API.

Onde seus dados vivem

Tudo em um único arquivo SQLite. Faça backup, mova, exclua — é seu.

SO	Caminho
macOS	~/Library/Application Support/local-memory-mcp/memory.sqlite
Linux	~/.local/share/local-memory-mcp/memory.sqlite
Windows	%APPDATA%\local-memory-mcp\memory.sqlite

Substituição: MEMORY_DB_PATH=/your/preferred/path.sqlite

Privacidade

• Seus dados nunca saem da sua máquina
• Sem telemetria, sem phone-home, sem analytics
• Sem conta necessária, sem chaves de API
• Código aberto — leia cada linha do código

Comparação

Recurso	local-memory-mcp	Penfield	Official MCP Memory	MemPalace	Mem0	Zep	Letta	AutoMem
Local-first	Sim	Sim	Sim	Sim	Não (nuvem)	Não (nuvem)	Parcial	Sim
Recuperação híbrida (BM25 + vetorial)	Sim (RRF)	Sim	Não	Não (somente vetorial)	Somente vetorial	Somente vetorial	Vetorial + grafo	Vetorial + grafo
Embeddings multilíngues	Sim (e5-small, DE/EN/ES + mais 100)	Desconhecido	Não	Desconhecido	Focado em inglês	Focado em inglês	Misto	Misto
Grafo de conhecimento	Sim (entidades + relações)	Sim	Sim (triplas)	Não	Nível pago	Sim	Sim	Sim (FalkorDB)
Fatos bi-temporais	Sim (esquema)	Desconhecido	Não	Não	Sim	Sim	Parcial	Desconhecido
Proteção contra duplicatas	Sim (FTS5 + similaridade)	Não	Não	Não	Desconhecido	Desconhecido	Desconhecido	Desconhecido
Rastreamento de decisões	Sim (exclusivo)	Não	Não	Não	Não	Não	Não	Não
Contexto de sessão	Sim (carregamento automático)	Sim	Não	Não	Não	Não	Sim	Sim
Ferramentas	25	17	5	29	API	API	API	API
Bi-temporal asOf	Sim (v2.1)	Desconhecido	Não	Não	Sim	Sim	Parcial	Desconhecido
Scanner de contradições	Sim (v2.1, sem LLM)	Não	Não	Não	Orientado por LLM	Orientado por LLM	Não	Não
Substituição de fatos	Sim (v2.2, preservando asOf)	Não	Não	Não	Orientado por LLM	Sim	Parcial	Desconhecido
Reflexão / consolidação	Sim (v2.1, sem LLM)	Não	Não	Não	Orientado por LLM	Sim (sleeptime)	Sim (sleeptime)	Não
Exportação / importação portátil	Sim (v2.2, envelope JSON)	Desconhecido	Não	Não	API	API	.af arquivo	Desconhecido
Linguagem	TypeScript	TypeScript	TypeScript	Python	Python	Python	Python	Python
Armazenamento	SQLite + sqlite-vec	SQLite	Arquivo JSON	ChromaDB	Nuvem	Nuvem	Diversos	FalkorDB + Qdrant
Chaves de API necessárias	Não	Não	Não	Não	Sim (nuvem)	Sim (nuvem)	Opcional	Opcional
Instalação	npx ou .mcpb	npx	npx	pip + venv	Cadastre-se	Cadastre-se	pip / Docker	pip / Docker
Pacote multiplataforma	Sim (4 SO)	Não	Não	n/d	n/d	n/d	n/d	n/d
Preço	Gratuito para sempre	Gratuito	Gratuito	Gratuito	US$ 0-249/mês	US$ 0-499/mês	Gratuito	Gratuito

Onde nos destacamos: o único MCP de memória local, licenciado sob MIT, sem necessidade de chaves de API, que oferece recuperação híbrida (BM25 + cosseno vetorial via RRF) com embeddings multilíngues e instaladores com um clique para todos os sistemas operacionais desktop. O rastreamento de decisões continua sendo exclusivo nosso.

local-memory-mcp vs. StudioMeyer Memory

Dois produtos, mesma equipe, casos de uso diferentes:

	local-memory-mcp (este repositório)	StudioMeyer Memory (hospedado)
Onde	Sua máquina (SQLite + sqlite-vec)	Nuvem (nosso próprio Postgres, Hetzner Alemanha, UE)
Ferramentas	25	56
Busca	FTS5 + sqlite-vec híbrido (RRF)	FTS5 + pgvector + reordenação com cross-encoder
Embeddings	Local (multilingual-e5-small, 384-dim)	Nuvem (vários modelos, reordenação)
Multi-dispositivo	Não	Sim
Multi-agente	Não	Sim
Preço	Gratuito para sempre	Nível gratuito / EUR 9 Pro / EUR 19 Team
Instalação	npx ou .mcpb (Linux / macOS / Windows)	memory.studiomeyer.io
Repositório	local-memory-mcp	studiomeyer-memory (documentação)

Comece local. Faça upgrade quando precisar de equipes, sincronização multi-dispositivo ou reordenação com cross-encoder — memory_export produz um envelope que importa diretamente para o nível hospedado, então você leva toda a sua memória com você.

Também da StudioMeyer

Servidor	O que faz	Link
StudioMeyer Memory	Memória de IA hospedada com 56 ferramentas, busca semântica, multi-agente	memory.studiomeyer.io
StudioMeyer CRM	CRM nativo de IA -- 33 ferramentas, pipeline, leads, receita	crm.studiomeyer.io
StudioMeyer GEO	Monitoramento de visibilidade de IA -- 23 ferramentas, 8 plataformas de LLM	geo.studiomeyer.io
MCP Crew	Personas de agente para Claude -- 10 ferramentas, 8 papéis, 3 fluxos de trabalho	crew.studiomeyer.io

Segurança

Consulte SECURITY.md para o modelo de ameaças, o processo de relato e notas sobre falsos positivos conhecidos de scanners SAST. Em particular: db.exec(schema) em src/db/client.ts é o executor de strings SQL de better-sqlite3, não child_process.exec — alguns scanners baseados em padrões o sinalizam sem resolução de importação. O repositório contém zero código de execução de shell (verifique com grep -rn child_process src/).

Contribuindo

Issues e PRs são bem-vindos. Consulte CONTRIBUTING.md.

Sobre a StudioMeyer

StudioMeyer é um estúdio de IA e design sediado em Palma de Mallorca, trabalhando com clientes em todo o mundo. Construímos sites personalizados e infraestrutura de IA para pequenas e médias empresas. Stack de produção no Claude Agent SDK, MCP e n8n, com Sentry, Langfuse e LangGraph para observabilidade e uma camada de proteção interna.

Licença

MIT

---

Construído pela StudioMeyer -- estúdio web focado em IA de Mallorca.