Link

Was ist Link?

Link ist eine Open-Source-Speicherebene für lokale KI-Agenten. Rohe Quellen werden zu einem einsehbaren Markdown-Wiki. Explizite „Merke dir das"-Anfragen werden zu überprüfbaren Erinnerungen. Agenten rufen kompakten, quellenbasierten Kontext über die CLI, MCP, offizielle Skills oder den lokalen Viewer ab, ohne das gesamte Wiki in ein Chatfenster zu kippen.

Das Wiki ist die Speicherebene. Das Produkt ist eine dauerhafte Speicherung, die auf Ihrer Maschine bleibt, in einfachen Dateien lesbar bleibt und über mehrere Agenten hinweg geteilt werden kann, statt in einem einzigen Anbieterprofil eingeschlossen zu sein.

Related MCP server: mcp-ltm

So funktioniert's

Link gibt Agenten vier einfache Aktionen:

1. Erfasssen Sie Notizen, Transkripte, Dokmente, Bildschirmaufnahmen und Projektkontext in raw/.

2. Strukturieren Sie quellenbasiere Seiten unter wiki/.

3. Merken Sie explizite Präferenzen, Entscheidungen, Fakten und Projektkontext als überprüfbare Erinnerung.

4. Rufen Sie kompakte Abfragepakete über die CLI, MCP, offizielle Skills oder den lokalen Webviewer ab.

Die meisten Agenten-Sitzungen starten bei null. Sie erklären erneut Präferenzen, Repository-Entscheidungen, Projektbedingungen und warum etwas wichtig ist. Link verwandelt diesen wiederholten Kontext in lokalen Speicher, den Agenten abfragen können.

Link folgt Andrej Karpathys LLM-Wiki-Muster: halten Sie Wissen außerhalb des Chatfensters, machen Sie Behauptungen überprüfbar und lassen Sie Kontext sich im Laufe der Zeit anreichern.

Warum Link anders ist

Jedes andere Agenten-Speichersystem speichert Erinnerungen als Embeddings in einer Vektordateibank oder als einen von LLM extrahierten Graph. Link hat vier architektomische Verpflichtungen eingegangen, die diese Designs nicht nachträglich anbingen können:

1. Speicher, den Sie lesen können. Jede Erinnerung ist eine einfche Markdown-Datei — öffnen Sie sie, grepen Sie sie, git-diffen Sie sie. Selbst wenn Link morgen verschwände, gehört Ihrer Speicher immer noch Ihnen.

2. Überprüfte Schreibvorgänge. Agenten schlagen vor; Sie stimmen zu. Auch die automatischen Sitzungs-Hooks erfassen Vorschläge, niemals Fakten.

3. Kein LLM in der Speicherebene. Erfassung und Abruf sind deterministisch — nichts kann eine Tatsache in Ihren Speicher halluzinieren, weil es kein Modell im Schreibpfad gibt.

4. Nachweislich lokl. CI blockiert ausgehenden Netzwercode in der Laufzeit, und die optionalen semantischen Modelle laden nach einer einmaligen expliziten Einrichtung nur offline.

Und die Behauptungen sind gemessen, nicht behauptet — siehe die Benchmarks unten. Namentliche Vergleiche gegen Mem0/OpenMemory, Zep/Grapiti und Letta: Warum Link?

Benchmarks

Einfache Dateien ohne LLM in der Speicherebene, gemessen gegen die Systeme, die überall eines haben:

Jede Zahl wird mit ihrer Konfiguration, dem Richtermodell, den Einschränkungen und den Experimenten geliefert, die verloren haben — einschließlich LongMemEval end-to-end, wo wir beide Seiten unter dem neutralen Huyuan-3-Schiedsrichter neu bewerteten: mem0s GPT-5- Antworten erzielen 91.0%, Links Budget-Modell-Antworten 80.6%. Ihre veröffentliche Zahl hät stand, und die Lücke folgt dem antwortenden Modell, nicht der Speicherebene — das isoliert die Zeile mit der 99.4%-Belegabruf-Quote oben. Vollständige Methodik und Repoduktionsschritte: benchmarks/RESULTS.md.

