Link

Link

Memoria local para agentes de IA.

Link les da a Codex, Claude, Cursor, Kiro, VS Code, Copilot, Antigravity y otros agentes locales la misma memoria respaldada por fuentes, almacenada localmente como Markdown.

Sitio web · Cómo funciona · Memoria · Herramientas y CLI · Configuración · Documentación · Registro MCP · PyPI · Homebrew

Inicio rápido

brew install gowtham0992/link/link   # or: pip install link-mcp
lnk setup                            # wires every agent you have

Luego trabaja con normalidad. Dile a un agente "recuerda que desplegamos los martes", apruébalo una vez, y cualquier otro agente lo recordará en una sesión nueva mañana.

lnk status                                   # is it wired up and being used?
lnk import claude-code                       # bring existing memory in
brew install --cask gowtham0992/link/linkbar # macOS menu bar app

La memoria vive en Markdown plano que puedes abrir, y nada se vuelve duradero sin tu aprobación.

¿Qué es Link?

Link es una capa de memoria de código abierto para agentes de IA locales. Las fuentes en bruto se convierten en una wiki Markdown inspeccionable. Las solicitudes explícitas de "recuerda esto" se convierten en memorias revisables. Los agentes recuperan contexto compacto respaldado por fuentes a través de la CLI, MCP, habilidades oficiales o el visor local sin volcar toda la wiki en una ventana de chat.

La wiki es la capa de almacenamiento. El producto es memoria duradera que permanece en tu máquina, sigue siendo legible en archivos planos y se puede compartir entre múltiples agentes en lugar de quedar encerrada dentro de un perfil de un proveedor.

Pregunta con tus propias palabras; Link coincide por significado, no por palabras clave. Todo local, todo archivos planos.

Cómo funciona

Link les da a los agentes cuatro movimientos simples:

1. Captura notas, transcripciones, documentos, capturas de pantalla y contexto de proyectos en raw/.
2. Estructura páginas respaldadas por fuentes bajo wiki/.
3. Recuerda preferencias explícitas, decisiones, hechos y contexto de proyectos como memoria revisable.
4. Recupera paquetes de consulta compactos a través de la CLI, MCP, habilidades oficiales o el visor web local.

La mayoría de las sesiones de agentes comienzan desde cero. Vuelves a explicar preferencias, decisiones del repositorio, restricciones del proyecto y por qué algo importa. Link convierte ese contexto repetido en memoria local que los agentes pueden consultar.

Link sigue el patrón LLM Wiki de Andrej Karpathy: mantén el conocimiento fuera de la ventana de chat, haz que las afirmaciones sean inspeccionables y deja que el contexto se acumule con el tiempo.

Por qué Link es diferente

Cada otro sistema de memoria para agentes almacena memoria como incrustaciones en una base de datos vectorial o como un grafo extraído por LLM. Link hizo cuatro compromisos arquitectónicos que esos diseños no pueden añadir a posteriori:

1. Memoria que puedes leer. Cada memoria es un archivo Markdown plano — ábrelo, hazle grep, hazle git-diff. Si Link desapareciera mañana, tu memoria sigue siendo tuya.
2. Escrituras controladas por revisión. Los agentes proponen; tú apruebas. Incluso los ganchos automáticos de sesión capturan propuestas, nunca hechos.
3. Sin LLM en la capa de memoria. La ingesta y la recuperación son deterministas — nada puede alucinar un hecho en tu memoria, porque no hay modelo en la ruta de escritura.
4. Demostrablemente local. CI bloquea el código de red saliente en el tiempo de ejecución, y los modelos semánticos opcionales se cargan solo sin conexión después de una configuración explícita.

Y las afirmaciones se miden, no se aseveran — mira los puntos de referencia a continuación. Comparaciones nombradas contra Mem0/OpenMemory, Zep/Graphiti y Letta: ¿Por qué Link?

Puntos de referencia

Archivos planos sin LLM en la capa de memoria, medidos contra los sistemas que tienen uno en todas partes:

