Link

¿Qué es Link?

Link es una capa de memoria de código abierto para agentes de IA locales. Las fuentes sin procesar se convierten en una wiki Markdown inspeccionable. Las solicitu des explícitas de «recuerda esto» se convierten en recuerdos revisables. Los agentes recuperan un contexto compacto y respaldado por fuentes a través de la CLI, MCP, las skills 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 una memoria duradera que se queda en tu máquina, sigue siendo legible en archivos de texto plano y puede compartirse entre varios agentes en lugar de quedar encerrada en un único perfil de proveedor.

Related MCP server: mcp-ltm

Cómo funciona

Link ofrece a los agentes cuatro acciones sencillas:

1. Captura notas, transcripciones, documentos, capturas de pantalla y contexto del 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, las skills oficiales o el visor web local.

La mayoría de las sesiones de agentes empiezan de cero. Tú 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: mantener el conocimiento fuera de la ventana de chat, hacer que las afirmaciones sean inspeccionables y dejar que el contexto se acumule con el tiempo.

Por qué Link es diferent

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 asumió cuatro compromisos arquitctónicos que esos diseños no pueden añadir a posteriori:

1. Memoria que puedes leer. Cada recuerdo es un archivo Markdown de texto plano — ábrelo, házle grep, házle git diff. Si Link desapreciera mañana, tu memoria seguiría siendo tuya.

2. Escrituras contoladas 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 la recuperación son deterministas — nada puede alucinar un hecho en tu memoria, porque no hay ningún 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 solo se cargan sin conexión tras una configuación explícita.

Y las afirmaciones están medidas, no son simples declaraciones — 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 cifra incluye su configuación, su modelo de juez, sus salvedades y los expermentos que perdieron — incluido LongMemEval de extremo a extremo, donde volvimos a evaluar ambos lados con el árbitro neutral Hunyuan 3: las respuestas de GPT-5 de mem0 puntúan 91.0%, y las del modelo económico de Link, 80.6%. Su cifra publicada se sostiene, y la brecha sigue al modelo de respuesta, no a la capa de memoria — eso es lo que aísla la fila de recuperación de evidencia del 99.4% anteror. Metodología completa y pasos de reproducción: benchmarks/RESULTS.md.

Memoria que puedes llevar a cualquiera parte — 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 bare en tu homelab — sin servidor ni cuenta. Los secretos se analizan antes de que nada salga, los conflictos se convierten en elementos de revisión en lugar de marcadores de git, y las capturas privadas nunca se sincroniizan. lnk team-sync ejecuta un cerebro de equipo compartido sobre los mismos raíles.

"¿Qué creía en ese entonces?" Pregunta en lenguaje natural: lnk recall "where does local data live in March" devuelve lo que era cierto entonces, reconstruido a partir de los archvos fechados y de 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 en un momento dado desde lenguaje natural: 0.917, idéntico 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, recuperaciones que ellos deciden hacer — y lnk wins responde con recuentos, mientras que lnk digest informa de la historia semanal, incluendo memorias que nunca se han recuperado. El libro de registro almacena qué memoria se leyó y cuándo, nunc a lo que preguntaste; nunc a se sincroniiza, y LINK_USAGE=off lo desactiva. Y la memoria lleg a todos los agentes, no solo a los conectados: la primera respueta de herramienta MCP de una sesión lleva el resúmen, sea cual sea la herramienta llamada.

Inicio rápido

Dos comandos: verlo funcionar y luego hacerlo 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 espacio de trabajo, todos los agentes leen la misma memoria). Es idempotente: después de cualquier brew upgrade, vuélve a ejecutarlo y todo — runtime del espacio de trabajo, aprovisiónamiento MCP, hooks — se actualiza. ¿Prefieres conectar un agente explícitamente? lnk onboard --agent claude-code --write --hooks sigue haciendo exactmente eso.

lnk proof crea un espacio de trabajo desechable, escrib e una memoria revisada y la recupera a través del mismo camino que usan la CLI, las skills 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 crea entonces ~/link, aprovisiona el runtime de MCP y conecta al agente, incluidos los hooks de sesión que capturan la memoria automáticamente mientras trabajas (sustituye claude-code por codex, cursor, kiro, copilot, antigravity u otros). Elimina --write para previsuali zar la configuación sin tocar nada, o elimina --agent para crear solo el espacio de trabajo.

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

¿Quieres ver primero la interfaz, el grafo y las páginas de origen? lnk try && lnk serve link-demo. Las rutas para Windows, checkout del código fuente, solo MCP y primero skills están en la guía First 10 Minutes.

O siembra tu repositorio actual como un paso aparte 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 archvos de proyecto permitidos como README.md, AGENTS.md, CLAUDE.md, .cursorrules y archvos de reglas del editor, bloquea valores con aspecto de secreto, escrib e una págin a de proyecto respaldada por la fuent e y reconstruye el grafo. No crea memorias duraderas; los agentes deberían segir usando propuestas de memoria revisadas para preferencias y deciciones.

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 comprobación de la primera ejecución en la interfaz local: disponibilidad, siembra del contexto del proyecto, primera memoria, conexión del agente e indicaciones iniciales. El visor web es solo de uso local. Se vincula a 127.0.0.1, no tiene cuentas de usario ni autenticación, y no debería exponerse a Internet salvo 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 de rendimiento como de evidencia de valor: temporizaciones de caché/búsqueda/consulta, forma del payload del grafo y una estimación de cuánto contexto amplio de wiki evitó enviar al agente el paquete Link acotado.

