Linksee Memory

linksee-memory

Tu agente lo olvida todo cuando termina una sesión. Peor aún: se desvía silenciosamente de lo que decidiste la semana pasada.

Linksee Memory detecta cuando tu proyecto se desvía de sus propias decisiones — la opción abandonada en una bifurcación, el pipeline que se detuvo silenciosamente, el código que contradice lo que acordaste — y un guardián de reinyección vuelve a sacar a la superficie la decisión bloqueada antes de que el agente actúe. Las reglas que has endurecido explícitamente quedan bloqueadas.

Debajo hay un MCP de memoria local-first y multi-LLM — un solo archivo SQLite del que Claude Code, Cursor, Windsurf, OpenAI Codex y Gemini CLI leen. No solo "qué pasó" sino POR QUÉ: memoria estructurada en 6 capas con recuperación de precisión y una caché de diff consciente de AST (50–99% de ahorro de tokens en relecturas).

npx -y linksee-memory setup — un comando, listo.

🌐 Página de aterrizaje: linksee-site.vercel.app (incluye incorporación para no desarrolladores en Claude Desktop / Cursor / Claude Code / OpenAI Codex / Gemini CLI) 📖 Documentación: docs.linksee.app — referencia completa: el mapa del producto y la deriva, instalación y las 11 herramientas

🪄 Tres hechizos para recordar

Hazlo automático: añade "Usa Linksee Memory" a tu prompt de sistema / CLAUDE.md.

🗺️ No solo memoria — un mapa del producto

La memoria es el punto de entrada. Conéctala a un map.yaml de cómo encaja tu producto, y el CLI linksee-memory map detecta la deriva con evidencia archivo:línea:

La demo de 30 segundos de arriba: el README dice --export. El código no. Linksee lo detecta — y muestra qué más tocaría un cambio.

npx -y linksee-memory map where README.md   # this file belongs to the README node — and what it touches
npx -y linksee-memory map explain readme    # README promises --export; the code doesn't implement it — drift, with evidence
npx -y linksee-memory map affects readme    # changing the README also touches docs, the CLI help, and the npm listing

→ ver El Mapa para el flujo completo.

📣 Como se ha visto en

• Zenn: Tu Claude Code, en realidad olvida por completo la sesión anterior — 73 ♡ en Zenn, 165+ usuarios en Hatena Bookmark, recogido por blogs de tecnología + shorts de YouTube (mayo de 2026)
• Zenn: Tu servidor MCP, en realidad solo usa Tools (implementación completa de 5 bloques / v0.3.0) — el 1% de los servidores MCP que implementan los 5 bloques
• Zenn: Tu memoria de Claude, en realidad solo queda en Claude (método para cruzar 5 LLM) — patrón de memoria entre LLM (12 de mayo de 2026)
• Zenn: La historia de estar detenido 3 semanas en el listado de Glama (5 trampas y soluciones) — retrospectiva de despliegue en npm + Glama

「Cordex/Cursor/Code/Gemini 全部につなげられるから、 横断的にできてる MCP ってところがこれのすごいところ」 — Hatena Bookmark, mayo de 2026 (165+ usuarios)

🎬 Vélo en acción

Deriva, detectada. Las decisiones no sobreviven los límites de sesión — pero sus consecuencias sí. Pregunta a cualquier sesión:

You:    What's drifting right now?
Agent:  [calls drift_status]

        28 anchors: ⚪ 1 held · 🔵 27 aligned

        Needs attention:
        ⚪ HELD — "Focus on 4 areas: Recipe layer, agent-native API,
           Japanese market, Agent Insights"
           ↻ Reopens 2026-07-04

        Everything else is aligned — no unaccounted divergence.

La memoria subyacente. La detección de deriva solo funciona porque el por qué sobrevive al límite de sesión:

Sin linksee-memory — lunes por la mañana, nueva sesión de Claude:

You:    We deployed last week but it crashed. How did we fix it?
Claude: I don't have access to previous sessions. Can you describe
        what happened and walk me through the problem?

[30 minutes of log-spelunking and re-explanation]

Con linksee-memory — misma pregunta, resultado diferente:

You:    We deployed last week but it crashed. How did we fix it?
Claude: Let me check my caveats...

        🧠 [caveat] NextAuth sessions invalidate when JWT_SECRET
           rotates — redeploy all affected projects in parallel.
           (from session 2026-04-13, importance: 0.9)

        Is this the deploy you're asking about? We hit it when
        we rotated secrets mid-flow.

You:    Yes, exactly. Let's not repeat that.

Esa única memoria caveat es lo que separa "almacenamiento plano de hechos" de "el agente realmente recuerda el POR QUÉ". linksee-memory lo almacena en seis capas explícitas para que la recuperación siga siendo explicable.

🔍 Detección de deriva — "Datadog de intenciones"

La mayoría de los equipos toman decisiones y luego las olvidan. El agente de la semana pasada decidió "usaremos FTS5 en lugar de búsqueda vectorial" — pero esta semana una nueva sesión instala pgvector sin saber por qué se rechazó eso. Eso es deriva. No es un error. No es malicia. Solo contexto olvidado.

