SSD Nodes Learn Hosting plans →
Guías Matt ConnorPor Matt Connor

Memmy: memoria local compartida para agentes en un VPS

Configura Memmy 1.2.2 desde el código fuente en Ubuntu. Ejecuta el servicio en el puerto 18960 y guarda la memoria compartida de tus agentes en SQLite local.

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

Qué es Memmy y qué almacena

Memmy es un centro de memoria local para agentes de IA que se ejecuta en su propio VPS (servidor privado virtual). Mantiene una base de datos SQLite con lo que sus agentes han aprendido, y cada agente en el servidor lee y escribe en ese mismo almacén. El proyecto es memmy-agent de MemTensor, bajo licencia MIT, en la versión 1.2.401 a fecha de 1 de noviembre de 2026; Memory tiene una versión independiente 2.1.7.

Solo una parte es relevante en un servidor. Memmy distribuye un servicio de memoria que escucha en http://127.0.0.1:18960, una interfaz de línea de comandos (CLI) memmy-memory que se comunica con dicho servicio, y un entorno de escritorio. El entorno de escritorio solo está empaquetado para macOS y Windows, por lo que en un VPS Linux usted ejecuta el servicio y la CLI. Esto es suficiente para proporcionar una memoria compartida a Claude Code, Codex y Cursor.

Memmy clasifica lo que almacena en cuatro capas. Capture primero guarda un Raw Turn independiente, luego escribe un elemento L1 Trace por cada paso capturado, incluyendo peticiones, respuestas, llamadas a herramientas y resultados. L2 Policy es un procedimiento derivado de trazas que demostraron ser útiles. L3 World Model es conocimiento estable sobre un proyecto o un entorno. Skill es un procedimiento invocable cristalizado a partir de una política. Capture crea trazas L1, los procesos en segundo plano desarrollan las capas superiores y las escrituras explícitas pueden seleccionar una capa. Si estas distinciones parecen abstractas, la memoria es una de las etapas posteriores en una ruta por etapas para aprender a construir agentes, y las capas cobran más sentido una vez que usted mismo ha escrito un bucle de agente simple y ha observado cómo olvida todo entre ejecuciones.

Qué cambia un hub de memoria compartida frente a la memoria por herramienta

Cada agente actual incluye su propia memoria. Claude Code mantiene archivos de instrucciones en el repositorio. Cursor guarda reglas en la base de datos del área de trabajo. Codex almacena registros de sesión en ~/.codex. Cada almacén pertenece a una sola herramienta, por lo que un dato que usted enseñó el lunes en una herramienta es desconocido el martes en otra. Usted paga por esto dos veces: una en tokens gastados al volver a explicar el mismo proyecto, y otra en trabajo incorrecto cuando un agente actúa bajo una suposición que usted ya corrigió en otro lugar.

Un hub traslada el almacén fuera de la herramienta. Memmy también lee los almacenes existentes, por lo que usted no comienza desde una base de datos vacía. Su escáner reconoce diez fuentes integradas: Claude Code en ~/.claude/projects/**/*.jsonl, Codex en ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode en ~/.local/share/opencode/opencode.db, los archivos state.vscdb de Cursor, las bases de datos SQLite de OpenClaw en ~/.openclaw, Hermes en ~/.hermes, DeepSeek Harness en ~/.dsh/sessions, WorkBuddy en ~/.workbuddy/projects, Pi en ~/.pi/agent/sessions y QwenWork en ~/.qwenworkcn/projects. El entorno de escritorio permite añadir otro agente por nombre y solicita la ruta de su historial solo cuando no puede encontrar al agente por sí mismo. El escáner del lado del servidor no tiene fuentes personalizadas, por lo que en un VPS sin interfaz gráfica usted obtiene las integradas.

Los contadores de importación no coincidirán, y esto es esperado. El escáner agrupa los mensajes por fuente y conversación, luego escribe una memoria L1 por cada turno completo. Un turno se considera completo cuando tiene contenido de usuario no vacío y termina con un mensaje de asistente no vacío, por lo que un turno incompleto no aporta nada hasta que una sincronización posterior pueda completarlo. Los mensajes se desduplican mediante puntos de control de conversación e identificadores de turno estables. El recuento escaneado, el recuento de mensajes importados y el recuento de nuevas memorias difieren en la misma ejecución.

