PLUR Memory Engine

Memoria persistente local-first para agentes de IA compatibles con MCP.

Documentación

PLUR — Tus agentes comparten la misma memoria

Memoria persistente y abierta para agentes de IA — local-first, sin costo, compartida entre herramientas MCP (Claude Code, Codex, Cursor, Hermes, OpenClaw). La memoria de tu agente son engramas en texto plano que puedes leer, corregir y eliminar — no pesos que no puedes tocar.

plur.ai · Benchmark · Engram Spec · npm · Comparaciones

Benchmarks

PLUR es memoria, no solo recuperación — por eso lo medimos en más de un eje, sobre el corpus completo, y publicamos el harness para que puedas reproducir cada número.

Recall de recuperación — LongMemEval-S completo (N=500), R@5, totalmente local:

Stack	R@5	Notas
Solo BM25	92.2%	sin embedder — totalmente aislado
Híbrido (BGE-small, predeterminado de fábrica)	95.6%	embedder local incluido, cero descargas
+ BGE-reranker-v2-m3	97.6%	cross-encoder local, máxima calidad — opcional, ≈5s p50 en CPU

Los números provienen de plur-ai/plur-bench, que es la fuente de verdad para cada cifra de benchmark que PLUR publica. Si un número en el repositorio y un número de plur-bench discrepan, gana plur-bench — es el harness reproducible, y es lo que CI verifica en regresiones.

Granularidad de chunks, puntuación de documento canónico, SHA256 del corpus fijado — reprodúcelo en plur-ai/plur-bench. No se requiere ninguna llamada en la nube para estos números (un embedder en la nube opcional, openai-3-large, alcanza 97.0% híbrido). Un reranker más rápido — ms-marco-minilm-l6 (p50≈245ms vs ≈5s de BGE en CPU) — intercambia un poco de recall por latencia de sub-segundo.

Pruébalo tú mismo — y cuéntanos qué obtienes. El harness es plur-ai/plur-bench: ejecutable en CPU, sin necesidad de API key para la ruta local, corpus auto-descargado y verificado por SHA. Si lo ejecutas, nos encantaría ver tus números — abre un issue o discusión con tus resultados, especialmente si no coinciden con los nuestros. La reproducción independiente vale más que cualquier número que publiquemos, y te acreditaremos con gusto.

Recuperación ≠ precisión de respuesta — y los reportamos por separado, nunca mezclados. La precisión de respuesta de extremo a extremo (evaluada por LLM) con el stack de reranker es 60.5%, frente al 52.0% de volcar el contexto completo en el prompt y 5.5% sin memoria alguna.

Impacto en tareas de agente — misma tarea, con memoria vs sin ella: Haiku + PLUR supera a Opus sin ella a aproximadamente 10× menos costo; reglas de casa 12–0 entre Haiku, Sonnet y Opus.

Operativo — búsqueda local-first, sin costo, soberanía de datos por diseño.

Más en progreso: LoCoMo, suites de tareas agénticas, portabilidad entre herramientas, corrección de decay/contradicción. Metodología completa →

La idea

Corriges el estilo de código de tu agente el lunes. El martes, comete el mismo error. Explicas tu arquitectura en Cursor. Esa noche, Claude Code no tiene idea.

PLUR arregla esto. Instálalo una vez, y las correcciones, preferencias y convenciones persisten — entre sesiones, herramientas y máquinas. Tu memoria se almacena como YAML plano en tu disco. Sin nube, sin llamadas API, sin caja negra.

La parte interesante: en nuestro benchmark de enrutamiento de herramientas y conocimiento local, Haiku con memoria PLUR superó a Opus sin ella — 2.6x mejor en enrutamiento de herramientas, a aproximadamente 10x menos costo. Resulta que el cuello de botella no es la inteligencia del modelo. Es el contexto.

El modelo se alquila; tu memoria se posee. Cambia Haiku por Opus para lo que sea que salga el próximo mes — el razonamiento es un commodity que no controlas. La parte que es tuya — todo lo que el agente ha aprendido sobre tu trabajo, tus correcciones, tus convenciones — no debería vivir en la nube de alguien más ni estar horneado en pesos que no puedes leer. PLUR lo mantiene en archivos planos en tu disco, en un formato abierto que puedes inspeccionar, corregir y eliminar. Eso es lo que realmente significa poseer tu inteligencia.