La página /health refleja el bucle de disponibilidad en el navegador: estado de validación, escrituras interumpidas, estado de revisión de memoria y comandos de reparación copiables. El visor sigue siendo document-first: rutas comunes en la navegación superior, herramientas más profundas en more y un esquema de contenidos además de enlaces relacionados con el grafo en las páginas estructuradas.

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

LinkBar — la app de la barra de menú (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 Accept en un toque cuando lleg a una captura de sesión, un pulso en vivo mientras los agentes escriben y un navegador sobre cada archvo de memoria — todo ejecutándose con los mismos comandos lnk revisados que la CLI.

brew install --cask gowtham0992/link/linkbar

Sin firmar a propósito (sin cuota de Apple que infle nada): el cask elimina el indicador de cuarentena al instalar, así que se abre como cualquier app. Si compilas desde el código fuent e: 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 recuperar la memoria revisada desde el Markdown local en lugar de pedirte que te repitas.

Para una versión automati zada y limpia de la misma idea, ejecuta:

lnk proof

Formas de usar Link

Elige la superificie que se adapte a cómo trabajas. Todas leen y escriben la misma wiki de Markdown local.

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

¿Prefieres skills en lugar de MCP? Link incluye skills pequeñas y cargables de forma perezosa en skills/. Permiten que un agente use lnk health, lnk query, lnk ingest-status, lnk session-end y lnk remember directamente, sin configuació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 instador 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 instadores crean o actualizan ~/link, instalan o mejran link-mcp, escriben instrucciones ligeras para el agente y conservan los datos existentes de la wiki en la reinstalación. Usa --project cuando un repositorio necesite memoria de proyecto separada.

En Windows, usa el instador 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 orientados a la 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 configuació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 ayudante de conexión de menor nivel. Ambos previsuali zan la configuación exacta primero; añade --write cuando quieras que Link actualice el archvo de configuació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 hooks de sesión — Claude Code, Codex y Cursor — añade --hooks (también funciona con lnk onboard) para que el bucle de memoria sea automático: el resúmen se inyecta al inicio de la sesión y las notas de solo propuesta se capturan al final de la sesión, de modo que la memoria ya no depinde de que el agente recuerde llamar a Link. Las sesiones vacías y los eventos de fin duplicados se omiten, y cuando la cola de pendientes se acumula, el resúmen sugiere al agente ofrecer una pasada de solo lectura lnk consolidate. La memoria duradera sigue requiriendo tu aprobación. El soporte de hooks de Codex y Cursor es nuevo (conectado a sus esquemas documentados — informa de los probemas).

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 por defeco y la de respaldo. La coincidencia por parafraseo es opcional: después de los dos comandos de configuación siguientes, «cómo debería estructurar mis pull requests» encuentr a una memoria guardada sobre el estilo de los commits. Hasta entonces, la recuperación coincie en palabras compartidas, y un fallo te dice cómo activar la coincidencia por parafraseo. 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 carg a solo sin conexión después de una configuación explícita única, los embeddings viven en JSON plano dentro de .link-cache/, la similitud se ejecuta en el mismo proceso sin base de datos vectorial, y las coincidencias solo semánticas llevan etiquetas de confianza con tope 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 caliad eleva el hit@1 por superposición de tokens de 0.589 a 0.749 y el hit@3/hit@5 de parafraseo puro (cero superposición 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 con evidencia anotada 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 re-rank 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"]
    }
  }
}

--surface slim es la superificie MCP recomendada para agentes: seis herramientas evidientes para recordar, recuperar, ingerir, revisar, estado y vías de escape de administración. La superificie de compatibilidad completa sigue disponible con --surface full.

En macOS/Python de Homebrew, si pip informa de externally-managed-environment, usa un venv dedicado:

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

Configuación completa: guía de MCP.

Los usarios de Obsidian pueden importar una bóveda existente a raw/ para la ingesta del agente, o abrir ~/link/wiki directamente como 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. Deja notas crudas, transcrpciones, 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 para el agente tanto de la wiki como de la capa de memoria.

El modelo de almacenamiento es simple e inspeccionable:

Si un archivo sin procesar ya se ingirió y luego se editó, lnk ingest-status lo marca como obsolieto e indic a tu agente que actualice la página de origen existente en lugar de crear un duplicado.

Qué Obtienen los Agentes

Cuando un agente usa Link a través de la superficie MCP recomendada, obiene seis herramientas orientadas al modelo. Los flujos de trabajo de CLI y skills invocan el mismo comportamiento central mediante lnk.

• status: preparación, estado del esquema, validación, escrituras interrumpidas y próximas acciones seguras.

