Memora

O servidor é executado automaticamente quando configurado no Claude Code. Invocação manual:

# Default (stdio mode for MCP)
memora-server

# With graph visualization server
memora-server --graph-port 8765

# HTTP transport (alternative to stdio)
memora-server --transport streamable-http --host 127.0.0.1 --port 8080

Claude Code

Adicione a .mcp.json na raiz do seu projeto:

Banco de dados local:

{
  "mcpServers": {
    "memora": {
      "command": "memora-server",
      "args": [],
      "env": {
        "MEMORA_DB_PATH": "~/.local/share/memora/memories.db",
        "MEMORA_ALLOW_ANY_TAG": "1",
        "MEMORA_GRAPH_PORT": "8765"
      }
    }
  }
}

Banco de dados na nuvem (Cloudflare D1) - Recomendado:

{
  "mcpServers": {
    "memora": {
      "command": "memora-server",
      "args": ["--no-graph"],
      "env": {
        "MEMORA_STORAGE_URI": "d1://<account-id>/<database-id>",
        "CLOUDFLARE_API_TOKEN": "<your-api-token>",
        "MEMORA_ALLOW_ANY_TAG": "1"
      }
    }
  }
}

Com D1, use --no-graph para desabilitar o servidor de visualização local. Em vez disso, use o grafo hospedado na sua URL do Cloudflare Pages (veja Grafo na Nuvem).

Banco de dados na nuvem (S3/R2) - Modo de sincronização:

{
  "mcpServers": {
    "memora": {
      "command": "memora-server",
      "args": [],
      "env": {
        "AWS_PROFILE": "memora",
        "AWS_ENDPOINT_URL": "https://<account-id>.r2.cloudflarestorage.com",
        "MEMORA_STORAGE_URI": "s3://memories/memories.db",
        "MEMORA_CLOUD_ENCRYPT": "true",
        "MEMORA_ALLOW_ANY_TAG": "1",
        "MEMORA_GRAPH_PORT": "8765"
      }
    }
  }
}

Codex CLI

Adicione a ~/.codex/config.toml:

[mcp_servers.memora]
  command = "memora-server"  # or full path: /path/to/bin/memora-server
  args = ["--no-graph"]
  env = {
    AWS_PROFILE = "memora",
    AWS_ENDPOINT_URL = "https://<account-id>.r2.cloudflarestorage.com",
    MEMORA_STORAGE_URI = "s3://memories/memories.db",
    MEMORA_CLOUD_ENCRYPT = "true",
    MEMORA_ALLOW_ANY_TAG = "1",
  }

Todas as 43 ferramentas MCP são registradas incondicionalmente, então cada sessão de agente é injetada com o esquema completo de ferramentas de ~12.700 tokens, mesmo quando a maioria das ferramentas nunca é chamada. MEMORA_TOOL_PROFILE expõe um subconjunto por implantação, de modo que uma ferramenta restrita está genuinamente ausente — faltando em tools/list E não despachável (call_tool retorna unknown-tool, não uma execução oculta). O perfil é aplicado e atestado na inicialização; o perfil ativo e a contagem de ferramentas expostas são registrados em stderr.

• Não definido / vazio = full. Nenhuma implantação existente muda de comportamento.
• Um valor desconhecido aborta a inicialização com uma mensagem listando os valores válidos. Ele nunca cai silenciosamente para full — um erro de digitação não deve reexpor ferramentas de manutenção destrutivas (memory_rebuild_embeddings, memory_delete_batch) a todos os workers. Falha fechada.
• memory_list está em leader, mas não em agent. Foi excluído de ambos enquanto custava 163-174s em um armazenamento D1 contra os 0,22s de memory_list_compact; #973 corrigiu isso (agora ~1,1s). Ele permanece fora de agent porque a superfície de leitura de um worker é deliberadamente estreita, não por velocidade.
• A fronteira líder/agente é dados em memora/tool_profile.py (dois frozensets). Editá-la é uma linha, não uma varredura de 43 decoradores.
• O prune exclui do dict privado _tool_manager._tools do FastMCP, então memora fixa mcp>=1.27,<1.28 (o minor auditado) e executa uma atestação de inicialização através dos manipuladores de requisição MCP registrados de baixo nível (_mcp_server.request_handlers[ListToolsRequest] / [CallToolRequest] — o callable de despacho real que requisições de clientes usam, não os helpers Python FastMCP.list_tools / call_tool) que se recusa a iniciar se o SDK instalado rotear listagem/despacho para outro lugar (deriva de implementação privada). O pin é a proteção estática; a atestação é o backstop em tempo de execução. Aumentar o limite superior exige reexecutar tests/test_tool_profile.py.
• Sob implantação em contêiner, o perfil é por contêiner, enquanto os papéis são por agente. Um contêiner servindo o líder de um workspace e seus workers precisa do superconjunto líder; agent removeria create_section/store_document/delete/digest/tags do líder.
• memora-server (ou seja, memora.server.main()) é o único caminho de serviço com perfil suportado. Um embedder direto que importa memora.server.mcp e chama mcp.run() por conta própria ignora o perfilamento completamente (o mcp global ainda contém todas as 43 ferramentas); embedders que desejam perfilamento devem chamar apply_tool_profile por conta própria ou usar main().