Las herramientas de memoria recuerdan lo que hiciste. Nada nota cuando te desvías de lo que decidiste — esa es la capa que añade Linksee Memory. Piensa en "Datadog para decisiones de producto": las divergencias no contabilizadas salen a la superficie como deriva, la evolución intencional (registrada como supersede/fix) permanece en silencio.

Cómo funciona

1. Declara decisiones como anclas: declare_anchor({ kind: "decision", statement: "We use FTS5, not vector search", violation_signal: ["pgvector", "embedding"] })
2. El motor detecta cuando la realidad del código comprometido diverge de estas anclas
3. La derivación de estado clasifica cada ancla:
   • 🔴 Deriva — la realidad diverge sin resolución registrada
   • 🟡 Revisión — una señal suave espera tu decisión
   • ⚪ En espera — reconociste la brecha, la aparcaste con una fecha de revisión
   • 🔵 Alineado — la realidad coincide con la intención, o una resolución registrada explica el cambio
4. Resuelve con fix, supersede, acknowledge o dismiss — más dos compuertas: harden (PreToolUse bloqueará) y soften (de vuelta a una advertencia)

La regla decisiva: una divergencia contabilizada por una resolución registrada (supersede/fix/acknowledge) NO es deriva. Solo se marcan las brechas no contabilizadas. Esto significa que la evolución intencional permanece en silencio mientras que el abandono silencioso se detecta.

Taxonomía de 4 especies

Las anclas se clasifican en cuatro especies con diferentes formatos de visualización:

🗺️ El Mapa — linksee-memory map

La detección de deriva (arriba) verifica anclas individuales. El Mapa lo eleva a todo el producto: un map.yaml que describe cómo el valor llega a tu usuario (discover → understand → try → adopt → retain → monetize → expand), con dependencias tipadas entre las piezas — README, listado npm, incorporación, el motor que las impulsa. El reconciliador verifica ese mapa contra tu código real, y el CLI responde la pregunta que un ingeniero realmente tiene:

Estoy tocando este archivo — ¿dónde está en el mapa y qué más debe moverse?

1. ¿Dónde estoy? — localiza un archivo (o, sin argumento, infiere de tus ediciones recientes):

$ npx -y linksee-memory map where README.md
"README.md" belongs to this Map node:

  readme  [understand]  convergence
    changes ripple to:
      must fix together (hard):  lp, docs-site
      should align (soft):       onboarding, client-configs
      fyi (may ripple):          telemetry-contract

El radio de explosión está graduado — must fix together vs should align vs fyi — para que una onda amplia no sea ruido plano.

2. ¿Por qué está en este estado? — el diagnóstico, con evidencia archivo:línea:

$ npx -y linksee-memory map explain readme

STATUS
  declared: healthy (active)
  reality:  implemented / matches
  verdict:  declared and reality agree (verified)

EVIDENCE
  ✓ README's Tools section lists where_am_i
      README.md:424 — found "where_am_i" in section "Tools"

El estado declarado y el veredicto de realidad se muestran por separado — un suspect declarado a mano que el escáner refuta se lee como "declarado sospechoso, refutado por la realidad (→ convergencia)", no una mezcla confusa.

3. Triage de todo el proyecto: npx -y linksee-memory map status — un % de salud, qué es reparable ahora en código vs verificaciones externas, y cualquier aplazamiento sin fecha de vencimiento (para que "contabilizado" no se convierta silenciosamente en un cementerio de deriva).

Cómo funciona

• map.yaml (raíz del repositorio) es la fuente de verdad del estado deseado: una columna vertebral de viaje × capas de superficie/implementación × bordes tipados (must-stay-consistent-with / should-align-with / realizes).
• reconcile verifica el reality declarado de cada nodo contra el código (signal / regex / section_contains / verificaciones de archivos) y superpone un veredicto — la realidad anula lo que declaraste a mano, con evidencia.
• where_am_i también es una herramienta MCP, para que un agente de codificación pueda re-anclarse a mitad de tarea.

Comandos: where · affects · explain · status · next · reconcile · inspect --json · blueprint. Añade --lang ja para etiquetas en japonés.

🛡 Guardián de reinyección — hacer cumplir las decisiones antes de la acción

La detección de deriva (arriba) es post-hoc — te dice que la realidad divergió después de que el cambio aterrice. El guardián de reinyección es la mitad pre-acción: vuelve a sacar a la superficie la decisión que bloqueaste antes de que el agente ejecute la herramienta que la rompería.

Existe para un modo de fallo específico y exasperante (anthropics/claude-code#15443): "Claude leyó la regla, la entendió y aun así usó cp." Tener la regla en el contexto no es suficiente — así que el guardián se ejecuta fuera de la voluntad del agente, como un hook de Claude Code:

Es fail-open por construcción: cualquier error de parseo / BD / lógica no saca nada a la superficie y deja pasar la acción. Lo único que alguna vez bloquea es una contradicción explícita hard en una decisión que tú declaraste.

Actívalo

npx -y linksee-memory setup ofrece conectarlo al .claude/settings.json de tu proyecto (Paso 4). Para hacerlo a mano, coloca este bloque en .claude/settings.json en la raíz de tu proyecto — apunta al binario linksee-memory-guard instalado globalmente, así que no se necesita paso de compilación:

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup|resume|compact",
        "hooks": [
          { "type": "command", "command": "npx -y linksee-memory guard", "timeout": 15 }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Edit|Write|Bash",
        "hooks": [
          { "type": "command", "command": "npx -y linksee-memory guard", "timeout": 8 }
        ]
      }
    ]
  }
}

