Mnemo con Ollama: memoria local, despliegue y control

Tu modelo de Ollama ya puede responder preguntas, pero cada conversación empieza desde cero. La decisión de proyecto que comentaste ayer, la preferencia que fijaste hoy y la restricción que necesitarás mañana se olvidan.

Ese es el problema de memoria en los LLM locales. Ollama ofrece un servicio de modelo capaz de responder. Qué responde, y si recuerda las restricciones que ya le diste, depende de cuánto contexto repitas manualmente en cada prompt.

Mnemo no intenta rehacer RAG. Usa un grafo de conocimiento y extracción de entidades para gestionar memoria a largo plazo, de modo que tu LLM local recuerde decisiones de proyecto y relaciones entre entidades en lugar de preguntarte otra vez: “¿Para qué sirve esta API?“

1. Qué es Mnemo: posicionamiento y capacidades clave

1.1 Leer el posicionamiento

En “local-first AI memory layer” hay dos partes importantes:

• local-first: los datos se guardan localmente, no suben a la nube, se pueden migrar y no dependen de la vida de un SaaS concreto
• memory layer: no es otro RAG ni otro framework de agentes. Solo se ocupa de la memoria: extracción de entidades, construcción del grafo y recuperación semántica

Por ejemplo: preguntas “¿cuál es la URL base de la API de este proyecto?”. Una búsqueda vectorial pura puede devolver varios fragmentos relacionados con “API”, pero no sabe a qué proyecto te refieres. La recuperación por grafo puede seguir la cadena “proyecto -> API -> baseUrl” y devolver el valor de configuración que definiste antes.

La condición es que la extracción de entidades sea correcta. Si el LLM divide mal “URL base de la API” en dos entidades, “API” y “URL base”, el grafo se parte y la recuperación se corta. Ahí empieza la acumulación de ruido.

Con el posicionamiento claro, las capacidades principales se entienden mejor.

1.2 Matriz de capacidades clave

El README de Mnemo enumera cuatro capacidades principales:

1. persistent knowledge graph (grafo de conocimiento persistente)

   • Entidades y relaciones se guardan en SQLite, no en vectores de un solo uso
   • La estructura del grafo se puede consultar, exportar y migrar

2. entity extraction (extracción de entidades)

   • Identifica automáticamente entidades en conversaciones, como personas, proyectos, APIs y decisiones
   • No es recuperación vectorial pura. Convierte “¿para qué sirve esta API?” en una estructura entidad-relación consultable
   • La calidad depende de la comprensión del LLM. Un LLM local como llama3 puede identificar mal entidades en conversaciones complejas, y la acumulación de ruido es un riesgo continuo. El README no da una solución automática de limpieza, así que debes revisar la calidad del grafo regularmente

3. semantic retrieval (recuperación semántica)

   • Combina búsqueda de texto completo en fragmentos, búsqueda de nombres de entidad, expansión del grafo, filtro de relaciones y ranking ponderado
   • Reduce el peso de resultados expandidos para que las coincidencias directas superen relaciones inferidas y el contexto no crezca sin control

4. graph-first vs pure vector search

La búsqueda vectorial pura pregunta: “¿qué se parece?”. La recuperación por grafo pregunta: “¿qué está relacionado?”. La primera puede devolver ruido semánticamente parecido pero irrelevante. La segunda puede seguir cadenas de relaciones entre entidades.

La comparación lo deja más claro:

1.3 Stack técnico y licencia

Stack técnico:

Railway - Plataforma de despliegue moderna, sin ops complejas, en producción en minutos

Empezar ahora →Anuncio

• Rust, dividido en cuatro crates que veremos en la siguiente sección
• SQLite para almacenamiento local, con modo WAL
• petgraph para el grafo en memoria
• API de OpenAI, Ollama o Anthropic como backend LLM

Licencia: MIT License. Se puede usar, modificar y redistribuir.

Recordatorios de riesgo:

• Proyecto temprano, según el README de GitHub del 2026-06-05
• APIs y arquitectura pueden cambiar
• No hay validación de producción a gran escala documentada
• Los datos de rendimiento del README son mediciones propias, no una prueba independiente

2. Arquitectura: cuatro crates en Rust

Mnemo está escrito en Rust y dividido en cuatro crates con responsabilidades claras:

mnemo-core: lógica central

• Extracción de entidades, construcción del grafo y lógica de recuperación
• No depende de un backend LLM concreto; define interfaces

mnemo-api: servidor

• Ofrece la API HTTP, por defecto en el puerto 8080
• Recibe conversaciones, llama a core y devuelve resultados
• Health check: curl http://localhost:8080/health

mnemo-cli: herramienta de línea de comandos

• Depuración, gestión y consultas
• Llama a la API de Mnemo por HTTP para ingesta, recuperación, inspección de entidades y vaciado completo

mnemo-bench: pruebas de rendimiento

• Los 122 Rust tests, 21 Python tests y 12 benchmarks mencionados en el README están asociados a esta parte
• Fuente de las mediciones declaradas

Ventajas de separar en cuatro crates:

• core se puede probar de forma aislada, sin depender de la API
• cli facilita la depuración local sin arrancar el servicio
• bench queda separado y no afecta al código de producción

Inconvenientes:

• Necesitas la toolchain completa de Rust para compilar, salvo que uses Docker
• Cuando cambian las APIs entre crates, puede tocar sincronizar varios puntos

3. Instalación y despliegue: tres rutas

Mnemo ofrece tres rutas de despliegue, ordenadas por complejidad:

3.1 Docker + Ollama: la forma más rápida de probar

Requisitos: Docker y Ollama instalados.

# 1. clonar el proyecto
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. arrancar Docker
docker compose up -d

# 3. descargar el modelo dentro de Docker
docker exec mnemo-ollama ollama pull llama3

# 4. health check
curl http://localhost:8080/health

Nota: los comandos pueden cambiar. Usa el README de GitHub como fuente de verdad.

Explicación: Docker compose arranca dos contenedores: mnemo-api, el servidor, y mnemo-ollama, el servicio Ollama. Este último es opcional. Si ya tienes Ollama corriendo localmente, puedes usar solo el contenedor mnemo-api y conectarlo con MNEMO_LLM_BASE_URL=http://host.docker.internal:11434/v1.

Verificar la conexión LLM: cuando el health check devuelve {"status":"ok"}, la API está arrancada, pero la conexión al LLM aún no está probada. Envía una petición de prueba con curl:

curl -X POST http://localhost:8080/ingest \
  -H "Content-Type: application/json" \
  -d '{"content":"El proyecto Atlas usa https://api.example.test como URL base","source":"chat","session_id":"mnemo-trial"}'

Tras escribir, llama a /retrieve para comprobar la recuperación:

curl -X POST http://localhost:8080/retrieve \
  -H "Content-Type: application/json" \
  -d '{"text":"¿Cuál es la URL base de la API de Atlas?","session_id":"mnemo-trial"}'

Si la respuesta contiene entidades, fragmentos de memoria o context_prompt, funcionan extracción y recuperación.

Alibaba Cloud - Opción preferida para desarrolladores, 15 % de descuento exclusivo en Lighthouse

Obtener 15% dto. →Anuncio

Ventajas:

• No necesitas toolchain de Rust
• Docker gestiona dependencias automáticamente
• Ollama y Mnemo quedan en la misma red compose, así que la red es sencilla

Desventajas:

• Docker consume recursos
• Depurar es más incómodo, porque debes entrar al contenedor para inspeccionar SQLite
• Los logs quedan repartidos en dos contenedores

3.2 Binary: compilación local

Requisitos: toolchain de Rust instalada, incluidos cargo y rustc, y Ollama instalado.

# 1. clonar el proyecto
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. compilar la crate de API
cargo install --path crates/mnemo-api

# 3. configurar la dirección de Ollama
export MNEMO_LLM_BASE_URL=http://localhost:11434/v1