# Leader deployment — exposes 19 tools
MEMORA_TOOL_PROFILE=leader memora-server

# Agent worker — exposes 12 tools
MEMORA_TOOL_PROFILE=agent memora-server

# Full (default) — all 43 tools, existing behaviour
memora-server

# Typo refuses to start:
# MEMORA_TOOL_PROFILE=agnt memora-server
# Error: unknown MEMORA_TOOL_PROFILE='agnt'; valid values: full, leader, agent

Um processo memora pode servir todos os workspaces. MEMORA_DATABASES é um registro JSON de {name: storage URI}; um cliente alcança seu armazenamento em /mcp/<name>. O seletor é a URL já em .mcp.json, não um argumento de ferramenta — um db opcional em cada ferramenta são 43 chances de esquecer um, e cada erro escreveria no armazenamento de outra pessoa.

MEMORA_DATABASES não definido é o formato antigo: um backend de MEMORA_STORAGE_URI / MEMORA_DB_PATH, um /mcp. Implantações stdio existentes não mudam.

Roteamento (streamable-http apenas):

A vinculação é fixa por sessão MCP, não por requisição. Uma sessão aberta em /mcp/alpha e reutilizada contra /mcp/beta ainda resolve para alpha. Um cliente não pode trocar de banco de dados no meio de uma conversa.

Configuração malformada se recusa a iniciar (não cai para o banco de dados legado): JSON inválido, um não-objeto, chaves duplicadas, uma URI vazia, um nome que não é um segmento de caminho de URL, ou MEMORA_DEFAULT_DB ausente/desconhecido quando mais de um banco de dados está listado.

Par funcional — execute isto, conecte-se a isto. Um listener streamable-HTTP, não uma entrada MCP command (isso geraria um filho stdio que nunca fala MCP no stdio). As credenciais vivem no processo do servidor.

MEMORA_DATABASES='{"memora":"d1://<account-id>/<memora-db-id>","ob1":"d1://<account-id>/<ob1-db-id>"}' \
MEMORA_DEFAULT_DB=memora \
CLOUDFLARE_API_TOKEN='<token>' \
MEMORA_VECTOR_SCAN_PAGE_SIZE=100 \
memora-server --transport streamable-http --host 127.0.0.1 --port 8000 --no-graph

{
  "mcpServers": {
    "memora": {
      "type": "http",
      "url": "http://127.0.0.1:8000/mcp/ob1"
    }
  }
}

Variante contêiner / proxy (o lançador usual deste host, não o comando acima): scripts/memora-instance.sh up myinstance inicia o mesmo servidor HTTP dentro de um contêiner e coloca scripts/memora_proxy.py em 127.0.0.1:<PORT> (8910 para a instância memora). A URL do workspace é então http://127.0.0.1:8910/mcp/ob1. Veja Implantação em Contêiner.

Um registro pode misturar d1://, s3:// e caminhos locais; parse_backend_uri despacha com base no esquema.

memory_stats relata o banco de dados vinculado. Ele retorna database (o nome que esta sessão realmente resolveu) e database_source (path, registry_default ou unconfigured). Um nome válido, mas errado, em .mcp.json é de outra forma indetectável: toda ferramenta funciona, leituras são bem-sucedidas e escritas caem silenciosamente no armazenamento de outro projeto. Chame memory_stats e verifique database contra o workspace que você pretendia.

