Link

Link

Memoria local para agentes de IA.

Link 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

¿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 de texto plano y se puede compartir entre múltiples agentes en lugar de quedar encerrada en un perfil de un solo proveedor.

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

Cómo funciona

Link ofrece a los agentes cuatro movimientos simples:

1. Captura notas, transcripciones, documentos, capturas de pantalla y contexto de proyecto en raw/.
2. Estructura páginas respaldadas por fuentes en wiki/.
3. Recuerda preferencias, decisiones, hechos y contexto de proyecto explícitos 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

Todos los demás sistemas de memoria para agentes almacenan la memoria como embeddings 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 de texto plano: ábrelo, haz grep, haz 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 hooks automáticos de sesión capturan propuestas, nunca hechos.
3. Sin LLM en la capa de memoria. La ingesta y el recuerdo son deterministas: nada puede alucinar un hecho en tu memoria, porque no hay modelo en la ruta de escritura.
4. Demostrablemente local. La CI bloquea el código de red saliente en el runtime, y los modelos semánticos opcionales se cargan solo sin conexión tras una configuración explícita.

Y las afirmaciones se miden, no se declaran: consulta los benchmarks a continuación. Comparaciones explícitas contra Mem0/OpenMemory, Zep/Graphiti y Letta: ¿Por qué Link?

Benchmarks

Archivos de texto plano sin LLM en la capa de memoria, medidos frente a los sistemas que lo tienen en todas partes:

Cada número incluye su configuración, modelo de juez, advertencias y los experimentos que perdieron — incluido LongMemEval de extremo a extremo, donde re-evaluamos ambos lados bajo el árbitro neutral Hunyuan 3: las respuestas 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 repo bare 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 raíles.

"¿Qué creía entonces?" Pregunta en lenguaje natural: lnk recall "where does local data live in March" devuelve lo que era verdad entonces, reconstruido a partir de los archivos fechados y su linaje de sustitución — mientras que la misma pregunta sin la fecha devuelve la verdad de hoy. Determinista: una regex y un calendario, sin modelo. Precisión puntual desde lenguaje natural: 0.917, idéntica a preguntar con una fecha ISO.

"¿Mi agente está usando esto realmente?" 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 los agentes, recuerdos que eligieron hacer — y lnk wins responde con conteos, mientras que lnk digest informa la historia semanal incluyendo memorias que nunca se han recuperado. El libro de registro almacena qué memoria se leyó y cuándo, nunca lo que 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, sea cual sea la herramienta llamada.

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 acepta automáticamente:

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 respecto al agente por diseño (un servidor MCP, un workspace, todos los agentes leen la misma memoria). Es idempotente: después de cualquier brew upgrade, ejecútalo de nuevo y todo — runtime del workspace, aprovisionamiento MCP, hooks — se actualiza. ¿Prefieres conectar un agente explícitamente? lnk onboard --agent claude-code --write --hooks sigue haciendo exactamente eso.

lnk proof crea un workspace desechable, escribe una memoria revisada y la recupera a través de la misma ruta 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 runtime MCP y conecta el agente — incluidos los hooks de sesión que capturan memoria automáticamente mientras trabajas (cambia claude-code por codex, cursor, kiro, copilot, antigravity u otros). Añade --write para previsualizar la configuración sin tocar nada, o añade --agent para solo crear el workspace.

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

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

O siembra tu repositorio actual como un paso separado para que el primer recuerdo real no esté vacío:

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 deberían seguir usando propuestas de memoria revisadas para preferencias y decisiones.

La fórmula 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 UI local: preparación, siembra de contexto de proyecto, primera memoria, conexión de agentes y prompts 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 del payload del grafo y una estimación de cuánto contexto amplio de wiki evitó enviar a un agente el paquete acotado de Link.

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 la barra de menús (macOS)

La memoria de Link, ambiental. LinkBar pone la puerta de revisión en tu barra de menú: una paleta global (⌥⌘M) para recordar o memorizar desde cualquier app, notificaciones nativas con Aceptar de un toque cuando llega una captura de sesión, un pulso en vivo mientras los agentes escriben, y un navegador sobre cada archivo de memoria — todo ejecutándose con los mismos comandos lnk revisados que la CLI.

brew install --cask gowtham0992/link/linkbar

Sin firma a propósito (sin tarifa de Apple inflando nada): el cask elimina la marca de cuarentena al instalar, así que se abre como cualquier app. Para compilar desde el código fuente: cd apps/LinkBar && bash Scripts/bundle.sh --install.

Demo Impactante: Una Memoria, Dos Agentes

Este es el momento para el que Link fue creado:

1. En un agente, di:

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

2. En otro agente conectado al mismo workspace ~/link, di:

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

3. El segundo agente debería recuperar la memoria revisada desde el 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 se ajuste a 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 skills 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 la memoria respaldada por fuentes y explora el grafo de conocimiento — todo en 127.0.0.1, sin cuentas, sin backend.