Es deliberadamente a nivel de proyecto — el guardián hace cumplir las decisiones de este repositorio, y optas por participar por proyecto en lugar de dejar que deniegue llamadas de herramientas en todas partes (el hook Stop de la configuración, por el contrario, es global de usuario). Declara lo que debe vigilar con declare_anchor(...); establece card_policy.gate_mode:'hard' en una ancla para que una contradicción bloquee en lugar de solo advertir (el valor suave por defecto solo reinyecta). Las anclas obsoletas (at_risk), superadas o deshabilitadas por tarjeta nunca bloquean.

¿Desarrollando linksee-memory en sí? El repositorio usa el guardián en modo dogfooding a través de un .claude/settings.json (ignorado por git) que apunta a la compilación local (node ${CLAUDE_PROJECT_DIR}/dist/bin/guard-hook.js) para que se ejecute contra tus cambios no confirmados. Los proyectos de usuarios finales deben usar la forma publicada npx -y linksee-memory guard de arriba.

Qué hace

La mayoría de los servicios de "memoria de agente" (Mem0, Letta, Zep) guardan una lista plana de hechos. Luego el agente mira "archivo editado X 30 veces" y no tiene idea de por qué. Y ninguno de ellos nota cuando el trabajo de esta semana contradice la decisión de la semana pasada. linksee-memory mantiene el POR QUÉ — y vigila la deriva.

Es un servidor de Model Context Protocol (MCP) con 11 herramientas que da a cualquier agente de IA memoria estructurada + detección de deriva:

Cuatro pilares

1. Detección de deriva — declara decisiones como anclas, luego el motor detecta automáticamente cuando la realidad comprometida diverge de la intención declarada. Piensa en "Datadog para decisiones de producto" — las divergencias no contabilizadas salen a la superficie como deriva, la evolución intencional (registrada como supersede/fix) permanece en silencio.
2. Portabilidad entre agentes — archivo SQLite único en ~/.linksee-memory/memory.db. El mismo cerebro para Claude Code, Cursor, Windsurf, OpenAI Codex, Gemini CLI.
3. Memoria estructurada con POR QUÉ primero — seis capas explícitas (goal / context / emotion / implementation / caveat / learning). Resuelve "la memoria plana de hechos es inútil sin objetivos".
4. Ahorro de tokens vía read_smart — sha256 + fragmentación por AST/encabezados/indentación. Las relecturas devuelven solo diffs. Medido 86% ahorrado en una edición típica de archivo TS, 99% ahorrado en relecturas sin cambios.

🧠 La estructura de 6 capas

┌─────────────────────────────────────────────────────────────┐
│ 🎯 goal           ← what the user is working toward         │
├─────────────────────────────────────────────────────────────┤
│ 🧭 context        ← why this, why now — constraints, people │
├─────────────────────────────────────────────────────────────┤
│ 💗 emotion        ← user tone signals (frustration, etc.)   │
├─────────────────────────────────────────────────────────────┤
│ 🛠  implementation ← how it was done (+ what failed)         │
├─────────────────────────────────────────────────────────────┤
│ ⚠️  caveat         ← "never do this again" · auto-protected │
├─────────────────────────────────────────────────────────────┤
│ 🌱 learning       ← patterns distilled from cold memories   │
└─────────────────────────────────────────────────────────────┘
                            │
                            ▼
           Ranked recall via relevance × heat × momentum × importance
                  Returns match_reasons explaining each hit

Cada memoria está etiquetada con exactamente una capa. Las entradas de la capa caveat están protegidas contra el olvido automático. Las memorias frías de baja importancia se consolidan automáticamente en entradas de learning al iniciar el servidor.

Inicio rápido — Un solo comando

npx -y linksee-memory setup

Esto hace todo:

1. Registra el servidor MCP con Claude Code
2. Instala la habilidad del agente (enseña al agente cuándo recordar/recordar)
3. Configura la captura automática (cada sesión se guarda en tu cerebro local)
4. Ofrece conectar el guardia de reinyección en este proyecto (aplicación de decisiones previas a la acción)

Reinicia Claude Code y luego simplemente chatea con normalidad. Añade "Usa Linksee" a cualquier mensaje para activar el recuerdo de memoria.

Configuración manual (si prefieres paso a paso)

claude mcp add -s user linksee -- npx -y linksee-memory

npx -y linksee-memory install-skill

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          { "type": "command", "command": "npx -y linksee-memory sync" }
        ]
      }
    ]
  }
}

Otros editores / CLIs

Linksee Memory es un servidor MCP estándar (stdio). Cualquier herramienta que hable MCP puede conectarse:

{
  "mcpServers": {
    "linksee": {
      "command": "npx",
      "args": ["-y", "linksee-memory"]
    }
  }
}

{
  "mcpServers": {
    "linksee": {
      "command": "npx",
      "args": ["-y", "linksee-memory"]
    }
  }
}

codex mcp add linksee -- npx -y linksee-memory

[mcp_servers.linksee]
command = "npx"
args = ["-y", "linksee-memory"]

{
  "mcpServers": {
    "linksee": {
      "command": "npx",
      "args": ["-y", "linksee-memory"]
    }
  }
}

{
  "mcpServers": {
    "linksee": {
      "command": "npx",
      "args": ["-y", "linksee-memory"]
    }
  }
}

Todos los editores comparten el mismo ~/.linksee-memory/memory.db. Una decisión tomada en Claude Code se recuerda en Cursor. Una advertencia registrada en Windsurf evita el mismo error en Codex.

Ubicación de la base de datos

Predeterminado: ~/.linksee-memory/memory.db. Sobrescribe con la variable de entorno LINKSEE_MEMORY_DIR.

Desinstalación

# 1. Remove the MCP server registration
claude mcp remove linksee

# 2. Remove the hooks from settings.json (edit the file, delete the linksee entries):
#    ~/.claude/settings.json          → the Stop hook running "npx -y linksee-memory sync"
#    <project>/.claude/settings.json  → the SessionStart/PreToolUse hooks running "npx -y linksee-memory guard"

# 3. Remove the installed skill and all local memory (optional)
rm -rf ~/.claude/skills/linksee-memory
rm -rf ~/.linksee-memory   # deletes all stored memory — nothing is kept anywhere else

Nada sale nunca de tu máquina, así que el paso 3 borra por completo todo lo que Linksee almacenó.

Novedades en v0.9

Novedades en v0.8

11 Herramientas

Herramientas de memoria

Herramientas de deriva (v0.8.0)

Herramientas de punto de bifurcación (v0.10)

Las versiones anteriores exponían 3 herramientas — v0.8.0 añadió 4 herramientas de deriva que permiten a los agentes consultar y actuar sobre la divergencia intención ↔ realidad a nivel de producto; v0.10 añadió el trío de puntos de bifurcación para el triaje de propuestas huérfanas; where_am_i añade el re-anclaje posicional por turno del Mapa de Verdad Actual. Las herramientas de memoria no han cambiado.

Utilidades CLI

Las 6 capas de memoria

Cada entidad (persona / empresa / proyecto / archivo / concepto) puede tener memorias en seis capas. Desde v0.4, cada memoria usa el formato estructurado de 3 ejes (altitud × tipo × estado):

{
  "title": "freee OAuth token expires in 24h",
  "altitude": "implementation",
  "type": "outcome",
  "state": "done",
  "what": "freee OAuth token expires in 24 hours. Must refresh proactively.",
  "why": "freee uses short-lived tokens unlike most SaaS (usually 30-90 day expiry)",
  "affects": ["src/integrations/freee/auth.ts"],
  "next_action": null
}

• Las memorias de caveat están protegidas automáticamente contra el olvido (lecciones dolorosas, nunca se pierden).
• Las memorias de goal evitan la decadencia mientras el objetivo está activo.
• state rastrea el ciclo de vida: open → decided → in_progress → done / stalled / superseded.

Arquitectura

Un solo archivo SQLite (better-sqlite3 + tokenizador de trigramas FTS5 para JP/EN) contiene cinco capas:

• Capa 1 — entities (hechos: personas / empresas / proyectos / conceptos / archivos)
• Capa 2 — edges (asociaciones, adyacencia de grafo)
• Capa 3 — memories (significados estructurados de 6 capas por entidad)
• Capa 4 — events (registro de series temporales para cálculo de calor / impulso)
• Capa 5 — file_snapshots + session_file_edits (caché de diff + vinculación conversación↔archivo)

La vinculación conversación↔archivo es la clave. Cada edición de archivo capturada por el hook de Stop se almacena junto con el mensaje del usuario que impulsó la edición. Así, recall({ path: "server.ts" }) devuelve "este archivo fue editado 30 veces en 3 días, y aquí están las instrucciones reales del usuario que motivaron cada cambio".

Por qué estas decisiones de diseño

• Local primero — tu historial de conversaciones es privado. Nada sale de tu máquina.
• Archivo único — memory.db es un artefacto portátil. Copia de seguridad = copia del archivo.
• MCP stdio — funciona con cada agente que hable MCP, sin plugins por host.
• Reutiliza esquemas probados — heat_score / momentum_score portados de un código base de inteligencia de ventas en producción. Basado en reglas, sin dependencia de LLM en la ruta crítica.

Hoja de ruta