# 4. arrancar el servicio
mnemo-api

Nota: los comandos pueden cambiar. Usa el README de GitHub como fuente de verdad; esta ruta requiere toolchain de Rust.

Explicación: el tiempo de compilación depende del hardware y de la caché de Cargo. Después, mnemo-api usa mnemo.db en el directorio actual por defecto. Puedes cambiar la ruta con MNEMO_DB_PATH o la configuración TOML.

Verificar la conexión con Ollama: antes de arrancar, confirma que Ollama corre en localhost:11434 y que el modelo se descargó con ollama pull llama3. Luego prueba con curl:

curl -X POST http://localhost:8080/ingest \
  -H "Content-Type: application/json" \
  -d '{"content":"Probar extracción de entidades en Mnemo","source":"cli-check"}'

Ventajas:

• No depende de Docker
• Depuración más sencilla, porque es un proceso local y los logs quedan en la misma terminal
• Puedes usar mnemo-cli directamente contra SQLite local
• Puerto y ruta de la base se pueden personalizar con variables de entorno

Desventajas:

• Requiere toolchain completa de Rust
• Primera compilación lenta
• La gestión de dependencias puede fallar, por ejemplo si cargo.lock está obsoleto

3.3 OpenAI-compatible: LLM en la nube

Requisitos: tienes una API key de OpenAI, Anthropic u otro backend compatible con OpenAI.

Lista de variables de entorno, verificada con el README de GitHub de 2026-06:

export MNEMO_LLM_BASE_URL=https://api.openai.com/v1
export MNEMO_LLM_API_KEY=sk-...
export MNEMO_LLM_MODEL=gpt-4o-mini
export MNEMO_LLM_PROVIDER=openai

Luego arranca:

mnemo-api

Nota: los nombres de variables pueden cambiar. Usa el README de GitHub como fuente de verdad.

Casos adecuados:

• Tu equipo local no tiene suficiente cómputo y usas un LLM en la nube
• Ya tienes cuota de OpenAI API
• Aceptas que el contenido de conversación se suba a la API cloud. Con un LLM cloud, la ventaja local-first solo cubre el almacenamiento local, no el tráfico de inferencia

Elige una de las tres rutas según tu situación. Luego toca mirar el rendimiento.

4. Rendimiento: mediciones declaradas en el README

El README de Mnemo lista mediciones propias, revisadas de nuevo el 17 de julio de 2026:

Condiciones de prueba:

KiloClaw - OpenClaw gestionado para empresas: orquestación de agentes IA y enrutamiento inteligente

Empezar →Anuncio

• Apple M2, debug build
• SQLite en modo WAL
• petgraph en memoria

Datos de rendimiento:

• Pipeline completo de recuperación: unos 4,2 ms
• Release build declara ser 3 a 5 veces más rápido, aproximadamente 0,8 a 1,4 ms

Nota: es una medición del README, no una prueba independiente. El rendimiento cambia con hardware, volumen de datos y backend LLM.

Cómo leer estos números:

• 4,2 ms es tiempo de recuperación, no tiempo de inferencia LLM. La inferencia LLM es el cuello de botella
• SQLite WAL más un grafo en memoria puede hacer que la recuperación sea rápida
• Esto mide solo recuperación, no velocidad de conversación

La experiencia real depende de:

• tiempo de inferencia LLM, mucho más lento que recuperar contexto
• longitud de la conversación, porque extraer entidades también usa inferencia LLM
• volumen de datos, porque un grafo más grande puede ralentizar la búsqueda

Sugerencia: ejecuta mnemo-bench en el hardware objetivo. Los números del README son referencia, no promesa.

5. Rasgos local-first y límites

5.1 Ventajas de local-first

La idea central de local-first es sencilla: los datos están en tu máquina.

Ventajas concretas:

1. Privacidad

   • Conversaciones, entidades y relaciones se guardan en SQLite local
   • No se suben a un SaaS de terceros, siempre que uses un LLM local