Speicher, den Sie überallhin mitnehmen können — und beweisen können, dass er funktioniert

Drei Fragen, die jedes Speichersystem beantworten können sollte, und wie Link sie mit Mechanismen statt Versprechen beantwortet:

„Ist das auf allen meinen Rechnern?“ lnk sync verschiebt überprüftes Wissen durch ein Git-Remote, das du kontrollierst — ein privates GitHub-Repo, ein Bare-Repo im Homelab — ohne Server und ohne Konto. Geheimnisse werden gescannt, bevor etwas das System verlässt, Konflikte werden zu Review-Einträgen statt zu Git-Markern, and private Aufzeichnungen werden nie synchronisiert. lnk team-sync betreibt ein gemeinsames Team-Gehirn auf denselben Gleisen.

„Was habe ich damals geglaubt?“ Frag in einfacher Sprache: lnk recall "where does local data live in March" liefert, was damals galt, rekonstruiert aus den datierten Dateien und ihrer Ablösungslinie — während dieselbe Frage ohne Datum die heutige Wahrheit liefert. Deterministisch: ein Regex und ein Kalender, kein Modell. Zeitpunktgenauigkeit aus einfacher Sprache: 0,917, identisch mit einer Frage mit einem ISO-Datum.

„Nutzt mein Agent das wirklich?“ Das ist die Frage, die die meisten Memory-Systeme nicht über sich selbst beantworten können. Link zeichnet Abrufe lokal auf — Sitzungs-Briefings, die an Agenten gesendet werden, und Abrufe, die sie bewusst durchführen — und lnk wins antwortet mit Zählwerten, während lnk digest den Wochengessicht liefert, einschließlich Erinnerungen, die nie abgerufen wurden. Das Hauptbuch speichert, welche Erinnerung wann gelesen wurde, nie, wonach du gefragt hast; es wird nie synchronisiert, und LINK_USAGE=off deaktiviert es. Und das Wissen erreicht jeden Agenten, nicht nur die eingebundenen: Die erste MCP-Tool-Antwort einer Sitzung trägt das Briefing, egal welches Tool aufgerufen wurde.

Schnellstart

Zwei Befehle: erst sehen, wie es funktioniert, dann zu deinem machen.

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

Hast du bereits über Tools verstreute Erinnerungen? Hol sie als überprüfbare Vorschläge nach Hause — nichts wird automatisch akzeptiert:

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

lnk setup erkennt die auf deinem Rechner installierten Agenten — Claude Code, Codex, Cursor, Windsurf, Zed, Kiro, Gemini CLI — und verbindet sie alle auf einmal; Link ist von Natur aus agentunabhängig (ein MCP-Server, ein Workspace, jeder Agent liest dasselbe Wissen). Es ist idempotent: Nach jedem brew upgrade einfach erneut ausführen, und alles — Workspace-Laufzeit, MCP-Bereitstellung, Hooks — wird aktualisiert. Du möchtest lieber einen Agenten explizit einbinden? lnk onboard --agent claude-code --write --hooks erledigt genau das weiterhin.

lnk proof erstellt einen Wegwerf-Workspace, schreibt eine überprüfte Erinnerung und ruft sie über denselben Pfad ab, den CLI, Skills und MCP nutzen — das Kernversprechen (ein lokaler Speicher, von verschiedenen Agenten wiederverwendbar, kein Cloud-Profil) in einer Sekunde:

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 erstellt dann ~/link, richtet die MCP-Laufzeit ein und bindet den Agenten an — einschließlich der Sitzungs-Hooks, die beim Arbeiten automatisch Erinnerungen erfassen (ersetze claude-code durch codex, cursor, kiro, copilot, antigravity oder andere). Lass --write weg, um die Kofiguration anzusehen, ohne etwas zu verändern, oder lass --agent weg, um nur den Workspace zu erstelen.

Der installierte Befehl heißt lnk, weil link bereits ein Systemdienstprogramm von POSIX/macOS ist. Aus einem Quellcode-Checkout verwende stattdessen python3 link.py ....

