deepmem

Migra desde Mem0 con una sola línea - mismo MemoryClient, mismas firmas de método:

# Before - Mem0
from mem0 import MemoryClient
client = MemoryClient(api_key="m0-...")

# After - DeepMem (only the import changes)
from deepmem import MemoryClient
client = MemoryClient(api_key="dm_live-...")   # get a key at deepmem.dev

pip install deepmem-client

Convierte conversaciones en memoria a largo plazo buscable: una API FastAPI delante de un almacén vectorial Qdrant, con extracción de hechos mediante LLM, recuperación híbrida (vector + BM25 + refuerzo de entidades + decaimiento temporal), caché semántica, destilación por lotes asíncrona, controles GDPR y un servidor MCP integrado. Funciona en modo abierto: sin clave de API, sin registro de usuario, por lo que puedes desplegarlo para tus propios agentes en minutos.

¿Prefieres no autoalojarlo? DeepMem Cloud es la versión gestionada de este mismo motor en deepmem.dev: la misma API, sin infraestructura. Regístrate, obtén una clave (dm_...), apunta tu base URL a https://deepmem.dev, y listo. Tanto la nube como el servidor de código abierto hablan la misma API compatible con Mem0, así que el código del cliente es idéntico.

Migra desde Mem0

¿Ya usas Mem0? Cambia a DeepMem cloud en una línea. El paquete deepmem-client expone la misma clase MemoryClient - mismo nombre de clase, mismos parámetros de método, mismo estilo filters={"user_id": ...} - de modo que todo lo que va después del import queda intacto.

pip install deepmem-client

# before (Mem0)
from mem0 import MemoryClient
client = MemoryClient(api_key="m0-...")
client.add(messages, user_id="alex")
client.search("What can Alex cook?", filters={"user_id": "alex"})

# after (DeepMem cloud) - change one import line
from deepmem import MemoryClient
client = MemoryClient(api_key="dm_live_...")        # key at https://deepmem.dev
client.add(messages, user_id="alex")                # identical calls
client.search("What can Alex cook?", filters={"user_id": "alex"})

• add(infer=True) es asíncrono en DeepMem cloud - devuelve PENDING y los hechos aparecen unos segundos después. (El add de Mem0 también es asíncrono - devuelve PENDING.) Pasa infer=False para almacenamiento sincrónico de texto sin procesar que es inmediatamente buscable.

• Sin relaciones de grafo - DeepMem utiliza recuperación híbrida por vectores (vector + BM25 + decaimiento temporal), por lo que relations siempre es []. Las funciones de grafo de Mem0 no están replicadas.

• reset es diferente - El de Mem0 afecta a toda la cuenta; el de DeepMem es por user_id con guarda de confirmación.

Related MCP server: Structured-sh

Precios

DeepMem Cloud es 10 veces más barato que Mem0 en todos los planes de pago: la misma forma de planes, una décima parte del precio.

Autohospedado en su lugar: a 0 $ , pagando solo tu propia LLM, tu propio embedding y tu propio Qdrant. (Mem0 no ofrece autohospedaje; los precios de la nube provienen de su sitio.)

Planes y límites: deepmem.dev · mem0.ai

Comparación

No hay titulares elegidos a dedo. Aquí está la comparación.

¹ Estimado: prompt de sistema de ~4k tokens + 1k de respuesta en GPT-4o-mini por recuerdo en DeepMem Cloud, frente a >100k tokens por conversación en Mem0 (que reprocesa todas las preguntas/respuestas con GPT-4o class). Si se activa la deduplicación en DeepMem, los costes reales bajan aún más.

Por qué DeepMem

Las conversaciones y los hallazgos se pierden cuando termina una sesión. DeepMem es memoria persistente y buscable para agentes de IA, autohospedable y compatible con MCP. En lugar de recordatorios estilo "saber que ya hemos hablado de esto" (que se desvanecen), DeepMem almacena hechos reales en una base vectorial, con recuperación híbrida y caché semántica, para que los agentes recuerden lo que importa entre sesiones.

Mem0 es el pionero que hizo famoso el patrón de memoria para agentes de IA. Pero comparado con DeepMem:

Qué es (honestamente)

• Recuperación híbrida, no un grafo de conocimiento. La búsqueda combina similitud vectorial, coincidencia de palabras clave BM25, refuerzo de entidades y decaimiento temporal. No hay capa de grafo; si eso es lo que necesitas, mira Zep.