Cada número incluye su configuración, modelo de juez, advertencias y los experimentos que perdieron — incluido el extremo a extremo de LongMemEval, donde re-juzgamos ambos lados bajo el árbitro neutral Hunyuan 3: las respuestas de GPT-5 de mem0 puntúan 91.0%, las respuestas del modelo económico de Link 80.6%. Su número publicado se sostiene, y la brecha sigue al modelo que responde, no a la capa de memoria — eso es lo que aísla la fila de recuperación de evidencia del 99.4% anterior. Metodología completa y pasos de reproducción: benchmarks/RESULTS.md.

Memoria que puedes llevar a cualquier lugar — y demostrar que funciona

Tres preguntas que todo sistema de memoria debería responder, y cómo Link las responde con mecanismos en lugar de promesas:

"¿Está en todas mis máquinas?" lnk sync mueve la memoria revisada a través de un remoto git que tú controlas — un repositorio privado de GitHub, un repositorio simple de homelab — sin servidor y sin cuenta. Los secretos se escanean antes de que algo salga, los conflictos se convierten en elementos de revisión en lugar de marcadores de git, y las capturas privadas nunca se sincronizan. lnk team-sync ejecuta un cerebro de equipo compartido sobre los mismos rieles.

"¿Qué creía en ese entonces?" Pregunta en lenguaje natural: lnk recall "dónde viven los datos locales en marzo" devuelve lo que era verdad entonces, reconstruido a partir de los archivos fechados y su linaje de reemplazo — mientras que la misma pregunta sin la fecha devuelve la verdad de hoy. Determinista: una expresión regular y un calendario, sin modelo. Precisión puntual desde lenguaje natural: 0.917, idéntico a preguntar con una fecha ISO.

"¿Mi agente realmente está usando esto?" La pregunta que la mayoría de los sistemas de memoria no pueden responder sobre sí mismos. Link registra las recuperaciones localmente — resúmenes de sesión enviados a agentes, recuperaciones que eligieron hacer — y lnk wins responde con conteos, mientras que lnk digest informa la historia semanal incluyendo memorias que nunca han sido recuperadas. El libro mayor almacena qué memoria se leyó y cuándo, nunca qué preguntaste; nunca se sincroniza, y LINK_USAGE=off lo desactiva. Y la memoria llega a todos los agentes, no solo a los conectados: la primera respuesta de herramienta MCP de una sesión lleva el resumen, sin importar qué herramienta se llamó.

Inicio rápido

Dos comandos: míralo funcionar, luego hazlo tuyo.

brew install gowtham0992/link/link
lnk proof     # see the promise (~1 second, no setup)
lnk setup     # wire every agent you have — workspace, MCP, session hooks, one command

¿Ya tienes memoria dispersa entre herramientas? Tráela a casa como propuestas revisables — nada se autoacepta:

lnk import claude-code   # or: cursor, codex, file --file chatgpt.txt

lnk setup detecta los agentes instalados en tu máquina — Claude Code, Codex, Cursor, Windsurf, Zed, Kiro, Gemini CLI — y los conecta todos a la vez; Link es agnóstico de agente por diseño (un servidor MCP, un espacio de trabajo, cada agente lee la misma memoria). Es idempotente: después de cualquier brew upgrade, ejecútalo de nuevo y todo — tiempo de ejecución del espacio de trabajo, aprovisionamiento de MCP, ganchos — se actualiza. ¿Prefieres conectar un agente explícitamente? lnk onboard --agent claude-code --write --hooks aún hace exactamente eso.

lnk proof crea un espacio de trabajo desechable, escribe una memoria revisada y la recupera a través del mismo camino que usan la CLI, las habilidades y MCP — la promesa central (una memoria local, reutilizable por diferentes agentes, sin perfil en la nube) en un segundo:

Cross-agent memory continuity works
Memory: created and reviewed: Cross-agent Link proof
Recall: found through the same bounded recall path used by CLI, skills, and MCP.
Result: proof passed

lnk onboard --agent claude-code --write luego crea ~/link, aprovisiona el tiempo de ejecución de MCP y conecta el agente — incluidos los ganchos de sesión que capturan memoria automáticamente mientras trabajas (intercambia claude-code por codex, cursor, kiro, copilot, antigravity u otros). Omite --write para previsualizar la configuración sin tocar nada, u omite --agent para solo crear el espacio de trabajo.

El comando instalado es lnk porque link ya es una utilidad de sistema POSIX/macOS. Desde un checkout de la fuente, usa python3 link.py ... en su lugar.