Möchtest du zuerst die UI, den Graphen und die Quellseiten? lnk try && lnk serve link-demo. Windows-, Quellcode-Checkout-, MCP-only- und Skill-first-Pfade findest du im Leifaden „First 10 Minutes“.

Oder initialisiere dein aktuelles Repository als eigenen Schritt, damit der erste echte Abruf nicht leer ist:

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

lnk seed liest zugelassene Projektdateien wie README.md, AGENTS.md, CLAUDE.md, .cursorrules und Editor-Regeldateien, blockiert Werte, die wie Geheimnisse aussehen, schreibt eine quellengestützte Projektseite und baut den Graphen neu auf. Es erstellt keine dauerhaften Erinnerungen; Agenten sollten für Präferenzen und Entscheidungen weiterhin überprüfte Erinnerungsvorschläge verwenden.

Die Homebrew-Formel wird im öffentlichen Tap gowtham0992/homebrew-link gepflegt.

Öffnen:

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

Verwende /onboard, wenn du dieselbe Ersteinrichtungs-Checkliste in der lokalen UI möchtest: Bereitschaft, Projektkontext-Initialisierung, erste Erinnerung, Agentenanbindung und Einstiegsprompts. Der Web-Viewer ist nur für den lokalen Gebrauch bestimmt. Er bindet an 127.0.0.1, hat keine Benutzerkonten oder Authentifizierung und solte nicht dem Internet ausgesetzt werden, es sei denn, du fügst eine eigene Authentifizierungsebene hinzu.

Teste die Wertschleife:

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 liefert sowohl Leistungs- als auch Wertnachweise: Cache/Suche/Abfrage-Zeiten, Form des Graph-Payloads und eine Schätzung, wie viel breiten Wiki-Kontext das begrenzte Link-Paket vermieden hat, an einen Agenten zu senden.

Die Seite /health spiegelt die Bereitschaftsschleife im Browser wider: Validierungsstatus, unterbrochene Schreibvorgänge, Status der Memory-Überprüfung und kopierbare Reparaturbefehle. Der View-er bleibt dokomentorientiert — häufige Pfade in der oberen Navigaton, weiterführende Werkzeuge unter more und eine Inhaltsübersicht sowie graphbezogene Links auf struktuierten Seiten.

Die erzeugte Demo ist das öffentliche Proof-Wiki. Generierter Inhalt in wiki/, raw/ und link-demo/ wird von git ignoriert, sodass persönliche Erinnerungen nicht versehentlich veröffentlicht werden.

LinkBar — die Menüleisten-App (macOS)

Links Wissen, allgegenwärtig. LinkBar bringt die Review-Schleuse in deine Menüleiste: eine globale Palete (⌥⌘M) zum Abrufen oder Merken aus jeder App, native Benachrichtigungen mit Akzeptieren per Tipp, wenn eine Sitzungsaufzeichnung eintrifft, ein Live-Puls, während Agenten schreiben, und einen Browser über jede Memory-Datei — alles läuft über dieselben überprüften lnk-Befehle wie die CLI.

brew install --cask gowtham0992/link/linkbar

Bewusst unsigniert (keine Apple-Gebühr, die irgendetwas verteuert): Das Cask entfernt das Quarantäne-Flag bei der Installaton, sodass es sich wie jede App öffnet. Stattdessen aus dem Quellcode bauen: cd apps/LinkBar && bash Scripts/bundle.sh --install.

Killer-Demo: Eine Erinnerung, zwei Agenten

Das ist der Mom ent, für den Link gebaut wurde:

1. Sage in einem Agenten:

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

2. Sage in einem anderen Agenten, der mit demselben ~/link- Workspace verbunden ist:

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

3. Der zweite Agent sollte die überprüfte Erinnerung aus lokalem Markdown abrufen, anstatt dich zu bitten, dich zu wiederholen.

Für eine saubere automatisierte Version derselben Idee führe Folgendes aus:

lnk proof

Einsatzmöglichkeiten von Link

Wähle die Oberfläche, die zu deiner Arbeitsweise passt. Sie alle lesen und schreiben dasselbe lokale Markdown-Wiki.

