Skip to content
Proyectos

vshulcz/deja-vu has 1,493 GitHub stars and 178 forks. GitHot measured +112 in 7 days. Last checked 2026-11-10 19:01 UTC. Last push 2026-11-02.

Cómo se miden estas cifras

Claude Code memory, Codex memory, Cursor memory, OpenCode memory, Gemini CLI memory, Windsurf memory & Cline memory across 44 agents. AI coding memory, Claude Code history, Cursor history, local coding agent memory, MCP memory server & Claude compaction.

What you can do

  • Starts full on day one. Months of existing transcripts across all forty-three agents are searchable immediately — fix a bug in Codex and Claude Code, Cursor or OpenCode recalls it.
  • Automatic recall via hooks & MCP. Surfaces prior sessions at session start, before a file edit or command runs, and when a command fails.
  • Survives compaction. Over 43 measured compactions, summaries kept 77% of decisions and 0.2% of commands; deja hands back the rest (how).
  • Indexes code changes, not just chat. Tracks opened files, commands with exit codes, and exact Edit spans (deja blame <file>:<line>, deja restore <path>).

Crecimiento de estrellas medido

in 24h
Actualización retrasada
in 7 days
+112
in 15 days
Actualización retrasada
in 1 month
Actualización retrasada

Cambios netos en períodos que se solapan, no totales diarios. Los datos no disponibles se dejan en blanco. Las estrellas indican interés, no calidad.

docs/readme/README.es.md

Original

deja-vu

Que tus agentes de código dejen de depurar otra vez lo que ya arreglaste.

Claude Code, Codex, Cursor y el resto de los agentes de esta máquina ya guardan cada sesión en disco. deja lo indexa todo, meses atrás incluidos, y le pasa lo que importa al agente que está trabajando ahora.

English | 简体中文 | 繁體中文 | 日本語 | 한국어 | Español | Português | Français | Deutsch | Русский | Türkçe | हिन्दी

GitHub Stars CI coverage Release npm License: MIT

Documentación · Benchmarks · Comparación

la misma pregunta al mismo agente dos veces: sin memoria no recuerda nada, con deja responde con una conclusión de hace ocho meses

curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh
deja install --auto
Recall
97.2% R@5 en LongMemEval-S
las 500 preguntas · MemPalace 96.6%, agentmemory 95.2%
mismas 19,195 sesiones: 19/100 en primer lugar, la siguiente 14
Tokens
la mitad de tokens que agentmemory
53,558 frente a 104,974 en una tarea ya resuelta
477 tokens de definiciones de herramientas, la menor de siete
Indexado
13.6 s para indexar 19,195 sesiones
la siguiente de siete: 72 s
26 ms hasta la primera respuesta, 97 ms de mediana de búsqueda

Mantengo deja-vu, así que cada driver, el corpus y la regla de puntuación están en este repositorio · la comparación directa y cómo volver a medir una fila que dudes · ejecuciones de LongMemEval y LoCoMo

Instalación

curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh
deja install --auto

El script deja el binario en ~/.local/bin. Si ese directorio todavía no está en tu PATH, la misma shell no encuentra el segundo comando: ejecuta la línea next: que imprime el script, con la ruta completa, o abre una shell nueva cuando la línea de PATH ya esté añadida.

Si raw.githubusercontent.com no está accesible, hay un espejo en npm con la misma versión:

npm i -g @vshulcz/deja-vu --registry=https://registry.npmmirror.com
deja install --auto

Diez segundos para instalar, unos diez para indexar. El segundo comando conecta el recall por MCP a cada agente que encuentra, activa el recall al inicio de sesión donde el agente lo soporta y construye el primer índice, para que la siguiente sesión no espere nada.

Abre una sesión nueva y pregunta por algo de hace meses:

¿ya nos peleamos antes con jwt refresh rotation? busca en tu memoria

Tampoco hace falta preguntar: con el recall automático activado, el agente ya sabe al abrir la sesión qué se resolvió en este proyecto. Para buscar tú mismo, ejecuta deja.