Saúde de um processo multi-banco de dados: GET /health é liveness (sem I/O de banco de dados — o único sinal em que um supervisor pode reiniciar). GET /health/db é uma superfície de alerta (sempre HTTP 200; status é ok, degraded, unknown — sem snapshot ainda, uma atualização expirou, ou evidência mais antiga que a máxima obsolescência — ou error se o próprio registro está inutilizável). GET /health/db/{name} é a sonda específica do workspace (200 ou 503). Retirar todo o processo porque um armazenamento está degradado derruba os saudáveis junto.

Com MEMORA_DATABASES não definido, um processo ainda vincula um banco de dados por sua vida útil (MEMORA_STORAGE_URI / MEMORA_DB_PATH). Esse é o formato original um-armazenamento-um-contêiner-uma-porta.

Com MEMORA_DATABASES definido, um contêiner serve todos os workspaces e clientes selecionam um armazenamento pelo caminho da URL (/mcp/<name>). Veja Roteamento multi-banco de dados. scripts/memora-instance.sh quer um de STORAGE_URI, VOLUME ou MEMORA_DATABASES por arquivo de instância (load() exige pelo menos um). Se mais de um estiver definido, cmd_up usa MEMORA_DATABASES, depois STORAGE_URI, depois VOLUME.

Dockerfile constrói uma imagem sem credenciais; scripts/memora-instance.sh implanta uma instância de instances/myinstance.env (ou outro arquivo nomeado). O CLI de tempo de execução do script é $MEMORA_CONTAINER_BIN (padrão container — o CLI da Apple). Cada operação de contêiner que o script executa honra essa substituição (build, up, status, logs, down). O processo memora_proxy.py gerado codifica container list, que também é o motivo do proxy existir: esse tempo de execução reatribui o IP do contêiner a cada início.

./scripts/memora-instance.sh build   myinstance   # build the image
./scripts/memora-instance.sh up      myinstance   # run the container
./scripts/memora-instance.sh proxy   myinstance   # render a LaunchAgent + print install commands
./scripts/memora-instance.sh status                # every instance at a glance

Então aponte o workspace para ele — a configuração completa do cliente, sem segredos nela. Uma instância de registro precisa do armazenamento no caminho (/mcp/<name>); /mcp puro é o padrão do registro:

{"mcpServers": {"memora": {"type": "http", "url": "http://127.0.0.1:8910/mcp/ob1"}}}

Credenciais nunca entram na imagem, no arquivo de instância ou na configuração HTTP do workspace. Elas são lidas em tempo de execução de uma configuração de credenciais separada ($CRED_SOURCE — em si um .mcp.json contendo apenas o bloco mcpServers.memora.env) e injetadas com -e. Se o arquivo de instância não definir CRED_SOURCE, o script usa ~/.config/memora/credentials.mcp.json quando esse arquivo existe, caso contrário ~/repos/agentic-box/.mcp.json. Passe todas as variáveis que esse arquivo define, não algumas escolhidas a dedo: um contêiner iniciado com apenas as chaves de incorporação perde silenciosamente a consolidação LLM de memory_absorb em vez de falhar ruidosamente.

Por que o proxy existe — leia isto antes de decidir que você não precisa dele. O tempo de execução padrão (container da Apple) reatribui o IP de um contêiner a cada início, não apenas na recriação. Um cliente MCP lê sua configuração uma vez na inicialização, então um endereço movido não produz um erro: produz um travamento silencioso permanente. scripts/memora_proxy.py mantém um 127.0.0.1:<PORT> estável na frente do endereço móvel e re-resolve por conexão.

Dois modos de falha que ele distingue, que custaram uma interrupção para aprender:

• A consulta executou e o contêiner não está listado → ele realmente se foi. Recuse.
• A consulta não pôde executar (timeout sob pressão de memória do host) → nada de novo é conhecido. Continue servindo o último endereço bom conhecido, limitado por MEMORA_PROXY_STALE_GRACE (300s). Conflitar os dois derrubou todos os workspaces enquanto os contêineres estavam respondendo normalmente em endereços inalterados.

Defina MEMORA_TOOL_PROFILE por instância (veja Perfis de Ferramentas). Observe que o perfil é por contêiner, enquanto os papéis são por agente: se um contêiner serve o líder de um workspace e seus workers, ele precisa do superconjunto líder.