¿Quieres la interfaz de usuario, el grafo y las páginas de fuentes primero? lnk try && lnk serve link-demo. Las rutas de Windows, checkout de fuente, solo MCP y primero habilidades están en la guía Primeros 10 minutos.

O siembra tu repositorio actual como un paso separado para que la primera recuperación real no esté vacía:

cd /path/to/your/project
lnk seed . ~/link
lnk query "what is this project about?" ~/link --budget small

lnk seed lee archivos de proyecto en la lista permitida como README.md, AGENTS.md, CLAUDE.md, .cursorrules y archivos de reglas del editor, bloquea valores que parecen secretos, escribe una página de proyecto respaldada por fuentes y reconstruye el grafo. No crea memorias duraderas; los agentes aún deberían usar propuestas de memoria revisadas para preferencias y decisiones.

La fórmula de Homebrew se mantiene en el tap público gowtham0992/homebrew-link.

Abre:

http://127.0.0.1:3000
http://127.0.0.1:3000/onboard
http://127.0.0.1:3000/graph
http://127.0.0.1:3000/health

Usa /onboard cuando quieras la misma lista de verificación de primera ejecución en la interfaz de usuario local: preparación, siembra de contexto del proyecto, primera memoria, conexión de agentes y indicaciones iniciales. El visor web es solo para uso local. Se vincula a 127.0.0.1, no tiene cuentas de usuario ni autenticación, y no debería exponerse a internet a menos que añadas tu propia capa de autenticación.

Prueba el bucle de valor:

lnk start link-demo --task "working on agent memory"
lnk query "why does Link help agents?" link-demo --budget small
lnk brief "working on agent memory" link-demo
lnk benchmark "agent memory" link-demo
lnk health link-demo

lnk benchmark informa tanto evidencia de rendimiento como de valor: tiempos de caché/búsqueda/consulta, forma de la carga útil del grafo y una estimación de cuánto contexto amplio de wiki el paquete limitado de Link evitó enviar a un agente. La página /health refleja el bucle de preparación en el navegador: estado de validación, escrituras interrumpidas, estado de revisión de memoria y comandos de reparación copiables. El visor sigue siendo documento-primero — rutas comunes en la navegación superior, herramientas más profundas bajo more, y un esquema de contenidos más enlaces relacionados con el grafo en páginas estructuradas.

La demo generada es la wiki de prueba pública. El contenido generado dentro de wiki/, raw/ y link-demo/ es ignorado por git para que la memoria personal no se publique por accidente.

LinkBar — la aplicación de barra de menús (macOS)

La memoria de Link, ambiental. LinkBar pone la puerta de revisión en tu barra de menús: una paleta global (⌥⌘M) para recordar o memorizar desde cualquier aplicación, notificaciones nativas con Aceptar de un toque cuando llega una captura de sesión, un pulso en vivo mientras los agentes escriben, un navegador sobre cada archivo de memoria y un panel de estado que señala memorias que nombran archivos que tu repositorio ya no tiene — todo ejecutándose sobre los mismos comandos lnk revisados que la CLI. Elige el espacio de trabajo en Ajustes; por defecto es ~/link.

brew install --cask gowtham0992/link/linkbar

Sin firmar a propósito (sin tarifa de Apple inflando nada): el cask elimina la bandera de cuarentena al instalar, así que se abre como cualquier aplicación. ¿Compilar desde el código fuente en su lugar? cd apps/LinkBar && bash Scripts/bundle.sh --install.

Demo Impactante: Una Memoria, Dos Agentes

Este es el momento para el que Link está construido:

1. En un agente, di:

   remember that I prefer local, source-backed memory for AI agents
   

2. En otro agente conectado al mismo espacio de trabajo ~/link, di:

   start with Link before we continue
   what does Link remember about local agent memory?
   

3. El segundo agente debería recordar la memoria revisada desde Markdown local en lugar de pedirte que te repitas.

Para una versión automatizada limpia de la misma idea, ejecuta:

lnk proof

Formas de Usar Link

Elige la superficie que coincida con cómo trabajas. Todas leen y escriben la misma wiki local en Markdown.