opencode, DeepSeek Harness, Zed, Kimi Code, Codex CLI, Grok Build, OpenClaw, pi y Hermes tienen además su propio paquete, para quien está acostumbrado a instalar extensiones desde ahí:

opencode plugin opencode-deja
dsh plugin --profile web add dsh-deja
# Zed: busca deja en el panel de extensiones
# Kimi Code: /plugins install https://github.com/vshulcz/deja-vu
# Codex CLI: codex plugin marketplace add https://github.com/vshulcz/deja-vu && codex plugin add deja-vu@deja-vu
# Grok Build: grok plugin marketplace add vshulcz/deja-vu && grok plugin install deja
openclaw plugins install clawhub:@vshulcz/openclaw-deja && openclaw config set plugins.entries.deja-vu.hooks.allowConversationAccess true
pi install npm:@vshulcz/pi-deja
hermes plugins install deja-memory

deja install --auto ya conecta todo lo anterior, así que cualquiera de los dos caminos basta. Los dos juntos tampoco estorban: cada paquete lee lo que escribió deja install y solo completa lo que falta, sin registrar herramientas por duplicado ni hacer el recall dos veces. Los detalles están en extensions/.

La misma búsqueda existe como skill, instalable por cualquier agente que lea SKILL.md:

npx skills add https://github.com/vshulcz/deja-vu --skill deja-search   # skills CLI: Claude Code, Cursor, Goose, Copilot…
openclaw skills install @vshulcz/deja-search                            # ClawHub
hermes skills install vshulcz/deja-vu/skills/deja-search                # Hermes

El skill llama al binario deja que ya tienes instalado; no trae uno propio.

Otras vías: brew install deja-vu, go install github.com/vshulcz/deja-vu/cmd/deja@latest, o npx @vshulcz/deja-vu "consulta" para probarlo sin instalar nada. En Windows el script de instalación termina con unsupported OS porque es un script de shell; usa scoop install deja-vu (está en el bucket main de Scoop) o winget install vshulcz.deja-vu, o coge deja-vu_<version>_windows_amd64.zip de la última release y pon deja.exe en el PATH.

Solo el binario ya es una instalación completa: indexar, buscar, show, ctx, blame, --json y el borrado de credenciales no necesitan nada más. Lo que hace deja install es enchufar MCP a tus agentes y activar el recall al inicio de sesión: vale la pena, pero es opcional.

Búscalo tú mismo

deja sin argumentos en una terminal abre una búsqueda sobre el historial de todos los agentes. Empieza por las sesiones detrás de tu cambio sin commitear, luego las recientes de este proyecto, y la lista se acota mientras escribes.