• Almacena preferencias, no volcados de código. Los grandes bloques de código delimitados se eliminan antes de la extracción por LLM, de modo que el almacén se llena de hechos duraderos sobre el usuario o el proyecto, no de implementaciones pegadas.

• BYOK, multi-proveedor. Trae tu propia clave de OpenAI, Anthropic o cualquier proveedor compatible con OpenAI, y tu propio proveedor de embeddings.

Inicio rápido

Tres formas de ejecutarlo.

1. Nube (cero configuración)

# Before - Mem0
from mem0 import MemoryClient
client = MemoryClient(api_key="m0-...")

# After - DeepMem (only the import changes)
from deepmem import MemoryClient
client = MemoryClient(api_key="dm_live-...")   # get a key at deepmem.dev

2. Docker (un comando)

pip install deepmem-client

3. Desde el código fuente

pip install deepmem-client

¿Prefieres no autohospedar? DeepMem Cloud es la versión gestionada de este mismo motor en deepmem.dev - misma API, sin infraestructura. Regístrate, obtén una clave (dm_live_...), apunta tu URL base a https://deepmem.dev, listo. La nube y el servidor de código abierto hablan la misma API compatible con Mem0, por lo que el código del cliente es idéntico.

Funciones destacadas

API compatible con Mem0. El cliente deepmem es un reemplazo directo de mem0.MemoryClient - mismos nombres de métodos, mismos parámetros, mismas respuestas. Mueve tu integración cambiando una sola línea.

Sin registros de tu parte. Deja api_key vacío para desarrollo local sin fricción; añade una clave para desbloquear rate limits más altos y telemetría de errores.

Almacena preferencias, no volcados de código. add() con infer=True extrae solo hechos compactos. Los grandes bloques de código delimitados se eliminan antes de la extracción por LLM, de modo que el almacén se llena de hechos duraderos sobre el usuario o el proyecto, no de implementaciones pegadas.

Recuperación híbrida, no un grafo de conocimiento. La búsqueda combina similitud vectorial, coincidencia de palabras clave BM25, refuerzo de entidades y decaimiento temporal. No hay capa de grafo; si eso es lo que necesitas, mira Zep.

BYOK, multi-proveedor. Trae tu propia clave de LLM (OpenAI, Anthropic, o cualquier proveedor compatible con OpenAI) y tus propios embeddings.

Autohospedaje amigable. Un solo binario, SQLite para metadatos, Qdrant para vectores, y una imagen Docker publicada en GitHub Container Registry. Sin dependencias externas más allá de una clave de LLM.

MCP listo. deepmem-mcp expone deepmem_add / deepmem_search / deepmem_reset para Claude Desktop y otros clientes MCP. 30 segundos de configuración.

Privacidad y RGPD. Sin terceros en la ruta de datos: la telemetría es opt-in y anónima (un simple contador de eventos, sin IPs). Autohospeda para un aislamiento total.

API compatible con Mem0

La API sigue el modelo de Mem0: POST /v1/memories/ para añadir, GET /v1/memories/ para listar, DELETE /v1/memories/ para eliminar, POST /v1/search/ para buscar. (Los enrutados con barra invertida también están disponibles, por compatibilidad con los SDKs de Mem0.)

Uso básico (SDK de Python de DeepMem)

# before (Mem0)
from mem0 import MemoryClient
client = MemoryClient(api_key="m0-...")
client.add(messages, user_id="alex")
client.search("What can Alex cook?", filters={"user_id": "alex"})

# after (DeepMem cloud) - change one import line
from deepmem import MemoryClient
client = MemoryClient(api_key="dm_live_...")        # key at https://deepmem.dev
client.add(messages, user_id="alex")                # identical calls
client.search("What can Alex cook?", filters={"user_id": "alex"})

Uso con el SDK de Mem0

export DEEPMEM_API_KEY=dm_live_...      # from https://deepmem.dev
curl https://deepmem.dev/v1/memories \
  -H "Authorization: Bearer $DEEPMEM_API_KEY" -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"I am Pat, I live in Lisbon."}],"user_id":"pat","infer":false}'