Estas superficies son independientes. lnk serve / serve.py es solo el visor web local. Los comandos CLI, las habilidades oficiales y las herramientas MCP leen los mismos archivos wiki/ directamente, así que Claude, Codex, Kiro, Cursor u otro agente pueden usar Link incluso cuando el visor web no está en ejecución.

El visor web local: navega por memoria respaldada por fuentes y explora el grafo de conocimiento — todo en 127.0.0.1, sin cuentas, sin backend.

¿Prefieres habilidades en lugar de MCP? Link incluye habilidades CLI pequeñas y cargables de forma diferida bajo skills/. Permiten que un agente use lnk health, lnk query, lnk ingest-status, lnk session-end y lnk remember directamente, sin configuración MCP ni un visor web en ejecución.

skills/link-health/SKILL.md
skills/link-retrieve/SKILL.md
skills/link-ingest/SKILL.md
skills/link-memory/SKILL.md

Guía completa: Habilidades de Link.

Instalar Para Tu Agente

Ejecuta un instalador desde el checkout clonado:

bash integrations/codex/install.sh
bash integrations/kiro/install.sh
bash integrations/claude-code/install.sh
bash integrations/cursor/install.sh
bash integrations/copilot/install.sh
bash integrations/vscode/install.sh
bash integrations/antigravity/install.sh

Los instaladores crean o actualizan ~/link, instalan o actualizan link-mcp, escriben instrucciones ligeras para el agente y preservan los datos existentes de la wiki al reinstalar. Usa --project cuando un repositorio necesite memoria de proyecto separada.

En Windows, usa el instalador de PowerShell correspondiente:

.\integrations\codex\install.ps1
.\integrations\kiro\install.ps1
.\integrations\claude-code\install.ps1
.\integrations\cursor\install.ps1
.\integrations\copilot\install.ps1
.\integrations\vscode\install.ps1
.\integrations\antigravity\install.ps1

Luego pregúntale a tu agente:

is Link ready?
start with Link before we continue
seed this project into Link
ingest raw/notes.md into Link
remember that I prefer short release notes
query Link for the release process
what does Link remember about local personal memory?
end this session with Link memory proposals

Para agentes CLI-primero o habilidades de Link, usa el mismo bucle de inicio directamente:

lnk seed . ~/link
lnk start ~/link --task "working on Link release"
lnk session-end session-notes.md ~/link --limit 3

Si quieres una configuración guiada para un espacio de trabajo real y un agente, usa lnk onboard --agent AGENT. Si tu agente ya tiene instrucciones y solo necesitas la conexión MCP, usa el helper de conexión de nivel inferior. Ambos previsualizan la configuración exacta primero; añade --write cuando quieras que Link actualice el archivo de configuración del agente.

lnk onboard --agent codex
lnk onboard --agent codex --write
lnk connect codex ~/link
lnk connect codex ~/link --write
lnk connect kiro ~/link --write
lnk verify-mcp ~/link

Para agentes con soporte de ganchos de sesión — Claude Code, Codex y Cursor — añade --hooks (funciona con lnk onboard también) para hacer el bucle de memoria automático: el informe se inyecta al inicio de la sesión y las notas solo-propuesta se capturan al final de la sesión, así que la memoria ya no depende de que el agente recuerde llamar a Link. Las sesiones vacías y los eventos finales duplicados se omiten, y cuando el acumulado crece, el informe empuja al agente a ofrecer una pasada de solo lectura lnk consolidate. La memoria duradera aún requiere tu aprobación. El soporte de ganchos de Codex y Cursor es nuevo (conectado a sus esquemas documentados — reporta problemas).

lnk connect claude-code ~/link --hooks --write
lnk connect codex ~/link --hooks --write    # session-start brief (Codex has no session-end event)
lnk connect cursor ~/link --hooks --write
lnk consolidate ~/link                      # read-only backlog plan, apply only with approval

Opcional: recuperación semántica híbrida (sigue siendo totalmente local)