• recall: la única ruta de lectura para resúmenes de inicio, paquetes de consulta listos para responder, búsqueda en el 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), por lo que los agentes verifican las coincidencias débiles o parafraseadas con el usuario en lugar de confiar en ellas.

• remember: memoria local duradera solo tras 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: pasos exactos a seguir para archivos sin procesar, segurid de las fuentes, detección de ingesta obsolieta, validación y comprobaciones de reconstrucción.

• review: bandeja de entrad de memória, perfil, audtoría, registo, explcación, archivo, restauración, olvido y flujos de revisión de ciclo de vida; además de review(action="consolidate"), un plan de trabajo pendiente de solo lectura que se aplica únicamente con la aprobación del usuário para cada acción.

• admin: la vía de escape para copias de segurid, migración, exportación de grafos, páginas, capturas, reconstrucciones, acciones de compatibilidad y actualizaciones avanzadas.

El bucle estable orientado a agentes está documentado en Contrato de Memoria de Link: preparación 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 que la confirme, actualice, archive u olvide, en lugar de confiar en contexto obsoleto.

Usa expires_at para contexto temporal que deba salir automáticamente de la recuperación predeterminada después de una fecha; Link mantiene la página Markdown inspeccionable y pide al usuario que la actualice, archive o elimine.

Usa visibility para separar dónde se aplica una memoria de quién debe verla: private permanece personal, project está pensado para un espacio de trabajo de proyecto y team significa que el usuario aprobó explícitamente compartirla con un equipo.

Para el traspaso de 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. El contenido de las fuentes sin procesar y los cuerpos de las memorias no se incluyen.

Para la auditabilidad del día a día, lnk memory-log ~/link muestra lo que Link recordó, actualizó, revisó, archivó, restauró, olvidó o aceptó recientemente de capturas sin procesar.

Para la 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. Al pasar --confirm se reemplazan los archivos locales después de crear un respaldo de seguridad cuando sea posible; raw/ sigue excluido a menos que se indique --include-raw explícitamente. Si una escritura de varios 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 una prueba de valor local, lnk wins ~/link muestra memorias reutilizables, memoria revisada, procedencia, continuidad del proyecto, salvaguardas de actualidad y prompts copiables sin rastrear el comportamiento del usuario.

Para la memoria de equipo respaldada por Git, lnk team-sync ~/link comprueba si el espacio de trabajo está listo para compartir páginas revisadas de wiki/ mientras mantiene raw/, cachés, copias de seguridad, marcadores locales de MCP Python 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 varios usuarios crearía falsas alarmas de manipulación. La sincronización de equipo también bloquea el estado "ready" cuando la bandeja de memoria no está despejada o cuando memorias activas con visibility: private se incluirían mediante un git add wiki amplio.

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

Para un compañero de equipo, un 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 el HTML renderizado del wiki sin raw/, capturas, marcadores de operación, estado MCP en vivo ni páginas de memoria por defecto. --include-memories exporta solo memorias no privadas; usa --include-private-memories únicamente para un archivo personal o una revisión aprobada explícitamente. Bloquea la exportación si las páginas del wiki contienen valores con aspecto de 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 del agente

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

1. status para comprobar la preparación y las próximas 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 las fuentes sin procesar y después de ediciones de fuentes para comprobaciones de validación/reconstrucción.

5. remember solo cuando el usuario pide explícitamente a Link que recuerde algo o aprueba una memoria propuesta.

6. review para los flujos 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 grafos, capturas, reconstrucciones, acciones de compatibilidad y mantenimiento avanzado.

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

Privacidad y seguridad

Link es local-primero:

• Sin telemetría en el CLI instalado, el servidor MCP, la IU web local o el runtime del wiki.

• Sin backend alojado.

• Sin llamadas externas a API desde serve.py o link-mcp.

• Las fuentes sin procesar y las páginas generadas del wiki son ignoradas por git por defecto.

• lnk backup excluye raw/ a menos que pases explícitamente --include-raw.

• Las claves de API, tokens de proveedor, JWT, credenciales de registro y bloques de claves privadas con aspecto de secreto 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 de secreto dentro de las páginas del wiki antes de que puedan servirse a través de la IU local o devolverse mediante el contexto del agente.

• La recupración semántica opcional permanece local: los modeos se cargan solo sin conexión en el momento de la recupración (solo el lnk semantic --setup explícito puede descargar un modeo, una vez), y los embeddings viven en JSON plano bajo .link-cache/.

• Los hooks automáticos de sesión almacenan notas de solo propuesta; la extracción de transcripciones omite las llamadas y salidas de herramientas, y no se escribe memória duradera sin revisión.

• El servidor web local se vincula a 127.0.0.1 y no está pensado para exponerse a internet sin autenticación adicional.

Antes de compartir un repositorio, una demo o un 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 mediante pull requests dirigidas a main. La rama develop es una rama de integración para mantenedores destinada a trabajo de lanzamiento de mayor envergadura antes de proponerse 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 del contribuidor: Contribuciones.

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

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