Escribir una búsqueda en la pantalla de deja, leer la sesión encontrada y continuarla en otro agente

  • ↑↓ elige una sesión, ↵ la abre en la coincidencia, n y N recorren las coincidencias, esc vuelve atrás. Dentro de una sesión, / busca una palabra y ] [ saltan entre las preguntas que hiciste.
  • La caja acepta filtros: un agente con dos puntos (codex:), today, yesterday, week, month e in:<proyecto>.
  • r reanuda la sesión en el agente que la escribió. o la continúa en cualquier otro agente, que empieza con lo que la sesión preguntó, decidió y dejó pendiente.
  • tab cambia entre este proyecto, todos los proyectos y Deleted, las sesiones que su agente borró y que deja aún guarda; R devuelve una a su sitio.
  • ? lista todas las teclas, ^k tiene el resto (copiar el id de la sesión o la ruta del proyecto, olvidar una sesión), en la lista, q sale; esc retrocede un paso y sale con la caja de búsqueda vacía.

Con DEJA_TUI=0 imprime en su lugar el resumen en texto, que también es deja brief. Por una tubería, imprime qué está indexado y qué comando ejecutar a continuación.

Qué obtienes

Resuelto en Codex, recordado por Claude. Cuarenta y un agentes de código escriben cada conversación en archivos locales y deja convierte esos archivos en una capa de memoria que todos pueden leer.

Búsqueda hacia atrás deja "connection pool exhausted" recorre gigabytes, incluido todo lo anterior a instalar deja. Una pregunta en lenguaje natural cae en el modo por relevancia. El tiempo es una pista, no un filtro.
Recall entre agentes La herramienta MCP deja en modo recall responde «esto lo arreglamos hace tres semanas» desde cualquier agente, sin importar quién lo arreglara entonces.
Sobrevive a la compactación Medido en 43 compactaciones: el resumen conservó el 77% de las decisiones y el 0.2% de los comandos que ejecutaste. El 99.8% restante lo devuelve deja. En Claude Code y Codex, deja anota la tarea, los archivos y los comandos en el momento en que empieza la compactación, y los devuelve una vez, después de ella.
Recall en el momento de actuar Antes de que el agente edite un archivo o ejecute un comando, el hook PreToolUse dice qué se decidió antes sobre ese archivo, cuál es la forma de ese comando que funciona aquí, o que el programa simplemente no existe en esta máquina. Cuando un comando falla, el hook PostToolUse muestra qué se ejecutó después del mismo error en esta máquina: justo el par que el agente no va a preguntar.
Indexa el trabajo, no solo las palabras Cada archivo abierto en cada turno, cada comando ejecutado con su código de salida, y el fragmento exacto que reemplazó una edición. Precisamente lo que pierde cualquier resumen.

Además: deja promote <id> --state rejected marca una decisión revertida, y desde entonces cada resultado muestra que se intentó y se descartó; un resultado avisa de que «4 archivos de esta sesión han cambiado desde entonces» y calla cuando no puede saberlo; deja sync ssh laptop mueve la memoria entre máquinas solo añadiendo, sin nube en medio; deja handoff --to codex empaqueta el contexto actual para seguir en otro agente; las claves, tokens, JWT y bloques de clave privada de formas conocidas se quitan al indexar, aunque emparejar patrones no es detectar secretos y una forma desconocida puede pasar.

Dibuja tu propio trabajo

deja stats --card dibuja directamente en la terminal; dale un nombre de archivo y escribe un SVG para el README de tu perfil. Para publicarlo en otro sitio, conviértelo a PNG: esa página convierte en tu propio navegador.

tarjeta de estadísticas de deja: un año de sesiones como mapa de calor, de qué agentes vinieron y cuál fue la más larga

La referencia completa está en el sitio de documentación.

Privacidad

Indexar y buscar son operaciones locales. Solo usan la red deja update, deja sync ssh, la comprobación de versión dentro de deja doctor, deja embed, que va al endpoint que tú configures (y, una vez construido el sidecar semántico, cada búsqueda, que envía la consulta a ese endpoint), y una consulta diaria a la última release desde un comando interactivo. Esa consulta no envía datos de sesiones; DEJA_OFFLINE=1 o DEJA_NO_UPDATE_NOTICE=1 la desactiva.

Las credenciales se limpian al indexar: claves de AWS, asignaciones api_key= y token=, tokens bearer y JWT desnudos, bloques PEM de clave privada, tokens de distintos proveedores, URLs con forma scheme://user:pass@host, valores de alta entropía que ninguna regla cubre, y contraseñas escritas en prosa —«the admin password is …», donde no hay ningún separador en el que apoyarse. El valor pasa a ser [redacted:<kind>] y el texto alrededor sigue siendo buscable. deja share y deja sync export limpian otra vez al exportar. Emparejar patrones no es detectar secretos: una forma que las reglas no conocen puede pasar tal cual, ver el modelo de seguridad.

deja forget saca sesiones del índice reconstruido y deja una lápida, así que el siguiente deja index no puede recuperarlas del historial original. El modelo de seguridad documenta los flujos de datos, los límites del borrado, los supuestos de confianza y la verificación de releases.

Línea de comandos

deja a secas en una terminal abre la pantalla de búsqueda. Con una consulta o cualquiera de los comandos de abajo, imprime y termina:

$ deja "jwt refresh token"
[claude] api        · Jul 8 · 8f31c0a9 — 2 matches
  login started failing after refresh token rotation; jwt kid mismatch in tests
  fixed by reloading jwks cache after rotateKey and adding a clock-skew test
[codex]  web        · Jul 1 · b77d91e2 — 1 match
  refresh token cookie needed SameSite=Lax in local callback flow
Comando Qué hace
deja <consulta> Busca en todo el historial. Varias palabras son AND, las comillas exigen texto contiguo; si no hay coincidencia exacta prueba formas de la palabra y grafías cercanas.
deja En una terminal, la búsqueda a pantalla completa de arriba. deja brief imprime en su lugar el resumen en texto: las sesiones de hoy, lo que deja entregó, el trabajo reciente y una búsqueda para probar.
deja wip Qué estaba haciendo la última sesión en este directorio: la tarea, a qué se llegó, los archivos abiertos, el último comando y si falló. Todo deducido de los registros, sin depender de que alguien tomara notas.
deja blame <ruta>[:línea] Qué sesiones discutieron este archivo, qué se decidió y por qué. Con número de línea: el commit que la cambió por última vez y la sesión que escribió esa línea o el texto que ese commit reemplazó.
deja files <tema> Al revés: qué archivos tocó realmente el trabajo sobre un tema.
deja how <herramienta> Cómo se ejecuta esto de verdad en esta máquina, con argumentos reales, sacados de comandos que los agentes ya corrieron.
deja fix <error> Qué se ejecutó después del mismo error en esta máquina, y tras lo cual el error no volvió a aparecer. Nunca un merge, un force push ni un borrado.
deja friction Errores que aparecen en tres o más sesiones distintas, indicando de qué herramientas vienen.
deja ctx <consulta> Resumen en Markdown del mejor resultado, con el código que cambió, listo para meter en un prompt.
deja resume <id> Vuelve a abrir la sesión encontrada en la herramienta a la que pertenece.
deja view Exporta toda la memoria a un único archivo HTML local. Sin servidor, nada sale de la máquina.
deja doctor [--deep] Autodiagnóstico; con --deep verifica el índice contra los archivos de origen.
deja mcp El servidor MCP por stdio, el mismo que conecta deja install.

La referencia completa está en la documentación de comandos.

Herramientas MCP

El servidor expone una sola herramienta, deja, y el parámetro mode elige la capacidad: recall, context, blame, fix, how, orient, remember, handoff. deja install la conecta sola, así que esto solo importa si configuras un agente a mano. Los seis nombres antiguos siguen funcionando en los clientes ya conectados.

Una herramienta en lugar de siete es una cuestión de coste, no de estilo. Un servidor MCP conectado envía las definiciones de sus herramientas con cada petición, así que se pagan en cada turno haya llamado el agente algo o no: 477 tokens aquí, frente a 8,283 del mayor de los siete servidores medidos. El de deja era 828 hasta que el esquema se redujo a una herramienta con modos.

Herramientas soportadas

Con el recall automático activado, Claude Code y Codex entregan a deja el registro actual cuando empieza la compactación, y deja se queda con lo que el resumen está a punto de perder: la tarea, las conclusiones, los archivos, en qué terminó cada comando y qué queda sin hacer. El siguiente hook de la misma sesión y el mismo directorio lo devuelve de una vez, sin pasar de 4 KB, con una línea sobre si el repositorio cambió desde entonces. deja stats cuenta las llamadas a herramientas entre la compactación y la primera edición, que es con lo que se midió esto. Los detalles están en recuperación tras la compactación.

Claude Code · Cline · Codex CLI · opencode · aider · Gemini CLI · Cursor · Antigravity · Grok Build · Hermes · Goose · Qwen Code · Kimi Code · pi · omp (Oh My Pi) · OpenClaw · Copilot CLI · VS Code Copilot Chat · Amp · prime-agent (PrimeIntellect) · Roo Code · Continue · Crush · DeepSeek Harness · Cherry Studio · Senpi · gajae-code · Kimchi Coding · Command Code · ZCode · CodeWhale · Reasonix · Kiro · Kilo Code · CodeBuddy Code · TRAE CLI · Muse Code · Junie · JetBrains AI Assistant · Devin CLI · Windsurf / Devin Desktop · MiniMax Code · Zed.

Qué soporta cada uno —recall por MCP, recall automático, skills, comandos, resume, handoff— está en la matriz de capacidades del README en inglés. Las rutas de almacenamiento personalizadas se indican con variables DEJA_*_ROOT, y también se respetan las variables de migración de cada herramienta.

Agentes con su propio paquete

deja install --auto conecta estos igual que el resto, y ese siempre es el camino más corto. Además cada uno tiene un paquete en su propio ecosistema, para quien instala extensiones desde ahí:

Agente Paquete Instalación
opencode npm opencode-deja opencode plugin opencode-deja
DeepSeek Harness npm dsh-deja dsh plugin --profile web add dsh-deja
Zed deja-context-server Zed → Extensions → deja
Kimi Code plugin deja /plugins install https://github.com/vshulcz/deja-vu
Codex CLI plugin deja-vu codex plugin marketplace add https://github.com/vshulcz/deja-vu, luego codex plugin add deja-vu@deja-vu
Grok Build plugin deja grok plugin marketplace add vshulcz/deja-vu, luego grok plugin install deja
OpenClaw ClawHub y npm @vshulcz/openclaw-deja openclaw plugins install clawhub:@vshulcz/openclaw-deja
pi (y omp) npm @vshulcz/pi-deja pi install npm:@vshulcz/pi-deja
Hermes proveedor de memoria deja-memory, en el catálogo de plugins de Hermes hermes plugins install deja-memory, o desde GitHub: hermes plugins install vshulcz/deja-vu/extensions/hermes

Cualquiera de los dos caminos basta y los dos juntos no rompen nada: cada paquete lee primero lo que dejó escrito deja install. opencode, dsh y OpenClaw solo completan lo que falta; Kimi, Grok, Codex y pi se apartan si el instalador ya lo conectó; en Zed ambos lados usan el mismo id de servidor. Así que el orden de instalación no importa.

Todos usan el deja que ya tienes instalado; la copia dentro del paquete es solo el respaldo.

Recall semántico, opcional

Apunta deja embed a un Ollama local, LM Studio o cualquier endpoint compatible con OpenAI mediante DEJA_EMBED_URL y preguntar con otras palabras también acierta. Sin un runtime disponible, la búsqueda léxica y el recall por MCP funcionan como siempre.

Evidencia

58% menos tokens en una tarea que esta máquina ya había resuelto · 88.9% hit@1 en LongMemEval-S (conjunto depurado de 470 preguntas) · 71.9% en LoCoMo · consultas en milisegundos sobre gigabytes de historial
Once ejecuciones por brazo: 53,558 tokens frente a 126,222 sin nada conectado, y 52,815 frente a 103,443 en una versión posterior, otra vez once ejecuciones · lo que cuesta terminar una tarea · los dos harnesses de recuperación están en este repositorio y corren sobre datasets públicos en minutos · comprueba los números tú mismo

deja bench recall     # cota inferior de regresión del ranking: 100 consultas, la mitad en ruso, CI falla si el recall baja
deja bench context    # 30 cadenas de tareas con semilla más cinco controles negativos
deja bench block      # si la respuesta sigue estando en el fragmento de texto entregado
deja bench prompt     # cuándo habla el hook por prompt y cuándo habla de más
deja bench ingest     # coste de una actualización del índice: sin cambios, un turno añadido, un archivo nuevo, reescritura completa
deja bench read       # cuánto cuesta leer un almacén en base de datos y qué le hace un solo valor largo

El experimento de contexto compara el recall de deja con el historial completo, un grep ingenuo y el arranque en frío. Con la semilla por defecto:

Enfoque Tokens (mediana) Cobertura (mediana) Tokens del control negativo
deja-recall 1,096 1.00 0
full-history 80,547 1.00 78,145
naive-grep 273,238 1.00 0
cold 0 0.00 0

La misma cobertura de hechos que hacer grep sobre los logs en crudo con unas 250 veces menos tokens; unas 70 veces menos que las sesiones encontradas reproduciéndolo todo; y nada inyectado en las cadenas sin historial relevante. El generador del corpus y el etiquetado de relevancia son código Go normal y revisable. Antes de creer cualquier número, mira cómo define «relevante», incluidos los nuestros.

Medido sobre un almacén real: 2,419 sesiones, 179k mensajes, 1.9 GB de registros.

Métrica Resultado
Consulta dentro del proceso mediana 0.7–0.8 ms, unos 15 ms en los pajares de LongMemEval-S
deja <consulta> de extremo a extremo mediana de unos 0.2 s en ese almacén: arranque del proceso, comprobación de frescura de todos los almacenes, ranking, impresión
Solo la comprobación de frescura unos 50 ms cuando nada ha cambiado
Tamaño del índice 200 MB, alrededor del 10% del corpus

El índice es incremental. Cuando un archivo de sesión crece, se vuelve a leer solo ese archivo.

Cómo funciona

Un índice invertido local en ~/.cache/deja: parsea almacenes JSONL y SQLite, limpia credenciales, escribe records.bin y cubos de palabras, y guarda el estado de cada archivo en manifest.gob, de modo que una segunda ejecución solo ingiere lo que cambió. El servidor MCP, las estadísticas, share y sync leen ese mismo índice. Los detalles están en docs/ARCHITECTURE.md.

Preguntas frecuentes

¿En qué se diferencia de otras herramientas de memoria?
deja Plataformas de memoria
(Mem0, Letta, memU)
Búsqueda de sesiones
(cass)
Conoce el trabajo anterior a su instalación sí no sí
Necesita un paso de captura no, la transcripción es la memoria el agente o tu código escriben hechos no
Necesita clave de LLM o de embeddings no sí opcional
Recuerda sin que se lo pidan al inicio de sesión y antes de ejecutar herramientas no no

La comparación completa cubre quince de ellas.

¿Va a ralentizar a mi agente?

Un recall es una consulta léxica a un índice local: mediana de 0.7–0.8 ms y nada esperando a un modelo. El hook añade el arranque del proceso y la comprobación de frescura de los almacenes: en un índice de 19k sesiones, el hook de cada prompt tarda 107 ms de mediana.

¿Dónde está el historial de sesiones de Claude Code y se puede buscar?

En ~/.claude/projects, un archivo JSONL por sesión; Codex en ~/.codex/sessions, Cursor en el SQLite state.vscdb. deja los lee donde están: deja a secas abre una pantalla para buscarlos y leerlos, deja search hace lo mismo desde un script, deja last lista las sesiones recientes de todos los agentes y deja view abre todo el historial como una página local. Las rutas por agente están en dónde se guardan las sesiones.

Ha desaparecido mi historial de Claude Code, ¿lo he perdido?

Claude Code borra los registros de más de 30 días (cleanupPeriodDays en ~/.claude/settings.json) y claude --resume solo lista lo que queda. Las sesiones que deja indexó antes de la limpieza siguen siendo buscables después de que el archivo desaparezca. Los detalles están en archivos de sesión en disco.

¿Cómo borro todo?
deja uninstall --all
rm -rf ~/.cache/deja ~/.local/share/deja ~/.config/deja

El índice está en ~/.cache/deja, tus notas de remember y promote en ~/.local/share/deja, y las reglas, la lista de exclusión y el lanzador de hooks en ~/.config/deja (o bajo XDG_DATA_HOME y XDG_CONFIG_HOME si están definidos; en Windows las notas están en %AppData%\deja).

Guías

Escritas por situación, no por función:

Por herramienta: opencode · Zed · Grok Build · Gemini CLI · OpenClaw · Goose · Cline · pi y omp · Hermes

Desarrollo

make build test lint, y luego CONTRIBUTING.md. Un agente nuevo empieza por el registro de parsers. Las prioridades y lo que no vamos a hacer están en ROADMAP.md.

Licencia

MIT © Vladislav Shulcz

⭐ Star deja-vu on GitHub

Explorar proyectos relacionados