¿Prefieres skills en lugar de MCP? Link incluye skills CLI pequeñas y cargables bajo demanda en skills/. Permiten que un agente use lnk health, lnk query, lnk ingest-status, lnk session-end y lnk remember directamente, sin configuración de 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: Link Skills.

Instalación 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 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 orientados a CLI o skills 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 workspace 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 muestran una vista previa de 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 session-hook — Claude Code, Codex y Cursor — añade --hooks (también funciona con lnk onboard) para hacer automático el bucle de memoria: el brief se inyecta al inicio de la sesión y las notas solo-propuesta se capturan al final de la sesión, así la memoria ya no depende de que el agente recuerde llamar a Link. Las sesiones vacías y los eventos de fin duplicados se omiten, y cuando el backlog se acumula, el brief sugiere al agente ofrecer una pasada de solo lectura lnk consolidate. La memoria duradera aún requiere tu aprobación. El soporte de hooks para 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 la opción predeterminada y el respaldo. La coincidencia por paráfrasis es opcional: después de los dos comandos de configuración siguientes, "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 embeddings estáticos. La recuperación nunca toca la red: el modelo se carga solo sin conexión después de una configuración explícita única, los embeddings 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 limitadas 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 por solapamiento de tokens de 0.589 a 0.749 y el hit@3/hit@5 de paráfrasis pura (cero solapamiento de tokens) 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 en 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 rerank opcional). 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 un vault existente en raw/ para la ingesta del agente, o abrir ~/link/wiki directamente como vault 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

Internamente, 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 "remember" 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 simple 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.

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 de CLI y skills llaman al mismo comportamiento central a través de lnk.

• status: readiness, estado del esquema, validación, escrituras interrumpidas y próximas acciones seguras.
• recall: la única ruta de lectura para briefs 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 recuperada lleva una etiqueta confidence (strong, moderate, weak) y un campo match (lexical, semantic, hybrid cuando el nivel semántico local opcional está instalado), así los agentes verifican 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, review_after opcional y expires_at opcional.
• 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 revisión del ciclo de vida — además de review(action="consolidate"), un plan de backlog 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 Link Memory Contract: readiness primero, recuperación acotada, escrituras de memoria explícitas, herramientas de auditoría y semántica de compartición.

Usa review_after para preferencias o decisiones sensibles al tiempo. Cuando llega esa fecha, la memoria reaparece en la bandeja de revisión de Link para que un agente pueda pedir al usuario confirmarla, actualizarla, archivarla u olvidarla 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 pide al usuario actualizarla, archivarla o eliminarla. Usa visibility para separar dónde aplica una memoria de quién debería verla: private permanece personal, project está destinada a un workspace de proyecto y team significa que el usuario aprobó explícitamente compartirla con un equipo.

Para traspaso de equipo o revisión de seguridad, lnk compliance-export --output audit.json escribe un paquete JSON redactado con readiness, 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 auditoría 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 muestra una vista previa de lo que se restauraría. Pasar --confirm reemplaza archivos locales después de crear un respaldo de seguridad cuando es 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 snapshot de rollback; lnk operations ~/link --recover <marker> --confirm restaura el snapshot después de que lo revises.

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

Para memoria de equipo respaldada por Git, lnk team-sync ~/link comprueba si el workspace está listo para compartir páginas wiki/ revisadas mientras mantiene raw/, cachés, respaldos, marcadores Python locales de MCP 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 "ready" cuando la bandeja de entrada de memoria no está clara o las memorias activas visibility: private serían incluidas 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 del visor local:

lnk share "Prefer local memory" ~/link

Para un paquete de revisión estático y de solo lectura, lnk snapshot exporta HTML de wiki renderizado sin raw/, capturas, marcadores de operación, estado MCP en vivo ni páginas de memoria de forma predeterminada. --include-memories exporta solo memorias no privadas; usa --include-private-memories únicamente para un archivo personal o una revisión explícitamente aprobada. Bloquea la exportación si las páginas wiki contienen valores con aspecto secreto 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 comprobar 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 el contexto duradero.
4. ingest antes de tocar fuentes sin procesar y después de ediciones de fuentes para comprobaciones de validación/reconstrucción.
5. remember solo cuando el usuario pida explícitamente a Link que recuerde algo o apruebe 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 la CLI instalada, el servidor MCP, la interfaz web local o el tiempo de ejecución de la wiki.
• Sin backend alojado.
• Sin llamadas externas a API desde serve.py o link-mcp.
• Las fuentes sin procesar y las páginas wiki generadas son ignoradas por git por defecto.
• lnk backup excluye raw/ a menos que pases explícitamente --include-raw.
• Claves de API con aspecto secreto, tokens de proveedor, JWT, credenciales de registro y bloques de claves privadas se detectan en fuentes sin procesar, capturas y comprobaciones de higiene de lanzamiento. lnk validate y lnk doctor también fallan si se encuentran valores con aspecto secreto dentro de las páginas 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 los embeddings viven en JSON plano bajo .link-cache/.
• Los ganchos 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 trabajos de lanzamiento más grandes antes de que se proponga a main.

Antes de abrir un 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 contribuciones: Contribuciones.

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

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