Link

Link

Memória local para agentes de IA.

O Link dá ao Codex, Claude, Cursor, Kiro, VS Code, Copilot, Antigravity e outros agentes locais a mesma memória com origem em fontes, armazenada localmente como Markdown.

Site · Como funciona · Memória · Ferramentas e CLI · Configuração · Documentação · Registro MCP · PyPI · Homebrew

Início rápido

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

Depois, trabalhe normalmente. Diga a um agente "lembre que fazemos deploy às terças", aprove uma vez, e todos os outros agentes vão lembrar disso em uma nova sessão amanhã.

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

A memória vive em Markdown simples que você pode abrir, e nada se torna durável sem a sua aprovação.

O que é o Link?

O Link é uma camada de memória de código aberto para agentes de IA locais. Fontes brutas se tornam um wiki Markdown inspecionável. Pedidos explícitos de "lembre disso" se tornam memórias revisáveis. Os agentes recuperam contexto compacto com origem nas fontes por meio da CLI, MCP, habilidades oficiais ou do visualizador local, sem despejar o wiki inteiro em uma janela de chat.

O wiki é a camada de armazenamento. O produto é memória durável que fica na sua máquina, permanece legível em arquivos simples e pode ser compartilhada entre vários agentes, em vez de ficar presa em um perfil de um único fornecedor.

Pergunte com suas próprias palavras; o Link encontra pelo significado, não por palavras-chave. Tudo local, tudo em arquivos simples.

Como funciona

O Link dá aos agentes quatro movimentos simples:

1. Capturar anotações, transcrições, documentos, capturas de tela e contexto de projeto em raw/.
2. Estruturar páginas com origem nas fontes em wiki/.
3. Lembrar preferências, decisões, fatos e contexto de projeto explícitos como memória revisável.
4. Recuperar pacotes de consulta compactos por meio da CLI, MCP, habilidades oficiais ou do visualizador web local.

A maioria das sessões de agente começa do zero. Você reexplica preferências, decisões de repositório, restrições de projeto e por que algo importa. O Link transforma esse contexto repetido em memória local que os agentes podem consultar.

O Link segue o padrão LLM Wiki de Andrej Karpathy: mantenha o conhecimento fora da janela de chat, torne as afirmações inspecionáveis e deixe o contexto se acumular ao longo do tempo.

Por que o Link é diferente

Todos os outros sistemas de memória para agentes armazenam memória como embeddings em um banco vetorial ou como um grafo extraído por LLM. O Link fez quatro compromissos arquiteturais que esses designs não conseguem adicionar depois:

1. Memória que você pode ler. Cada memória é um arquivo Markdown simples — abra-o, use grep, faça git-diff. Se o Link desaparecer amanhã, sua memória ainda é sua.
2. Gravações com portão de revisão. Agentes propõem; você aprova. Até os ganchos automáticos de sessão capturam propostas, nunca fatos.
3. Sem LLM na camada de memória. Ingestão e recuperação são determinísticas — nada pode alucinar um fato na sua memória, porque não há modelo no caminho de gravação.
4. Comprovadamente local. O CI bloqueia código de rede de saída no runtime, e os modelos semânticos opcionais carregam somente offline após uma configuração explícita.

E as afirmações são medidas, não apenas declaradas — veja os benchmarks abaixo. Comparações nomeadas contra Mem0/OpenMemory, Zep/Graphiti e Letta: Por que o Link?

Benchmarks

Arquivos simples sem LLM na camada de memória, medidos contra os sistemas que têm um em todo lugar:

Cada número acompanha sua configuração, modelo de juiz, ressalvas e os experimentos que perderam — incluindo o ponta a ponta LongMemEval, onde reavaliamos os dois lados sob o árbitro neutro Hunyuan 3: as respostas do GPT-5 do mem0 pontuam 91,0%, as respostas do modelo de orçamento do Link 80,6%. O número publicado deles se sustenta, e a lacuna acompanha o modelo de resposta, não a camada de memória — é isso que a linha de recuperação de evidências de 99,4% acima isola. Metodologia completa e passos de reprodução: benchmarks/RESULTS.md.