Instalación

Dile a tu agente

Pega esto en tu agente de codificación (Claude Code, Cursor, Windsurf, OpenClaw):

Set up PLUR memory for me: run `npx @plur-ai/mcp init`, then check my PLUR status to confirm it works.

¿Prefieres una configuración guiada? plur.ai tiene la configuración exacta para tu herramienta — Claude Code, Cursor, Windsurf u OpenClaw.

Configuración manual (Claude Code)

Un comando configura todo — almacenamiento, configuración MCP y hooks de Claude Code:

npx @plur-ai/mcp init

Esto crea ~/.plur/ para almacenamiento, añade PLUR a tu .mcp.json e instala hooks de Claude Code para la inyección automática de engramas. Los hooks también cierran automáticamente el ciclo de vida de la memoria: un hook de SessionEnd captura un episodio de cierre y limpia el estado de la sesión cuando una conversación termina, para que la memoria se cierre limpiamente incluso si el agente olvida llamar a plur_session_end. PLUR se instala globalmente — un servidor MCP, un almacén, disponible en cada proyecto. Solo ejecutas init una vez.

Para configuraciones multi-proyecto, usa dominio/scope para separar el conocimiento:

cd ~/projects/my-app
npx @plur-ai/cli init --domain myapp --scope project:my-app

Esto crea un .plur.yaml en el proyecto con valores predeterminados que los hooks aplican automáticamente. Los engramas aprendidos en ese proyecto se etiquetan; el recall filtra por scope pero siempre incluye conocimiento global.

Establece el scope por engrama, según el contenido. El scope no es una configuración única por sesión — cada llamada a plur_learn toma su propio scope, elegido según de qué trata el engrama. El conocimiento de equipo/compartido va a un scope de equipo (p. ej. group:<org>/<team>, usado por PLUR Enterprise); los detalles de proyecto a project:<name>; las preferencias personales se quedan locales. No dejes que el conocimiento relevante para el equipo caiga en global al omitir el scope — global se filtra a cada proyecto y (con un almacén de equipo configurado) nunca llega al equipo. plur_session_start lista los scopes remotos a los que un token puede escribir.

Instalación global (inicio más rápido)

npm install -g @plur-ai/mcp
plur-mcp init

Cursor

Ejecuta init desde la raíz de tu proyecto — configura el .cursor/mcp.json de Cursor (además de los hooks de Cursor y una regla de contexto):

npx @plur-ai/mcp init

PLUR se ejecuta bajo un perfil de herramientas reducido en Cursor (PLUR_TOOL_PROFILE=cursor) — Cursor limita las herramientas que un workspace puede exponer, así que PLUR muestra un conjunto central curado (learn / recall / inject / status) en lugar de los 43, con el resto accesible a través de plur_admin. El soporte para Cursor se lanzó en v0.13.

Codex

npx @plur-ai/cli init --codex

Registra el servidor MCP vía codex mcp add, escribe hooks de ciclo de vida en ~/.codex/hooks.json y añade una sección de PLUR a AGENTS.md. Se auto-detecta cuando existe ~/.codex/.

La inyección usa búsqueda híbrida (BM25 + embeddings) con un fallback automático a BM25 si el embedder es lento o no está disponible. Establece PLUR_HOOK_HYBRID=0 para forzar BM25 (aplica también a los hooks de Antigravity; PLUR_CODEX_HYBRID se respeta como alias). PLUR_HOOK_HYBRID_DEADLINE_MS ajusta el plazo del fallback — mantenlo por debajo del timeout de hooks de tu harness (Codex 25s, Antigravity 20s).

Un paso manual después de la instalación: abre Codex, ejecuta /hooks y confía en las entradas de PLUR. Codex toma huella de cada hook y se niega a ejecutar los que no son de confianza — silenciosamente, sin advertencia y con código de salida cero. Hasta que confíes en ellos, la memoria simplemente nunca se carga. plur doctor también lo dice.

Qué integración obtienes

Cada cliente MCP puede llamar a las herramientas de PLUR. Solo algunos tienen un adaptador — los hooks y el contexto siempre activo que hacen que la memoria se cargue automáticamente en lugar de esperar a que el agente lo piense. Sin uno, el recall y el aprendizaje dependen completamente de que el modelo elija llamar a las herramientas, lo que se degrada gravemente bajo presión de contexto.