Esta es la pieza que se complementa con cómo Claude Code gestiona el contexto dentro de una sesión. La gestión de contexto decide qué cabe en una sola ventana. Un hub de memoria decide qué sobrevive después de que esa ventana se cierra.

Requisitos en el VPS

  • Node.js 22 o superior. La documentación de Memmy lo requiere y Ubuntu 24.04 incluye Node 18.
  • git y una cadena de herramientas de compilación, ya que better-sqlite3 es un módulo nativo que puede compilarse durante la instalación.
  • Memoria RAM para la instalación del espacio de trabajo raíz y su cadena de compilación de frontend.
  • Espacio en disco libre para node_modules y la base de datos.
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 debería mostrar v22 o superior para la compilación desde el código fuente documentada. Un v18 aquí significa que el paso de NodeSource no se aplicó. La configuración engine-strict de npm utiliza false por defecto, por lo que una declaración de motor incompatible normalmente genera una advertencia en lugar de fallar automáticamente en la instalación.

Instalar Memmy desde el código fuente en 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 el espacio de trabajo @memmy/memory en Memory/dist. También construye AgentSourceCore, el visor de memoria y los recursos de integración necesarios para dicho espacio de trabajo. Verifique que el módulo nativo se haya cargado:

node -e "const Database = require('better-sqlite3'); const db = new Database(':memory:'); db.close(); console.log('better-sqlite3 loads')"

Si esa línea arroja un error en lugar de imprimir el resultado, lea el error para identificar el fallo de carga o de inicialización de la base de datos. En caso de una discrepancia en el módulo nativo, ejecute npm rebuild better-sqlite3, que es exactamente lo que hace el script de inicio del propio proyecto antes de lanzar cualquier proceso.

El archivo README documenta bash scripts/dev-start.sh como un comando de inicio único. No lo ejecute en un VPS sin interfaz gráfica (headless). Este comando inicia el shell de escritorio Electron y un servidor de desarrollo Vite en el puerto 19000 junto al servicio de memoria; como Electron requiere una pantalla, el script se detiene o termina en un servidor sin sesión gráfica.

Las versiones recientes también incluyen memmy-agent-linux-cli.tar.gz y un install.sh para Linux x64 y arm64. El instalador requiere Node.js 22.23.4+ dentro de la rama 22.x, 24.22.1+ dentro de la 24.x, o 26.12.1+ dentro de la 26.x, además de una sesión de usuario de systemd; rechaza otras versiones principales. Coloca los lanzadores memmy y memmy-memory en ~/.local/bin e inicia el servicio de memoria como una unidad de usuario en 127.0.0.1:18960. Esta guía mantiene la compilación desde el código fuente porque es la vía que permite leer cada script antes de su ejecución.

Inicie el servicio de memoria y compruebe que responde

npm run memory:serve:dev

Esta es la forma documentada de ejecutar el servicio de memoria desde el código fuente. Se vincula a 127.0.0.1:18960, mantiene la base de datos en ~/.memmy/memory-service/memory.sqlite y lee la configuración desde ~/.memmy/config.yaml. El servidor acepta los mismos valores como flags cuando desea especificarlos:

npm run memory:serve:dev -- \
  --host 127.0.0.1 --port 18960 \
  --db ~/.memmy/memory-service/memory.sqlite \
  --config ~/.memmy/config.yaml

Desde una segunda terminal, consulte al servicio si está activo:

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

El endpoint de salud no solicita un token, por lo que es la sonda adecuada. Si curl termina con el código 7 y un mensaje Failed to connect to 127.0.0.1 port 18960, la conexión falló; esto por sí solo no determina si existe un proceso escuchando. Verifique la dirección, el puerto y el firewall local, y lea la terminal donde se ejecuta el servicio para identificar errores de inicio. ss -lntp | grep 18960 confirma el socket una vez que el servicio está activo.