Memória que você pode levar para qualquer lugar — e provar que funciona

Três perguntas que todo sistema de memória deveria responder, e como o Link responde com mecanismos em vez de promessas:

"Está em todas as minhas máquinas?" lnk sync move memória revisada por um remoto git que você controla — um repositório GitHub privado, um repositório bare de homelab — sem servidor e sem conta. Segredos são verificados antes de qualquer coisa sair, conflitos viram itens de revisão em vez de marcadores git, e capturas privadas nunca sincronizam. lnk team-sync executa um cérebro de equipe compartilhado nos mesmos trilhos.

"O que eu acreditava naquela época?" Pergunte em linguagem simples: lnk recall "onde os dados locais ficam em março" retorna o que era verdade na época, reconstruído dos arquivos datados e da linhagem de substituição deles — enquanto a mesma pergunta sem a data retorna a verdade de hoje. Determinístico: uma regex e um calendário, sem modelo. Precisão pontual em linguagem simples: 0,917, idêntico a perguntar com uma data ISO.

"Meu agente está realmente usando isso?" A pergunta que a maioria dos sistemas de memória não consegue responder sobre si mesmos. O Link registra recuperações localmente — resumos de sessão enviados aos agentes, recuperações que eles escolheram fazer — e lnk wins responde com contagens, enquanto lnk digest relata a história semanal incluindo memórias que nunca foram recuperadas. O registro armazena qual memória foi lida e quando, nunca o que você perguntou; ele nunca sincroniza, e LINK_USAGE=off o desativa. E a memória alcança todos os agentes, não apenas os conectados: a primeira resposta de ferramenta MCP de uma sessão carrega o resumo, independentemente da ferramenta chamada.

Início rápido

Dois comandos: veja funcionar, depois torne-o seu.

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

Já tem memória espalhada por ferramentas? Traga-a para casa como propostas revisáveis — nada é aceito automaticamente:

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

lnk setup detecta os agentes instalados na sua máquina — Claude Code, Codex, Cursor, Windsurf, Zed, Kiro, Gemini CLI — e conecta todos de uma vez; o Link é agnóstico de agente por design (um servidor MCP, um workspace, todos os agentes leem a mesma memória). Ele é idempotente: após qualquer brew upgrade, execute novamente e tudo — runtime do workspace, provisionamento MCP, ganchos — é atualizado. Prefere conectar um agente explicitamente? lnk onboard --agent claude-code --write --hooks ainda faz exatamente isso.

lnk proof cria um workspace descartável, escreve uma memória revisada e a recupera pelo mesmo caminho que a CLI, habilidades e MCP usam — a promessa central (uma memória local, reutilizável por diferentes agentes, sem perfil em nuvem) em um 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 então cria ~/link, provisiona o runtime MCP e conecta o agente — incluindo os ganchos de sessão que capturam memória automaticamente enquanto você trabalha (troque claude-code por codex, cursor, kiro, copilot, antigravity ou outros). Adicione --write para visualizar a configuração sem tocar em nada, ou adicione --agent para apenas criar o workspace.

O comando instalado é lnk porque link já é um utilitário de sistema POSIX/macOS. A partir de um checkout da fonte, use python3 link.py ....

Quer a interface, o grafo e as páginas de fonte primeiro? lnk try && lnk serve link-demo. Caminhos para Windows, checkout da fonte, somente MCP e primeiro com habilidades estão no guia Primeiros 10 Minutos.

Ou semeie seu repositório atual como uma etapa separada para que a primeira recuperação real não fique vazia:

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

lnk seed lê arquivos de projeto na lista de permissões, como README.md, AGENTS.md, CLAUDE.md, .cursorrules e arquivos de regras do editor, bloqueia valores que parecem segredos, escreve uma página de projeto com origem nas fontes e reconstrói o grafo. Ele não cria memórias duráveis; os agentes ainda devem usar propostas de memória revisadas para preferências e decisões.