curl https://deepmem.dev/v1/memories/search \
  -H "Authorization: Bearer $DEEPMEM_API_KEY" -H "Content-Type: application/json" \
  -d '{"query":"Where does Pat live?","user_id":"pat"}'

MCP

cp .env.example .env          # add an LLM key
docker compose up --build     # DeepMem (HTTP :8000 + MCP :8001) + Qdrant sidecar
curl http://localhost:8000/health

Búsqueda

docker pull langdeepmem/deepmem:latest
docker run -p 8000:8000 -p 8001:8001 -e DEEPSEEK_API_KEY=sk-... langdeepmem/deepmem:latest

API

POST /v1/memories/ - Crear memoria

Extrae y almacena hechos de un mensaje. La extracción es asíncrona por defecto; pasa infer=false para almacenar el texto sin procesar sincrónicamente.

git clone https://github.com/deepmemteam/deepmem.git && cd deepmem
pip install -r requirements.txt
cp .env.example .env          # add an LLM key + embedder config
python server/start.py        # HTTP :8000 + MCP :8001

GET /v1/memories/ - Listar memorias

import httpx
httpx.post("http://localhost:8000/v1/memories",
    json={"messages":[{"role":"user","content":"I'm Pat, I live in Lisbon."}],
          "user_id":"pat"})
print(httpx.post("http://localhost:8000/v1/memories/search",
    json={"query":"Where does Pat live?","user_id":"pat"}).json()["results"])

DELETE /v1/memories/ - Eliminar memoria(s)

URL:    https://deepmem.dev/mcp
Auth:   Authorization: Bearer dm_live_...   (your deepmem.dev API key)
Tools:  deepmem_write / deepmem_search

POST /v1/memories/search - Búsqueda semántica

claude mcp add --transport http deepmem https://deepmem.dev/mcp \
  --header "Authorization: Bearer dm_live_..."

DELETE /v1/memories/all - Borrar todas las memorias (con guarda)

/plugin marketplace add deepmemteam/deepmem-claude-plugin
/plugin install deepmem@deepmem

GET /health - Healthcheck

{
  "mcpServers": {
    "deepmem": {
      "url": "https://deepmem.dev/mcp",
      "headers": { "Authorization": "Bearer ${env:DEEPMEM_API_KEY}" }
    }
  }
}

Autenticación

export DEEPMEM_API_KEY=dm_live_...
dsh web --patch "$PWD/examples/dsh/deepmem.cordis.yml"

Desarrollo

Construcción

{
  "mcpServers": {
    "deepmem": {
      "command": "python",
      "args": ["server/mcp_server.py"],
      "env": { "DEEPMEMORY_BASE_URL": "http://localhost:8000" }
    }
  }
}

Pruebas

client (HTTP / MCP)
  -> FastAPI (:8000)
       -> rate-limit middleware (per-IP token bucket on add/search)
       -> SemanticCache.check            (return cached facts on similarity hit)
       -> AsyncBatchDistiller.enqueue    (POST /v1/memories, infer=true)
            ↳ silence-window or max_batch triggers on_batch_ready
                ↳ VectorStore.process_batch  (LLM extraction -> Qdrant upsert)
       -> VectorStore.search             (vector + BM25 + entity + time-decay)
  -> LLM: OpenAI / Anthropic / OpenAI-compatible (fact extraction)
  -> BGE-M3 / Gemini / OpenAI-compatible (embeddings)
  -> Qdrant (vectors)  +  SQLite (audit history)
  -> MCP server (:8001)  deepmem_write / deepmem_search / deepmem_delete

Roadmap

• Historial / checkpoints de memoria

• Almacenamiento de archivos (Guardar, Leer, Listar)

• Adición de herramientas MCP más ricas

• Página de estado del servidor

• Soporte de usuarios múltiples con aislamiento

• Persistencia de memoria y recuerdo entre sesiones con la API de Mem0 (FTS + vectorial)

• Recuperación híbrida

• Modo demonio / Colas de trabajo

• Integración con GitHub para claves

• Servidor MCP con stdio y streamable-http

• Compatibilidad con cualquier LLM (OpenAI, Anthropic, etc.)

• Búsqueda semántica con filtros

• Compatibilidad con los parámetros filters y agent_id

• Parámetro infer en /v1/memories/

• Vectores, mensajes, metadatos y puntuaciones en las respuestas

• Voice Mode / integración con ChatGPT

