SSD Nodes Learn Hosting plans →
Guias Matt ConnorPor Matt Connor

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.

Verified Every command ran end-to-end on a fresh Ubuntu 24.04 server, July 31, 2026.

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.
  • git e uma toolchain de compilação, porque better-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_modules e 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 --version

node --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:build

npm 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:dev

Esta é 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.yaml

Numa segunda shell, peça ao serviço que indique se está ativo:

curl -sS http://127.0.0.1:18960/api/v1/health

O 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/add cria uma memória e POST /api/v1/memory/search consulta memórias.
  • GET /api/v1/memory/:id e DELETE /api/v1/memory/:id leem e removem uma entrada.
  • POST /api/v1/sessions/open e POST /api/v1/sessions/:sessionId/close delimitam uma sessão de agente.
  • POST /api/v1/turns/start e POST /api/v1/turns/:turnId/complete registam uma interação.
  • GET /api/v1/panel/overview, /api/v1/panel/analysis e /api/v1/panel/items alimentam 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 health

Se 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 health

A 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-vps

O 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/memmy

O 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.target

Nã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-string
sudo 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/health

status=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 e install.sh.
  • memory:serve:dev executa o ponto de entrada TypeScript através de tsx, que é um caminho de desenvolvimento. O repositório também inclui memory:serve para a saída compilada. Execute npm run sem 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.

Este artigo foi útil?