Variável de script em tempo de implantação (não uma variável de ambiente do memora-server — ela nunca chega ao processo dentro do contêiner):

instances/README.md cobre os campos de configuração e launchd/README.md o proxy supervisionado. REVERT.md documenta a restauração de um workspace para o servidor stdio direto.

Memora suporta três backends de embeddings:

Embeddings e o LLM são configurados separadamente.

Uma divisão parcial (apenas um MEMORA_EMBEDDING_* definido) é rejeitada para que o segredo de um provedor nunca seja enviado a outro host.

Armadilha — OpenRouter não tem endpoint de embeddings. O catálogo do OpenRouter é apenas chat/multimodal (sem modelos de embedding). Não aponte o caminho de embeddings para o OpenRouter via OPENAI_BASE_URL (ou uma URL base MEMORA). Essa combinação retorna 404 em toda chamada de embed; sem MEMORA_EMBEDDING_STRICT=1, Memora cai para TF-IDF e continua respondendo, então o armazenamento se enche de sacos de palavras-chave enquanto parece saudável. OpenRouter continua bom apenas para o LLM.

Exemplo funcional (LLM via OpenRouter, embeddings via Cloudflare Workers AI):

@cf/baai/bge-m3 é 1024-dimensional. O token precisa de permissão Workers AI. Formato do endpoint:

https://api.cloudflare.com/client/v4/accounts/<account_id>/ai/v1

{
  "env": {
    "MEMORA_EMBEDDING_MODEL": "openai",
    "OPENAI_API_KEY": "<openrouter-key>",
    "OPENAI_BASE_URL": "https://openrouter.ai/api/v1",
    "MEMORA_LLM_MODEL": "deepseek/deepseek-chat",
    "MEMORA_EMBEDDING_API_KEY": "<cloudflare-api-token-with-workers-ai>",
    "MEMORA_EMBEDDING_BASE_URL": "https://api.cloudflare.com/client/v4/accounts/<account_id>/ai/v1",
    "OPENAI_EMBEDDING_MODEL": "@cf/baai/bge-m3",
    "MEMORA_EMBEDDING_STRICT": "1"
  }
}

O que esta correção faz (sem exageros): embeddings e LLM podem usar provedores diferentes; uma divisão parcial é rejeitada; o modo estrito transforma degradação silenciosa em uma falha dura e nomeada.

Automático: Embeddings e referências cruzadas são calculados automaticamente quando você memory_create, memory_update ou memory_create_batch.

Reconstrução manual necessária quando a impressão digital do armazenamento muda — não apenas MEMORA_EMBEDDING_MODEL, mas também:

• Endpoint de embeddings (MEMORA_EMBEDDING_BASE_URL / host)
• ID real do modelo (OPENAI_EMBEDDING_MODEL, por exemplo, mudar para @cf/baai/bge-m3)
• Tipo ou dimensões do vetor (sacos TF-IDF de palavras-chave vs densos 1024-d; ou 384 vs 1024)
• Armazenamento misto (algumas linhas densas, algumas esparsas) — similaridade de cosseno só compartilha chaves, então tipos mistos resultam em recall 0.0 para linhas antigas

Formato da impressão digital: backend|model|repr (por exemplo, openai|@cf/baai/bge-m3|dense:1024). O valor de meta legado openai sozinho é tratado como incompatibilidade.

# After changing embedding model/endpoint, rebuild all embeddings
memory_rebuild_embeddings

# Then rebuild cross-references to update the knowledge graph
memory_rebuild_crossrefs

Um servidor HTTP integrado inicia automaticamente junto com o servidor MCP, fornecendo uma visualização interativa do grafo de conhecimento.

Painel de Detalhes

Painel de Linha do Tempo

Acesso local:

http://localhost:8765/graph

Acesso remoto via SSH:

ssh -L 8765:localhost:8765 user@remote
# Then open http://localhost:8765/graph in your browser

Configuração:

{
  "env": {
    "MEMORA_GRAPH_PORT": "8765"
  }
}

Para desativar: adicione "--no-graph" aos argumentos na sua configuração MCP.

Recursos da Interface do Grafo