Diese Oberflächen sind unabhängig. lnk serve / serve.py ist nur der lokale Web-Viewer. CLI-Befehle, offizielle Skills und MCP-Tools lesen dieselben wiki/-Dateien direkt, sodass Claude, Codex, Kiro, Cursor oder ein anderer Agent Link auch dann verwenden können, wenn der Web-Viewer nicht läuft.

Bevorzugst du Skills statt MCP? Link enthält kleine, nachladbare CLI-Skills unter skills/. Sie ermöglichen einem Agenten, lnk health, lnk query, lnk ingest-status, lnk session-end und lnk remember direkt zu verwenden, ohne MCP-Einrichtung oder laufenden Web-Viewer.

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

Vollständiger Leitfaden: Link Skills.

Installation für deinen Agenten

Führe einen Installer aus dem geklonten Checkout aus:

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

Installer erstellen oder aktualisieren ~/link, installieren oder aktualisieren link-mcp, schreiben schlanke Agentenanweisungen und bewahren vorhandene Wiki-Daten bei der Neuinstallation auf. Verwende --project, wenn ein Repository ein separates Projektgedächtnis benötigt.

Unter Windows verwende den passenden PowerShell-Installer:

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

Dann frag deinen Agenten:

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

Für CLI-orientierte Agenten oder Link-Skills verwende direkt dieselbe Startschleife:

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

Wenn du eine geführte Einrichtung für einen echten Workspace und einen Agenten möchtest, verwende lnk onboard --agent AGENT. Wenn dein Agent bereits Anweisungen hat und du nur die MCP-Anbindung benötigst, verwende den Verbindungshelfer der unteren Ebene. Beide zeigen zuerst die genaue Konfiguration an; füge --write hinzu, wenn du möchtest, dass Link die Agentenkonfigurationsdatei aktualisiert.

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

Für Agenten mit Sitzungs-Hook-Unterstützung — Claude Code, Codex und Cursor — füge --hooks hinzu (funktioniert auch mit lnk onboard), um die Memory-Schleife zu automatisieren: Das Briefing wird zu Sitzungsbeginn eingefügt, und am Sitzungsende werden nur Vorschlagsnotizen erfasst, sodass das Wissen nicht mehr davon abhängt, dass der Agent sich merkt, Link aufzurufen. Leere Sitzungen und doppelte End-Ereignisse werden übersprungen, und wenn sich ein Rückstau aufbaut, erinnert das Briefing den Agenten daran, einen schreibgeschützten lnk consolidate-Durchlauf anzubieten. Dauerhaftes Wissen erfordert weiterhin deine Genehmigung. Die Hook-Unterstützung für Codex und Cursor ist neu (an ihre dokumentierten Schemata angebunden — melde Probleme).

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

Optional: hybrider semantischer Abruf (weiterhin vollständig lokal)

Der lexikalische Abruf ist immer die Standard- und die Fallback-Option. Paraphrasenabgleich ist optional: Nach den beiden folgenden Einrichtungsbefehlen findet „Wie sollte ich meine Pull-Requests strukturieren?“ eine Erinnerung, die zum Commit-Stil gespeichert wurde. Bis dahin erfolgt der Abruf über gemeinsame Wörter, und ein Fehlversuch zeigt dir, wie du den Paraphrasenabgleich aktivierst. Die Installation der optionalen semantischen Erweiterung fügt ein kleines lokales Static-Embedding-Modell hinzu. Der Abruf berührt niemals das Netzwerk: Das Modell lädt nach einer einmaligen expliziten Einrichtung nur offline, Embeddings liegen als einfaches JSON unter .link-cache/, die Ähnlichkeit läuft prozessintern ohne Vektordatenbank, und rein semantische Treffer tragen begrenzte Konfidenzlabels, damit Agenten prüfen, bevor sie ihnen vertrauen.

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