Harness	Herramientas	Auto-inyección + cumplimiento
Claude Code	✅	✅ hooks + `CLAUDE.md`
Codex	✅	✅ hooks + `AGENTS.md` (confía en `/hooks` una vez)
Cursor	✅	✅ hooks + reglas
OpenClaw	✅	✅ plugin ContextEngine
Hermes	✅	✅ plugin
Antigravity CLI (`agy`)	✅	✅ hooks + `AGENTS.md`
Windsurf, Gemini CLI, otros clientes MCP	✅	❌ solo herramientas

Si tu harness está en la última fila, pega la sección de PLUR de CLAUDE.md en su propio archivo de contexto (AGENTS.md, GEMINI.md, …) como medida provisional — eso restaura la capa de instrucciones, aunque no la inyección automática.

Antigravity CLI (agy)

npx @plur-ai/cli init --antigravity

Escribe hooks y el servidor MCP en la configuración global de agy (~/.gemini/config/) y añade una sección de PLUR a AGENTS.md. Se auto-detecta cuando existe ~/.gemini/antigravity-cli/. Sin paso de confianza — agy ejecuta los hooks configurados en la primera invocación; solo reinicia agy.

Antigravity no tiene evento de inicio de sesión ni hook por prompt, así que PLUR lo maneja todo desde PreInvocation: el recall por prompt se lee de la transcripción de la conversación, y la memoria del turno se re-inyecta como un mensaje efímero en cada invocación del modelo para que sobreviva a las llamadas de herramientas sin acumularse en el historial.

Usuarios de Gemini CLI: Google está migrando Gemini CLI a Antigravity — instala agy y ejecuta el comando anterior. Gemini CLI en sí sigue siendo solo herramientas.

OpenClaw

openclaw plugins install @plur-ai/claw
openclaw config set plur.enabled true

Eso es todo. PLUR trabaja en segundo plano desde aquí. No se necesitan cambios en el flujo de trabajo — solo usa tus herramientas como siempre. Las correcciones se acumulan automáticamente.

DeepSeek Harness

dsh plugin add @plur-ai/dsh

Nativo, no un puente MCP. PLUR se monta como un plugin de Cordis y escribe tus engramas directamente en el prompt del sistema, para que el modelo los lea de la misma manera que lee sus propias instrucciones — sin llamada de herramienta, sin ida y vuelta, y sin turno gastado decidiendo si mirar. La sección se re-renderiza en cada ensamblaje en lugar de anexarse, para que la memoria no se acumule en el contexto mientras corre una sesión.

Cinco herramientas (plur_recall, plur_learn, plur_forget, plur_feedback, plur_status) siguen registradas para cuando el agente quiera alcanzar la memoria deliberadamente. El scope predeterminado es cerrado — cada workspace obtiene el suyo, resuelto desde su .plur.yaml.

/plur reporta el estado; /plur-memory abre el visor de memoria a continuación.

Hermes Agent

pip install plur-hermes
npm install -g @plur-ai/cli

El plugin se registra automáticamente a través del sistema de plugins de Hermes. Inyecta memorias relevantes antes de cada llamada al LLM, extrae aprendizajes de las respuestas del agente y expone todas las herramientas de PLUR al agente. Hermes recurre a la CLI de PLUR.

Python SDK (LangChain, llama.cpp, scripts)

Para entornos Python que no son Hermes:

pip install "plur-ai @ git+https://github.com/plur-ai/plur.git#subdirectory=packages/python"
npm install -g @plur-ai/cli   # bridge (required)

Nota: plur-ai aún no está en PyPI — usa la instalación por git de arriba hasta que se resuelva #915.

from plur_ai import Plur

plur = Plur()
plur.learn("always use async generators for streaming LLM output")
results = plur.recall("streaming patterns")
context = plur.inject("write a streaming endpoint", limit=10)

plur-ai se conecta al mismo almacén en disco que Claude Code y OpenClaw — la memoria escrita desde Python es inmediatamente visible en todas tus herramientas. Consulta packages/python/examples/ para ejemplos de integración con LangChain y llama.cpp.

Verifica que funciona