El resto de la API (interfaz de programación de aplicaciones) HTTP se encuentra bajo /api/v1.

  • POST /api/v1/memory/add escribe en la memoria y POST /api/v1/memory/search realiza consultas.
  • GET /api/v1/memory/:id y DELETE /api/v1/memory/:id leen y eliminan una entrada.
  • POST /api/v1/sessions/open y POST /api/v1/sessions/:sessionId/close delimitan una sesión de agente.
  • POST /api/v1/turns/start y POST /api/v1/turns/:turnId/complete registran un turno.
  • GET /api/v1/panel/overview, /api/v1/panel/analysis y /api/v1/panel/items alimentan el panel de control.

Memmy reserva un bloque de puertos, y en modo headless solo utiliza el primero: 18960 para la memoria, 18970 para la salud de la pasarela, 18980 para la interfaz web y la administración HTTP, 18990 para la API compatible con OpenAI que inicia memmy serve, luego 19000 para el servidor de desarrollo Vite del frontend de escritorio y 19001 para su socket de recarga en caliente. La página de puertos del proyecto todavía lista 19010 para la recarga en caliente, pero la configuración de Vite establece 19001. Si algún proceso en su equipo ya ocupa uno de estos, esa lista es donde debe buscar.

De dónde procede realmente el comando memmy-memory

Aquí es donde suele fallar la primera instalación, así que léalo en el paquete en lugar de hacer suposiciones. El nombre del comando no tiene ninguna relación con el nombre del repositorio. Procede del campo bin del workspace que lo define:

node -p "JSON.stringify(require('./Memory/package.json').bin)"

Esto muestra {"memmy-memory":"./dist/src/cli/index.js"}. Por tanto, el punto de entrada compilado es Memory/dist/src/cli/index.js y sólo existe después de npm run memory:build, porque la compilación es la que crea dist y marca el archivo como ejecutable. Ejecútelo directamente:

node Memory/dist/src/cli/index.js health

Si quiere el nombre corto en su PATH, cree un enlace al mismo archivo:

sudo ln -s "$PWD/Memory/dist/src/cli/index.js" /usr/local/bin/memmy-memory
memmy-memory health

La CLI usa http://127.0.0.1:18960 de forma predeterminada y acepta --url, --token, --config, --source y --user-id. Sus subcomandos son init, health, search, add, get y delete, además de las llamadas de sesión y de turno que usan los agentes en lugar de las personas, y install, upgrade, service y stop para administrar el servicio. memmy-memory search "deploy steps" y memmy-memory add "staging migrates on deploy" son los dos que más ejecuta un agente.

¿Cómo se conecta Claude Code a Memmy?

Memmy no se registra a sí mismo como un servidor dentro de Claude Code. Se conecta a través de archivos que Claude Code ya lee, y su alcance depende de qué memmy-memory ejecute. Desde una descarga del código fuente, memmy-memory init --agent claude escribe una Skill memmy-memory en ~/.claude/skills/ y un bloque de memoria marcado en ~/.claude/CLAUDE.md; posteriormente, Claude Code ejecuta memmy-memory como un comando de shell ordinario cuando esas instrucciones se lo indican. El lanzador que el instalador de Linux coloca en ~/.local/bin va más allá: el mismo comando también registra hooks en ~/.claude/settings.json para SessionStart, UserPromptSubmit, Stop, PostCompact y SessionEnd, los cuales inyectan la memoria relevante y guardan cada turno completado sin que el modelo tenga que decidir hacerlo.

Escriba la instrucción manualmente una vez, ya que así sabrá exactamente qué se le indicó al agente. Claude Code lee CLAUDE.md desde la raíz del proyecto al inicio de cada sesión, por lo que una sección como esta constituye la integración completa en la ruta de origen:

## 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.