Gemessen, nicht behauptet: Im mitgelieferten Benchmark mit 1.176 Fällen hebt die Qualitätsstufe den Token-Overlap-Hit@1 von 0,589 auf 0,749 und den reinen Paraphrase-Hit@3/Hit@5 (ohne Token-Überschneidung) um das ~4-Fache, bei ~10 ms pro Abruf ohne Dienst oder Vektordatenbank. Auf der Drittanbieter-Retrieval-Strecke LoCoMo (1.536 evidenzannotierte Fragen über 5.882 Konversationsrunden) hebt der hybride Abruf den Any-Evidence-Hit@10 von 0,628 auf 0,737 (0,794 mit der optionalen Rerank-Stufe). Vollständige Methodik, ehrliche Einschränkungen und Reproduktionsschritte: 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 ist die empfohlene MCP-Oberfläche für Agenten: sechs naheliegende Tools für Abruf, Erinnern, Ingest, Überprüfung, Status und Admin-Notausgänge. Die vollständige Kompatibilitätsoberfläche ist weiterhin mit --surface full verfügbar.

Unter macOS/Homebrew-Python: Wenn pip externally-managed-environment meldet, verwende ein dediziertes venv:

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

Vollständige Einrichtung: MCP-Leitfaden.

Obsidian-Benutzer können ein vorhandenes Vault in raw/ importieren, damit Agenten es verarbeiten können, oder ~/link/wiki direkt als Vault zum Bearbeiten von Link-Seiten öffnen:

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

Siehe den Obsidian-Leitfaden für den Import-, Bearbeitungs- und Validierungsablauf.

Speichermodell

Unter der Haube trennt Link quellengestütztes Wissen von dauerhaftem Agentengedächtnis:

1. Lege rohe Notizen, Transkripte, Artikel und Projektkontext in raw/ ab.

2. Agenten verarbeiten diese Quellen zu prüfbaren Seiten unter wiki/.

3. Explizite „remember“-Anfragen werden zu überprüfbaren Memory-Seiten.

4. Abfragen rufen kompakten Agentenkontext sowohl aus der Wiki- als auch aus der Memory-Ebene ab.

Das Speichermodell ist schlicht und einsehbar:

Wenn eine Rohdatei bereits erfasst und später bearbeitet wurde, markiert lnk ingest-status sie als veraltet und weist deinen Agenten an, die vorhandene Quellenseite zu aktualisieren, anstatt ein Duplikat zu erstellen.

Was Agenten erhalten

Wenn ein Agent Link über die empfohlene MCP-Oberfläche nutzt, erhält er sechs auf Modelle ausgerichtete Tools. CLI- und Skill-Workflows rufen dasselbe Kernverhalten über lnk auf.

• status: Bereitschaft, Schema-Zustand, Validierung, unterbrochene Schreibvorgänge und sichere nächste Aktionen.

• recall: der einzige Lesepfad für Start-Briefings, antwortfertige Abfragepakete, Wiki-Suche, Graph-Kontext, Token-Budgets und Folgeaktionen. Jede abgerufene Erinnerung trägt ein confidence-Label (strong, moderate, weak) und ein match-Feld (lexical, semantic, hybrid, wenn die optionale lokale semantische Ebene installiert ist), sodass Agenten schwache oder paraphrasierte Übereinstimmungen mit dem Benutzer verifizieren, anstatt ihnen zu vertrauen.

• remember: dauerhafte lokale Erinnerung nur nach ausdrücklicher Benutzerfreigabe, mit Duplikat-/Konfliktprüfungen, Herkunft, Review-Status, Sichtbarkeit, optionalem review_after und optionalem expires_at.

• ingest: genaue nächste Schritte für Rohdateien, Quellensicherheit, Erkennung veralteter Ingest-Vorgänge, Validierung und Rebuild-Prüfungen.

• review: Erinnerungs-Posteingang, Profil, Audit, Log, Erklären, Archivieren, Wiederherstellen, Vergessen und Lebenszyklus-Review-Workflows – plus review(action="consolidate"), einen schreibgeschützten Backlog-Plan, der nur mit benutzerseitiger Freigabe pro Aktion angewendet wird.