• ✅ Superficie unificada de 3 herramientas (remember / recall / read_smart) — v0.7.0
• ✅ Auto-consolidación al iniciar el servidor — v0.7.0
• ✅ Plugin de Claude Code (claude plugin add -- linksee-memory)
• ✅ Cinco bloques MCP (Herramientas + Recursos + Prompts + Sampling + Roots + Elicitation)
• ✅ Captura automática mediante stop-hook para Claude Code
• ✅ FTS5 de trigramas JP/EN
• ✅ Configuración con un solo comando (npx -y linksee-memory setup)
• ✅ Memoria estructurada v2 (clasificación de 3 ejes: altitud × tipo × estado)
• ✅ Multi-LLM: Claude Code, Cursor, Windsurf, OpenAI Codex, Gemini CLI
• ✅ Página de aterrizaje (linksee-site.vercel.app)
• ✅ Motor de detección de deriva + 4 herramientas MCP de deriva — v0.8.0
• ✅ Mapa de verdad de 4 especies (hipótesis/restricción/compromiso/fuente_de_verdad) — v0.8.0
• ✅ Panel con visualización del Registro de Decisiones
• 🔮 Plugin de Obsidian (leer mapa de verdad en tu bóveda)
• 🔮 Búsqueda vectorial mediante sqlite-vec (ya en dependencias, backend de incrustación pendiente)
• 🔮 Sincronización en la nube entre dispositivos (nivel Pro)

Comparación con la auto-memoria de Claude Code

