Linksee Memory

linksee-memory

Claude Code lo olvida todo cuando inicias una nueva sesión. Tu sucesor sabe aún menos.

Linksee Memory te permite entregar un proyecto — a tu próxima sesión, a Cursor o Codex, a la persona que te siga — con las razones adjuntas. Registra una decisión una vez (remember({ content, anchor: {} })) y vuelve antes de que el agente actúe sobre ella: se reinyecta al inicio de la sesión y antes de cada Edición / Escritura / Bash que la toque. Cambia de opinión sobre el registro y deja de insistir; déjalo y evita que el próximo agente repita el error de la semana pasada.

Por debajo: detección de deriva en todos los proyectos que ejecutas en paralelo — cuáles se alejaron silenciosamente de su objetivo (🔴), cuáles fueron verificados y se mantienen (🔵), cuáles nadie ha revisado aún (⚫). Un solo archivo SQLite local que Claude Code, Cursor, Windsurf, OpenAI Codex y Gemini CLI leen todos. Nada sale de tu máquina.

npx -y linksee-memory setup — un comando, activo en cada repositorio.

🌐 Página de inicio: linksee.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

Preguntas que esto responde

Estas son las preguntas que la gente realmente escribe — medidas, textualmente (2026-09-04). Si la tuya está aquí, esta es la respuesta.

Claude Code olvida todo cuando inicio una nueva sesión. ¿Cómo hago para que recuerde decisiones entre sesiones?
Ejecuta npx -y linksee-memory setup. Cada nueva sesión abre con recall() — un resumen de lo que necesita atención, dónde estás, qué está sin resolver — y tus decisiones bloqueadas se reinyectan antes de que el agente actúe. Nada que reexplicar.

Claude Codeがセッションをまたぐと過去の経緯を忘れてしまいます。記憶を持たせる方法を教えてください。
npx -y linksee-memory setup の一回で入ります。新しいセッションは recall() の brief（注意すべきこと・いまどこか・未解決）から始まり、固定した決定は行動の直前に再注入されます。説明し直す必要はありません。

¿Cuál es el mejor servidor MCP para memoria persistente entre agentes de codificación de IA?
Respuesta honesta: si "recordar entre sesiones" es todo lo que necesitas, un CLAUDE.md es suficiente — lo medimos. Linksee es para los tres momentos en que no lo es: justo antes de un error, cuando cambias de opinión, y cuando ejecutas muchos proyectos y necesitas ver cuál se desvió.

AIコーディングエージェント用の記憶MCPサーバーでおすすめはありますか？
正直に言うと、「セッションを跨いで覚える」だけなら CLAUDE.md で足ります（実測しました）。Linksee が要るのは、間違いかけたとき・方針を変えたとき・並行案件のどれが外れたかを知りたいとき、の3場面です。

Quiero una memoria compartida entre Claude Code, Cursor y OpenAI Codex. ¿Qué herramientas existen para eso?
Un solo archivo SQLite. Claude Code, Cursor, Windsurf, OpenAI Codex y Gemini CLI leen y escriben la misma memoria — una decisión tomada en uno aparece en los otros.

Claude CodeとCursorとCodexで同じ記憶を共有したいのですが、どうすればいいですか？
SQLite ファイル1つを全員で読みます。Claude Code / Cursor / Windsurf / Codex / Gemini CLI のどこで決めた決定も、他のエージェントの行動の直前に出てきます。

Mi agente de IA sigue reimplementando cosas que ya decidimos no hacer. ¿Cómo puedo detectar que un código se ha desviado de decisiones pasadas?
Declara la decisión (remember({ content, anchor: { violation_signal: [...] } })). El guardián entonces advierte — o bloquea, si lo has endurecido — en el momento en que una edición la contradice, y drift_status muestra cada decisión que la realidad ha dejado silenciosamente.

過去に決めた設計方針とコードがずれていないかを検出できるツールはありますか？
決定を宣言しておくと（remember({ content, anchor: {...} })）、それに反する編集の直前に警告（hardened なら拒否）が出ます。drift_status は「宣言と現実がずれた決定」を証拠つきで一覧します。

¿Existe una alternativa local-first y autoalojada a Mem0 para la memoria de agentes?
Sí. Sin cuenta, sin clave API, sin nube — un archivo local, con licencia MIT. npx -y linksee-memory setup y está activo.