• Interfaz de gestión de memoria

• Historial de conversaciones

Seguridad

• Privacidad: sin terceros en la ruta de datos - solo tu servidor, tu proveedor de LLM, tu proveedor de embeddings.

• Sin registro de datos: no registramos tus conversaciones, recuerdos ni metadatos. Evitamos por diseño los registros de contexto largo.

• Autenticación: servidor local por defecto; añade autenticación por token para proteger los endpoints.

Licencia

MIT © 2025 DeepMem

Guía de inicio rápido

systemctl restart deepmem.service     # scripts/start.sh -> uvicorn :8000
journalctl -u deepmem -f

pip install -r requirements.txt
DEEPMEMORY_DEBUG=1 python -m uvicorn server.main:app --reload --host 0.0.0.0 --port 8000
pytest tests/ -x -v

GXP19

MCP

Este repositorio incluye un servidor MCP de referencia en mcp/, escrito en TypeScript con @modelcontextprotocol/sdk. Expone herramientas para que los asistentes de IA lean y escriban recuerdos:

Un único servidor MCP puede atender a varios agentes (Claude Desktop, Cursor, etc.) y a varios usuarios, con almacenes de memoria con permiso de lectura.

Ejemplo de configuración de Claude Desktop

GXP

En este ejemplo, desktop es el perfil de Claude Desktop, y deployment es el perfil del servidor de aplicaciones de producción de tu agente. El MCP se resolvió en dist/mcp.js: un binario de Node.js que implementa el protocolo MCP sin servidor HTTP.

Sobre la autenticación: el MCP se adhiere estrictamente a la lista de perfiles (no a ALLOWED_ORIGINS), por lo que las aplicaciones cliente no pueden especificar un perfil que no hayas aprobado explícitamente. Si tu despliegue requiere más flexibilidad, define ALLOWED_ORIGINS para permitir coincidencias de subcadenas (por ejemplo, "https://claude.ai" para cualquier proyecto de Claude.ai), o MEDIATOR_CP_URL para activar el procesamiento automático de URLs.

Despliegue del servidor: Docker

GXP

GXP

Uso

API REST

GXP

API de Python

GXP

React

GXP

Licencia

MIT

¿Preguntas? Abre un issue en GitHub o únete a nuestro Discord.

Navegación rápida

• Inicio rápido → docs/quickstart.md

• Guía de la API → docs/api.md

• Despliegue en producción → docs/deployment.md

• Referencia de MCP → docs/mcp.md

• Guía de contribución → CONTRIBUTING.md

La nube expone un endpoint MCP remoto (HTTP transmisible):

URL:    https://deepmem.dev/mcp
Auth:   Authorization: Bearer dm_live_...   (your deepmem.dev API key)
Tools:  deepmem_write / deepmem_search

Funciona con Claude Code, Claude Desktop, Cursor y cualquier cliente compatible con MCP.

Claude Code - un comando:

claude mcp add --transport http deepmem https://deepmem.dev/mcp \
  --header "Authorization: Bearer dm_live_..."

O instala el plugin (incluye un comando /deepmem:setup que guía la configuración de la clave API):

/plugin marketplace add deepmemteam/deepmem-claude-plugin
/plugin install deepmem@deepmem

Cursor → Configuración → MCP → Añadir nuevo servidor MCP, o edita ~/.cursor/mcp.json (global) / .cursor/mcp.json (por proyecto). Cursor resuelve las variables ${env:NAME} en url y headers, por lo que la clave puede estar en una variable de entorno en lugar del archivo de configuración:

{
  "mcpServers": {
    "deepmem": {
      "url": "https://deepmem.dev/mcp",
      "headers": { "Authorization": "Bearer ${env:DEEPMEM_API_KEY}" }
    }
  }
}

(con DEEPMEM_API_KEY=dm_live_... exportada en tu shell, o pega la clave literal si lo prefieres). Los listados de MCP comunitarios con un clic "Añadir a Cursor" están en cursor.directory; los plugins oficiales se incluyen en el Cursor Marketplace.

DeepSeek Harness (dsh) - un archivo overlay, sin necesidad de plugin dsh (dsh conecta cualquier servidor MCP a través de su puente genérico dsh-mcp-client):

export DEEPMEM_API_KEY=dm_live_...
dsh web --patch "$PWD/examples/dsh/deepmem.cordis.yml"