Pregunta a tu agente: "¿Cuál es mi estado de PLUR?" — debería llamar a plur_status y devolver tu conteo de engramas y la ruta de almacenamiento.

Lee tu memoria

plur dashboard

Abre una página local que lista cada engrama: qué se aprendió, qué se recupera realmente y con qué frecuencia. Solo lectura, solo loopback y servida desde tu propia máquina — nada se sube. --port la mueve, --no-open omite el navegador. Dentro de DeepSeek Harness, la misma página está a un /plur-memory de distancia.

Disponible en inglés y 中文; sigue tu navegador, o ?lang=zh.

Míralo en acción

Una vez que esté funcionando, enséñale algo a tu agente una sola vez:

"Usa siempre pnpm en este proyecto — npm install rompe el lockfile en CI."

Inicia una nueva sesión al día siguiente y pregunta:

You: How do I run the tests?

<plur-memory> 1 engram · project:my-api </plur-memory>

Agent: Use pnpm — you mentioned npm breaks the lockfile in CI:

  pnpm test                           # full suite
  pnpm test -- src/auth.test.ts       # single file

Nueva sesión. Sin recordatorio. La corrección estaba allí.

Ese es el momento en que PLUR da resultados — el agente recuerda una convención de proyecto que mencionaste una vez, sin que esté en ningún archivo que pueda leer.

Cómo funciona

PLUR tiene dos primitivas de almacenamiento: Engrams — conocimiento aprendido que persiste entre sesiones. Cada engrama es una afirmación tipada ("siempre usa despliegues blue-green", "nunca hagas force-push a main") con:

Activación — fuerza de recuperación que decae con el tiempo (modelo ACT-R) y se fortalece al acceder. Los hechos obsoletos se desvanecen naturalmente de la inyección sin limpieza manual.
Señales de retroalimentación — calificaciones positivas/negativas que entrenan la calidad de inyección con el tiempo
Alcance — espacio de nombres jerárquico (global, project:myapp, cluster:prod, service:api) que controla dónde aplica el engrama
Polaridad — clasificación automática de reglas "hacer" vs "no hacer", para que las restricciones se inyecten por separado de las directivas
Asociaciones — enlaces a otros engramas, incluyendo bordes de co-acceso que se forman automáticamente cuando los engramas se recuperan juntos

Episodios — registros de eventos con marca de tiempo para "qué pasó y cuándo". Cada episodio captura un resumen, marca de tiempo, atribución de agente y canal. Usa episodios para líneas de tiempo de incidentes, registros de sesión e historial operativo. Consulta por rango de tiempo, agente o canal.

You correct your agent  →  engram created  →  YAML on your disk
Agent fixes an incident →  episode captured →  timeline searchable
Next session starts     →  relevant engrams injected  →  agent remembers
You rate the result     →  engram strengthens or decays  →  quality improves
Unused engrams          →  activation decays  →  naturally fade from injection

La búsqueda es completamente local: BM25 (con ponderación IDF, saturación TF, normalización de longitud) + embeddings BGE + fusión de rango recíproco. Cero llamadas API, cero costo por consulta. Metodología de referencia →

Los plugins (OpenClaw, Hermes) capturan automáticamente aprendizajes de conversaciones de agentes — no se necesita guardado manual. Las correcciones del agente se convierten en engramas sin que hagas nada.

Consulta la especificación completa de engramas para detalles del esquema, modelo de activación y algoritmo de inyección.

Formato abierto

El engrama es un formato abierto y versionado — no una caja negra. Cada engrama es YAML plano validado contra un JSON Schema publicado, generado desde la misma fuente Zod que usa el motor (los esquemas viven en spec/). Léelo, hazle diff en git, escribe tus propias herramientas contra él, o construye un motor diferente sobre el mismo formato — tu memoria no está bloqueada a PLUR.

Uso

import { Plur } from '@plur-ai/core'

const plur = new Plur()

// Learn from a correction. The engine's read and write methods are async —
// they return promises so a `Plur` can be backed by a network store as well
// as by the default local YAML one.
await plur.learn('toEqual() in Vitest is strict — use toMatchObject() for partial matching', {
  type: 'behavioral',
  scope: 'project:my-app',
  domain: 'dev/testing'
})

// Recall (hybrid: BM25 + embeddings, zero cost)
const results = await plur.recallHybrid('vitest assertion matching')

