# Memory OS: un sistema de memoria con prioridad local para Hermes

> Dale a Hermes una capa de memoria local para que recuerde archivos de proyecto, sesiones anteriores, datos y procedimientos durante nuevos trabajos.

Verificado el 4 jun 2026.

## Memory OS: un sistema de memoria con prioridad local para Hermes

Memory OS se añade a Hermes Agent para que tu agente deje de olvidarlo todo en cuanto termina una sesión.

No hay un interruptor de encendido y apagado.

Estás conectando archivos, dos bases de datos, un motor vectorial y procesos en segundo plano, todo en tu propia máquina, para que tu memoria nunca salga del equipo ni cueste una suscripción.

## Recursos

-   [Memory OS en GitHub](https://github.com/ClaudioDrews/memory-os) - 769 estrellas, licencia MIT, creado el 31 may 2026.
-   [Guía de configuración (install.md)](https://github.com/ClaudioDrews/memory-os/blob/HEAD/setup/install.md) - el documento oficial de instalación paso a paso con todos los comandos.
-   [Explicaciones de las capas](https://github.com/ClaudioDrews/memory-os/tree/HEAD/layers) - un documento por capa de memoria para entender el funcionamiento interno.
-   [Artículo de MarkTechPost](https://www.marktechpost.com/2026/06/01/meet-memory-os-a-6-layer-open-source-memory-stack-built-on-top-of-hermes-agent/) - un artículo externo sobre el proyecto, fechado el 1 jun 2026.

## Cómo funciona

Memory OS da a Hermes varias «capas» de memoria que trabajan juntas.

El README las enumera como archivos del espacio de trabajo, sesiones, datos estructurados, una bifurcación del plugin de recuperación Fabric, una base de datos vectorial Qdrant, una wiki que se organiza sola y una jerarquía de referencia fiable (Ground Truth) que indica al agente que confíe de verdad en lo que recuerda.

Antes de cada respuesta, el sistema recupera las memorias más relevantes de esas fuentes y las incorpora al prompt, para que el agente responda como un compañero que estuvo en todas las sesiones anteriores.

Una salvedad: este proyecto tiene pocos días de vida, no tiene versiones etiquetadas ni publica pruebas de recuperación o velocidad.

Trátalo como software en una fase temprana y pruébalo antes de depender de él.

## Paso 1: asegúrate de tener la máquina y las herramientas adecuadas

Memory OS funciona sobre Hermes Agent y varias herramientas, así que prepara eso antes de tocar nada más.

La guía de configuración pide Hermes Agent 0.14.0 o posterior, Python 3.11 o posterior, Docker 24.0 o posterior y al menos 8 GB de RAM, con 16 GB recomendados.

Ejecuta estas comprobaciones para confirmar que cada herramienta está instalada:

```
hermes --version
python3 --version
docker --version
```

Si falta algún comando o la versión es demasiado antigua, corrige eso primero.

Todos los pasos posteriores dan por hecho que ya funcionan; si no, fallarán en silencio o de forma visible.

## Paso 2: descarga el código de Memory OS en tu equipo

La instalación copia plugins, ejecuta scripts de configuración y construye servicios de Docker desde el repositorio, así que necesitas los archivos del proyecto en el disco local.

Clona el repositorio y entra en él:

```
git clone https://github.com/ClaudioDrews/memory-os.git
cd memory-os
```

Todos los comandos a partir de aquí dan por hecho que estás dentro de esta carpeta `memory-os`.

## Paso 3: instala el plugin Icarus incluido

Memory OS incluye su propia copia de un plugin llamado Icarus que se encarga de recuperar información entre sesiones.

Lo copias en la carpeta de plugins de Hermes:

```
cp -r icarus/ ~/.hermes/plugins/icarus/
```

Esta es una bifurcación muy modificada de Icarus, y el autor dice que no es compatible con la versión original.

No la sustituyas por la original, porque Memory OS depende de los cambios personalizados de esta bifurcación.

## Paso 4: instala las dependencias de Python y crea las bases de datos

Memory OS guarda tus sesiones y datos en dos pequeñas bases de datos SQLite, y un script de configuración las crea por ti.

Instala primero los paquetes de Python y después ejecuta el script de configuración de las bases de datos:

```
pip install -r requirements.txt
python setup/setup_db.py
```

Esto crea `state.db` para tu historial de conversaciones y `memory_store.db` para tus datos estructurados.

Puedes ejecutarlo tantas veces como quieras, porque solo crea las tablas que aún no existen.

Añade `--dry-run` para previsualizar lo que haría sin escribir nada.

## Paso 5: activa Icarus en la configuración de Hermes y reinicia

Hermes solo ejecuta los plugins que figuran como habilitados, así que el plugin no hace nada hasta que le indicas que lo cargue.

Abre `~/.hermes/config.yaml` y añade `icarus` a la lista de habilitados para que quede así:

```
enabled:
  - icarus                    # required, activates fabric tools and context injection hooks
```

Después reinicia la pasarela y confirma que se cargó el plugin:

```
hermes gateway restart
hermes status
```

La salida de estado debe mencionar `icarus` junto con sus herramientas y hooks.

Si no aparece, Hermes no cargó el plugin y nada de lo que depende de él funcionará.

## Paso 6: inicia la infraestructura local con Docker

Las partes pesadas de Memory OS se ejecutan como contenedores de Docker porque deben permanecer activas mientras trabaja tu agente: la base de datos vectorial Qdrant, una caché Redis y un proceso en segundo plano.

Entra en la carpeta `docker`, crea un pequeño archivo de ajustes `.env` e inicia los servicios.

Ejecuta esto desde la carpeta `docker`, porque el proceso se construye con rutas relativas a esa ubicación:

```
cd docker

cat > .env << EOF
OPENROUTER_API_KEY=sk-or-...
REDIS_PASSWORD=$(openssl rand -hex 16)
EMBEDDING_DIMS=4096
COLLECTION_NAME=knowledge_base
LOG_LEVEL=INFO
EOF

docker compose up -d
```

La línea `OPENROUTER_API_KEY` solo importa si usas OpenRouter para las representaciones vectoriales.

Déjala vacía si ejecutas un proveedor local como Ollama.

Confirma que se iniciaron los tres servicios:

```
docker compose ps
curl -s http://localhost:6333/healthz
```

redis, qdrant y worker deben mostrar «Up», y la comprobación de estado debe devolver «ok».

## Paso 7: define las variables de entorno que necesita Hermes

Memory OS lee la ruta de su carpeta fabric y los ajustes de representaciones vectoriales del archivo de entorno de Hermes.

Añade estas líneas a tu perfil de Hermes en `~/.hermes/.env`, sustituyendo `your-user` por tu nombre de usuario real:

```
FABRIC_DIR=/home/your-user/vault/fabric
ICARUS_EXTRACTION_MAX_TOKENS=4096
EMBEDDING_DIMS=4096
HERMES_AGENT_NAME=hermes
```

Usa rutas absolutas completas que empiecen por `/home/`, nunca el atajo `~`.

La pasarela de Hermes se ejecuta como servicio en segundo plano y no expande `~`, así que una ruta con tilde no se resuelve y la capa fabric lee silenciosamente de un lugar equivocado.

## Paso 8: aplica los cambios de Ground Truth en SOUL.md y rulebook.md

El autor lo considera el paso más importante.

Si lo omites, el agente ignora las memorias que acaba de recibir y pierde tiempo redescubriendo lo que ya sabía.

Memory OS te da el texto exacto para pegar en dos archivos de Hermes:

-   `~/.hermes/rulebook.md` recibe tres modificaciones de `modifications/execution-agent-protocol.md`.
-   `SOUL.md` recibe una sección Ground Truth de `modifications/soul-rulebook.md`.

Abre esos dos archivos de modificaciones en el repositorio y síguelos al pie de la letra.

El texto está pensado para copiarse literalmente, no para escribirlo a mano, así que toma la redacción exacta del README del repositorio.

Cada modificación empieza con un marcador de comentario.

Antes de pegarla, busca ese marcador en tus archivos y omite cualquier modificación que ya esté presente, porque duplicarla puede corromper tu configuración.

## Paso 9: prepara las carpetas de la wiki y programa las tareas de mantenimiento

La capa wiki convierte notas sin procesar en páginas de conocimiento limpias y enlazadas, y los scripts en segundo plano mantienen ordenada tu memoria con el tiempo.

Primero indica al sistema dónde está tu bóveda y crea la estructura de carpetas vacía:

```
export VAULT_PATH=/home/your-user/path/to/vault
mkdir -p $VAULT_PATH/wiki/{raw,concepts,entities,comparisons,_meta,_archive}
```

Colocas los documentos fuente en `raw/` y el proceso escribe por ti las páginas depuradas en las otras carpetas.

Los scripts de mantenimiento están pensados para ejecutarse de forma programada, y Hermes puede hacerlo por ti.

La tarea de incorporación a la wiki, por ejemplo, se ejecuta una vez por hora:

```
hermes cron create \
  --name "wiki-continuous-ingest" \
  --schedule "0 * * * *" \
  --script /path/to/scripts/wiki_continuous_ingest.py \
  --no-agent \
  --deliver local
```

Una trampa antes de habilitar el análisis semanal de deterioro: ejecuta primero `backfill_decay_metadata.py` una vez.

Sin esa carga inicial de metadatos, el analizador encuentra cero elementos para limpiar y no hace nada en silencio, así que crees que funciona cuando nunca toca nada.

Consulta la guía de instalación del repositorio para ver la lista completa de scripts y sus frecuencias recomendadas.

## Paso 10: reinicia y demuestra que funciona

Un último reinicio hace que Hermes recoja todos los cambios de configuración, entorno y código del plugin, porque solo surten efecto al reiniciar.

```
hermes gateway restart
```

Después, dentro de un chat de Hermes, ejecuta estas comprobaciones para confirmar que las capas responden:

```
/plugins
fabric_brief()
fact_store(action='probe', entity='test')
```

La lista de plugins debe mostrar Icarus, `fabric_brief()` debe devolver las entradas recientes aunque al principio esté vacía, y la consulta de datos debe volver vacía hasta que empieces a guardarlos.

Si falla una comprobación, lee la sección de resolución de problemas del repositorio antes de cambiar nada más.

Relaciona síntomas comunes, como que Qdrant muestre cero puntos o que se corten las entradas de fabric, con soluciones concretas.

Una última cosa para ajustar tus expectativas: es infraestructura pesada que funciona junto a la memoria integrada de Hermes en lugar de sustituirla, así que cuenta con mantenimiento real.

Dale una semana antes de juzgarlo.

El README dice que la incorporación de contexto y la wiki solo alcanzan su ritmo tras los primeros días de sesiones acumuladas.