Sea claro sobre lo que esto le aporta. Sin los hooks, es una integración a nivel de instrucción, por lo que funciona cuando el modelo decide ejecutar el comando, y no de otra forma. Nada fuerza la llamada. Si una sesión termina sin el add, la instrucción por sí misma no guardó nada; un escaneo posterior del historial aún puede importar el turno completado. Ese es el mismo compromiso que con los archivos de memoria propios de Claude Code, con una diferencia: el almacén es compartido, por lo que la nota también llega a Codex y Cursor en la misma máquina. Los hooks cierran la brecha en lugar de solicitarlo amablemente, que es también la razón por la cual la memoria persistente se sitúa junto a los límites de presupuesto y las reglas de permisos entre los plugins de DeepSeek Harness que vale la pena instalar.

La dirección opuesta no requiere ninguna configuración. El escáner de Memmy ya lee ~/.claude/projects/**/*.jsonl, que es donde Claude Code escribe las transcripciones de sus sesiones. Ejecute Memmy en el mismo servidor donde ejecuta Claude Code dentro de una sesión de tmux y el trabajo de ayer se convierte en memoria sin que usted tenga que configurar nada.

¿Memmy funciona como servidor MCP para Claude Code?

No, y conocer esta limitación ahorra una tarde de trabajo. MCP (model context protocol) tiene clientes y servidores. Memmy es un cliente. Se conecta a servidores MCP y ofrece sus herramientas a su propio entorno de ejecución de agentes. No publica un endpoint MCP al que claude mcp add pueda conectarse. El único puente MCP del repositorio pertenece a la integración de Composio dentro de la API local de escritorio, y esa API escucha en un puerto aleatorio en 127.0.0.1, protegido por su propia cabecera x-memmy-mcp-token.

El lado cliente se configura en ~/.memmy/config.yaml, el archivo al que apunta MEMMY_CONFIG, en tools.mcpServers:

tools:
  mcpServers:
    example:
      type: stdio
      command: npx
      args:
        - "-y"
        - "your-mcp-server"
      toolTimeout: 30
      enabledTools:
        - "*"

type acepta stdio, sse y streamableHttp. Un servidor stdio se ejecuta como proceso hijo de Memmy, por lo que su comando debe existir en el mismo equipo y ejecutarse con el mismo usuario. Si ya mantiene servidores MCP en ejecución en un VPS, esos son los que debe enumerar aquí.

Mantener el almacén de memoria privado

Todo lo que posee Memmy reside bajo ~/.memmy: config.yaml, el espacio de trabajo, memory-service/memory.sqlite y los archivos de ejecución. El escaneo y la ingesta ocurren localmente, y las memorias se escriben en ese archivo SQLite local, por lo que la postura predeterminada es genuinamente local.

La conexión a la nube es una ruta que debe vigilar. MEMMY_CLOUD_SERVICE nombra el origen de la nube. El código no establece un valor predeterminado para ella, pero .env.example, que los pasos de instalación copian a .env, la establece en https://api.memmy.cn. Esto respalda el modo de cuenta con sus tokens de prueba, y siempre que se establece, el código de análisis de Memmy también envía eventos de uso a esa dirección, incluso en modo de clave API: nombres de eventos y comandos, versiones y un ID de instalación. La CLI informa solo de palabras de comando fijas, nunca de consultas de búsqueda o texto de memoria, y el código de análisis no envía nada cuando el valor no está definido, por lo que en un servidor que solo utiliza claves API, deje esa línea vacía en .env antes de iniciar nada. El programa de mejora de la memoria es un interruptor independiente en la configuración de privacidad.

Las llamadas al modelo son otra ruta. Si configura un proveedor de incrustaciones (embeddings) alojado, el texto de la memoria que se está incrustando se envía a ese proveedor para que pueda convertirse en un vector. El almacenamiento local no ayuda en ese caso. Utilice el proveedor de incrustaciones local integrado o un endpoint de incrustaciones que usted mismo aloje para cerrar esa ruta. Los modelos alojados de resumen, evolución y filtro de relevancia también reciben contenido de memoria cuando se ejecutan esos trabajos, así que revise también la configuración de esos modelos.

Mantenga el puerto 18960 en la dirección de loopback. No necesita ninguna regla de firewall, porque un servicio vinculado a 127.0.0.1 no es accesible desde fuera de la máquina en absoluto. Acceda a él desde su portátil a través de SSH:

ssh -N -L 18960:127.0.0.1:18960 you@your-vps

El servicio de memoria actual rechaza las direcciones de vinculación que no sean de loopback. Establecer storage.token en la configuración, o la variable de entorno MEMMY_MEMORY_TOKEN o MEMORY_SERVICE_TOKEN, protege las llamadas a la API de memoria ordinarias con un token de portador (bearer token); el estado de salud permanece sin autenticar, y el visor del navegador utiliza comprobaciones independientes para las solicitudes locales. Los valores de configuración admiten referencias a ${ENV_NAME}, por lo que el token y sus claves API de modelo permanecen fuera del archivo en sí. Ese es el mismo hábito que mantener los secretos fuera de los agentes de IA en cualquier otro lugar, y una política de denegación predeterminada en ufw es su red de seguridad si una versión futura cambia su dirección de vinculación predeterminada.

Realice una copia de seguridad de ~/.memmy antes de confiar en ella

memory.sqlite es el almacén completo. Los vectores residen en ese mismo archivo mediante la extensión sqlite-vec, por lo que un solo archivo constituye la copia de seguridad. Copiarlo con cp mientras el servicio está escribiendo puede generar una base de datos inconsistente. Utilice el comando de copia de seguridad propio de SQLite:

mkdir -p ~/memmy-backup
sqlite3 ~/.memmy/memory-service/memory.sqlite ".backup '$HOME/memmy-backup/memory.sqlite'"

Esto genera una copia consistente mientras el servicio sigue en ejecución. Envíela fuera del servidor de forma programada, que es para lo que sirve restic para almacenamiento externo. Perder config.yaml le costará los ajustes del proveedor que puede volver a escribir. Perder memory.sqlite le costará los recuerdos registrados desde su última copia de seguridad utilizable; el servicio también crea una copia de seguridad local antes de las migraciones de esquema, pero esta no es una copia externa actual.

Ejecutar el servicio de memoria bajo systemd

npm run memory:serve:dev en una shell termina al cerrar la sesión. Un archivo de unidad mantiene el servicio activo tras los reinicios. Se ejecuta como usuario memmy, desde una copia en /opt/memmy, con su configuración en el directorio home de dicho usuario. Detenga la copia que se ejecuta en su shell, mueva la copia y la configuración, y actualice el enlace 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

El servicio mantiene su base de datos en /home/memmy/.memmy, por lo que inicia con un almacén vacío.

