---
title: "MentisDB: memoria persistente y self-hosted para tus agentes de IA"
excerpt: "MentisDB es un motor de memoria en Rust, self-hosted y open source, que le da a Claude Code, Cursor o Codex un cerebro persistente vía MCP: sobrevive a los reinicios de contexto y lo controlas tú, no tu proveedor."
date: "2026-07-15T11:00:00.000Z"
category: "Inteligencia Artificial"
tech_article: true
seo_title: "MentisDB: memoria persistente y self-hosted para agentes de IA"
seo_description: "Qué es MentisDB, el motor de memoria en Rust para agentes de IA: ledger hash-chained, self-hosted, open source y conectable a Claude Code, Cursor y Codex vía MCP."
author:
  name: "angel cruz"
  picture: "https://angelcruzdevcdn.nyc3.cdn.digitaloceanspaces.com/images/me/angel-cruz.png"
ogImage:
  url: "/images/open-graph/og-image.png"
---

Tu agente de IA es brillante durante una sesión y amnésico entre sesiones. Cierras la terminal, se llena la ventana de contexto, cambias de modelo, y todo lo que "aprendió" (la decisión de arquitectura que tomaste juntos, la convención rara del proyecto, el error que ya cometió una vez) se evapora. Al día siguiente vuelves a explicarle lo mismo.