Claude Code incluye una función de memoria integrada en ~/.claude/projects/<path>/memory/*.md — notas markdown planas para preferencias de usuario. linksee-memory lo complementa:

• auto-memoria = tu álbum de recortes de "recuerda que prefiero X"
• linksee-memory = cerebro estructurado entre agentes con caché de diff de archivos y el PORQUÉ de cada edición

Usa ambos.

Seguridad y privacidad

linksee-memory se ejecuta localmente y está diseñado para leer — y enviar — lo menos posible.

• Primero local. La memoria es un único archivo SQLite en ~/.linksee-memory/memory.db. Sin cuenta, sin nube, sin clave API.
• La telemetría es opcional y está DESACTIVADA por defecto. setup pregunta una vez; no se envía nada a menos que aceptes allí (o configures LINKSEE_TELEMETRY=basic). Incluso entonces nunca envía tu código fuente, contenido de archivos, prompts, conversaciones, nombres de entidades/proyectos ni la base de datos de memoria — solo contadores anónimos (detalles).
• Sin rastreo automático de repositorios. linksee lee: memoria que guardas explícitamente, tu map.yaml, los archivos específicos que señala una verificación de realidad del mapa, la base de datos SQLite local y — cuando se activa el stop hook — la transcripción de tu sesión de Claude Code (localmente, para capturar lo sucedido). No rastrea tu repositorio, lee .env/secretos/node_modules ni toca tu directorio personal por su cuenta.
• Transporte MCP limpio. El servidor escribe solo JSON-RPC en stdout; todos los registros van a stderr.
• Los hooks están documentados y se pueden eliminar. setup añade un stop hook (captura de sesión) y un hook de guardia opcional. No hacen llamadas de red por defecto, tienen límite de tiempo, fallan de forma abierta (un error de hook nunca interrumpe tu sesión) y se enumeran en Desinstalación.
• Sin superficie de inyección de shell. Los subcomandos se ejecutan mediante spawn con argumentos de matriz y shell: false, desde una lista de permitidos fija; map.yaml se analiza con el analizador seguro yaml (sin ejecución de etiquetas arbitrarias).
• Cadena de suministro. MIT, publicado desde un único propietario. npx -y linksee-memory ejecuta el paquete publicado — fija una versión en CI si necesitas reproducibilidad.

¿Encontraste un problema de seguridad? Consulta SECURITY.md.

Telemetría (opcional, desactivada por defecto)

linksee-memory incluye telemetría anónima opcional que nos ayuda a entender qué servidores MCP y flujos de trabajo funcionan realmente en el mundo real. No se envía nada a menos que lo actives explícitamente. Sin contenido de conversaciones, sin contenido de archivos, sin nombres de entidades, sin rutas de proyectos — nunca.

Activar

export LINKSEE_TELEMETRY=basic     # opt in
export LINKSEE_TELEMETRY=off       # opt out (or just unset the variable)
# `linksee-memory setup` also asks once and records your choice in
# ~/.linksee-memory/telemetry-consent (delete that file to be asked again).

Exactamente qué se envía (contrato de Nivel 1)

Después de que cada sesión de Claude Code termina, el stop hook envía un POST a https://linksee-site.vercel.app/api/telemetry/linksee que contiene solo estos campos:

Lo que NUNCA se envía:

• ❌ Mensajes de conversación (usuario o asistente)
• ❌ Contenido de archivos
• ❌ Nombres de entidades, nombres de proyectos, rutas de archivos, URLs
• ❌ Texto de la capa de memoria (objetivo / contexto / emoción / implementación / advertencia / aprendizaje)
• ❌ Tokens de autenticación, claves API, secretos
• ❌ Tu dirección IP (solo un hash unidireccional para detección de abuso)

Por qué preguntamos

Los datos agregados de uso de MCP ayudan al proyecto KanseiLink a clasificar qué integraciones de agentes funcionan realmente para desarrolladores reales. Si estás dispuesto a contribuir, LINKSEE_TELEMETRY=basic toma 1 segundo de configurar y ayuda a que todo el ecosistema MCP mejore.

El esquema completo del payload y la lógica de validación son de código abierto — lee src/lib/telemetry.ts si quieres verificar exactamente qué sale de tu máquina.

Precios

Gratis para siempre.

linksee-memory es primero local y se ejecuta completamente en tu máquina. No hay ningún componente alojado por el que debas pagar. La base de datos SQLite vive en tu directorio personal; la copia de seguridad = copia del archivo.

Sin cuenta, sin tarjeta de crédito, sin clave API. Solo instala y usa.

Solución de problemas

npx -y linksee-memory import --all

recall({ query: "...", max_tokens: 800 })   // default is 2000

recall({ query: "...", entity_name: "my-project", layer: "caveat" })

rm -rf ~/.linksee-memory   # nuke everything; next run creates a fresh DB

Preguntas frecuentes

Soporte

• Problemas e informes de errores: github.com/michielinksee/linksee-memory/issues
• Solicitudes de funciones: abre un issue con la etiqueta enhancement
• Preocupaciones de seguridad: consulta SECURITY.md si está presente, o presenta un aviso privado en GitHub
• Empresa: Synapse Arrows PTE. LTD. (Singapur)

Registro de cambios

v0.11.3 — Robustez + higiene de MCP (2026-06-16)

• Recuperación de base de datos corrupta: si ~/.linksee-memory/memory.db no se puede leer, linksee lo preserva como memory.db.corrupt-<timestamp> e inicia uno nuevo (con un mensaje claro) en lugar de fallar con un error SQLite crudo. Los recuerdos antiguos siguen siendo recuperables en la copia de seguridad.
• La descripción de la herramienta recall ya no sugiere editar tu prompt del sistema — mejor ciudadanía de MCP.

v0.11.2 — Más endurecimiento de arranque en frío (2026-06-16)

• stats funciona en una base de datos nueva en lugar de fallar con no such table — asegura que el esquema exista primero (puede ser el primer comando que ejecute un usuario nuevo).
• map --help imprime el uso en lugar de intentar importar un mapa.

v0.11.1 — Correcciones de arranque en frío (2026-06-16)

• Ejecuta cualquier CLI a través del nombre del paquete: npx -y linksee-memory setup (y map, sync, guard, stats, import, install-skill). Un usuario nuevo no podía acceder a los binarios independientes (linksee-memory-setup, …) mediante npx — npx resuelve nombres de paquetes, no nombres de binarios hermanos — por lo que la instalación de un solo comando daba 404. El binario principal ahora despacha subcomandos; los binarios independientes permanecen como alias.
• map sale correctamente con un mensaje de siguiente paso cuando aún no hay map.yaml (antes era un stack trace crudo — el estado exacto de un usuario de primera vez).
• serverInfo ahora informa la versión real del paquete (antes estaba fijado a una cadena antigua).

v0.11.0 — El Mapa: where_am_i + linksee-memory map (2026-06-15)

La memoria es el punto de entrada; el mapa del producto es la nueva superficie. La detección de desviación crece desde anclas individuales hasta un mapa de producto completo que navegas desde la CLI.

• where_am_i (11.ª herramienta MCP) — localiza el tema/archivo actual en el Mapa de Verdad Actual y obtén su radio de impacto. Llámala sin argumentos para auto-localizar desde tus ediciones recientes.
• CLI linksee-memory map — where · affects · explain · status · next · reconcile · inspect --json · blueprint. Un map.yaml (fuente de verdad de git) describe cómo el valor llega a tu usuario; el reconciliador lo verifica contra tu código con evidencia archivo:línea. Bilingüe: añade --lang ja.
• Radio de impacto graduado (must fix together / should align / fyi), veredictos declarado-vs-realidad, y un guardián anti-cementerio para la desviación contabilizada.
• Claves por proyecto para que el Mapa maneje muchos proyectos a la vez.

v0.8.0 — Herramientas MCP de detección de desviación (2026-06-08)

3 herramientas → 7 herramientas. La mayor actualización desde el lanzamiento — los agentes ahora pueden detectar, consultar y resolver la desviación intención ↔ realidad.

Nuevas herramientas:

• drift_status — devuelve el mapa de verdad con clasificación de 4 especies y estado de desviación por nodo
• check_decision — inmersión profunda en una sola ancla: estado, bordes, candidatos pendientes
• declare_anchor — registra una decisión/restricción/prohibición como nodo del mapa de verdad (con campos v9 de ProjectCoreNode)
• resolve_drift — cierra el bucle de retroalimentación: corregir / superar / reconocer / descartar

Nuevo módulo de motor:

• truth-engine.ts — lógica de derivación de estado migrada del panel al motor MCP. Cualquier cliente MCP ahora puede consultar el estado de desviación sin un panel.
• Corrección de prioridad de resolución: cuando múltiples resoluciones referencian la misma ancla, la más reciente gana (por marca de tiempo resolved_at). Evita que un reconocimiento obsoleto eclipse una corrección más nueva.
• Clasificación de 4 especies: nodos clasificados por decision_mode en hipótesis / restricción / compromiso / fuente_de_verdad con guía de formato de visualización.

Sin cambios disruptivos en las herramientas de memoria existentes. Las 3 herramientas de memoria (remember, recall, read_smart) no cambian.

v0.7.2 — Ergonomía de recall + detección automática de bordes + precisión del clasificador (2026-05-30)

Pase de calidad sobre v0.7.0 / v0.7.1 — UX de agente diario más nítida y datos más limpios para el panel:

• Disciplina de tokens recall: elimina el content_raw redundante de la respuesta (el content analizado ya estaba allí — era un duplicado 2×), y realmente aplica max_tokens mediante ensamblaje codicioso que mide el tamaño serializado real (antes era una estimación plana de ~100 tok/memoria). Añade approx_tokens a la respuesta para que el agente pueda ver su uso de presupuesto. La misma consulta que antes devolvía ~15,800 tokens para un presupuesto de 1200 ahora se mantiene dentro de él.
• Precisión de recall: recuerdos casi duplicados — misma entidad + texto central casi idéntico, p. ej. el mismo mensaje capturado bajo goal y learning — se colapsan a uno en el conjunto de resultados. Los pesos compuestos se adaptan a la especificidad de la consulta: las consultas de múltiples términos ponderan la relevancia más alto para que los recuerdos fijados pero fuera de tema no abarroten recalls estrechos.
• Deduplicación de captura (lado de escritura): session-extractor ahora produce COMO MÁXIMO un recuerdo por turno de usuario, con prioridad goal[first_intent] > caveat > decision > context. Un mensaje de primera intención que contenga palabras de decisión (p. ej. "決めた" / "これで進めよう") ya no se guarda dos veces como goal y learning.
• Detección automática de memory_edges: la tabla memory_edges previamente vacía ahora se puebla durante el barrido de consolidación en modo de suspensión. detectMemoryEdges() vincula un recuerdo DECISION posterior al recuerdo de decisión anterior más reciente del mismo tema dentro de una entidad (cadena, no camarilla) para que el panel pueda renderizar Cadenas de Pivote. La relación predeterminada es extends — una decisión posterior del mismo tema se basa en la anterior, pero NO la desactiva. Los marcadores de reversión explícitos (やめる / revert / instead of) producen contradicts; los marcadores de reemplazo explícitos (の代わり / replaces / deprecate) producen supersedes. Evita la desactivación silenciosa de decisiones aún válidas.
• Precisión de inferType / inferState: los acuses de charla trivial ("そうだね" / "ありがとう"), el contenido pegado de terminal/git/correo, y el meta-ruido ya no se clasifican como decision — devuelven note / open antes del coincidencia de patrones. El valor predeterminado de la capa de aprendizaje → decision está controlado por este guardián. Las decisiones reales (採用 / 決めた, incluso después de un abridor de acuse) sobreviven.

Sin migración de esquema, sin cambios disruptivos de API. Las filas existentes conservan su contenido almacenado; las mejoras del clasificador se aplican a nuevas capturas en adelante.

v0.7.1 — Correcciones de revisión (2026-05-29)

Basado en la revisión de diseño de Opus 4.7 de v0.7.0:

• P0 — Guía de parámetros requeridos: la descripción de la herramienta remember ahora incluye la sección "PARÁMETROS REQUERIDOS POR MODO" para que los LLM sepan exactamente qué campos se necesitan para crear vs actualizar vs eliminar.
• P0 — Guía de migración: los nombres de herramientas obsoletos (forget, recall_file, etc.) ahora devuelven ejemplos de migración específicos en lugar de errores genéricos.
• P1 — Fusión de ruta de recall + consulta: cuando tanto path como query se proporcionan a recall, los resultados del historial de archivos y la búsqueda de memoria se fusionan en una sola respuesta.
• P2 — Seguridad de auto-consolidación: verificación de existencia de tabla mediante sqlite_master antes de consultar la tabla consolidations, evitando errores en bases de datos nuevas.

v0.7.0 — Superficie unificada de 3 herramientas (2026-05-29)

8 herramientas → 3 herramientas. Siguiendo el patrón probado de Context7 de menos herramientas = mejor consistencia entre LLMs.

Cambio disruptivo: Las siguientes herramientas se eliminan de la superficie MCP. Llamarlas devuelve una guía de migración:

Nuevas herramientas unificadas:

• remember — crear + actualizar + eliminar en una sola herramienta. El modo se infiere de los parámetros.
• recall — búsqueda + historial de archivos + vista general en una sola herramienta. El modo se infiere de los parámetros.
• read_smart — sin cambios.

Otros cambios:

• Auto-consolidación al inicio del servidor (setTimeout no bloqueante, umbral de 7 días, verificación de seguridad sqlite_master)
• Paquete de plugin de Claude Code (claude plugin add -- linksee-memory)
• Los errores de obsolescencia incluyen ejemplos de migración específicos

Todas las funciones de manejo internas se conservan — esto es un cambio de superficie, no una reescritura de lógica.

v0.2.0 — Preparación para lanzamiento con inglés primero (2026-04-20)

Prepara el paquete para una audiencia más amplia (principalmente angloparlante) en Reddit, Hacker News y Discord de Anthropic. Sin cambios disruptivos de API.

• SKILL.md bilingüe (habilidad de invocación automática). La habilidad incluida que linksee-memory-install-skill copia en ~/.claude/skills/linksee-memory/SKILL.md estaba primero en japonés; ahora es principalmente en inglés con frases de activación en japonés preservadas en línea. Los hablantes de inglés ahora pueden activar la habilidad con frases naturales en inglés ("how did we solve this before?", "same error again", "remember this") además de los disparadores en japonés existentes.
• La salida CLI de instalación de habilidades es bilingüe: las frases de prueba de ejemplo mostradas después de la instalación incluyen tanto inglés como japonés.
• Cobertura EN del extractor de sesiones (linksee-memory-import): patrones de regex ampliados para decisiones, fallos y advertencias, de modo que los registros de sesión de Claude Code en inglés se etiqueten automáticamente correctamente. Las adiciones incluyen let's go, pivot, switch to, settled on, approved, doesn't work, stuck, same error again, hit an error, debug, broke, revert.
• Sugerencia de error de olvido de advertencias más clara: el mensaje anterior decía "lower importance below 0.9 first, then forget", lo cual era engañoso: las memorias de la capa de advertencias están permanentemente protegidas independientemente de la importancia. La sugerencia ahora distingue correctamente la protección por capa de la protección por fijación.
• Reelaboración del README para preparación de lanzamiento: se añadió un escenario de antes/después "See it in action", diagrama ASCII de 6 capas, insignias del Registro Oficial MCP + puntuación de Glama, enlace a la página de destino y un FAQ de 8 elementos que cubre preguntas que surgen durante lanzamientos públicos.
• Interno: SKILL.md ahora documenta el emparejamiento con la habilidad KanseiLink como ejemplo de flujo de trabajo en inglés.

No hay cambios de código en la superficie del protocolo MCP; todos los clientes MCP existentes siguen funcionando sin cambios.

v0.1.1 — Ajuste del umbral de fijación (2026-04-19)

Basado en comentarios del mundo real de que las memorias importance=0.95 no se trataban como fijadas a pesar de la intención.

• Umbral de fijación reducido de >= 1.0 a >= 0.9. Las memorias con importance >= 0.9 ahora están exentas del barrido de olvido automático y aparecen pinned: true en las respuestas de recall y remember. Esto coincide con el modelo mental natural ("0.9 = alta importancia = debería sobrevivir a la limpieza") sin requerir 1.0 exacto.
• Todas las memorias existentes con importance >= 0.9 (incluidas las más antiguas configuradas en 0.9 o 0.95) se fijan automáticamente, sin necesidad de migración.
• Descripciones de herramientas y mensajes de error actualizados para reflejar el nuevo umbral.

v0.1.0 — Actualización importante de UX (2026-04-18)

Basado en una semana de uso interno, esto es lo que cambió:

Nuevas herramientas

• update_memory — edición atómica con memory_id preservado. Resuelve el error "forget+remember breaks session_file_edits links".
• list_entities — primitiva rápida de "¿qué sé sobre?" para la inicialización de sesión. Admite filtros kind/min_memories y devuelve desglose por capas.
• npx -y linksee-memory stats — CLI de resumen de base de datos local.

Mejoras en recall

• Matriz match_reasons en cada memoria: p. ej. ["content_match_fts", "heat:hot", "pinned"].
• score_breakdown con puntuaciones por dimensión (relevancia / calor / impulso / importancia).
• Paginación mediante offset / has_more / stopped_by.
• Parámetro limit (límite máximo, complementa el presupuesto de max_tokens).
• Filtro band para solicitar solo memorias calientes/templadas/frías/congeladas.
• mark_accessed=false para consultas de vista previa que no deben aumentar el calor.
• Alias de capas: decisions → learning, warnings → caveat, how → implementation, etc.
• Corrección: actualización oportunista de puntuaciones de impulso de entidades obsoletas. Las entidades recordadas más de 1 h después del último remember() ya no devuelven impulso obsoleto.

Mejoras en remember

• Control de calidad: rechaza salida de asistente pegada / registros de CI / trazas de pila a menos que force=true.
• importance=1.0 ahora fija implícitamente la memoria (sobrevive al olvido automático).
• Se aceptan alias de capas.

Cambios en forget

• Las memorias fijadas (importancia=1.0) ahora se conservan junto con las memorias de la capa de advertencias.
• Respuesta de error clara al intentar eliminar una memoria protegida o inexistente.
• dry-run ahora incluye sample_ids_to_drop.

Cambios en consolidate

• Modo de vista previa dry_run: true — informa el número de clústeres y candidatos sin escribir.

Infraestructura

• Corregido el error de migración de base de datos nueva (consultaba la tabla meta antes de que existiera).
• Actualizado a Node 20+ para uso de características de lenguaje estructurado.

Todos los cambios son retrocompatibles: las integraciones existentes siguen funcionando. El banner de versión de Server.ts ahora informa v0.1.0.

Versiones anteriores

Ver GitHub Releases.

Licencia

MIT — Synapse Arrows PTE. LTD.