[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

Mantenga el token fuera de la unidad. Colóquelo en /etc/memmy/memory.env, propiedad de root, con permisos 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 en la salida de estado significa que systemd no pudo ejecutar ExecStart en absoluto, así que verifique which npm: es /usr/bin/npm en una instalación de NodeSource y algo dentro del home del usuario en nvm, lo cual systemd no encontrará. Una unidad que inicia y termina inmediatamente requiere revisar su estado de salida y el journal: el código 0 es una salida limpia, mientras que otros resultados incluyen salidas distintas de cero, señales y tiempos de espera agotados. Ejecute journalctl -u memmy-memory -n 50 para ver la salida del servicio. La mecánica es la misma que para cualquier otro servicio de systemd en un VPS.

El proyecto ofrece ahora dos alternativas a nivel de usuario. La ruta del README para una compilación desde el código fuente es memmy-memory install --service-only, que descarga el runtime de Memory fijado y registra un servicio de usuario; el instalador de Linux configura memmy-memory.service como una unidad systemd --user. Ninguno habilita linger, así que ejecute sudo loginctl enable-linger <user> para mantener el gestor de servicios de ese usuario activo tras cerrar sesión e iniciarlo al arrancar el sistema.

Lo que Memmy aún no hace

  • No existe una compilación para escritorio Linux. Los scripts de empaquetado cubren macOS y Windows, por lo que el entorno de trabajo y su asistente de configuración inicial no están disponibles en el propio servidor. El servicio de memoria ahora incluye un visor de navegador en http://127.0.0.1:18960/viewer/, accesible a través del túnel SSH mencionado anteriormente. Linux recibe un tarball de CLI y install.sh en su lugar.
  • memory:serve:dev ejecuta el punto de entrada de TypeScript a través de tsx, una ruta de desarrollo. El repositorio también incluye memory:serve para la salida compilada. Ejecute npm run sin argumentos para ver qué scripts tiene realmente su copia local.
  • La recuperación construye su ventana de búsqueda a partir de las últimas 2000 filas vectoriales y luego aplica una selección Top-K dentro de esa ventana. En un almacén muy grande, una memoria antigua puede quedar fuera de este rango.
  • La incrustación (embedding) ocurre después de la captura, y si falla, se envía a una cola de reintento en lugar de bloquear el turno del agente. Es posible que una memoria añadida hace un momento aún no sea localizable mediante búsqueda vectorial.
  • Un segundo servidor con su propia base de datos SQLite local tiene una memoria independiente.

La versión 1.2.401 al 1 de noviembre de 2026 describe un proyecto joven que evoluciona rápidamente. Los flags, rutas y nombres de scripts cambian entre versiones. Lea el campo bin y la salida de npm run en su propia copia local en lugar de confiar en un comando copiado de cualquier lugar, incluido este.

FAQ

¿Por qué la comprobación de estado devuelve "connection refused"?

Un código de salida 7 de curl con Failed to connect to 127.0.0.1 port 18960 indica una conexión fallida, no si Memmy está detenido, bloqueado, escuchando en otro lugar o inaccesible. Verifique la dirección y el puerto, ejecute ss -lntp | grep 18960 y lea la terminal o el journal donde se inició el servicio. Si el registro informa de una discrepancia en el módulo nativo de SQLite, ejecute npm rebuild better-sqlite3. Compruebe también su versión de Node: la documentación de la fuente requiere Node 22 o superior, mientras que el instalador de Linux solo acepta Node.js 22.23.4+ dentro de 22.x, 24.22.1+ dentro de 24.x, o 26.12.1+ dentro de 26.x.

¿De dónde proviene el comando memmy-memory tras compilar desde el código fuente?

Proviene del campo bin del paquete del espacio de trabajo @memmy/memory, no del nombre del repositorio. Ejecute node -p "JSON.stringify(require('./Memory/package.json').bin)" dentro del directorio de trabajo y mostrará {"memmy-memory":"./dist/src/cli/index.js"}. Ese archivo solo existe después de npm run memory:build, ya que la compilación crea dist y marca el archivo como ejecutable. Ejecútelo como node Memory/dist/src/cli/index.js health o cree un enlace simbólico en /usr/local/bin para usar el nombre corto.

¿Puedo añadir Memmy a Claude Code con claude mcp add?

No. Memmy es un cliente MCP, no un servidor MCP. Se conecta a los servidores listados bajo tools.mcpServers en ~/.memmy/config.yaml y ofrece sus herramientas a su propio entorno de ejecución. Claude Code accede a Memmy a la inversa, ejecutando la CLI memmy-memory como un comando de shell. memmy-memory init --agent claude escribe una Skill y un bloque CLAUDE.md que le indican cuándo actuar, y el lanzador del instalador de Linux también añade hooks de Claude Code que guardan los turnos automáticamente.

¿El uso de Memmy envía mis recuerdos a un servicio en la nube?

El escaneo y la ingesta se ejecutan localmente, y los recuerdos se escriben en ~/.memmy/memory-service/memory.sqlite en su propio disco. MEMMY_CLOUD_SERVICE, configurado en https://api.memmy.cn dentro de .env.example, gestiona el modo de cuenta y los tokens de prueba, y recibe analíticas de uso sin el texto de los recuerdos mientras esté configurado; déjelo vacío si solo utiliza claves de API. El programa de mejora de memoria tiene un interruptor de privacidad independiente. Un modelo de embedding alojado recibe el texto de la memoria que convierte en vector; utilice el proveedor local integrado o un endpoint que usted mismo ejecute para mantener ese procesamiento local. Los modelos alojados de resumen, evolución y filtrado de relevancia también reciben el contenido de la memoria cuando se ejecutan esas tareas.

¿Te resultó útil este artículo?