A fórmula Homebrew é mantida no tap público gowtham0992/homebrew-link.

Abra:

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

Use /onboard quando quiser a mesma lista de verificação da primeira execução na interface local: prontidão, semeadura de contexto de projeto, primeira memória, conexão de agente e prompts iniciais. O visualizador web é apenas para uso local. Ele vincula a 127.0.0.1, não tem contas de usuário ou autenticação, e não deve ser exposto à internet a menos que você adicione sua própria camada de autenticação.

Experimente o ciclo 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 relata evidências de desempenho e valor: tempos de cache/busca/consulta, formato do payload do grafo e uma estimativa de quanto contexto amplo do wiki o pacote limitado do Link evitou enviar a um agente. A página /health espelha o loop de prontidão no navegador: estado de validação, gravações interrompidas, status de revisão de memória e comandos de reparo copiáveis. O visualizador permanece centrado no documento — caminhos comuns na navegação superior, ferramentas mais profundas sob more, e um sumário de conteúdo além de links relacionados a grafos em páginas estruturadas.

A demonstração gerada é a wiki de prova pública. Conteúdo gerado dentro de wiki/, raw/ e link-demo/ é ignorado pelo git para que memória pessoal não seja publicada por acidente.

LinkBar — o app de barra de menus (macOS)

A memória do Link, de forma ambiente. O LinkBar coloca o portão de revisão na sua barra de menus: uma paleta global (⌥⌘M) para recordar ou lembrar de qualquer app, notificações nativas com Aceitar em um toque quando uma captura de sessão chega, um pulso ao vivo enquanto agentes estão gravando, um navegador sobre cada arquivo de memória e um painel de status que sinaliza memórias nomeando arquivos que seu repositório não tem mais — tudo rodando nos mesmos comandos lnk revisados que a CLI. Escolha o workspace nas Configurações; o padrão é ~/link.

brew install --cask gowtham0992/link/linkbar

Sem assinatura de propósito (sem taxa da Apple inflando nada): o cask remove a flag de quarentena na instalação, então ele abre como qualquer app. Para compilar a partir do código-fonte: cd apps/LinkBar && bash Scripts/bundle.sh --install.

Demonstração Matadora: Uma Memória, Dois Agentes

Este é o momento para o qual o Link foi feito:

1. Em um agente, diga:

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

2. Em outro agente conectado ao mesmo workspace ~/link, diga:

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

3. O segundo agente deve recordar a memória revisada do Markdown local em vez de pedir que você se repita.

Para uma versão automatizada e limpa da mesma ideia, execute:

lnk proof

Maneiras de Usar o Link

Escolha a superfície que combina com como você trabalha. Todas leem e gravam a mesma wiki Markdown local.

Essas superfícies são independentes. lnk serve / serve.py é apenas o visualizador web local. Comandos CLI, skills oficiais e ferramentas MCP leem os mesmos arquivos wiki/ diretamente, então Claude, Codex, Kiro, Cursor ou outro agente podem usar o Link mesmo quando o visualizador web não está em execução.

O visualizador web local: navegue pela memória com suporte a fontes e explore o grafo de conhecimento — tudo em 127.0.0.1, sem contas, sem backend.

Prefere skills em vez de MCP? O Link acompanha skills CLI pequenas e carregáveis sob demanda em skills/. Elas permitem que um agente use lnk health, lnk query, lnk ingest-status, lnk session-end e lnk remember diretamente, sem configuração de MCP ou um visualizador web em execução.

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

Guia completo: Link Skills.

Instale para o Seu Agente

Execute um instalador a partir do 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

Os instaladores criam ou atualizam ~/link, instalam ou atualizam link-mcp, gravam instruções leves de agente e preservam dados existentes da wiki na reinstalação. Use --project quando um repositório precisar de memória de projeto separada.

No Windows, use o instalador PowerShell correspondente:

.\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

Então pergunte ao seu 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 que priorizam CLI ou skills do Link, use o mesmo loop de inicialização diretamente:

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

