Memmy: memória local para agentes em um VPS
Aprenda a compilar o Memmy no Ubuntu e executar o serviço na porta 18960. Claude Code, Codex e Cursor compartilham notas em uma base SQLite local.
O que o Memmy é e o que armazena
O Memmy é um hub de memória local para agentes de IA que é executado no seu próprio VPS (servidor virtual privado). Ele mantém um único banco de dados SQLite com o que os seus agentes aprenderam, e todos os agentes do servidor leem e gravam nesse mesmo armazenamento. O projeto é memmy-agent da MemTensor, licenciado sob a MIT, na versão 1.2.401 em 1 de novembro de 2026; o Memory tem versionamento independente e está na versão 2.1.7.
Apenas uma parte dele é relevante em um servidor. O Memmy inclui um serviço de memória que escuta em http://127.0.0.1:18960, uma memmy-memory interface de linha de comando (CLI) que se comunica com esse serviço e uma bancada de trabalho para desktop. A bancada de trabalho é fornecida apenas para macOS e Windows, portanto, em um VPS Linux, você executa o serviço e a CLI. Isso é suficiente para fornecer uma memória compartilhada ao Claude Code, ao Codex e ao Cursor.
O Memmy organiza o que armazena em quatro camadas. O Capture armazena primeiro um Raw Turn separado e depois grava um item L1 Trace para cada etapa capturada, incluindo solicitações, respostas, chamadas de ferramentas e resultados. L2 Policy é um procedimento induzido a partir de traces que demonstraram ser úteis. L3 World Model é conhecimento estável sobre um projeto ou ambiente. Skill é um procedimento chamável cristalizado a partir de uma policy. O Capture cria traces L1, os jobs em segundo plano desenvolvem as camadas superiores e as gravações explícitas podem selecionar uma camada. Se essas distinções parecerem abstratas, a memória é uma das etapas posteriores em um caminho em etapas para aprender a criar agentes, e as camadas ficam mais claras depois que você escreve um loop de agente simples e observa que ele esquece tudo entre as execuções.
O que um hub de memória partilhada altera em comparação com a memória por ferramenta
Atualmente, cada agente inclui a sua própria memória. O Claude Code mantém ficheiros de instruções no repositório. O Cursor mantém regras na sua base de dados da área de trabalho. O Codex mantém logs de sessão em ~/.codex. Cada armazenamento pertence a uma ferramenta. Por isso, um facto que ensinou na segunda-feira numa ferramenta é desconhecido na terça-feira noutra. Paga esse custo duas vezes: uma vez nos tokens gastos a explicar novamente o mesmo projeto e outra no trabalho incorreto quando um agente age com base numa suposição que já corrigiu noutro local.
Um hub retira o armazenamento da ferramenta. O Memmy também lê os armazenamentos existentes, por isso não começa com uma base de dados vazia. O scanner conhece dez fontes integradas: Claude Code em ~/.claude/projects/**/*.jsonl, Codex em ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode em ~/.local/share/opencode/opencode.db, os ficheiros state.vscdb do Cursor, as bases de dados SQLite do OpenClaw em ~/.openclaw, Hermes em ~/.hermes, DeepSeek Harness em ~/.dsh/sessions, WorkBuddy em ~/.workbuddy/projects, Pi em ~/.pi/agent/sessions e QwenWork em ~/.qwenworkcn/projects. A bancada de trabalho para desktop pode adicionar outro agente pelo nome e só pede o caminho do histórico quando não consegue encontrar o agente automaticamente. O scanner no servidor não tem fontes personalizadas. Por isso, num VPS headless, obtém as fontes integradas.
Os contadores de importação não coincidem, e isso é esperado. O scanner agrupa as mensagens por origem e conversa e depois escreve uma memória L1 por cada turno completo. Um turno é considerado completo quando tem conteúdo de utilizador não vazio e termina com uma mensagem do assistente não vazia. Assim, um turno incompleto não contribui com nada até que uma sincronização posterior o possa completar. As mensagens são deduplicadas com checkpoints de conversa e IDs de turno estáveis. A contagem analisada, a contagem de mensagens importadas e a contagem de memórias novas são diferentes na mesma execução.
Esta é a parte que complementa como o Claude Code gere o contexto numa sessão. A gestão de contexto decide o que cabe numa única janela. Um hub de memória decide o que permanece depois de essa janela ser fechada.
O que é necessário no VPS
- Node.js 22 ou mais recente. A documentação do Memmy exige essa versão, mas o Ubuntu 24.04 disponibiliza o Node 18.
gite uma toolchain de compilação, porquebetter-sqlite3é um módulo nativo que pode ser compilado durante a instalação.- RAM para a instalação do workspace root e para a respetiva cadeia de compilação frontend.
- Espaço livre em disco para
node_modulese para a base de dados.
sudo apt update
sudo apt install -y git build-essential python3 curl ca-certificates sqlite3
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
node --versionnode --version deve apresentar v22 ou uma versão mais recente para a compilação a partir do código-fonte documentada. Um v18 neste ponto indica que o passo do NodeSource não foi aplicado. Por predefinição, engine-strict utiliza false, por isso uma declaração de engine incompatível normalmente gera um aviso em vez de falhar automaticamente a instalação.
Instalar o Memmy a partir do código-fonte no Ubuntu 24.04
git clone https://github.com/MemTensor/memmy-agent.git
cd memmy-agent
cp .env.example .env
npm install
npm run memory:buildnpm run memory:build compila o workspace @memmy/memory em Memory/dist. Também compila o AgentSourceCore, o visualizador de memória e os recursos de integração necessários para esse workspace. Confirme que o módulo nativo foi carregado:
node -e "const Database = require('better-sqlite3'); const db = new Database(':memory:'); db.close(); console.log('better-sqlite3 loads')"Se essa linha gerar um erro em vez de imprimir a saída, leia o erro para identificar a falha no carregamento ou na inicialização da base de dados. Se houver incompatibilidade no módulo nativo, execute npm rebuild better-sqlite3. É exatamente isso que o script de arranque do projeto faz antes de iniciar qualquer componente.
O README documenta bash scripts/dev-start.sh como um comando de arranque único. Não o execute num VPS sem interface gráfica. Ele inicia a shell de desktop Electron e um servidor de desenvolvimento Vite na porta 19000, juntamente com o serviço de memória. Como o Electron precisa de um display, o script pode ficar bloqueado ou terminar num servidor sem uma sessão gráfica.
As versões recentes também incluem memmy-agent-linux-cli.tar.gz e um install.sh para Linux x64 e arm64. O instalador precisa do Node.js 22.23.4+ dentro da série 22.x, 24.22.1+ dentro da série 24.x ou 26.12.1+ dentro da série 26.x, além de uma sessão de utilizador systemd. Ele rejeita outras versões principais. Instala os launchers memmy e memmy-memory em ~/.local/bin e inicia o serviço de memória como uma unidade de utilizador em 127.0.0.1:18960. Este guia mantém a compilação a partir do código-fonte porque esse é o método que permite ler cada script antes de o executar.
Inicie o serviço de memória e confirme que responde
npm run memory:serve:devEsta é a forma documentada de executar o serviço de memória a partir do código-fonte. O serviço fica associado a 127.0.0.1:18960, mantém a base de dados em ~/.memmy/memory-service/memory.sqlite e lê a configuração de ~/.memmy/config.yaml. O servidor aceita os mesmos valores como flags quando é necessário especificá-los explicitamente:
npm run memory:serve:dev -- \
--host 127.0.0.1 --port 18960 \
--db ~/.memmy/memory-service/memory.sqlite \
--config ~/.memmy/config.yamlNuma segunda shell, peça ao serviço que indique se está ativo:
curl -sS http://127.0.0.1:18960/api/v1/healthO endpoint de health não pede um token, por isso é a sonda adequada. Se o curl terminar com o código 7 e uma mensagem Failed to connect to 127.0.0.1 port 18960, a ligação falhou; isso, por si só, não confirma se existe um processo a escutar. Verifique o endereço, a porta e a firewall local. Consulte também o terminal onde o serviço está a ser executado para procurar erros de arranque. ss -lntp | grep 18960 confirma o socket quando o serviço está ativo.
O resto da API HTTP (interface de programação de aplicações) está disponível em /api/v1.
POST /api/v1/memory/addcria uma memória ePOST /api/v1/memory/searchconsulta memórias.GET /api/v1/memory/:ideDELETE /api/v1/memory/:idleem e removem uma entrada.POST /api/v1/sessions/openePOST /api/v1/sessions/:sessionId/closedelimitam uma sessão de agente.POST /api/v1/turns/startePOST /api/v1/turns/:turnId/completeregistam uma interação.GET /api/v1/panel/overview,/api/v1/panel/analysise/api/v1/panel/itemsalimentam o dashboard.
O Memmy reserva um bloco de portas. Num ambiente sem interface gráfica, utiliza apenas as primeiras: 18960 para a memória, 18970 para o health do gateway, 18980 para a interface web e o HTTP de administração, 18990 para a API compatível com OpenAI que memmy serve inicia, depois 19000 para o servidor de desenvolvimento Vite do frontend de desktop e 19001 para o socket de hot reload. A página de portas do projeto ainda indica 19010 para o hot reload, mas a configuração do Vite define 19001. Se algum processo no seu sistema já estiver a utilizar uma dessas portas, consulte essa lista para identificar a origem.
De onde vem efetivamente o comando memmy-memory
É aqui que uma primeira instalação normalmente falha. Por isso, leia o valor a partir do pacote em vez de o tentar adivinhar. O nome do comando não tem relação com o nome do repositório. Vem do campo bin do workspace que o define:
node -p "JSON.stringify(require('./Memory/package.json').bin)"Isto apresenta {"memmy-memory":"./dist/src/cli/index.js"}. Portanto, o ponto de entrada compilado é Memory/dist/src/cli/index.js. Ele só existe depois de npm run memory:build, porque é a compilação que cria dist e marca o ficheiro como executável. Execute-o diretamente:
node Memory/dist/src/cli/index.js healthSe quiser o nome curto no seu PATH, crie uma ligação para o mesmo ficheiro:
sudo ln -s "$PWD/Memory/dist/src/cli/index.js" /usr/local/bin/memmy-memory
memmy-memory healthA CLI usa http://127.0.0.1:18960 por predefinição e aceita --url, --token, --config, --source e --user-id. Os seus subcomandos são init, health, search, add, get e delete, além das chamadas de sessão e de turno que os agentes usam em vez das pessoas, e de install, upgrade, service e stop para gerir o próprio serviço. memmy-memory search "deploy steps" e memmy-memory add "staging migrates on deploy" são os dois que um agente executa com mais frequência.
Como ligar o Claude Code ao Memmy?
O Memmy não se regista como servidor dentro do Claude Code. Liga-se através de ficheiros que o Claude Code já lê, e o alcance depende do memmy-memory que executar. A partir de um checkout do código-fonte, o memmy-memory init --agent claude escreve um Skill memmy-memory em ~/.claude/skills/ e um bloco de memória marcado em ~/.claude/CLAUDE.md. O Claude Code executa então memmy-memory como um comando shell normal quando essas instruções o determinam. O launcher que o instalador Linux coloca em ~/.local/bin vai mais longe: o mesmo comando também regista hooks em ~/.claude/settings.json para SessionStart, UserPromptSubmit, Stop, PostCompact e SessionEnd. Esses hooks injetam a memória relevante e guardam cada turno concluído, sem o modelo ter de decidir fazê-lo.
Escreva a instrução manualmente uma vez. Assim, sabe exatamente o que foi transmitido ao agente. O Claude Code lê CLAUDE.md a partir da raiz do projeto no início de cada sessão. Por isso, uma secção como esta constitui toda a integração pelo caminho do código-fonte:
## Memory
Before starting a task, run `memmy-memory search "<topic>"` and read what comes back.
When a task is done, run `memmy-memory add "<what you learned>"` for anything that will matter next session.Seja claro sobre o que isto proporciona. Sem os hooks, a integração é feita ao nível das instruções. Funciona quando o modelo decide executar o comando, e não de outra forma. Nada obriga à chamada. Se uma sessão terminar sem add, a própria instrução não guardou nada. Uma análise posterior do histórico ainda pode importar o turno concluído. Esta é a mesma concessão dos ficheiros de memória do próprio Claude Code, com uma diferença: o armazenamento é partilhado. Assim, a nota também fica disponível para o Codex e o Cursor na mesma máquina. Os hooks eliminam essa lacuna em vez de dependerem de um pedido explícito. É também por isso que a memória persistente aparece ao lado dos limites de orçamento e das regras de permissões entre os plugins do DeepSeek Harness que vale a pena instalar.
A outra direção não exige qualquer configuração. O scanner do Memmy já lê ~/.claude/projects/**/*.jsonl, que é onde o Claude Code escreve as transcrições das sessões. Execute o Memmy no mesmo servidor onde executa o Claude Code numa sessão tmux. O trabalho de ontem passa então a fazer parte da memória sem qualquer configuração adicional.
O Memmy funciona como servidor MCP para o Claude Code?
Não. Saber isto evita perder uma tarde. O MCP (model context protocol) tem clientes e servidores. O Memmy é um cliente. Liga-se a servidores MCP e disponibiliza as respetivas ferramentas ao seu próprio runtime de agente. Não publica um endpoint MCP ao qual o claude mcp add possa ligar-se. A única ponte MCP no repositório pertence à integração Composio dentro da API local do desktop, e essa API fica ligada a uma porta aleatória em 127.0.0.1, protegida pelo seu próprio cabeçalho x-memmy-mcp-token.
O lado do cliente é configurado em ~/.memmy/config.yaml, o ficheiro indicado por MEMMY_CONFIG, em tools.mcpServers:
tools:
mcpServers:
example:
type: stdio
command: npx
args:
- "-y"
- "your-mcp-server"
toolTimeout: 30
enabledTools:
- "*"type aceita stdio, sse e streamableHttp. Um servidor stdio é executado como processo filho do Memmy. Por isso, o comando tem de existir no mesmo sistema e ser executado pelo mesmo utilizador. Se já mantém servidores MCP em execução num VPS, são esses que deve indicar aqui.
Manter o armazenamento de memória privado
Tudo o que o Memmy possui fica em ~/.memmy: config.yaml, a área de trabalho, memory-service/memory.sqlite e os ficheiros de runtime. A análise e a ingestão são executadas localmente, e as memórias são gravadas nesse ficheiro SQLite local. Por isso, a configuração predefinida é efetivamente local.
A ligação à cloud é um ponto que deve monitorizar. MEMMY_CLOUD_SERVICE identifica a origem cloud. O código não define um valor predefinido para essa variável, mas .env.example, que os passos de instalação copiam para .env, define-a como https://api.memmy.cn. Esse valor ativa o modo de conta com os respetivos tokens de avaliação. Quando está definido, o código de analytics do Memmy também envia eventos de utilização para esse endereço, incluindo no modo de API key: nomes de eventos e comandos, versões e um ID de instalação. A CLI comunica apenas palavras de comando fixas, nunca consultas de pesquisa ou texto de memória. O código de analytics não envia nada quando o valor não está definido. Por isso, num servidor que use apenas API keys, deixe essa linha vazia em .env antes de iniciar qualquer componente. O programa de melhoria de memória é um controlo separado nas definições de privacidade.
As chamadas aos modelos são outro caminho. Se configurar um fornecedor de embeddings alojado, o texto da memória que está a ser convertido em embedding é enviado para esse fornecedor, que o transforma num vetor. O armazenamento local não impede esse envio. Use o fornecedor de embeddings local integrado ou um endpoint de embeddings alojado por si para fechar esse caminho. Os modelos alojados de resumo, evolução e filtragem por relevância também recebem conteúdo das memórias quando essas tarefas são executadas. Verifique igualmente essas definições de modelos.
Mantenha a porta 18960 no endereço de loopback. Não precisa de uma regra de firewall, porque um serviço associado a 127.0.0.1 não é acessível a partir de fora do servidor. Aceda-lhe a partir do seu portátil através de SSH:
ssh -N -L 18960:127.0.0.1:18960 you@your-vpsO serviço de memória atual rejeita endereços bind que não sejam de loopback. Definir storage.token na configuração, ou a variável de ambiente MEMMY_MEMORY_TOKEN ou MEMORY_SERVICE_TOKEN, protege as chamadas normais à API de memória com um bearer token. O endpoint de health continua sem autenticação, e o visualizador no browser usa verificações separadas para pedidos locais. Os valores de configuração suportam referências ${ENV_NAME}. Assim, o token e as API keys dos modelos não ficam guardados no próprio ficheiro. Este é o mesmo princípio de manter os segredos fora dos agentes de IA em todo o ambiente. Uma política ufw predefinida de negação funciona como proteção adicional se uma versão futura alterar o endereço bind predefinido.
Faça backup de ~/.memmy antes de confiar nele
memory.sqlite é todo o armazenamento. Os vetores ficam nesse mesmo ficheiro através da extensão sqlite-vec, portanto um único ficheiro é suficiente para o backup. Copiá-lo com cp enquanto o serviço escreve pode produzir uma base de dados inconsistente. Use o comando de backup do próprio SQLite:
mkdir -p ~/memmy-backup
sqlite3 ~/.memmy/memory-service/memory.sqlite ".backup '$HOME/memmy-backup/memory.sqlite'"Esse comando produz uma cópia consistente enquanto o serviço continua em execução. Transfira-a para fora do servidor segundo um agendamento; é para isso que serve o restic para armazenamento externo. Perder config.yaml custa-lhe definições do fornecedor que pode introduzir novamente. Perder memory.sqlite custa-lhe as memórias registadas desde o último backup utilizável. O serviço também cria um backup local antes das migrações de esquema, mas esse backup não é uma cópia externa atual.
Execute o serviço de memória com systemd
npm run memory:serve:dev numa shell termina quando a shell termina. Um ficheiro de unidade mantém o serviço ativo entre reboots. O serviço é executado como o utilizador memmy, a partir de um checkout em /opt/memmy, com a configuração no diretório home desse utilizador. Pare a cópia em execução na shell, depois mova o checkout e a configuração e atualize o destino do link memmy-memory:
sudo useradd -m -s /bin/bash memmy
sudo mkdir -p /opt/memmy
sudo mv ~/memmy-agent /opt/memmy/memmy-agent
sudo chown -R memmy:memmy /opt/memmy
sudo ln -sfn /opt/memmy/memmy-agent/Memory/dist/src/cli/index.js /usr/local/bin/memmy-memory
sudo install -d -o memmy -g memmy -m 700 /home/memmy/.memmy
sudo install -o memmy -g memmy -m 600 ~/.memmy/config.yaml /home/memmy/.memmy/config.yaml
sudo install -d -m 755 /etc/memmyO serviço mantém a base de dados em /home/memmy/.memmy, pelo que arranca com um armazenamento vazio.
[Unit]
Description=Memmy memory service
After=network-online.target
[Service]
Type=simple
User=memmy
WorkingDirectory=/opt/memmy/memmy-agent
EnvironmentFile=/etc/memmy/memory.env
ExecStart=/usr/bin/npm run memory:serve:dev
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.targetNão coloque o token na unidade. Guarde-o em /etc/memmy/memory.env, pertencente a root, com o modo 600:
MEMMY_CONFIG=/home/memmy/.memmy/config.yaml
MEMMY_MEMORY_TOKEN=replace-this-with-a-long-random-stringsudo systemctl daemon-reload
sudo systemctl enable --now memmy-memory
systemctl status memmy-memory --no-pager
curl -sS http://127.0.0.1:18960/api/v1/healthstatus=203/EXEC na saída de estado significa que o systemd não conseguiu executar ExecStart, pelo que deve verificar which npm: é /usr/bin/npm numa instalação com NodeSource e está em algo dentro do diretório home do utilizador quando é usado nvm, que o systemd não encontra. Uma unidade que arranca e termina imediatamente requer a verificação do estado de saída e do journal: o código 0 indica uma saída normal, enquanto outros resultados incluem saídas diferentes de zero, sinais e timeouts. Execute journalctl -u memmy-memory -n 50 para consultar a saída do serviço. O procedimento é igual ao de qualquer outro serviço systemd num VPS.
O projeto disponibiliza agora duas alternativas ao nível do utilizador. O procedimento do README para uma compilação a partir do código-fonte é memmy-memory install --service-only, que descarrega o runtime Memory fixado e regista um serviço do utilizador, e o instalador para Linux configura memmy-memory.service como uma unidade systemd --user. Nenhuma das alternativas ativa o linger, pelo que deve executar sudo loginctl enable-linger <user> para manter o gestor de serviços desse utilizador em execução depois do logout e iniciá-lo no boot.
O que o Memmy ainda não faz
- Não existe uma compilação para desktop Linux. Os scripts de empacotamento abrangem macOS e Windows, pelo que o workbench e o respetivo assistente de configuração inicial não estão disponíveis no próprio servidor. O serviço de memória inclui agora um visualizador no browser em
http://127.0.0.1:18960/viewer/, acessível através do túnel SSH acima. No Linux, estão disponíveis um tarball da CLI einstall.sh. memory:serve:devexecuta o ponto de entrada TypeScript através detsx, que é um caminho de desenvolvimento. O repositório também incluimemory:servepara a saída compilada. Executenpm runsem argumentos para ver que scripts o seu checkout realmente tem.- A recuperação cria a janela de pesquisa a partir das 2,000 linhas vetoriais mais recentes e aplica depois a seleção Top-K dentro dessa janela. Num armazenamento muito grande, uma memória antiga pode ficar fora dela.
- A criação de embeddings ocorre depois da captura. Uma falha é enviada para uma fila de novas tentativas, em vez de bloquear a execução do agente. Uma memória adicionada há pouco pode ainda não estar disponível na pesquisa vetorial.
- Um segundo servidor com a sua própria base de dados SQLite local tem uma memória separada.
A versão 1.2.401, em 1 November 2026, ainda descreve um projeto recente que evolui rapidamente. As flags, os caminhos e os nomes dos scripts mudam entre versões. Leia o campo bin e o resultado de npm run no seu próprio checkout, em vez de confiar num comando copiado de qualquer lugar, incluindo aqui.
FAQ
Por que a verificação de integridade retorna “connection refused”?
O código de saída 7 do curl com Failed to connect to 127.0.0.1 port 18960 confirma uma falha de ligação, mas não indica se o Memmy está parado, terminou de forma inesperada, está a escutar noutra porta ou está inacessível. Verifique o endereço e a porta, execute ss -lntp | grep 18960 e consulte o terminal ou o journal onde o serviço foi iniciado. Se o log indicar uma incompatibilidade no módulo nativo do SQLite, execute npm rebuild better-sqlite3. Verifique também a versão do Node: a documentação do código-fonte exige Node 22 ou posterior, enquanto o instalador para Linux aceita apenas Node.js 22.23.4+ na série 22.x, 24.22.1+ na série 24.x ou 26.12.1+ na série 26.x.
De onde vem o comando memmy-memory depois de compilar a partir do código-fonte?
Ele vem do campo bin do pacote do workspace @memmy/memory, não do nome do repositório. Execute node -p "JSON.stringify(require('./Memory/package.json').bin)" dentro do checkout para mostrar {"memmy-memory":"./dist/src/cli/index.js"}. Esse ficheiro só existe depois de npm run memory:build, porque a compilação cria dist e marca o ficheiro como executável. Execute-o como node Memory/dist/src/cli/index.js health ou crie um link simbólico para /usr/local/bin para usar o nome curto.
Posso adicionar o Memmy ao Claude Code com claude mcp add?
Não. O Memmy é um cliente MCP, não um servidor MCP. Ele liga-se aos servidores listados em tools.mcpServers dentro de ~/.memmy/config.yaml e disponibiliza as respetivas ferramentas ao seu próprio runtime. O Claude Code acede ao Memmy no sentido inverso, executando a CLI memmy-memory como um comando de shell. memmy-memory init --agent claude cria um Skill e um bloco CLAUDE.md que indicam quando o utilizar. O launcher do instalador para Linux também adiciona hooks do Claude Code que guardam automaticamente as interações.
Executar o Memmy envia as minhas memórias para um serviço cloud?
A análise e a ingestão são executadas localmente, e as memórias são gravadas em ~/.memmy/memory-service/memory.sqlite no seu próprio disco. MEMMY_CLOUD_SERVICE, definido como https://api.memmy.cn em .env.example, disponibiliza o modo de conta e os tokens de avaliação, além de receber dados analíticos de utilização sem o texto das memórias enquanto estiver definido. Esvazie-o se utilizar apenas API keys. O programa de melhoria das memórias tem uma opção de privacidade separada. Um modelo de embeddings alojado recebe o texto da memória que transforma num vetor. Para manter esse processamento local, utilize o provider local integrado ou um endpoint executado por si. Os modelos alojados de resumo, evolução e filtragem por relevância também recebem o conteúdo das memórias quando essas tarefas são executadas.