La recuperación léxica es siempre el valor predeterminado y el respaldo. La coincidencia por paráfrasis es opt-in: después de los dos comandos de configuración a continuación, "cómo debería estructurar mis pull requests" encuentra una memoria guardada sobre el estilo de commits. Hasta entonces, la recuperación coincide en palabras compartidas, y un fallo te dice cómo activar la coincidencia por paráfrasis. Instalar el extra semántico opcional añade un pequeño modelo local de incrustación estática. La recuperación nunca toca la red: el modelo se carga solo sin conexión después de una configuración explícita única, las incrustaciones viven en JSON plano bajo .link-cache/, la similitud se ejecuta en proceso sin base de datos vectorial, y las coincidencias solo-semánticas llevan etiquetas de confianza con límite para que los agentes verifiquen antes de confiar en ellas.

pip install "link-mcp[semantic]"          # fast tier: tiny static model, instant load
pip install "link-mcp[semantic-quality]"  # quality tier: contextual model, best recall
lnk semantic ~/link --setup   # one-time model fetch, with your approval
lnk semantic ~/link           # status: lexical only vs hybrid, active tier
python3 -m link_mcp --semantic-setup --wiki ~/link/wiki   # MCP-only installs

Medido, no afirmado: en el benchmark incluido de 1,176 casos, el nivel de calidad eleva el hit@1 de solapamiento de tokens de 0.589 a 0.749 y el hit@3/hit@5 de paráfrasis pura (solapamiento de tokens cero) en ~4×, a ~10 ms por recuperación sin servicio ni base de datos vectorial. En la pista de recuperación LoCoMo de terceros (1,536 preguntas anotadas con evidencia sobre 5,882 turnos de conversación), la recuperación híbrida eleva el hit@10 de cualquier evidencia de 0.628 a 0.737 (0.794 con el nivel de reordenamiento opt-in). Metodología completa, limitaciones honestas y pasos de reproducción: benchmarks/RESULTS.md.

python3 -m pip install --upgrade link-mcp
python3 -m link_mcp --version

{
  "mcpServers": {
    "link": {
      "command": "python3",
      "args": ["-m", "link_mcp", "--wiki", "~/link/wiki", "--surface", "slim"]
    }
  }
}

python3 -m venv ~/.link-mcp-venv
~/.link-mcp-venv/bin/python -m pip install --upgrade pip link-mcp

Los usuarios de Obsidian pueden importar una bóveda existente a raw/ para la ingesta del agente, o abrir ~/link/wiki directamente como una bóveda para editar páginas de Link:

lnk init ~/link
lnk import-obsidian ~/Documents/ObsidianVault ~/link

Consulta la Guía de Obsidian para el bucle de importación, edición y validación.

Modelo de Almacenamiento

Bajo el capó, Link separa el conocimiento respaldado por fuentes de la memoria duradera del agente:

1. Coloca notas crudas, transcripciones, artículos y contexto de proyecto en raw/.
2. Los agentes compilan esas fuentes en páginas inspeccionables bajo wiki/.
3. Las solicitudes explícitas de "recordar" se convierten en páginas de memoria revisables.
4. Las consultas recuperan contexto compacto del agente tanto de la wiki como de la capa de memoria.

El modelo de almacenamiento es plano e inspeccionable:

Si un archivo crudo ya fue ingerido y luego editado, lnk ingest-status lo marca como desactualizado y le dice a tu agente que refresque la página de fuente existente en lugar de crear un duplicado.

Las exportaciones estructuradas con un esquema compatible pueden usar ingesta determinista. La planificación es de solo lectura; la aplicación prepara el resultado completo, reconstruye el grafo, lo valida y registra la propiedad de la salida antes de cambiar la wiki en vivo:

lnk ingest raw/chezmoi-docs/export.jsonl ~/link \
  --adapter chezmoi-docs-graph-v1 \
  --exclude "Reference / Release history"

lnk ingest raw/chezmoi-docs/export.jsonl ~/link \
  --adapter chezmoi-docs-graph-v1 \
  --exclude "Reference / Release history" \
  --apply

Las ejecuciones posteriores actualizan solo las salidas propiedad del adaptador. Las ediciones manuales se convierten en conflictos. --replace-unmanaged es necesario para una primera migración sobre páginas existentes, y --prune es necesario para retirar páginas gestionadas que ya no están en el plan. Las notas y artículos arbitrarios continúan a través de la ingesta autoría-agente porque su estructura útil no puede inferirse de forma segura solo desde un formato de archivo.

Qué Obtienen los Agentes