Se você quiser uma configuração guiada para um workspace real e um agente, use lnk onboard --agent AGENT. Se o seu agente já tem instruções e você só precisa da conexão MCP, use o auxiliar de conexão de nível inferior. Ambos visualizam a configuração exata primeiro; adicione --write quando quiser que o Link atualize o arquivo de configuração do 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 com suporte a hooks de sessão — Claude Code, Codex e Cursor — adicione --hooks (funciona com lnk onboard também) para tornar o loop de memória automático: o briefing é injetado no início da sessão e notas somente de proposta são capturadas no final da sessão, então a memória não depende mais do agente lembrar de chamar o Link. Sessões vazias e eventos de término duplicados são ignorados, e quando o acúmulo de pendências aumenta, o briefing incentiva o agente a oferecer uma passagem lnk consolidate somente leitura. Memória durável ainda exige sua aprovação. O suporte a hooks do Codex e do Cursor é novo (conectado aos seus esquemas documentados — relate 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: recordação semântica híbrida (ainda totalmente local)

A recordação lexical é sempre o padrão e o fallback. A correspondência por paráfrase é opt-in: após os dois comandos de configuração abaixo, "como devo estruturar meus pull requests" encontra uma memória salva sobre estilo de commit. Até lá, a recordação corresponde por palavras compartilhadas, e uma falha informa como ativar a correspondência por paráfrase. Instalar o extra semântico opcional adiciona um pequeno modelo local de embeddings estáticos. A recordação nunca toca a rede: o modelo carrega somente offline após uma configuração explícita única, os embeddings ficam em JSON simples sob .link-cache/, a similaridade roda no processo sem banco de dados vetorial, e correspondências somente semânticas carregam rótulos de confiança limitados para que agentes verifiquem antes de confiar nelas.

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, não afirmado: no benchmark integrado de 1.176 casos, o nível de qualidade eleva o hit@1 de sobreposição de tokens de 0,589 para 0,749 e o hit@3/hit@5 de paráfrase pura (sobreposição zero de tokens) em ~4×, a ~10 ms por recordação sem serviço ou banco de dados vetorial. Na trilha de recuperação LoCoMo de terceiros (1.536 perguntas anotadas com evidências em 5.882 turnos de conversa), a recordação híbrida eleva o hit@10 de qualquer evidência de 0,628 para 0,737 (0,794 com o nível de reclassificação opt-in). Metodologia completa, limitações honestas e passos de reprodução: 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

Usuários do Obsidian podem importar um cofre existente para raw/ para ingestão por agente, ou abrir ~/link/wiki diretamente como um cofre para editar páginas do Link:

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

Veja o guia do Obsidian para o loop de importação, edição e validação.

Modelo de Armazenamento

Por baixo dos panos, o Link separa conhecimento com suporte a fontes de memória durável de agente:

1. Coloque notas brutas, transcrições, artigos e contexto de projeto em raw/.
2. Agentes compilam essas fontes em páginas inspecionáveis sob wiki/.
3. Solicitações explícitas de "lembrar" tornam-se páginas de memória revisáveis.
4. Consultas recuperam contexto compacto de agente tanto da wiki quanto da camada de memória.

O modelo de armazenamento é simples e inspecionável:

Se um arquivo bruto já foi ingerido e depois editado, lnk ingest-status o marca como desatualizado e informa ao seu agente para atualizar a página de fonte existente em vez de criar uma duplicata.

Exportações estruturadas com um esquema suportado podem usar ingestão determinística. O planejamento é somente leitura; a aplicação prepara o resultado completo, reconstrói o grafo, valida-o e registra a propriedade da saída antes de alterar a wiki ativa:

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

Execuções posteriores atualizam apenas saídas de propriedade do adaptador. Edições manuais tornam-se conflitos. --replace-unmanaged é necessário para uma primeira migração sobre páginas existentes, e --prune é necessário para aposentar páginas gerenciadas que não estão mais no plano. Notas e artigos arbitrários continuam pela ingestão de autoria do agente porque sua estrutura útil não pode ser inferida com segurança apenas a partir de um formato de arquivo.

O Que os Agentes Obtêm

Quando um agente usa o Link pela superfície MCP recomendada, ele obtém seis ferramentas voltadas ao modelo. Fluxos de trabalho de CLI e skill chamam o mesmo comportamento central por meio de lnk.

• status: prontidão, estado do esquema, validação, gravações interrompidas e próximas ações seguras.
• recall: o único caminho de leitura para briefings de inicialização, pacotes de consulta prontos para resposta, busca na wiki, contexto de grafo, orçamentos de tokens e ações de acompanhamento. Cada memória recordada carrega um rótulo confidence (strong, moderate, weak) e um campo match (lexical, semantic, hybrid quando o nível semântico local opcional está instalado), para que agentes verifiquem correspondências fracas ou por paráfrase com o usuário em vez de confiar nelas.
• remember: memória local durável somente após aprovação explícita do usuário, com verificações de duplicata/conflito, proveniência, estado de revisão, visibilidade, review_after opcional e expires_at opcional.
• ingest: próximos passos exatos para arquivos brutos, segurança de fontes, detecção de ingestão desatualizada, validação e verificações de reconstrução.
• review: caixa de entrada de memória, perfil, auditoria, log, explicar, arquivar, restaurar, esquecer e fluxos de trabalho de revisão de ciclo de vida — além de review(action="consolidate"), um plano de pendências somente leitura aplicado apenas com aprovação do usuário por ação.
• admin: a saída de escape para backup, migrar, validar, exportar grafo, páginas, capturas, reconstruções, ações de compatibilidade e atualizações avançadas.

O loop estável voltado ao agente está documentado em Link Memory Contract: prontidão primeiro, recordação limitada, gravações de memória explícitas, ferramentas de auditoria e semânticas de compartilhamento.

Use review_after para preferências ou decisões sensíveis ao tempo. Quando essa data chegar, a memória reaparece na caixa de entrada de revisão do Link para que um agente possa pedir ao usuário para confirmar, atualizar, arquivar ou esquecê-la em vez de confiar em contexto desatualizado. Use expires_at para contexto temporário que deve sair automaticamente da recordação padrão após uma data; o Link mantém a página Markdown inspecionável e pede ao usuário para atualizá-la, arquivá-la ou excluí-la. Use visibility para separar onde uma memória se aplica de quem deve vê-la: private permanece pessoal, project é destinada a um workspace de projeto e team significa que o usuário aprovou explicitamente compartilhá-la com uma equipe.

Para transferência de equipe ou revisão de segurança, lnk compliance-export --output audit.json grava um pacote JSON editado com prontidão, validação, status de revisão de memória, marcadores de operação e entradas recentes do log de auditoria. Conteúdos brutos de fontes e corpos de memória não são incluídos.

Para auditabilidade do dia a dia, lnk memory-log ~/link mostra o que o Link recentemente lembrou, atualizou, revisou, arquivou, restaurou, esqueceu ou aceitou de capturas brutas. Para recuperação, o lnk backup ~/link cria um arquivo local e lnk restore-backup <archive> ~/link mostra uma prévia do que seria restaurado. Passar --confirm substitui arquivos locais após criar um backup de segurança quando possível; raw/ ainda é excluído, a menos que --include-raw seja explícito. Se uma gravação de vários arquivos for interrompida, o lnk operations ~/link mostra o marcador e qualquer snapshot de reversão; o lnk operations ~/link --recover <marker> --confirm restaura o snapshot após você revisá-lo.

Para prova de valor local, o lnk wins ~/link mostra memórias reutilizáveis, memória revisada, proveniência, continuidade de projeto, proteções de atualização e prompts copiáveis sem rastrear o comportamento do usuário.

Para memória de equipe com suporte a Git, o lnk team-sync ~/link verifica se o workspace está pronto para compartilhar páginas wiki/ revisadas, mantendo raw/, caches, backups, marcadores Python MCP locais e wiki/log.md privados por padrão. O log de auditoria é local porque possui uma cadeia de hash de máquina única; mesclar logs de vários usuários criaria falsos alarmes de adulteração. A sincronização da equipe também bloqueia o status "pronto" quando a caixa de entrada de memória não está limpa ou memórias visibility: private ativas seriam incluídas por um git add wiki amplo.

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

Para um colega, revisor ou outro agente, o lnk share resolve uma página, memória, título, alias ou frase de busca em uma URL de visualização local:

lnk share "Prefer local memory" ~/link

Para um pacote de revisão estático e somente leitura, o lnk snapshot exporta HTML de wiki renderizado sem raw/, capturas, marcadores de operação, estado MCP ativo ou páginas de memória por padrão. O --include-memories exporta apenas memórias não privadas; use --include-private-memories apenas para um arquivo pessoal ou uma revisão explicitamente aprovada. Ele bloqueia a exportação se as páginas do wiki contiverem valores com aparência de segredo, a menos que você os substitua explicitamente.

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 do Agente

Para clientes MCP, os agentes devem usar o Link nesta ordem:

1. status para verificar prontidão e próximas ações seguras.
2. recall com uma consulta vazia uma vez no primeiro turno substancial de uma sessão.
3. recall(query, budget="micro"|"small") antes de leituras amplas de arquivos ou de pedir ao usuário para repetir contexto durável.
4. ingest antes de tocar em fontes brutas e após edições de fonte para validação/verificações de reconstrução.
5. remember somente quando o usuário pedir explicitamente ao Link para lembrar algo ou aprovar uma memória proposta.
6. review para fluxos de trabalho de caixa de entrada de memória, perfil, auditoria, log, explicação, arquivamento, restauração e esquecimento.
7. admin para backup, migração, exportação de gráfico, capturas, reconstruções, ações de compatibilidade e manutenção avançada.

Lista completa de ferramentas MCP: Configuração MCP.

Privacidade e Segurança

O Link em si é local-first:

• Sem telemetria no CLI instalado, servidor MCP, interface web local ou runtime do wiki.
• Sem backend hospedado.
• Sem chamadas de API externas do serve.py ou link-mcp.
• Fontes brutas e páginas de wiki geradas são ignoradas pelo git por padrão.
• lnk backup exclui raw/ a menos que você passe explicitamente --include-raw.
• Chaves de API com aparência de segredo, tokens de provedor, JWTs, credenciais de registro e blocos de chaves privadas são detectados em fontes brutas, capturas e verificações de higiene de lançamento. lnk validate e lnk doctor também falham se valores com aparência de segredo forem encontrados dentro de páginas do wiki antes que possam ser servidos pela interface local ou retornados pelo contexto do agente.
• A recordação semântica opcional permanece local: os modelos carregam offline apenas no momento da recordação (somente o lnk semantic --setup explícito pode buscar um modelo, uma vez), e as incorporações ficam em JSON simples sob .link-cache/.
• Ganchos automáticos de sessão armazenam apenas notas de proposta; a extração de transcrições pula chamadas de ferramentas e saídas, e nenhuma memória durável é escrita sem revisão.
• O servidor web local vincula-se a 127.0.0.1 e não deve ser exposto à internet sem autenticação adicional.

Antes de compartilhar um repositório, demonstração ou wiki:

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

Mais detalhes: Guia de segurança.

Documentação

Contribuindo

As contribuições devem vir por meio de pull requests direcionados a main. O branch develop é um branch de integração de mantenedores para trabalho de lançamento maior antes de ser proposto a main.

Antes de abrir um 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

Guia completo de contribuição: Contribuindo.

Não inclua dados pessoais de wiki, fontes brutas, tokens de registro, arquivos .env ou credenciais MCP locais em um PR.

Se o Link ajudar seus agentes a lembrarem melhor, dê uma estrela no GitHub para que mais pessoas possam encontrá-lo.