• admin: die Notausstiegsoption für Backup, Migration, Validierung, Graph-Export, Seiten, Captures, Rebuilds, Kompatibilitätsaktionen und erweiterte Updates.

Der stabile, agentenorientierte Ablauf ist unter Link Memory Contract dokumentiert: zuerst Bereitschaft, begrenzter Abruf, explizite Erinnerungs-Schreibvorgänge, Audit-Tools und Freigabe-Semantik.

Verwende review_after für zeitkritische Präferenzen oder Entscheidungen. Wenn dieses Datum erreicht ist, erscheint die Erinnerung erneut im Review-Posteingang von Link, sodass ein Agent den Benutzer bitten kann, sie zu bestätigen, zu aktuaisieren, zu archiivieren oder zu vergessen, anstatt veraltetem Kontext zu vertrauen.

Verwende expires_at für temporären Kontext, der nach einem Datum automatisch aus dem Standard-Recall verschwinden soll; Link hält die Markdown-Seite einsbar und bittet den Benutzer, sie zu aktualisieren, zu archivieren oder zu löschen. Verwende visibility, um zu trennen, wo eine Erinnerung gilt, von der Frage, wer sie sehen soll: private bleibt persönlich, project ist für einen Projekt-Workspace gedacht und team bedeutet, dass der Benutzer die Freigabe für ein Team ausdrücklich genehmigt hat.

Für die Team-Übergabe oder Sicherheitsüberprüfung schreibt lnk compliance-export --output audit.json ein geschwärztes JSON-Paket mit Bereitschaft, Validierung, Erinnerungs-Review-Status, Operations-Markern und aktuellen Audit-Log-Einträgen. Rohquelleninhalte und Erinnerungstexte sind nicht enthalten.

Für die tägliche Nachvollziehbarkeit zeigt lnk memory-log ~/link, was Link kürzlich als Erinnerung gespeichert, aktualisiert, überprüft, archiviert, wiederhergestellt, vergessen oder aus Roh-Captures übernommen hat.

Für die Wiederherstellung erstellt lnk backup ~/link ein lokales Archiv, und lnk restore-backup <archive> ~/link zeigt eine Vorschau dessen, was wiederhergestellt würde. Wenn du --confirm übergibst, werden lokale Dateien ersetzt, nachdem, wenn möglich, ein Sicherungs-Backup erstellt wurde; raw/ bleibt weiterhin ausgeschlossen, außer wenn --include-raw explizit angegeben ist.

Wenn ein Schreibvorgang über mehrere Dateien unterbrochen wird, zeigt lnk operations ~/link den Marker und einen etwaigen Rollback-Snapshot; lnk operations ~/link --recover <marker> --confirm stellt den Snapshot wieder her, nachdem du ihn überprüft hast.

Für den lokalen Nachweis des Nutzens zeigt lnk wins ~/link wiederverwendbare Erinnerungen, überprüfte Erinnerungen, Herkunft, Projektkontinuität, Frische-Schutzmechanismen und kopierbare Prompts, ohne das Benutzerverhalten zu verfolgen.

Für Git-gestütztes Team-Memory prüft lnk team-sync ~/link, ob der Workspace bereit ist, überprüfte wiki/-Seiten zu teilen, während raw/, Caches, Backups, lokale MCP-Python-Marker und wiki/log.md standardmäßig privat bleiben.

Das Audit-Log ist lokal, weil es eine Hash-Kette für eine einzelne Maschine besitzt; das Zusammenführen der Logs mehrerer Benutzer würde falsche Manipulationsalarme erzeugen. Team-Sync blockiert außerdem den Status „ready“, wenn der Erinnerungs-Posteingang nicht leer ist oder aktive Erinnerungen mit visibility: private durch ein breites git add wiki eingeschlossen würden.

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

Für einen Teamkollegen, Prüfer oder einen anderen Agenten löst lnk share eine Seite, eine Erinnerung, einen Titel, einen Alias oder einen Suchbegriff in eine lokale Viewer-URL auf:

lnk share "Prefer local memory" ~/link