Mem0 vs Zep vs Letta para la memoria a largo plazo de un agente de codificación — ¿cuál debería elegir?
Los instalamos y ejecutamos un escenario en todos. Almacenar y recuperar una decisión: todos pasan. La diferencia aparece antes de un error y cuando cambias de opinión — Linksee está construido para esos dos momentos; los otros te los dejan a ti.

¿Cómo evito que Claude Code repita el mismo error que cometió la semana pasada?
Regístralo como una advertencia (remember({ content, layer: 'caveat' })). Las advertencias están protegidas contra el olvido y vuelven cuando se toca el mismo terreno de nuevo — y si lo anclas, el guardián detiene la repetición antes de que ocurra.

開発の意思決定履歴をMCPサーバーで残しておく定番のやり方はありますか？
remember({ content, anchor: {} }) の1回で、記録と強制が同時に入ります。drift_status がその台帳で、各決定が いま守られているか（🔵）・ずれているか（🔴）・誰も確かめていないか（⚫）を示します。

🪄 Tres hechizos para recordar

Hazlo automático: añade "Use 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 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 destacado en

• Zenn: あなたの Claude Code、 実は前回のセッションを完全に忘れている — 73 ♡ en Zenn, 165+ usuarios en Hatena Bookmark, recogido por blogs técnicos + YouTube shorts (mayo 2026)
• Zenn: あなたの MCP server、 実は Tools しか使ってない (5 blocks 全実装 / v0.3.0) — el 1% de los servidores MCP que implementan los 5 bloques
• Zenn: あなたの Claude memory、 実は Claude にしか残らない (5 LLM 横断する方法) — patrón de memoria entre LLMs (12 de mayo de 2026)
• Zenn: Glama listing で 3 週間止まった話 (5 つの罠と解決策) — retrospectiva de despliegue npm + Glama

「Cordex/Cursor/Code/Gemini 全部につなげられるから、 横断的にできてる MCP ってところがこれのすごいところ」 — Hatena Bookmark, mayo 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 porqué sobrevive el 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, diferente resultado:

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 PORQUÉ". linksee-memory la almacena en seis capas explícitas para que la recuperación sea explicable.