Cuando un agente usa Link a través de la superficie MCP recomendada, obtiene seis herramientas orientadas al modelo. Los flujos de trabajo CLI y de habilidades llaman al mismo comportamiento central a través de lnk.

• status: preparación, estado del esquema, validación, escrituras interrumpidas y próximas acciones seguras.
• recall: la única ruta de lectura para informes de inicio, paquetes de consulta listos para responder, búsqueda en la wiki, contexto de grafo, presupuestos de tokens y acciones de seguimiento. Cada memoria recordada lleva una etiqueta confidence (strong, moderate, weak) y un campo match (lexical, semantic, hybrid cuando el nivel semántico local opcional está instalado), para que los agentes verifiquen coincidencias débiles o por paráfrasis con el usuario en lugar de confiar en ellas.
• remember: memoria local duradera solo después de la aprobación explícita del usuario, con comprobaciones de duplicados/conflictos, procedencia, estado de revisión, visibilidad, opcional review_after y opcional expires_at.
• ingest: próximos pasos exactos para archivos crudos, seguridad de fuentes, detección de ingesta desactualizada, validación y comprobaciones de reconstrucción.
• review: bandeja de entrada de memoria, perfil, auditoría, registro, explicación, archivo, restauración, olvido y flujos de trabajo de revisión del ciclo de vida — más review(action="consolidate"), un plan de acumulado de solo lectura aplicado solo con aprobación del usuario por acción.
• admin: la vía de escape para respaldo, migración, validación, exportación de grafo, páginas, capturas, reconstrucciones, acciones de compatibilidad y actualizaciones avanzadas.

El bucle estable orientado al agente está documentado en Contrato de Memoria de Link: preparación primero, recuperación limitada, escrituras de memoria explícitas, herramientas de auditoría y semántica de compartir.

Usa review_after para preferencias o decisiones sensibles al tiempo. Cuando esa fecha llegue, la memoria reaparece en la bandeja de entrada de revisión de Link para que un agente pueda pedirle al usuario que confirme, actualice, archive u olvide en lugar de confiar en contexto desactualizado. Usa expires_at para contexto temporal que debería salir automáticamente de la recuperación predeterminada después de una fecha; Link mantiene la página Markdown inspeccionable y le pide al usuario que la actualice, archive o elimine. Usa visibility para separar dónde se aplica una memoria de quién debería verla: private permanece personal, project está destinada a un espacio de trabajo de proyecto y team significa que el usuario aprobó explícitamente compartirla con un equipo.

Para la entrega al equipo o la revisión de seguridad, lnk compliance-export --output audit.json escribe un paquete JSON redactado con preparación, validación, estado de revisión de memoria, marcadores de operación y entradas recientes del registro de auditoría. Los contenidos crudos de fuentes y los cuerpos de memoria no se incluyen.

Para la auditabilidad diaria, lnk memory-log ~/link muestra lo que Link recientemente recordó, actualizó, revisó, archivó, restauró, olvidó o aceptó de capturas crudas. Para recuperación, lnk backup ~/link crea un archivo local y lnk restore-backup <archive> ~/link previsualiza lo que se restauraría. Pasar --confirm reemplaza archivos locales después de crear una copia de seguridad de seguridad cuando sea posible; raw/ sigue excluido a menos que --include-raw sea explícito. Si una escritura de múltiples archivos se interrumpe, lnk operations ~/link muestra el marcador y cualquier instantánea de reversión; lnk operations ~/link --recover <marker> --confirm restaura la instantánea después de que la revises.

Para prueba local de valor, lnk wins ~/link muestra memorias reutilizables, memoria revisada, procedencia, continuidad de proyectos, salvaguardas de frescura y indicaciones copiables sin rastrear el comportamiento del usuario.

Para memoria de equipo respaldada por Git, lnk team-sync ~/link verifica si el espacio de trabajo está listo para compartir páginas wiki/ revisadas mientras mantiene raw/, cachés, copias de seguridad, marcadores MCP Python locales y wiki/log.md privados por defecto. El registro de auditoría es local porque tiene una cadena de hash de una sola máquina; fusionar los registros de múltiples usuarios crearía falsas alarmas de manipulación. La sincronización de equipo también bloquea el estado "listo" cuando la bandeja de entrada de memoria no está clara o las memorias visibility: private activas se incluirían por un git add wiki amplio.