Für ein statisches, schreibgeschütztes Review-Paket exportiert lnk snapshot gerendertes Wiki-HTML standardmäßig ohne raw/, Captures, Operations-Marker, Live-MCP-Zustand oder Erinnerungsseiten. --include-memories exportiert nur nicht-private Erinnerungen; verwende --include-private-memories nur für ein persönliches Archiv oder eine ausdrücklich genehmigte Überprüfung. Der Export wird blockiert, wenn Wiki-Seiten geheimnisaussehende Werte enthalten, außer du überschreibst dies explizit.

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

Agentenvertrag

Für MCP-Clients sollten Agenten Link in dieser Reihenfolge verwenden:

1. status, um Bereitschaft und sichere nächste Aktionen zu prüfen.

2. recall mit einer leeren Abfrage einmal in der ersten inhaltlichen Runde einer Sitzung.

3. recall(query, budget="micro"|"small") vor umfangreichen Dateilesevorgängen oder bevor du den Benutzer bittest, dauerhaften Kontext zu wiederholen.

4. ingest vor dem Zugriff auf Rohquellen und nach Quellenänderungen für Validierungs-/Rebuild-Prüfungen.

5. remember nur, wenn der Benutzer Link ausdrücklich bittet, sich etwas zu merken, oder eine vorgeschlagene Erinnerung genehmigt.

6. review für Workflows zu Erinnerungs-Posteingang, Profil, Audit, Log, Erklären, Archivieren, Wiederherstellen und Vergessen.

7. admin für Backup, Migration, Graph-Export, Captures, Rebuilds, Kompatibilitätsaktionen und erweiterte Wartung.

Vollständige MCP-Tool-Liste: MCP-Setup.

Datenschutz und Sicherheit

Link selbst ist Local-first:

• Keine Telemetrie in der installierten CLI, im MCP-Server, in der lokalen Web-UI oder in der Wiki-Laufzeitumgebung.

• Kein gehostetes Backend.

• Keine externen API-Aufrufe von serve.py oder link-mcp.

• Rohquellen und generierte Wiki-Seiten werden von git standardmäßig ignoriert.

• lnk backup schließt raw/ aus, außer du übergibst explizit --include-raw.

• Geheimnisaussehende API-Schlüssel, Provider-Tokens, JWTs, Registry-Anmeldedaten und Private-Key-Blöcke werden in Rohquellen, Captures und Release-Hygiene-Prüfungen erkannt. lnk validate und lnk doctor schlagen ebenfalls fehl, wenn geheimnisaussehende Werte in Wiki-Seiten gefunden werden, bevor sie über die lokale UI ausgeliefert oder über Agentenkontext zurückgegeben werden können.

• Optionale semantische Erinnerung bleibt lokal: Modelle werden zum Abrufzeitpunkt nur offline geladen (nur das explizite lnk semantic --setup darf einmal ein Modell abrufen), und Embeddings liegen als einfaches JSON unter .link-cache/ ab.

• Automatische Session-Hooks speichern nur Vorschlagsnotizen; die Transkript-Extraktion überspringt Tool-Aufrufe und -Ausgaben, und ohne Überprüfung wird keine dauerhafte Erinnerung geschrieben.

• Der lokale Webserver bindet an 127.0.0.1 und ist nicht dafür gedacht, ohne zusätzliche Authentifizierung für das Internet freigegeben zu werden.

Bevor du ein Repo, eine Demo oder ein Wiki teilst:

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

Weitere Details: Sicherheitsleitfaden.

Dokumentation

Mitwirken

Beiträge sollten über Pull Requests erfolgen, die auf main abzielen. Der develop-Branch ist ein Maintainer-Integrationsbranch für größere Release-Arbeiten, bevor er main vorgeschlagen wird.

Bevor du einen PR eröffnest:

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

Vollständiger Leitfaden für Mitwirkende: Mitwirken.

Nimm keine persönlichen Wiki-Daten, Rohquellen, Registry-Tokens, .env-Dateien oder lokale MCP-Anmeldedaten in einen PR auf.

Wenn Link deinen Agenten hilft, sich besser zu erinnern, vergib einen Star auf GitHub, damit mehr Leute Link finden.