mnemo-mcp

Memória persistente de IA: armazenar, pesquisar e relembrar conhecimento entre sessões

Documentação

Servidor MCP Mnemo

Renomeado (2026-09-13): o repositório agora é mnemo — prioridade para CLI (comando mnemo). O pacote PyPI permanece mnemo-mcp; o servidor MCP continua sendo uma superfície secundária.

mcp-name: io.github.n24q02m/mnemo-mcp

Memória persistente para IA com busca híbrida e sincronização de embeddings. Aberto, gratuito, ilimitado.

Projetos irmãos de n24q02m (clique para expandir)

Projeto	Tagline	Tag
agent-chat-plugin	Agentes de IA pares conversam em uma pasta compartilhada — sem retransmissão humana, sem orquestrador, tra...	Ferramentas
better-code-review-graph	Grafo de conhecimento para revisões de código eficientes em tokens — busca semântica e chamadas de...	MCP
better-drive	Sincronização bidirecional com Google Drive com filtro .driveignore — mecanismo rclone, bandeja do Windows	Ferramentas
better-email-mcp	E-mail IMAP/SMTP para agentes de IA — ler, enviar, organizar pastas e gerenciar anex...	MCP
better-godot-mcp	Servidor MCP composto para Godot Engine — 17 ferramentas compostas para jogos assistidos por IA...	MCP
better-notion-mcp	Notion com prioridade para Markdown para agentes de IA — páginas, bancos de dados, blocos e comentários...	MCP
better-semantic-release	Fork do python-semantic-release com proteções de segurança de release integradas (orp...	Ferramentas
better-telegram-mcp	Telegram para agentes de IA — mensagens, chats, mídia e contatos em ambos os bo...	MCP
better-workspace-mcp	Servidor MCP do Google Workspace (Docs/Drive/Calendar/Gmail/Sheets/Slides/Tasks/Ch...	MCP
claude-plugins	Marketplace de plugins do Claude Code para os servidores MCP da n24q02m — instale busca web...	Marketplace
imagine-mcp	Compreensão e geração de imagens e vídeos para agentes de IA — em Gemini, Op...	MCP
jules-task-archiver	Extensão do Chrome para operações em lote em tarefas do Jules via API batchexecute — a...	Ferramentas
mcp-core	Fundação compartilhada para construir servidores MCP — transporte HTTP Streamable, OAut...	MCP
mnemo	Memória persistente para IA com busca híbrida e sincronização de embeddings. Aberto, gratuito, ilimi...	MCP
fastretrieval	Runtime de recuperação multimodelo para embeddings e reranking ONNX/GGUF	Biblioteca
skret	Segredos sem o servidor.	CLI
tacet	Uma cascata neuro-simbólica autodestiladora que amortiza o custo de LLM em conheci...	Ferramentas
web-core	Pacote de infraestrutura web compartilhada para busca, scraping, segurança HTTP e st...	Biblioteca
wet-mcp	Servidor MCP de código aberto para agentes de IA: busca web, extração de conteúdo e lib...	MCP

Roadmap (atual = Fase 3 / v2.x)

Fase	Versão	Status	Destaques
Fase 1	v1.x	Lançada	`memory(action="capture")` tipado (6 context_types + dedup) -- fusão híbrida RRF (k=60) + rerank com cross-encoder + decaimento temporal -- política de arquivamento por importância x recência + restauração -- migrações Alembic -- despacho LLM multiprovedor -- tríade de plugins (habilidades recall-context + memory-commit, hooks SessionStart + PostToolUse opcionais)
Fase 2	v1.x+1	Lançada	Compressão de memórias antigas orientada por LLM + sincronização Passport (pacote de importação/exportação criptografado para bootstrap entre máquinas) -- AES-256-GCM + Argon2id, backends S3 / R2 / B2 / MinIO + GDrive, delta-sync com LWW por linha
Fase 3	v2.0.0	Lançada (QUEBRA)	Grafo de conhecimento temporal -- colunas bitemporais `valid_from` / `valid_to` -- resolução de entidades via KNN de embeddings -- ações `entity_search` / `entity_graph` / `history` -- seções de pacote passport cientes de KG -- extração automática opcional `KG_AUTO_ENABLED` na captura

Recursos

Recuperação híbrida -- FTS5 + busca vetorial (sqlite-vec local, Vectorize no Cloudflare), fundidas via Reciprocal Rank Fusion (k=60), depois reordenadas por uma cadeia de rerank configurável (RERANK_MODELS, ordem = fallback litellm; vazio -> reranker local Qwen3 do Fastretrieval) com decaimento temporal e reforço de importância
Captura tipada -- memory(action="capture") com 6 context_types (conversation/fact/preference/skill/task/decision), deduplicação baseada em embeddings e cadeia LLM configurável (LLM_MODELS, ordem = fallback litellm)
Grafo de conhecimento -- Extração automática de entidades e rastreamento de relações; resultados principais reforçados por proximidade no grafo
Pontuação de importância + política de arquivamento -- Importância pontuada por LLM de 0,0 a 1,0; arquivamento suave quando recency_factor * (1 - importance) > 1.0; ação de restauração disponível
Gatilho de arquivamento automático -- Varredura em segundo plano a cada N capturas (padrão 100) -- sem necessidade de cron
Consolidação STM-para-LTM -- Resumo por LLM de memórias relacionadas em uma categoria
Detecção de duplicatas -- Avisa antes de adicionar memórias semanticamente semelhantes
Zero configuração -- O registro local integrado do Fastretrieval resolve embeddings e reranking Qwen3 ONNX, sem necessidade de chaves de API. Provedores de nuvem opcionais (Jina AI, Gemini, OpenAI, Cohere)
Sincronização entre máquinas -- Sincronização de mesclagem baseada em JSONL via Google Drive (cliente público OAuth de desktop incluído)
Tríade de plugins -- Inclui habilidades /recall-context + /memory-commit e hooks SessionStart + PostToolUse opcionais (veja docs/ARCHITECTURE.md)
Memória proativa -- Descrições de ferramentas e habilidades orientam a IA a salvar preferências, decisões e fatos no momento certo
Compressão por LLM -- Compressão por turno via despachante multiprovedor visa redução de ~3x em tokens com retenção de fatos >=0,9; salto gracioso quando nenhum provedor está configurado (veja docs/compression.md)
Sincronização Passport criptografada -- Pacotes AES-256-GCM + KDF Argon2id, backends S3 (R2 / B2 / MinIO) e Google Drive, delta-sync com última escrita vence por linha (veja docs/passport.md). Bootstrap via habilidade passport-bootstrap.
Grafo de conhecimento temporal -- Colunas bitemporais (valid_from / valid_to / superseded_by) em cada memória + deduplicação por resolução de entidades (KNN de embeddings com limite de cosseno padrão 0,85) + trilha de auditoria (tabela memory_audit com hashes de estado anterior/novo) + novas ações (entity_search / entity_graph / history) + extração automática opcional KG_AUTO_ENABLED na captura. QUEBRA para clientes que chamavam memory.get esperando resultados inclusivos de histórico: passe as_of para viagem no tempo; o padrão agora filtra para o estado atual (valid_to IS NULL).

Instalação rápida

# Method 1 (default): plugin install via Claude Code
/plugin marketplace add n24q02m/claude-plugins
/plugin install mnemo-mcp@n24q02m-plugins

# Method 2 (CLI): direct uvx invocation
claude mcp add mnemo -- uvx mnemo-mcp

# Method 3 (remote): point a client at an HTTP deployment
claude mcp add --transport http mnemo https://<your-host>/mcp

Matriz de instalação (stdio salvo indicação; veja a página Configuração para passos completos):

Cliente	Instalação
Claude Code (plugin)	`/plugin marketplace add n24q02m/claude-plugins` e depois `/plugin install mnemo-mcp@n24q02m-plugins`
Claude Code (stdio)	`claude mcp add mnemo -- uvx mnemo-mcp`
Codex	registre o comando stdio `uvx mnemo-mcp` sob `mcp_servers` em `~/.codex/config.toml`
Gemini CLI	adicione o JSON `mcpServers` abaixo em `~/.gemini/settings.json`
Cursor / Windsurf	adicione o JSON `mcpServers` abaixo via configurações MCP do cliente (`mcp.json`)
Qualquer cliente (HTTP auto-hospedado)	aponte o cliente para `https://<your-host>/mcp` (HTTP Streamable, protegido por OAuth)

Exemplo de configuração stdio (padrões locais zero-configuração):

{
  "mcpServers": {
    "mnemo": {
      "command": "uvx",
      "args": ["mnemo-mcp"]
    }
  }
}

Comparação com concorrentes

Recurso	mnemo	Mem0	Letta	OpenMemory
Recuperação híbrida (FTS + vetor)	sim (FTS5 + RRF; sqlite-vec local / Vectorize no Cloudflare)	sim	parcial	sim
Cadeia de rerank com cross-encoder	sim (Qwen3 local do Fastretrieval + Jina + Cohere)	parcial (apenas Cohere)	não	não
Pontuação com decaimento temporal	sim (meia-vida exp)	não	não	não
Reforço de importância na classificação	sim (LLM 0,0-1,0)	não	não	não
Política de arquivamento suave + restauração	sim (importância x recência)	não	não	não
Auto-hospedável (arquivo SQLite único)	sim (zero dependências externas)	parcial (prioridade nuvem)	sim (Postgres)	sim (Postgres + Qdrant)
Despacho LLM multiprovedor	sim (cadeia `LLM_MODELS`, qualquer provedor litellm)	parcial	sim	parcial
Tríade de plugins (habilidades + hooks)	sim (recall-context + memory-commit)	n/d	n/d	n/d
Sincronização entre máquinas	sim (OAuth GDrive incluído)	sim (nuvem)	n/d	n/d
Sincronização Passport criptografada de ponta a ponta	sim (AES-256-GCM + Argon2id, S3 + GDrive)	não	não	não
Compressão por LLM na captura	sim (multiprovedor, ~3x com retenção >=0,90)	não	não	não
Arquitetura de sincronização com backends plugáveis	sim (S3 / R2 / B2 / MinIO + GDrive)	não	não	não
Consultas bitemporais `valid_from` / `valid_to`	sim (viagem no tempo `as_of`)	não	parcial (apenas eventos)	não
Resolução de entidades via KNN de embeddings	sim (limite de cosseno ajustável)	não	não	não
Trilha de auditoria com hashes de estado	sim (tabela `memory_audit`)	não	não	não

Status

2026-05-02 -- Atualização de estabilização da arquitetura

Os últimos meses tiveram mudanças significativas no tratamento de credenciais e no padrão de auto-inicialização da ponte de daemon. Isso causou corridas entre processos, spam de abas no navegador e experiência de configuração inconsistente entre plugins. A arquitetura agora está estável: 2 modos limpos (stdio + HTTP), sem camada de ponte de daemon, sem auto-inicialização a partir do stdio.

Pedimos desculpas pelo período de instabilidade. Se você encontrou problemas com versões anteriores, atualize para a versão mais recente e siga a documentação de configuração atual -- a maioria das soluções alternativas anteriores não é mais necessária.

Plugins relacionados do mesmo autor:

wet-mcp -- Busca web + extração de conteúdo

imagine-mcp -- Compreensão + geração de imagens/vídeos

better-notion-mcp -- API do Notion

better-email-mcp -- Gerenciamento de e-mail

better-telegram-mcp -- Telegram

better-godot-mcp -- Godot Engine

better-code-review-graph -- Grafo de conhecimento para revisão de código

Todos os plugins compartilham a mesma arquitetura -- instale uma vez, aprenda os padrões que se transferem.

Documentação

Documentação completa em mcp.n24q02m.com/servers/mnemo-mcp/setup/:

Configuração -- métodos de instalação para Claude Code, Codex, Gemini CLI, Cursor, Windsurf, mcp.json
Visão geral dos modos -- stdio / relay local / relay remoto / OAuth remoto
Configuração multiusuário -- modelo de credenciais por sub do JWT

Instalar com agente de IA -- cole isto no seu agente de codificação de IA:

Instale o servidor MCP mnemo-mcp seguindo os passos em https://raw.githubusercontent.com/n24q02m/claude-plugins/main/plugins/mnemo-mcp/setup-with-agent.md

Smithery

mnemo-mcp é empacotado para Smithery — instale ou execute diretamente do registro. Ele inicia via stdio através de uvx mnemo-mcp sem necessidade de configuração para iniciar; as credenciais são configuradas em tempo de execução pelo próprio fluxo de configuração do servidor (veja Documentação). O comando de início publicado está em smithery.yaml.

Ferramentas

15 ferramentas MCP, 17 ações de memória. A superfície de memória é exposta tanto como 11 ferramentas especializadas de propósito único quanto como um dispatcher legado obsoleto memory (mesmas ações), além de config, help e config__open_relay:

Ferramenta	Ações	Descrição
`add_memory`, `search_memory`, `list_memories`, `update_memory`, `delete_memory`, `export_memories`, `import_memories`, `memory_stats`, `restore_memory`, `archived_memories`, `consolidate_memories`	(uma ação cada)	Ferramentas de memória especializadas de propósito único — a superfície recomendada
`memory` (dispatcher legado, OBSOLETO — use as ferramentas granulares acima; será removido em uma versão futura)	`add`, `capture`, `search`, `list`, `update`, `delete`, `export`, `import`, `stats`, `restore`, `archived`, `archive_now`, `consolidate`, `compress`, `entity_search`, `entity_graph`, `history`	CRUD principal + captura tipada (6 context_types) + busca híbrida (RRF + rerank + decaimento temporal) + importação/exportação + arquivamento suave + restauração + varredura de arquivamento sob demanda + consolidação LLM + compressão LLM + KG temporal (busca de entidades / grafo / histórico)
`config`	`status`, `sync`, `set`, `warmup`, `setup_sync`, `setup_status`, `setup_start`, `setup_skip`, `setup_reset`, `setup_complete`, `setup_relay`, `sync_now`, `export_passport`, `import_passport`	Status do servidor, acionar sincronização, atualizar configurações, pré-baixar modelo de embeddings, autenticar provedor de sincronização, gerenciar ciclo de vida do formulário de configuração HTTP, exportação/importação de passport
`help`	`topic="memory"` ou `topic="config"`	Documentação completa para qualquer ferramenta
`config__open_relay`	(modo relay HTTP)	Abrir o formulário de configuração de relay zero-config (registrado via mcp-core)

Trindade de plugins (instalação no marketplace do Claude Code):

Componente	Gatilho	Propósito
`mnemo:recall-context` skill	início de sessão, antes de decisões significativas, "o que eu sei sobre X?"	Puxa memórias relevantes ao cwd / tópico com filtragem `context_type`
`mnemo:memory-commit` skill	"lembre disso" / "salve isso" / "ghi nho" / "luu lai"	Captura manual tipada com árvore de decisão `context_type`
`mnemo:knowledge-audit` skill	periódico / "auditar memória"	Encontrar duplicatas, contradições, entradas desatualizadas; consolidar
`mnemo:session-handoff` skill	fim de sessão	Capturar decisões / preferências / correções / convenções / perguntas em aberto
`mnemo:temporal-query` skill	"a partir de" / "na época" / "histórico de" / "o que eu pensava então"	Snapshots pontuais via `action="as_of"` e rastreamento de cadeia de versões via `superseded_by`
Gancho SessionStart	toda inicialização de sessão	Empurrão não bloqueante para invocar `recall-context`
Gancho PostToolUse (opt-in)	`CAPTURE_AUTO_ENABLED=true`	Sugerir `memory-commit` após Write/Edit de CLAUDE.md / AGENTS.md / ARCHITECTURE.md / docs/*.md

Recursos MCP

URI	Descrição
`mnemo://stats`	Estatísticas do banco de dados e status do servidor

Prompts MCP

Prompt	Parâmetros	Descrição
`save_summary`	`summary`	Gerar prompt para salvar um resumo de conversa como memória
`recall_context`	`topic`	Gerar prompt para recuperar memórias relevantes sobre um tópico

Segurança

Fallbacks graciosos — Embedding Cloud → Local, sem fallback entre modos
Segurança de tokens de sincronização — Tokens OAuth armazenados em ~/.mnemo/tokens/ com permissões 600
Validação de entrada — Provedor de sincronização, pasta, remoto validados contra allowlists
Sanitização de erros — Sem credenciais em mensagens de erro

Compilar a partir do código-fonte

git clone https://github.com/n24q02m/mnemo.git
cd mnemo
uv sync
uv run mnemo-mcp

CLI

O pacote inclui dois scripts de console distintos:

mnemo — superfície de memória CLI-first (principal para scripts/agentes; nunca inicia um servidor): capture, recall, reflect, fetch e a família standing-* operam diretamente em um banco de memória SQLite. mnemo-pilot é um alias legado do mesmo ponto de entrada.
mnemo-mcp — o servidor MCP mais subcomandos operacionais de uso único. Uma invocação simples (ou qualquer flag prefixada com --) inicia o servidor; um subcomando inicial executa uma ação e sai.

Superfície de memória CLI-first (mnemo; todo subcomando aceita --db <path>, imprime um envelope JSON e sai com um código mapeado por taxonomia):

uvx --from mnemo-mcp mnemo recall --db ./mem.db "package naming" --k 3   # try without a persistent install

mnemo capture --db ./mem.db "keep PyPI name mnemo-mcp; repo is mnemo" --tags decision --category decision
mnemo recall --db ./mem.db "release ladder" --k 5        # search a subject's memories
mnemo reflect --db ./mem.db "why keep the alias?" --k 5  # bounded cited reflect over retrieval
mnemo fetch --db ./mem.db <memory_id>                    # fetch one memory by id
mnemo standing-refresh --db ./mem.db onboarding "how do releases cut?" --k 5   # materialize a standing page
mnemo standing-read --db ./mem.db onboarding             # cheap read with staleness info

CLI operacional do servidor (mnemo-mcp):

mnemo-mcp                       # start the stdio server (default transport)
mnemo-mcp --http                # start the Streamable HTTP server
                                # (also via MCP_TRANSPORT=http or TRANSPORT_MODE=http)

mnemo-mcp auth google           # authorize Google Drive sync via OAuth
mnemo-mcp auth google --client-id <ID> --client-secret <SECRET>   # bring-your-own OAuth client
mnemo-mcp logout                # clear the local Google Drive sync token
mnemo-mcp warmup                # pre-download Fastretrieval-managed local embedding + rerank models

mnemo-mcp config status         # report whether stored config exists
mnemo-mcp config delete --yes   # delete the stored (encrypted) config
mnemo-mcp relay status          # show the active browser-setup relay session
mnemo-mcp relay open            # open the relay setup form in a browser
mnemo-mcp relay reset           # clear relay session state
mnemo-mcp doctor                # environment diagnostics (Python, backend, store, mode)

Subcomando	Propósito
`auth <provider>`	Autorizar um provedor de credenciais de sincronização (atualmente `google`); `--client-id` / `--client-secret` fornecem um cliente OAuth próprio
`warmup`	Pré-baixar os modelos locais de embedding Qwen3 ONNX gerenciados pelo Fastretrieval + rerank para que o primeiro uso funcione offline
`config status` \| `config delete [--yes]`	Inspecionar ou remover a configuração criptografada armazenada
`relay status` \| `relay open` \| `relay reset`	Inspecionar, abrir ou limpar a sessão de configuração do navegador zero-config
`doctor`	Relatar versão do Python, backend de credenciais, diretório de armazenamento, configuração, sessão de relay e modo de armazenamento

Self-hosting (instância HTTP local)

Duas maneiras de executar o servidor para clientes MCP na sua máquina.

Dev: iniciar com `uv` (sem autenticação, apenas loopback)

uv run mnemo-mcp --http        # binds 127.0.0.1:8000, auth = "no-auth" by default

no-auth recusa binds fora do loopback, então isso é apenas localhost por construção — bom para testar o servidor localmente. O endpoint MCP é http://127.0.0.1:8000/mcp. Para uma configuração real, inicialize uma e edite-a:

uv run mnemo-mcp config-init   # writes ~/.mnemo/config.toml from the template

Sempre ativo: `docker compose` (autenticação por token, porta publicada em loopback)

docker-compose.http.yml é autocontido (constrói a imagem, persiste o estado no volume mnemo-data) e publica apenas em loopback:

cp mnemo-config/config.example.toml mnemo-config/config.toml   # then edit:
#   auth = "token"; set token_hash per the comments at the top of the example
docker compose -f docker-compose.http.yml up --build -d
# MCP endpoint: http://127.0.0.1:8771/mcp   (override the host port: MNEMO_PORT=9000 ...)

Configuração de token (também documentada na configuração de exemplo):

python -c "import secrets; print(secrets.token_urlsafe(32))"     # 1. mint token
MNEMO_AUTH_TOKEN=<token> uv run mnemo-mcp token-hash              # 2. print scrypt$ hash
# 3. paste the hash into token_hash in mnemo-config/config.toml; give clients the token

Para auth = "multi" (namespaces por usuário), monte também users.toml — veja a linha comentada em docker-compose.http.yml.

Consumidor CLI (sem necessidade de servidor)

A superfície mnemo fala diretamente com o banco de memória — útil para scripts e agentes:

mnemo capture --db ./mem.db "keep PyPI name mnemo-mcp; repo is mnemo" --tags decision --category decision
mnemo recall  --db ./mem.db "release ladder" --k 5
mnemo fetch   --db ./mem.db <memory_id>

Todo subcomando imprime um envelope JSON e aceita --db <path>. Veja CLI para a superfície completa (reflect, standing-*, doctor, …).

Apontando um cliente MCP para a instância

Registre o endpoint HTTP (transporte Streamable HTTP):

Claude Code: claude mcp add --transport http mnemo http://127.0.0.1:8771/mcp
Qualquer cliente MCP compatível com OpenAI-spec: URL do servidor http://127.0.0.1:8771/mcp; com auth = "token" envie o token compartilhado como credencial Bearer.

Configuração: local vs cloud, por tarefa

Cada célula de tarefa em mnemo-config/config.toml ([models.embed], rerank, chat, jev_score) é independente: base_url + api_key + model, HTTP compatível com OpenAI-spec. Misture livremente — por exemplo, OpenRouter cloud para chat enquanto embed/rerank apontam para um servidor local compatível com OpenAI-spec, ou tudo cloud. As chaves são apenas do host (os usuários finais nunca as veem) e podem alternativamente vir das variáveis de ambiente HULL_<TASK>_API_KEY.

Remoto (modo HTTP)

Implantado sobre HTTP, mnemo fala transporte Streamable HTTP e é protegido por OAuth. Aponte qualquer cliente MCP que suporte HTTP remoto + OAuth para https://<your-host>/mcp e autentique na primeira conexão; cada usuário autenticado recebe um armazenamento de credenciais isolado por usuário (veja Modelo de Confiança). Para montar uma instância, veja Implantar no Cloudflare.

A publicação pública de imagens OCI foi descontinuada. Tags históricas existentes no registro permanecem intactas; novas implantações de contêineres compilam a partir do código-fonte ou usam o registro gerenciado pelo Cloudflare.

Implantar no Cloudflare

Execute sua própria instância mnemo serverless no Cloudflare (Containers + D1 + Vectorize + KV).

Pausado em 2026-09-13 (apenas instância mantida): o token de implantação CF foi removido da conta por estar fora do manifesto (violação de processo), então o job de CD deploy-cf não faz nada atrás da variável de repositório CF_DEPLOY_ENABLED. A instância mantida congela na última versão implantada até que um token seja restabelecido via processo documentado e a variável seja definida como true. Self-hosting na sua própria conta (abaixo) não é afetado.

Pré-requisitos: uma conta Cloudflare no plano Workers Paid — necessário para Containers, D1 e Vectorize (o nível gratuito do Cloudflare não os inclui) — e o CLI wrangler.

git clone https://github.com/n24q02m/mnemo && cd mnemo
wrangler login
Provisione os bindings de armazenamento que mnemo usa — o banco de memórias, o índice de embeddings e o armazenamento de credenciais criptografadas:
```
wrangler d1 create mnemo-memories
wrangler vectorize create mnemo-memory-vectors-1536 --dimensions 1536 --metric cosine
wrangler kv namespace create mnemo-kv
```
Cole o ID do banco D1 e o ID do namespace KV retornados em wrangler.jsonc (o índice Vectorize vincula por nome, então nenhum ID é necessário), depois crie o esquema de memórias (tabelas, índices e o índice de texto completo FTS5) no banco que você acabou de criar:
```
wrangler d1 migrations apply mnemo-memories --remote
```
O SQL está em migrations/0001_init.sql, e o binding D1 em wrangler.jsonc aponta para essa pasta via migrations_dir: "migrations". A busca de texto completo usa FTS5, que o D1 inclui; a similaridade vetorial é servida pelo Vectorize em vez de uma extensão no banco, porque o D1 não pode carregar uma.
Compile o contêiner HTTP a partir deste checkout e envie-o para seu registro gerenciado pelo Cloudflare (CF Containers não podem puxar de registros externos diretamente), depois defina <YOUR_ACCOUNT_ID> em wrangler.jsonc:
```
docker build --target http -t mnemo-mcp:local .
wrangler containers push mnemo-mcp:local
# set image to registry.cloudflare.com/<YOUR_ACCOUNT_ID>/mnemo-mcp:local
```

Defina <YOUR_PUBLIC_URL> (por exemplo, https://mnemo.example.com) e <YOUR_WORKER_DOMAIN> (por exemplo, mnemo.example.com) em wrangler.jsonc, depois defina os segredos:

wrangler secret put CREDENTIAL_SECRET              # per-user vault key (encrypts the cf-kv credential store)
wrangler secret put MCP_RELAY_PASSWORD             # shared password gating the browser setup form
wrangler secret put MCP_DCR_SERVER_SECRET          # required once PUBLIC_URL is set (multi-user, per-JWT-sub)

wrangler deploy e conclua a configuração no formulário de relay do navegador no domínio do seu Worker. Salve os modelos, endpoints e chaves de provedor de cada sujeito lá, não em variáveis de ambiente do Worker. A rota gerenciada usa conclusão sem Minimax e embedding/reranking Cohere pagos através do Cloudflare AI Gateway — obtenha a autorização de orçamento necessária antes de usar os níveis pagos (Provider Spend Gate); veja a configuração por tarefa. O armazenamento mapeia para o Cloudflare via MCP_STORAGE_BACKEND=cf-kv (credenciais / tokens, criptografados), MEMORY_DB_BACKEND=cf-d1 (o banco de memórias + texto completo FTS5; não definido ou sqlite mantém o arquivo SQLite local em DB_PATH) e Vectorize (embeddings, cosseno). Embedding, reranking e conclusão em nuvem são resolvidos por sujeito autenticado. A inicialização remota não testa credenciais de provedor compartilhadas nem baixa modelos locais Fastretrieval. Configuração ausente do sujeito nunca seleciona um fallback de provedor/modelo em todo o processo.

Limite de Autoridade e Sincronização

Em implantações Cloudflare, Cloudflare D1 + Vectorize + KV é a única autoridade de produção:

D1 (MEMORY_DB_BACKEND=cf-d1): Armazenamento autoritativo para linhas de memória, metadados, intervalos válidos bitemporais e busca FTS5.
Vectorize (MCP_VECTORIZE_IDX): Índice vetorial denso para busca de similaridade semântica.
KV (MCP_STORAGE_BACKEND=cf-kv): Armazenamento criptografado de credenciais e sessão por usuário.
Limite de sincronização: MEMORY_DB_BACKEND=cf-d1 desativa o OAuth do Google Drive e todos os caminhos de sincronização externos mesmo se SYNC_ENABLED estiver ativado ou configurações antigas de S3/Google permanecerem. SYNC_ENABLED=false desativa independentemente a sincronização em implantações não-CF.
Inicialização local e self-host: stdio local (~/.mnemo/memories.db) e instâncias self-hosted mantêm sincronização passport opcional (OAuth Google Drive Device Code ou S3/R2/B2) para migração de workstation.

Implantação (instância mantida)

Toda release com tag é implantada automaticamente: o job de CD deploy-cf faz checkout da tag lançada, constrói a imagem http-slim, envia para o registry gerenciado pela Cloudflare como :<release-tag> imutável, implanta o Worker e faz o gate em um health check canário -- uma release está no ar exatamente na sua própria versão. Um dispatch beta reimplanta a beta; um dispatch estável é controlado pelo mantenedor. wrangler deploy manual contra a instância mantida não é permitido: isso quebraria a correspondência release-tag ↔ imagem-live. Self-hosting na sua própria conta Cloudflare (o botão acima) não é afetado.

Modelo de Confiança

Este plugin implementa TC-Local (vinculado à máquina, principal de confiança único). A divisão modo/armazenamento/criptografia abaixo é a classificação completa.

Modo	Armazenamento	Criptografia	Quem pode ler seus dados?
stdio (padrão)	`~/.mnemo/config.json`	AES-GCM, chave vinculada à máquina	Somente seu usuário do SO (permissão de arquivo 0600)
HTTP self-host	Igual ao stdio	Igual	Somente você (admin = usuário)
HTTP multi-usuário remoto (`PUBLIC_URL`)	Armazenamento de credenciais por JWT-sub	AES-GCM	Somente o usuário autenticado (isolamento por `sub`)

Nome de usuário do workspace (formulário de configuração HTTP)

O formulário de configuração do navegador tem um campo opcional nome de usuário do workspace. Inserir o mesmo nome de usuário sempre leva você ao mesmo bucket por sub, então suas credenciais e memórias permanecem acessíveis após uma reautorização e entre dispositivos, em vez de ficarem vinculadas ao subject único gerado para cada round-trip de /authorize. Deixar em branco mantém o comportamento anterior por autorização.

Limite de confiança: quando o formulário é protegido por um MCP_RELAY_PASSWORD compartilhado, o nome de usuário é uma chave de partição, não um segredo -- qualquer pessoa que conheça essa senha pode digitar qualquer nome de usuário e acessar esse bucket. Isso é aceitável para um grupo confiável; uma implantação multi-tenant não confiável precisa de um segredo por usuário ou OAuth delegado.

Migração única: usuários existentes devem reinserir suas credenciais uma vez após essa mudança. Nada é excluído; credenciais armazenadas sob o antigo subject aleatório simplesmente não são mais endereçadas.

Licença

Apache-2.0 -- Veja LICENSE.

mnemo-mcp

Documentação

Servidor MCP Mnemo

Sumário

Roadmap (atual = Fase 3 / v2.x)

Recursos

Instalação rápida

Comparação com concorrentes

Status

Documentação

Smithery

Ferramentas

Recursos MCP

Prompts MCP

Segurança

Compilar a partir do código-fonte

CLI

Self-hosting (instância HTTP local)

Dev: iniciar com uv (sem autenticação, apenas loopback)

Sempre ativo: docker compose (autenticação por token, porta publicada em loopback)

Consumidor CLI (sem necessidade de servidor)

Apontando um cliente MCP para a instância

Configuração: local vs cloud, por tarefa

Remoto (modo HTTP)

Implantar no Cloudflare

Limite de Autoridade e Sincronização

Implantação (instância mantida)

Modelo de Confiança

Nome de usuário do workspace (formulário de configuração HTTP)

Licença

Dev: iniciar com `uv` (sem autenticação, apenas loopback)

Sempre ativo: `docker compose` (autenticação por token, porta publicada em loopback)