// Inject relevant engrams into agent context. You get context blocks ready to
// paste into a prompt plus the IDs that went into them — not the engrams
// themselves. `budget` is the ceiling in tokens; selection fills it by relevance.
const injection = await plur.inject('Write tests for the user service', {
  scope: 'project:my-app',
  budget: 2000
})
console.log(injection.directives)   // also .constraints, .consider
console.log(`${injection.count} engrams, ${injection.tokens_used} tokens`)

// Feedback trains the system — rate anything you have an ID for, whether it came
// back from recall or went out in an injection (injection.injected_ids).
if (results[0]) await plur.feedback(results[0].id, 'positive')

// Capture an event (episode). Episode operations stay synchronous — they are
// backed by episodes.yaml, not the engram primary store.
plur.capture('Fixed CrashLoopBackOff on bee-3-4 by increasing memory limits', {
  agent: 'claude-code',
  channel: 'terminal'
})

// Query timeline
const incidents = plur.timeline({ agent: 'claude-code' })

// Sync across machines (use a private git remote — all engrams including private-visibility ones are pushed)
await plur.sync('git@github.com:you/plur-memory.git')

Herramientas

Herramienta	Qué hace
`plur_learn`	Almacena una corrección, preferencia o convención
`plur_learn_batch`	Almacena muchos engramas en una sola llamada (deduplicación por lote + aislamiento de fallos por elemento)
`plur_recall`	Recupera memorias relevantes — híbrido (BM25 + embeddings) por defecto; `mode:"keyword"` para solo BM25
`plur_inject_hybrid`	Selecciona engramas para la tarea actual dentro del presupuesto de tokens
`plur_feedback`	Califica relevancia (entrena calidad con el tiempo)
`plur_forget`	Retira una memoria (la activación decae, eventualmente se poda)
`plur_rescope`	Mueve un engrama existente a otro alcance — personal → equipo, o viceversa
`plur_session_scope`	Cambia el alcance de escritura predeterminado de la sesión a mitad de sesión
`plur_capture`	Registra un evento — incidente, resolución, hito de sesión
`plur_timeline`	Consulta historial de episodios por tiempo, agente o canal
`plur_ingest`	Extrae engramas de texto automáticamente
`plur_sync`	Sincroniza vía git. Los remotos `personal` reflejan todo (usa un repositorio privado); los remotos `shared` reciben solo engramas de alcance compartido y no privados
`plur_status`	Verifica salud del sistema y conteos de engramas
`plur_receipt`	Informe local y contado de lo que tu memoria recuperó para ti
`plur_outbox`	Inspecciona (y reintenta) escrituras de equipo en cola mientras su almacén estaba inaccesible

La bandeja de salida

Una escritura a un alcance de equipo va al almacén remoto de ese equipo. Cuando el almacén no puede ser alcanzado — VPN apagada, servidor caído, token expirado — el engrama no se pierde y no se descarta silenciosamente: se escribe localmente con metadatos de cola y se reintenta en el próximo inicio de sesión, en plur sync, o bajo demanda.

La cola no es un directorio. Vive como structured_data._outbox dentro de los engramas afectados en engrams.yaml, por lo que necesita un comando para verse:

plur outbox            # what is queued, for which scope, how long, last error
plur outbox --flush    # retry now

Lo mismo está disponible para agentes como plur_outbox ({flush: true} para reintentar), y plur status reporta el conteo pendiente. Ninguna superficie imprime la URL de destino o el token.

El recibo de memoria

plur receipt (y la herramienta MCP plur_receipt) muestran lo que tu memoria realmente hizo — contado desde el historial de recuperación propio de PLUR, nunca estimado:

Your Memory Receipt
===================
  2026-07-03 .. 2026-07-22  (71 sessions)

  423 times a memory you taught PLUR
  was put in front of the model.
  (plus 45 times an installed-pack memory)

  across 71 retrievals in 71 sessions
  drawing on 162 distinct engrams

  MOST-RELIED-ON
      34x  PLUR positioning thesis across every vertical: PLUR layers …
      28x  Datacore app CoS architecture: reasoning layer added on to…
      ...

  STORE HEALTH
       4,517   engrams stored (you: 3,746, packs: 771)
         162   retrieved at least once (4% of store)
       4,355   not retrieved since 2026-07-03 (96%)
    Over a short logging window a low rate is expected, not a fault —
    memory is meant to be selective, and much of the store predates logging.