• Painel de Detalhes - Visualize conteúdo de memórias, metadados, tags e memórias relacionadas
• Painel de Linha do Tempo - Navegue pelas memórias cronologicamente, clique para destacar no grafo
• Painel de Histórico - Registro de ações de todas as operações com entradas consecutivas agrupadas e referências de memória clicáveis (memórias excluídas mostradas com tachado)
• Painel de Chat - Faça perguntas sobre suas memórias usando chat com LLM baseado em RAG, com respostas em streaming e referências [Memory #ID] clicáveis
• Controle Deslizante de Tempo - Filtre memórias por intervalo de datas, arraste para explorar o histórico
• Atualizações em Tempo Real - Grafo, linha do tempo e histórico atualizam via SSE quando as memórias mudam
• Filtros - Menus suspensos de tag/seção, controles de zoom
• Renderização Mermaid - Blocos de código são renderizados como diagramas

Cores dos Nós

• 🟣 Tags - Tons de roxo por tag
• 🔴 Problemas - Vermelho (aberto), Laranja (em andamento), Verde (resolvido), Cinza (não será corrigido)
• 🔵 TODOs - Azul (aberto), Laranja (em andamento), Verde (concluído), Vermelho (bloqueado)

O tamanho do nó reflete o número de conexões.

Ao usar Cloudflare D1 como seu banco de dados, a visualização do grafo é hospedada no Cloudflare Pages - sem necessidade de servidor local.

Benefícios:

• Acesso de qualquer lugar (sem túnel SSH)
• Atualizações em tempo real via WebSocket
• Suporte a múltiplos bancos de dados via parâmetro ?db=
• Acesso seguro com Cloudflare Zero Trust

Configuração:

1. Crie o banco de dados D1:

   npx wrangler d1 create memora-graph
   npx wrangler d1 execute memora-graph --file=memora-graph/schema.sql
   

2. Implante o Pages:

   cd memora-graph
   npx wrangler pages deploy ./public --project-name=memora-graph
   

3. Configure os bindings no painel do Cloudflare:

   • Pages → memora-graph → Configurações → Bindings
   • Adicione D1: DB_MEMORA → seu banco de dados
   • Adicione R2: R2_MEMORA → seu bucket (para imagens)

4. Configure o MCP com o URI D1:

   {
     "env": {
       "MEMORA_STORAGE_URI": "d1://<account-id>/<database-id>",
       "CLOUDFLARE_API_TOKEN": "<your-token>"
     }
   }
   

Acesso: https://memora-graph.pages.dev

Proteja com Zero Trust:

1. Painel do Cloudflare → Zero Trust → Access → Applications
2. Adicione um aplicativo para memora-graph.pages.dev
3. Crie uma política com e-mails permitidos
4. Pages → Configurações → Ative a Política de Acesso

Consulte memora-graph/ para configuração detalhada e configuração de múltiplos bancos de dados.

Faça perguntas sobre sua base de conhecimento diretamente da interface do grafo. O painel de chat usa RAG (Geração Aumentada por Recuperação) para buscar memórias relevantes e transmitir respostas do LLM com suporte a chamadas de ferramentas.

• Alternar via o ícone de chat flutuante no canto inferior direito
• Busca semântica encontra as memórias mais relevantes como contexto
• Respostas em streaming com referências [Memory #ID] clicáveis que focam o nó do grafo
• Chamada de ferramentas — o LLM pode criar, atualizar e excluir memórias diretamente do chat (ex.: "salve isso como uma memória", "exclua a memória #42", "atualize a memória #10 com...")
• Funciona tanto no servidor local quanto na implantação do Cloudflare Pages

Configure o modelo de chat:

Requer uma API compatível com OpenAI (OPENAI_API_KEY + OPENAI_BASE_URL para local, segredo OPENROUTER_API_KEY para Cloudflare). O modelo de chat deve suportar uso de ferramentas (chamada de funções).

Encontre e mescle memórias duplicadas usando comparação semântica com IA:

# Find potential duplicates (uses cross-refs + optional LLM analysis)
memory_find_duplicates(min_similarity=0.7, max_similarity=0.95, limit=10, use_llm=True)

# Merge duplicates (append, prepend, or replace strategies)
memory_merge(source_id=123, target_id=456, merge_strategy="append")

Comparação com LLM analisa pares de memórias e retorna:

• verdict: "duplicado", "semelhante" ou "diferente"
• confidence: pontuação de 0,0 a 1,0
• reasoning: Breve explicação
• suggested_action: "mesclar", "manter_ambas" ou "revisar"

Funciona com qualquer API de chat compatível com OpenAI (OpenAI, OpenRouter, Azure, etc.) via OPENAI_BASE_URL. OpenRouter é adequado para este caminho de LLM; ele não fornece embeddings — configure embeddings separadamente (consulte Busca Semântica e Embeddings).

Armazene documentos estruturados (relatórios de pesquisa, decisões de arquitetura, post-mortems) como árvores de fragmentos pesquisáveis:

# Store a markdown document — auto-parsed into typed fragments
memory_store_document(
    content="# Research Report\n\n## Evidence Table\n| Claim | Confidence |\n...",
    document_key="research/memora-enhancements-2026-04-08",
    tags=["memora/research"]
)
# Returns: {root_id: 230, fragment_count: 100, node_map: {claim: [...], plan_item: [...], ...}}

# Retrieve the full document or specific fragment types
memory_get_document(document_key="research/memora-enhancements-2026-04-08")
memory_get_document(document_key="...", node_kinds=["claim"], content_mode="full")

# Delete a document and all its fragments
memory_delete_document(document_key="research/memora-enhancements-2026-04-08")

Como funciona: O analisador divide o markdown por estrutura — tabelas se tornam afirmações individuais, listas numeradas se tornam itens de plano, listas de URLs se tornam referências, e seções de risco se tornam fragmentos de risco. Cada fragmento é pesquisável independentemente via memory_semantic_search enquanto o documento completo é recuperável como uma unidade.

Tipos de fragmentos: claim, plan_item, reference, section_chunk, risk

Proteções de integridade: Fragmentos de documentos são protegidos contra modificação acidental:

• memory_delete requer force=True para fragmentos
• memory_merge recusa mesclar fragmentos
• memory_absorb exclui fragmentos da correspondência de similaridade
• memory_find_duplicates e memory_detect_supersessions ignoram fragmentos
• A interface do grafo oculta fragmentos, mostrando apenas o nó raiz do documento

Ferramentas estruturadas para tipos comuns de memória:

# Create a TODO with status and priority
memory_create_todo(content="Implement feature X", status="open", priority="high", category="backend")

# Create an issue with severity
memory_create_issue(content="Bug in login flow", status="open", severity="major", component="auth")

# Create a section placeholder (hidden from graph)
memory_create_section(content="Architecture", section="docs", subsection="api")

Analise memórias armazenadas e apresente insights acionáveis:

# Full analysis with LLM-powered pattern detection
memory_insights(period="7d", include_llm_analysis=True)

# Quick summary without LLM (faster, no API key needed)
memory_insights(period="1m", include_llm_analysis=False)

Retorna:

• Resumo de atividade — memórias criadas no período, agrupadas por tipo e tag
• Itens em aberto — TODOs e problemas abertos com detecção de obsoletos (configurável via MEMORA_STALE_DAYS; padrão memory_insights de 14, padrão da interface do grafo de 30 — mesma variável, dois consumidores)
• Candidatos a consolidação — pares de memórias semelhantes que poderiam ser mesclados
• Análise com LLM — temas, áreas de foco, lacunas de conhecimento e um resumo (requer OPENAI_API_KEY)

Gerencie relacionamentos entre memórias:

# Create typed edges between memories
memory_link(from_id=1, to_id=2, edge_type="implements", bidirectional=True)

# Edge types: references, implements, supersedes, extends, contradicts, related_to

# Remove links
memory_unlink(from_id=1, to_id=2)

# Boost memory importance for ranking
memory_boost(memory_id=42, boost_amount=0.5)

# Detect clusters of related memories
memory_clusters(min_cluster_size=2, min_score=0.3)

Para visualização offline, exporte memórias como um arquivo HTML estático:

memory_export_graph(output_path="~/memories_graph.html", min_score=0.25)

Isso é opcional - o Servidor de Grafo ao Vivo fornece a mesma visualização com atualizações em tempo real.

Navegue pelas memórias diretamente no Neovim com Telescope. Copie o plugin para sua configuração:

# For kickstart.nvim / lazy.nvim
cp nvim/memora.lua ~/.config/nvim/lua/kickstart/plugins/

Uso: Pressione <leader>sm para abrir o navegador de memórias com busca difusa e pré-visualização.

Requer: telescope.nvim, plenary.nvim e memora instalados no seu ambiente Python.