lnk team-sync ~/link --remote git@example.com:team/link-memory.git

Para un compañero de equipo, revisor u otro agente, lnk share resuelve una página, memoria, título, alias o frase de búsqueda en una URL de visor local:

lnk share "Prefer local memory" ~/link

Para un paquete de revisión estático de solo lectura, lnk snapshot exporta HTML de wiki renderizado sin raw/, capturas, marcadores de operación, estado MCP en vivo o páginas de memoria por defecto. --include-memories exporta solo memorias no privadas; usa --include-private-memories solo para un archivo personal o una revisión explícitamente aprobada. Bloquea la exportación si las páginas de wiki contienen valores que parecen secretos a menos que lo anules explícitamente.

lnk snapshot ~/link --output link-snapshot
lnk snapshot ~/link --output link-snapshot --include-memories --force
lnk snapshot ~/link --output personal-snapshot --include-memories --include-private-memories --force

Contrato de Agente

Para clientes MCP, los agentes deben usar Link en este orden:

1. status para verificar la preparación y las siguientes acciones seguras.
2. recall con una consulta vacía una vez en el primer turno sustantivo de una sesión.
3. recall(query, budget="micro"|"small") antes de lecturas amplias de archivos o de pedir al usuario que repita contexto duradero.
4. ingest antes de tocar fuentes sin procesar y después de ediciones de fuentes para validación/verificaciones de reconstrucción.
5. remember solo cuando el usuario pide explícitamente a Link que recuerde algo o aprueba una memoria propuesta.
6. review para flujos de trabajo de bandeja de entrada de memoria, perfil, auditoría, registro, explicación, archivo, restauración y olvido.
7. admin para copias de seguridad, migración, exportación de gráficos, capturas, reconstrucciones, acciones de compatibilidad y mantenimiento avanzado.

Lista completa de herramientas MCP: Configuración de MCP.

Privacidad y Seguridad

Link en sí es local-primero:

• Sin telemetría en el CLI instalado, servidor MCP, interfaz web local o tiempo de ejecución de wiki.
• Sin backend alojado.
• Sin llamadas API externas desde serve.py o link-mcp.
• Las fuentes sin procesar y las páginas de wiki generadas son ignoradas por git por defecto.
• lnk backup excluye raw/ a menos que pases explícitamente --include-raw.
• Claves API que parecen secretas, tokens de proveedor, JWTs, credenciales de registro y bloques de claves privadas se detectan en fuentes sin procesar, capturas y verificaciones de higiene de lanzamiento. lnk validate y lnk doctor también fallan si se encuentran valores que parecen secretos dentro de páginas de wiki antes de que puedan servirse a través de la interfaz local o devolverse a través del contexto del agente.
• El recuerdo semántico opcional permanece local: los modelos se cargan solo sin conexión en el momento del recuerdo (solo el lnk semantic --setup explícito puede obtener un modelo, una vez), y las incrustaciones viven en JSON plano bajo .link-cache/.
• Los enlaces automáticos de sesión almacenan notas solo de propuesta; la extracción de transcripciones omite llamadas y salidas de herramientas, y no se escribe memoria duradera sin revisión.
• El servidor web local se vincula a 127.0.0.1 y no está destinado a exponerse a internet sin autenticación adicional.

Antes de compartir un repositorio, demo o wiki:

python3 link.py doctor
python3 link.py validate
python3 scripts/check_release_hygiene.py

Más detalle: Guía de seguridad.

Documentación

Contribuciones

Las contribuciones deben llegar a través de solicitudes de extracción dirigidas a main. La rama develop es una rama de integración de mantenedores para trabajo de lanzamiento más grande antes de que se proponga a main.

Antes de abrir una PR:

python3 -m ruff check .
python3 -m pytest tests
python3 scripts/check_release_hygiene.py
python3 scripts/check_runtime_duplication.py
python3 scripts/check_tool_contract.py
git diff --check

Guía completa de contribuidores: Contribuir.

No incluyas datos personales de wiki, fuentes sin procesar, tokens de registro, archivos .env o credenciales MCP locales en una PR.

Si Link ayuda a tus agentes a recordar mejor, dale una estrella en GitHub para que más personas puedan encontrarlo.