🔍 Detección de Deriva — "Intent Datadog"

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é fue rechazado. 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 aparecen 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
   • ⚪ Mantenida — reconociste la brecha, la aparcaste con una fecha de revisión
   • 🔵 Alineada — 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 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 como 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 caducidad (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 es también una herramienta MCP, para que un agente de codificación pueda reanclarse 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 — aplica 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 e irritante (anthropics/claude-code#15443): "Claude leyó la regla, la entendió y aun así usó cp." Tener la regla en contexto no es suficiente — así que el guardián se ejecuta fuera de la voluntad del agente, como un hook de Claude Code:

Habilitarlo

npx -y linksee-memory setup conecta esto a ~/.claude/settings.json (Paso 4), por lo que está activo en cada repositorio — el mismo ámbito donde ya vive tu memoria. Un solo archivo SQLite contiene los anclajes de todos tus proyectos; aplicarlos por repositorio significaba declarar una decisión una vez y que no se aplicara en ningún lugar.

• --project-guard — solo este repositorio, el comportamiento antiguo
• --no-guard — omitirlo

Los anclajes con globs de affects se activan solo en rutas coincidentes; un anclaje sin ámbito se activa en su propio detect_terms / violation_signal. Nada se bloquea a menos que lo hayas endurecido explícitamente (resolve_drift(action:'harden')) — todo lo demás reinyecta la decisión como contexto.

Para conectarlo manualmente, coloca este bloque en .claude/settings.json (raíz del proyecto, o ~/.claude/settings.json para cada repositorio) — apunta al binario de linksee-memory-guard instalado globalmente, por lo 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 de ámbito de proyecto — el guardián aplica las decisiones de este repositorio, y optas por participar por proyecto en lugar de permitir que deniegue llamadas de herramientas en todas partes (el hook Stop de la configuración, en contraste, es global de usuario). Declara lo que debe vigilar con declare_anchor(...); establece card_policy.gate_mode:'hard' en un anclaje para que una contradicción bloquee en lugar de solo advertir (el valor suave predeterminado solo reinyecta). Los anclajes obsoletos (at_risk), superados o deshabilitados por tarjeta nunca bloquean.

¿Desarrollando linksee-memory? El repositorio usa el guardián mediante 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 sin confirmar. Los proyectos de usuarios finales deben usar la forma publicada de npx -y linksee-memory guard anterior.

Qué hace

La mayoría de los servicios de "memoria de agente" (Mem0, Letta, Zep) guardan una lista plana de hechos. Luego el agente ve "archivo editado X 30 veces" y no tiene idea de por qué. Y ninguno nota cuando el trabajo de esta semana contradice la decisión de la semana pasada. linksee-memory conserva el PORQUÉ — 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 anclajes, luego el motor detecta automáticamente cuando la realidad confirmada diverge de la intención declarada. Piensa en "Datadog para decisiones de producto" — las divergencias no contabilizadas aparecen como deriva, la evolución intencional (registrada como superar/corregir) permanece silenciosa.
2. Portabilidad entre agentes — un solo archivo SQLite en ~/.linksee-memory/memory.db. El mismo cerebro para Claude Code, Cursor, Windsurf, OpenAI Codex, Gemini CLI.
3. Memoria estructurada PORQUÉ-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 mediante read_smart — sha256 + fragmentación por AST/encabezados/sangría. Las relecturas devuelven solo diffs. Se midió un 86% de ahorro en una edición típica de archivo TS, 99% de ahorro 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 del 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 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 guardada en tu cerebro local)
4. Ofrece conectar el guardián de reinyección a este proyecto (aplicación de decisiones previa 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 previene 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.

Desinstalar

# 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 jamás de tu máquina, por lo que el paso 3 borra por completo todo lo que Linksee almacenó.

Novedades en v0.9

Novedades en v0.8

6 herramientas

Dos pilares, una superficie. Memoria y deriva reciben cada una el mínimo; nada más se expone. Once herramientas filtraban comportamiento dependiente del modelo entre Claude / GPT / Cursor / Codex / Gemini — seis es lo que un agente puede sostener sin un manual.

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

Arquitectura

Un único archivo SQLite (better-sqlite3 + tokenizador trigrama 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 diferencias + 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-first — tu historial de conversaciones es privado. Nada sale de tu máquina.
• Archivo único — memory.db es un artefacto portátil. Respaldo = copia de 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 producción de inteligencia de ventas. 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 + Muestreo + Raíces + Elicitación)
• ✅ Captura automática mediante hook de Stop para Claude Code
• ✅ FTS5 trigrama JP/EN
• ✅ Configuración en un 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.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 del 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 diferencias de archivos y POR QUÉ por edición

Usa ambos.

Seguridad y privacidad

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

• Local-first. La memoria es un archivo SQLite en ~/.linksee-memory/memory.db. Sin cuenta, sin nube, sin clave API.
• La telemetría es opcional y DESACTIVADA por defecto. setup pregunta una vez; no se envía nada a menos que aceptes allí (o establezcas 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 una verificación de realidad del mapa señala, la base de datos SQLite local y — cuando el hook de Stop se activa — la transcripción de tu sesión de Claude Code (localmente, para capturar lo que sucedió). No rastrea tu repositorio, lee .env/secretos/node_modules, ni toca tu directorio de inicio por su cuenta.
• Transporte MCP limpio. El servidor escribe solo JSON-RPC a stdout; todos los registros van a stderr.
• Los hooks están documentados y son removibles. setup agrega un hook de Stop (captura de sesión) y un hook guardián opcional. No hacen llamadas de red por defecto, están limitados en tiempo, fallan abiertamente (un error de hook nunca rompe tu sesión) y se listan 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? Ver 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 habilites explícitamente. Sin contenido de conversaciones, sin contenido de archivos, sin nombres de entidades, sin rutas de proyectos — nunca.

Habilitar

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 hook de Stop 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 capas 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 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 local-first y se ejecuta completamente en tu máquina. No hay componente alojado por el que debas pagar. La base de datos SQLite vive en tu directorio de inicio; respaldo = copia de 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 existe, 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> y comienza uno nuevo (con un mensaje claro) en lugar de fallar con un error SQLite crudo. Las memorias antiguas 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 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, …) vía npx — npx resuelve nombres de paquetes, no nombres de binarios hermanos — así 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 (era un stack trace crudo — el estado exacto de un usuario primerizo).
• serverInfo ahora informa la versión real del paquete (estaba fijada 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 deriva 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: agrega --lang ja.
• Radio de impacto graduado (must fix together / should align / fyi), veredictos declarado-vs-realidad y un guardián anti-cementerio para la deriva contabilizada.
• Claves por proyecto para que el Mapa maneje muchos proyectos a la vez.

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

3 herramientas → 7 herramientas. La actualización más grande desde el lanzamiento — los agentes ahora pueden detectar, consultar y resolver la deriva intención ↔ realidad.

Nuevas herramientas:

• drift_status — devuelve el mapa de verdad con clasificación de 4 especies y estado de deriva 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 / reemplazar / 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 deriva 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: los nodos se clasifican 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 recuerdo + detección automática de bordes + precisión del clasificador (2026-05-30)

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

• Disciplina de tokens de 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 (era una estimación plana de ~100 tok/memoria). Agrega 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.
• Precisión de recall: memorias casi duplicadas — misma entidad + texto central casi idéntico, p. ej., el mismo mensaje capturado bajo goal y learning — se colapsan a una en el conjunto de resultados. Los pesos compuestos se adaptan a la especificidad de la consulta: las consultas de múltiples términos ponderan más la relevancia para que las memorias fijadas fuera de tema no abarroten recuerdos estrechos.
• Deduplicación de captura (lado de escritura): session-extractor ahora produce COMO MÁXIMO una memoria por turno de usuario, con prioridad goal[first_intent] > caveat > decision > context. Un mensaje de primera intención que contiene 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 una memoria de DECISIÓN posterior a la 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 reconocimientos de charla ("そうだね" / "ありがとう"), el contenido pegado de terminal/git/email y el ruido meta 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 reconocimiento de apertura) 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 una sección "PARÁMETROS REQUERIDOS POR MODO" para que los LLM sepan exactamente qué campos se necesitan para crear, actualizar o 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 recuerdo y consulta: cuando se proporcionan tanto path como query a recall, los resultados del historial de archivos y la búsqueda de memoria se fusionan en una sola respuesta.
• P2 — Seguridad de consolidación automática: 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 que 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:

• Consolidación automática al iniciar el servidor (setTimeout no bloqueante, umbral de 7 días, verificación de seguridad sqlite_master)
• Paquete de plugin para Claude Code (claude plugin add -- linksee-memory)
• Los errores de obsolescencia incluyen ejemplos de migración específicos

Todas las funciones internas del manejador se conservan: este es un cambio de superficie, no una reescritura de lógica.

v0.2.0 — Preparación para lanzamiento en inglés (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 en la 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 conservadas en línea. Los angloparlantes ahora obtienen la habilidad activada con frases naturales en inglés ("¿cómo resolvimos esto antes?", "el mismo error otra vez", "recuerda esto") además de los activadores existentes en japonés.
• La salida CLI de instalación de habilidad es bilingüe: las frases de prueba de ejemplo que se muestran después de la instalación incluyen tanto inglés como japonés.
• Cobertura EN del extractor de sesiones (linksee-memory-import): patrones de expresión regular 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 "baje la importancia por debajo de 0.9 primero, luego olvide", lo cual era engañoso: las memorias de la capa de advertencias están protegidas permanentemente 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 agregó un escenario de antes/después "Véalo en acción", diagrama ASCII de 6 capas, insignias de puntuación del Registro Oficial MCP + 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.

Sin cambios de código en la superficie del protocolo MCP; todos los clientes MCP existentes continúan 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 = importancia alta = 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: no se necesita 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 conservado. Resuelve el error "olvidar+recordar rompe los enlaces de session_file_edits".
• 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 de 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 max_tokens).
• Filtro band para solicitar solo memorias calientes/tibias/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 de remember

• Verificación de calidad: rechaza salida de asistente pegada / registros de CI / seguimientos 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.
• La ejecución en seco 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 continúan funcionando. El banner de versión de Server.ts ahora informa v0.1.0.

Versiones anteriores

Consulte Lanzamientos de GitHub.

Licencia

MIT — Synapse Arrows PTE. LTD.