Consulta examples/dsh para más detalles y variantes self-hosted.

Self-hosted (stdio, servidor incluido, sin clave necesaria en modo abierto):

{
  "mcpServers": {
    "deepmem": {
      "command": "python",
      "args": ["server/mcp_server.py"],
      "env": { "DEEPMEMORY_BASE_URL": "http://localhost:8000" }
    }
  }
}

Este repositorio incluye un .cursor/mcp.json preconfigurado para el servidor self-hosted: abre el repositorio en Cursor y actívalo en Configuración → MCP.

Arquitectura

client (HTTP / MCP)
  -> FastAPI (:8000)
       -> rate-limit middleware (per-IP token bucket on add/search)
       -> SemanticCache.check            (return cached facts on similarity hit)
       -> AsyncBatchDistiller.enqueue    (POST /v1/memories, infer=true)
            ↳ silence-window or max_batch triggers on_batch_ready
                ↳ VectorStore.process_batch  (LLM extraction -> Qdrant upsert)
       -> VectorStore.search             (vector + BM25 + entity + time-decay)
  -> LLM: OpenAI / Anthropic / OpenAI-compatible (fact extraction)
  -> BGE-M3 / Gemini / OpenAI-compatible (embeddings)
  -> Qdrant (vectors)  +  SQLite (audit history)
  -> MCP server (:8001)  deepmem_write / deepmem_search / deepmem_delete

Una única colección de Qdrant (memories), filtrada estrictamente por el payload user_id. TenantValidator normaliza NFC y aplica un conjunto de caracteres [A-Za-z0-9._:-]{1,256} en user_id: nunca confíes en el valor crudo de la solicitud.

Configuración

La configuración se carga una vez desde variables de entorno (.env, auto-cargado) > config.json > valores predeterminados. Variables clave:

Los backends se seleccionan automáticamente según las variables de entorno: sin cambios de código.

• QDRANT_URL configurado -> Qdrant remoto; no configurado -> archivo local Qdrant en ./data/qdrant.

• CORS_ORIGINS=* se rechaza al arranque a menos que DEEPMEMORY_DEBUG=1.

Producción (systemd)

systemctl restart deepmem.service     # scripts/start.sh -> uvicorn :8000
journalctl -u deepmem -f

Para HTTPS, pon Caddy o Nginx delante; scripts/start.sh se ejecuta bajo systemd o cualquier gestor de procesos.

Benchmarks

Dos scripts reproducibles en /benchmarks:

• Nube vs nube: DeepMem cloud vs Mem0 cloud. Registra claves en deepmem.dev + mem0.ai, luego python benchmarks/benchmark_cloud.py.

• Self-hosted - tu DeepMem, tu hardware (sin clave, sin servicio externo): python benchmarks/run_benchmark.py.

Ambos incluyen una carga de trabajo autocontenida y reportan P50/P95/P99 + rendimiento. Los números al principio de este README se produjeron con estos scripts: vuelve a ejecutarlos y lee tus propios percentiles.

Preguntas frecuentes

¿Necesito la nube? No. El servidor de código abierto es totalmente funcional por sí solo. La nube (deepmem.dev) es la opción de cero operaciones: misma API.

¿Funciona sin conexión? La recuperación y el almacenamiento bruto (infer=false) funcionan sin red. La extracción de hechos con LLM (infer=true) necesita una clave de LLM, o ejecuta un modelo local compatible con OpenAI (Ollama / vLLM / LM Studio) y configura LLM_BASE_URL para apuntar a él.

¿Dónde están mis datos? En tu Qdrant (archivo local o servidor) más un registro de auditoría SQLite. Nada sale de tu máquina excepto las llamadas de LLM/embedding que configures.

¿Multiinquilino? Sí: una única colección de Qdrant filtrada por user_id. agent_id / run_id añaden alcance de agente y sesión.

¿Listo para producción? Se usa en producción bajo systemd con un Qdrant remoto. El Qdrant de archivo local es suficiente para desarrollo/un solo worker; usa un servidor Qdrant para múltiples workers o alto rendimiento.

Desarrollo

pip install -r requirements.txt
DEEPMEMORY_DEBUG=1 python -m uvicorn server.main:app --reload --host 0.0.0.0 --port 8000
pytest tests/ -x -v

Licencia

MIT.