2. Control de datos

   • El archivo SQLite se puede exportar, respaldar y migrar
   • No dependes de la vida de un SaaS; tus datos siguen contigo

3. Portabilidad

   • Al cambiar de máquina, copias el archivo SQLite
   • No necesitas volver a “entrenar” la memoria

4. Depuración

   • SQLite es un formato estándar y se puede revisar con cualquier herramienta SQLite
   • La estructura del grafo es visible, no una caja negra vectorial

5.2 Riesgos y límites

Local-first tiene ventajas, pero también riesgos:

1. Acumulación de ruido

   • La extracción de entidades no es perfecta y puede equivocarse
   • Las entidades mal reconocidas afectan recuperaciones futuras
   • Hace falta limpieza periódica, pero Mnemo no ofrece limpieza automática
   • La acumulación de ruido no es exclusiva de Mnemo; afecta a todos los sistemas de memoria automática. La diferencia es que el grafo de Mnemo se ve. Puedes ver entidades ruidosas y relaciones incorrectas. En sistemas vectoriales, el ruido queda escondido dentro de los vectores. Es una ventaja del grafo y también una carga de mantenimiento

2. Límites de borrado y recuperación

   • La API actual borra una entidad, un fragmento de memoria o todo el contenido con un encabezado de confirmación
   • No ofrece una transacción de alto nivel para deshacer la última escritura o una decisión completa
   • Si un error se extendió a varias entidades y relaciones, usa datos de source o session para delimitar qué borrar antes de restaurar una copia
   • Añade source, session_id y un identificador de auditoría a decisiones importantes, y valida la extracción antes de guardar hechos reales

3. Estado oculto

   • El grafo puede contener relaciones que no ves de inmediato
   • La recuperación puede devolver resultados sin que quede claro por qué salieron

4. Límites de uso

   • Con grandes volúmenes, SQLite + grafo en memoria puede sufrir presión
   • El uso compartido entre agentes necesita autorización, aislamiento y operación que Mnemo no aporta por sí solo

5.3 Tabla de decisión: cuándo usarlo y cuándo no

Juicio: si tu caso es “proyecto personal, alta privacidad, Ollama existente y volumen moderado”, Mnemo merece una prueba. Si es “gran volumen, colaboración de equipo y memoria global compartida”, conviene esperar a que madure o evaluar otra solución.

Recomendaciones concretas:

• Ejecuta primero la ruta Docker en un entorno de prueba y observa estructura del grafo, calidad de extracción de entidades y resultados de recuperación
• Usa conversaciones de prueba para medir riesgo de ruido. Di cosas irrelevantes a propósito y mira si Mnemo las identifica mal
• Prepara un plan de limpieza. Aprende pronto la estructura SQLite para saber borrar entidades incorrectas manualmente
• Sigue las actualizaciones del README. Es un proyecto temprano: APIs, arquitectura y comandos de despliegue pueden cambiar

6. Siguiente paso: navegación de la serie

Si todavía no leíste los artículos anteriores de la serie de LLM locales con Ollama, conviene seguir este orden:

1. Guía inicial de Ollama: el primer paso para ejecutar un gran modelo de lenguaje localmente

   • Empieza aquí si aún no instalaste Ollama

2. Llamadas a la API de Ollama: de curl a la interfaz compatible con OpenAI SDK

   • Mnemo usa una API compatible con OpenAI, así que conviene entender la API de Ollama

3. Ollama Embedding en la práctica: búsqueda vectorial local y RAG

   • Sirve para comparar la búsqueda vectorial pura con la cadena de texto completo, entidades y grafo de Mnemo

4. Gestión de memoria para AI Agent: memoria a largo plazo y gobernanza del conocimiento

   • Mnemo es una herramienta de capa de memoria; este artículo aborda la gobernanza de memoria de agentes

Después de estos cuatro artículos, instala Mnemo y ejecuta la ruta Docker localmente. El primer resultado útil es ver cómo luce realmente el grafo de conocimiento.