(Las estadísticas de REUSE y las advertencias de cobertura también se muestran; recortadas aquí por longitud.)

Es local y de solo lectura, y no lleva cifra de dólares o tokens por diseño: en una suscripción tu costo marginal de tokens es cero, y el valor de evitar un redescubrimiento no es medible desde estos datos. El recibo reporta solo lo que puede contar. La tasa de activación es cobertura del almacén sobre la ventana de registro, no una puntuación de calidad — es naturalmente baja y cae a medida que agregas engramas. --days N reduce la ventana; --json emite la forma cruda. (La herramienta MCP plur_receipt devuelve las mismas cifras más una línea summary que lleva este marco al agente.)

Sincronización entre dispositivos

plur.sync(remote) es git por debajo: hace commit de tu almacén de engramas y lo empuja al remoto que le des. Lo que se empuja depende del tipo declarado del remoto (sync.remote_type en config.yaml, o el argumento remote_type):

personal (predeterminado) — tu propia copia de seguridad/espejo entre tus máquinas. El remoto recibe todo lo que se empuja, incluyendo engramas visibility: private: visibilidad privada significa "no compartas esto en un paquete", no "no lo reflejes a mis propios dispositivos", así que los engramas privados intencionalmente te siguen de máquina a máquina. Por eso, siempre usa un remoto git privado (un repositorio privado de GitHub/GitLab, o tu propio servidor). PLUR muestra un warning en el resultado de sincronización siempre que haya engramas privados presentes. Nunca apuntes una sincronización personal a un repositorio público.
shared — un remoto visible para el equipo. Solo se empujan engramas con alcance de familia compartida (group:/project:/space:/team:/org:/public) y visibilidad no privada; los engramas de familia personal (local, global, user:*, agent:*) y los de visibilidad privada nunca llegan al remoto, por construcción. Nota que la visibilidad predeterminada es private, así que un remoto compartido recibe solo engramas cuya visibilidad se estableció deliberadamente — los compañeros de equipo obtienen lo que elegiste compartir, nada más. La misma garantía cubre los archivos de almacén hermanos (#686): un episodio, candidato o registro de tensión se empuja solo cuando cada engrama que referencia está a su vez en el conjunto de empuje — los registros derivados de engramas personales o privados (instantáneas de declaración de una tensión, episodio de informe de fallo) permanecen locales, al igual que cualquier registro que referencie un engrama que el filtro no puede resolver.

En ambos modos, los engramas scope: local son específicos de máquina por diseño (rutas, puertos locales, peculiaridades por host), así que se eliminan de cada commit y nunca llegan a ningún remoto. La eliminación ocurre en el blob preparado: tu copia de trabajo local siempre conserva cada engrama.

Detalles de referencia

Recuperación por categoría, de una ejecución anterior en el repositorio — LongMemEval-S completo (N=500), completamente local (BGE-small + BGE-reranker-v2-m3, granularidad de fragmentos). Su cifra general (98.0%) es anterior a la medición actual de plur-bench del mismo stack (97.6%) y no se ha vuelto a ejecutar por categoría; trata la forma como indicativa y la tabla principal anterior como actual.

Categoría	R@5	R@10
asistente-de-una-sesión	100.0%	100.0%
actualización-de-conocimiento	100.0%	100.0%
usuario-de-una-sesión	98.6%	100.0%
multi-sesión	98.5%	100.0%
razonamiento-temporal	97.7%	98.5%
preferencia-de-una-sesión	86.7%	90.0%
general	98.0%	99.0%

La recuperación (encontrar la memoria correcta) y la precisión de respuesta final (si el modelo responde correctamente) son ejes diferentes — PLUR los mide y reporta por separado, nunca los mezcla. Las cifras de impacto en el agente provienen de una ejecución A/B de la misma tarea (memoria vs sin memoria).

Metodología completa →

PLUR vs otras herramientas de memoria para agentes

Mem0, Letta (MemGPT) y Zep resuelven problemas reales — una API de memoria plug-and-play (Mem0), un sistema operativo de agente autogestionado (Letta), un grafo de conocimiento temporal (Zep). La apuesta de PLUR es una combinación que ninguno de ellos ofrece junto:

Texto plano que posees — los engramas son YAML legible por humanos que puedes leer, git diff, editar y eliminar de forma verificable. No vectores opacos, bloques de estado de agente o nodos de grafo que necesiten herramientas para inspeccionar.
Local-primero, costo cero — BM25 híbrido + embeddings locales, completamente offline, sin factura de API (98% R@5 en el corpus completo de LongMemEval-S sin llamada en la nube — ver arriba).
Compartible en equipo vía git — plur sync es git por debajo, así que la misma memoria te sigue entre máquinas y entre un equipo. La mayoría de las herramientas son de un solo usuario local o de equipo en la nube; PLUR es ambas, y tú conservas los datos.
Multi-herramienta — el mismo almacén ~/.plur/ funciona en Claude Code, Cursor, Windsurf, OpenClaw y Hermes. Tu memoria no está atrapada en un solo proveedor.
Aprende y olvida — recuperación entrenada con retroalimentación con decaimiento ACT-R y un escaneo de contradicciones bajo demanda, no un almacén que crece para siempre.

Si necesitas una API de memoria alojada o un grafo de conocimiento temporal, usa la herramienta construida para eso. Si quieres memoria que puedas leer, poseer, compartir con tu equipo y mover entre herramientas, eso es PLUR. Detalle lado a lado: comparaciones/.

Qué es PLUR — y qué no es

PLUR es memoria de agente — almacena correcciones, preferencias, convenciones y decisiones arquitectónicas que un agente de IA aprende durante sesiones de trabajo, y las inyecta de vuelta cuando son relevantes.

PLUR no es un motor de búsqueda de propósito general, un indexador de código base, ni un reemplazo para herramientas de inteligencia de código. No analiza ASTs, navega jerarquías de clases ni busca en tus archivos fuente. Si necesitas búsqueda consciente del código (tree-sitter, características de servidor de lenguaje, búsqueda de símbolos), herramientas como claude-mem o la búsqueda integrada de tu IDE son la opción correcta.

Los dos son complementarios:

	PLUR	Herramientas de inteligencia de código
Almacena	Conocimiento aprendido (engramas) + línea de tiempo de eventos (episodios)	Estructura de código, símbolos, definiciones
Búsqueda	Recuperación de engramas (BM25 + embeddings sobre memoria)	Recorrido de AST, búsqueda de símbolos, búsqueda semántica de código
Aprende	De correcciones de agentes, retroalimentación, patrones de uso	Del análisis estático del código fuente
Captura	Extrae automáticamente aprendizajes de conversaciones (vía plugins)	N/A
Decae	Sí — las memorias no usadas se desvanecen (modelo ACT-R)	No — el índice de código refleja el estado actual
Línea de tiempo	Los episodios rastrean qué pasó y cuándo (incidentes, correcciones, decisiones)	Solo registro de git
Multi-herramienta	Cualquier cliente MCP (Claude Code, Cursor, Windsurf, OpenClaw, Hermes)	Típicamente ligado a una herramienta

Aunque la búsqueda es una parte central de PLUR (encontrar el engrama correcto para inyectar), los objetivos de búsqueda son siempre engramas — no archivos, no código, no documentos. La búsqueda híbrida de PLUR (BM25 + embeddings + RRF) está optimizada para afirmaciones cortas en lenguaje natural, no para código fuente.

Paquetes

Paquete	Descripción
`@plur-ai/core`	Motor Engram — aprender, recordar, inyectar, buscar, decaer
`@plur-ai/mcp`	Servidor MCP para Claude Code, Cursor, Windsurf
`@plur-ai/claw`	Plugin OpenClaw ContextEngine
`@plur-ai/cli`	CLI — plur learn / recall / inject / status
`@plur-ai/dsh`	Plugin DeepSeek Harness — engrams en el prompt, sin llamada a herramienta
`@plur-ai/opencode`	Plugin opencode — engrams en el prompt, sin llamada a herramienta
`@plur-ai/migrate`	Migraciones de almacenamiento, incluidas con la versión a la que migran
`plur-hermes`	Plugin Hermes Agent (Python, mediante puente CLI)
`plur-ai`	SDK de Python — learn/recall/inject para LangChain, llama.cpp, scripts
`plur-langchain`	Adaptador LangChain BaseMemory + BaseChatMessageHistory

packages/ui es interno — las páginas del visor de memoria, incluidas en la CLI y el plugin DeepSeek Harness en lugar de publicarse. No está en npm.

Arquitectura

@plur-ai/core
├── engrams.ts           Engram CRUD + YAML persistence
├── episodes.ts          Episode capture + timeline queries
├── fts.ts               BM25 with IDF, TF saturation (k1/b), length normalization
├── embeddings.ts        BGE-small-en-v1.5, 384-dim, local ONNX
├── hybrid-search.ts     Reciprocal Rank Fusion
├── inject.ts            Context-aware selection + spreading activation
├── decay.ts             ACT-R activation decay
├── secrets.ts           Secret detection (API keys, passwords, tokens)
├── sync.ts              Git-based sync + file locking (O_EXCL)
├── storage.ts           Path detection + YAML I/O
└── storage-indexed.ts   Optional SQLite read index

@plur-ai/mcp          Wraps core as MCP tools
@plur-ai/claw          OpenClaw ContextEngine hooks (assemble/compact/afterTurn)
plur-hermes            Python plugin for Hermes Agent (auto inject/learn)
plur-ai                Python SDK — direct learn/recall/inject for scripts and frameworks

Almacenamiento

Todo es YAML plano. Ábrelo, léelo, edítalo.

~/.plur/
├── engrams.yaml     # learned knowledge (source of truth)
├── episodes.yaml    # session timeline
├── config.yaml      # settings
└── engrams.db       # optional SQLite read index (auto-generated)

PLUR_PATH anula la ubicación predeterminada.

La indexación está activada por defecto (index: true) y el backend se elige según el tamaño de tu almacenamiento, por lo que normalmente no hay nada que configurar:

Tamaño del almacenamiento	Backend	Qué responde a una consulta
menos de 5,000 engrams	`yaml`	BM25 en memoria + coseno exacto
5,000 y más	`pglite`	Postgres integrado + pgvector
50,000 y más	`postgres`	un servidor Postgres al que lo apuntas — BM25 en SQL; puntuaciones de recuerdo semántico en memoria (ver más abajo)

YAML sigue siendo la fuente de verdad en todos los niveles excepto postgres (ADR-0001, ADR-0005) — el índice es una caché que se reconstruye automáticamente, y puedes eliminarlo en cualquier momento. Establece backend: en config.yaml para fijar un nivel explícitamente.

Una advertencia sobre el nivel postgres, indicada aquí porque es la fila principal de esta tabla: el núcleo no escribe embeddings en un almacenamiento principal Postgres (enmienda ADR-0005). El recuerdo por palabras clave/BM25 se ejecuta en SQL, pero engram_embeddings permanece vacío a menos que tu despliegue lo complete, por lo que el recuerdo semántico e híbrido recurre a cargar engrams y puntuar en memoria — resultados correctos, al costo O(N) que este nivel evita de otro modo. El adaptador lo indica una vez al inicializar el esquema; vectorIndex: 'exact' lo reconoce y lo silencia.

sqlite (engrams.db, mediante better-sqlite3) es el índice heredado y ya no se selecciona automáticamente.

Requisitos

Node.js 18+
2GB de RAM como mínimo — el modelo de embeddings (runtime ONNX) necesita ~1GB para la instalación. En servidores con menos RAM, los embeddings se omiten y la búsqueda recurre a la coincidencia de palabras clave BM25.

Desarrollo

git clone https://github.com/plur-ai/plur.git
cd plur
pnpm install && pnpm build && pnpm test

~3500 pruebas en ~200 archivos. pnpm test:watch para desarrollo.

Contribuciones

Informes de errores — issue con pasos de reproducción
Solicitudes de funciones — issue que describa el caso de uso
Código — fork, rama, PR. Pruebas requeridas.
Integraciones — construye soporte PLUR para otras herramientas

Antes de enviar: pnpm test pasa, pnpm build tiene éxito, sin nuevas dependencias externas en el núcleo sin discusión.

Convenciones: TypeScript, validación Zod, Vitest, sin APIs externas en el núcleo, almacenamiento YAML, búsqueda de costo cero por defecto.

Licencia

Apache-2.0