[MentisDB](https://mentisdb.com/) ataca justo ese problema. Es un motor de memoria duradero, self-hosted y open source (MIT) escrito en Rust, que se conecta a tus agentes vía [MCP](/post/introduccion-a-mcp-model-context-protocol) y les da un cerebro persistente que sobrevive a reinicios, cambios de modelo y rotación de equipo. Lo desarrolla Angel Leon bajo el paraguas de CloudLLM-ai.

## El problema: agentes con amnesia

El [whitepaper de MentisDB](https://github.com/cloudllm-ai/mentisdb/blob/master/WHITEPAPER.md) resume bien la situación: la mayoría de los frameworks de agentes tratan la memoria a largo plazo como algo secundario. En la práctica se reduce a tres patrones, y los tres fallan:

- **Rellenar el prompt** con contexto en cada arranque. No escala y se pierde en cuanto se llena la ventana. Sobre esto ya escribí en [cómo reducir el consumo de tokens en Claude Code](/post/optimizar-claude-code-reducir-tokens).
- **Archivos Markdown sueltos** tipo notas. Sirven como ancla, pero no son consultables por semántica ni por relaciones.
- **El estado de sesión del proveedor.** Cómodo, hasta que cambias de proveedor o pierdes acceso a la cuenta y tu memoria desaparece con él.

MentisDB lo plantea como tres carencias concretas: **amnesia** (el agente olvida al reiniciarse el contexto), **lock-in** (la memoria vive en la API de un tercero) y **aprendizaje aislado** (cada sesión aprende sola, sin que el conocimiento se acumule para toda tu flota de agentes).

## Qué es MentisDB, en concreto

MentisDB modela la memoria del agente como un **ledger append-only encadenado por hash**. Piensa en un historial tipo Git, pero para recuerdos en vez de código: cada entrada se llama *thought* (pensamiento) y va enlazada a la anterior con un hash SHA-256. Si alguien modifica un registro, el hash deja de cuadrar y la manipulación se propaga hacia adelante por toda la cadena, así que detectarla es trivial.

Un *thought* no es texto plano: es un registro tipado con metadatos semánticos. El modelo de datos incluye 31 tipos semánticos (`Decision`, `Insight`, `Mistake`, `LessonLearned`...), 8 roles operativos (`Memory`, `Checkpoint`, `Handoff`...), tags, conceptos, puntuaciones opcionales de confianza e importancia, y relaciones tipadas con otros pensamientos (12 clases de arista: `Corrects`, `Invalidates`, `CausedBy`, `Supports`, `Contradicts`...).

El detalle de diseño clave: el agente escribe el **contenido** (tipo, rol, texto, tags, relaciones), pero **no puede falsificar los campos de integridad** (id, índice, timestamp, hashes). Esos los asigna la cadena al confirmar. Para provenance más fuerte, cada pensamiento puede firmarse con una clave Ed25519 del agente que lo produjo.

Todo esto vive en **chains** (cadenas), identificadas por un `chain_key`. Puedes tener una cadena compartida para toda la flota, o cadenas aisladas por agente, proyecto o equipo, dentro de un mismo daemon.

## Cómo se instala

MentisDB es un único binario en Rust, sin servidor de base de datos detrás (nada de Redis, Postgres ni Neo4j: el almacenamiento son archivos embebidos en disco). Necesitas Rust:

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
cargo install mentisdb
```

Si quieres búsqueda semántica local (embeddings vectoriales que corren en tu máquina, sin llamadas de red), compílalo con la feature correspondiente:

```bash
cargo install mentisdb --features local-embeddings
```

Y lo arrancas:

```bash
mentisdb            # daemon con dashboard TUI
mentisdb --headless # solo HTTP/MCP, sin interfaz
```

Por defecto expone el MCP en el puerto `9471`, la API REST en `9472` y el dashboard web en `9475`.

## Conectarlo a Claude Code, Cursor y Codex

Aquí es donde se vuelve útil a diario. MentisDB es un servidor MCP más (si nunca configuraste uno, revisa la [guía para crear un servidor MCP](/post/como-crear-un-servidor-mcp) o la lista de [mejores servidores MCP](/post/mejores-servidores-mcp)). La forma más rápida es dejar que el propio binario escriba la config:

```bash
mentisdb setup claude-code
```

Eso escribe la entrada en tu `~/.claude.json`. Si prefieres hacerlo a mano:

```bash
# Claude Code
claude mcp add --transport http mentisdb http://127.0.0.1:9471

# Codex
codex mcp add mentisdb --url http://127.0.0.1:9471
```

También trae asistente para Cursor, VS Code, GitHub Copilot CLI, Claude Desktop, Qwen Code y Gemini. Una vez conectado, el daemon expone **42 herramientas MCP**: las básicas son `mentisdb_append` (guardar un pensamiento) y `mentisdb_search` (buscarlo), más otras avanzadas como `mentisdb_ranked_search`, `mentisdb_recent_context` para retomar una sesión, o `mentisdb_merge_chains` para operar sobre cadenas.

## La búsqueda: local y multi-señal

Lo interesante del recuperador es que no depende de una API externa ni de un LLM en el camino crítico. Combina cuatro señales, todas locales: **BM25** (léxico), **similitud vectorial** (embeddings ONNX; el modelo por defecto `fastembed-minilm` pesa unos 28 MB), **expansión por grafo** (las relaciones tipadas entre pensamientos) y **Reciprocal Rank Fusion** para combinar los rankings.

Sobre los números que publica el proyecto, medidos en benchmarks estándar de memoria a largo plazo: **72.6% de Recall@10 en LoCoMo-10P** y **66.8% de Recall@5 en LongMemEval**. Como referencia de rendimiento, reporta entre 750 y 930 lecturas por segundo con 10.000 tareas concurrentes. Son cifras del propio repositorio, así que tómalas como lo que son (autorreportadas), pero el hecho de que el core corra sin llamadas de red ni facturas de API por cada escritura es el punto que de verdad importa.

## Skills versionadas y dashboard

Además de la memoria, MentisDB incluye un **registro de skills** tipo Git: instrucciones operativas para el agente, versionadas de forma inmutable. Cada subida a un `skill_id` existente crea una versión nueva en lugar de sobrescribir, con historial de auditoría, firma Ed25519 y diffs unificados. Es el mismo espíritu de las [buenas prácticas con `CLAUDE.md`](/post/claude-md-buenas-practicas), pero con versionado y distribución para toda la flota.

El dashboard web (en `https://127.0.0.1:9475/dashboard`, con TLS autofirmado) te deja navegar cadenas, inspeccionar pensamientos, gestionar el registro de agentes, comparar versiones de skills y exportar una cadena como `MEMORY.md`. Lo proteges con un PIN vía `MENTISDB_DASHBOARD_PIN`.

## Lo que de verdad lo diferencia: es tuyo

El argumento de fondo no es técnico, es de propiedad. La memoria de tu agente no vive en la infraestructura de un proveedor de IA: vive en tu disco (`~/.cloudllm/mentisdb/`) o en tu servidor, en archivos que puedes respaldar, versionar y mover. Para acceso remoto añades autenticación con bearer tokens:

```bash
mentisdb bearertoken create --global admin-laptop
```

Es la misma filosofía self-hosted de herramientas como [OpenClaw](/post/como-instalar-openclaw-guia-completa): control total a cambio de que el mantenimiento corre por tu cuenta. Si tu equipo levanta varios agentes en paralelo (algo cada vez más común cuando usas [subagentes en Claude Code](/post/subagentes-claude-code)), una cadena compartida convierte el aprendizaje de uno en el punto de partida de todos.

## ¿Para quién es?

MentisDB tiene sentido si te reconoces en alguno de estos casos:

- Trabajas a diario con agentes de IA para programar y te cansa repetir el mismo contexto cada sesión.
- Te importa **no** atarte a un proveedor: quieres que la memoria sea portable entre Claude Code, Cursor, Codex y lo que venga.
- Corres varios agentes y quieres que compartan lo aprendido.
- Te gusta la idea de una memoria auditable y a prueba de manipulaciones, no un blob opaco.

Si solo usas un asistente de forma casual, es probable que un buen `CLAUDE.md` te alcance. MentisDB brilla cuando la memoria del agente pasa de ser una comodidad a ser infraestructura.

## Preguntas frecuentes

### ¿MentisDB es gratis y open source?

Sí. Es open source con licencia MIT y self-hosted: lo instalas y corres tú, sin costo de licencia. El código está en [GitHub](https://github.com/cloudllm-ai/mentisdb).

### ¿Necesito una base de datos aparte?

No. Es un único binario en Rust y el almacenamiento son archivos embebidos en disco. No requiere Redis, Postgres ni ningún servidor externo.

### ¿Con qué agentes funciona?

Con cualquier cliente MCP. El asistente de configuración cubre Claude Code, Cursor, VS Code, Codex, GitHub Copilot CLI, Claude Desktop, Qwen Code y Gemini.

### ¿Qué lo diferencia de un vector database o de RAG?

Un vector database te da similitud semántica, pero no integridad ni atribución. MentisDB añade un ledger encadenado por hash (memoria a prueba de manipulaciones), pensamientos tipados con relaciones, y firma por agente, combinando búsqueda léxica, vectorial y por grafo sin depender de un LLM en el camino crítico.

### ¿La memoria es privada?

Sí, ese es el punto. Vive en tu máquina o tu servidor, no en la API de un proveedor de IA. Para exponerlo en red se protege con bearer tokens y el dashboard con un PIN.

## Cierre

MentisDB no es magia: es una pieza de infraestructura que le pone al problema de la memoria de agentes una solución sobria, auditable y bajo tu control. Si ya vives dentro del ecosistema MCP, conectarlo cuesta un par de comandos, y a cambio tus agentes dejan de empezar de cero cada mañana. Para entender el protocolo que lo hace posible, empieza por la [introducción a MCP](/post/introduccion-a-mcp-model-context-protocol).

---

## Sitemap

Índice completo del sitio: [/sitemap.md](https://www.angelcruz.dev/sitemap.md)

Canónico HTML: [https://www.angelcruz.dev/post/mentisdb-memoria-persistente-agentes](https://www.angelcruz.dev/post/mentisdb-memoria-persistente-agentes)