🌳 Yggdrasil

Schluss damit, jeder neuen KI-Session dein Projekt neu zu erklÀren.
Ein lokales GedĂ€chtnis fĂŒr Claude Code, Codex und jeden MCP-Agent — geteilt ĂŒber Sessions, Tools und Projekte hinweg. Null AbhĂ€ngigkeiten. Nichts verlĂ€sst deine Maschine.

Latest release PyPI Glama quality score Benchmarks AGPL-3.0 alpha

Installation · So funktioniert es · Zahlen · Vergleich · FAQ

Lies dies auf: English · РуссĐșĐžĐč · çź€äœ“äž­æ–‡ · Español · Français · æ—„æœŹèȘž

---

Yggdrasil — a brand-new session already knows your project, and recalls a fix from another project

Bei jedem neuen Chat vergisst deine KI alles. Du erklĂ€rst das Projekt, die Entscheidungen, die Stolperfallen erneut — jedes Mal, in jedem Tool. **Yggdrasil ist ein winziges, immer aktives GedĂ€chtnis, an das sich jeder Agent anschließt.** Öffne eine neue Session — in einem beliebigen Projekt, mit einer beliebigen KI — und sie weiß bereits, was du entschieden hast, was kaputtging und was noch offen ist. ```text $ cd ~/projects/checkout-api && claude # a brand-new session 🌳 Yggdrasil (injected automatically at session start) ‱ [project_status] payments refactor: idempotency keys added; open: e2e tests ‱ [lesson] webhook 401 → signing secret rotated; update env + redeploy > "have I solved a flaky websocket reconnect anywhere before?" 🌳 recall → found in project `realtime-dash`: refresh the token *before* opening the socket, then retry with capped backoff. ``` Kein „lass mich dir kurz in Erinnerung rufen, was wir gestern gemacht haben“ mehr. Es ist einfach da. ## 🚀 Installation Zwei Befehle, direkt in **Claude Code** (das Plugin startet ĂŒber [`uv`](https://docs.astral.sh/uv/)): ```text /plugin marketplace add VonderVuflya/Yggdrasil /plugin install yggdrasil ``` Die Engine startet beim ersten Gebrauch von selbst (lazy) und erzeugt ihr eigenes lokales Token — kein API-Key, keine Cloud, nichts zu konfigurieren. Codex und Cursor nutzen denselben Ablauf.
Alle anderen KanĂ€le — CLI-Daemon, Homebrew, npm, Claude Desktop, aus den Quellen 
 | Host / Tool | Befehl | | --- | --- | | **uvx** _(empfohlene CLI)_ | `uvx --from yggdrasil-memory ygg install` | | **npm / npx** | `npx yggdrasil-memory install` | | **pipx** | `pipx install yggdrasil-memory && ygg install` | | **pip** | `pip install yggdrasil-memory && ygg install` | | **Homebrew** _(macOS)_ | `brew install VonderVuflya/tap/yggdrasil && ygg install` | | **Claude Desktop** _(App)_ | zieh die `.mcpb` aus der [neuesten Release](https://github.com/VonderVuflya/Yggdrasil/releases/latest) auf Settings → Extensions und fĂŒge dein Token ein (`ygg token`) — die Desktop-App teilt sich dann dasselbe GedĂ€chtnis wie deine CLI-Agents ([Anleitung](../packaging/mcpb/README.md)) | | **aus den Quellen** | `uvx --from git+https://github.com/VonderVuflya/yggdrasil.git ygg install` | `ygg install` ist ein einmaliges, gefĂŒhrtes Setup: Es installiert einen immer aktiven Hintergrunddienst, registriert die MCP-Tools bei jedem gefundenen Agent-Host — **Claude Code, Codex, OpenCode** — und empfiehlt, wenn deine Hardware es hergibt, optionale lokale Modelle (oder wĂ€hle `none`, um konfigurationsfrei zu bleiben).
OpenCode — nichts zu konfigurieren Installiere zuerst [OpenCode](https://opencode.ai), dann fĂŒhre `ygg install` aus (oder `ygg redeploy`, falls Yggdrasil schon eingerichtet ist) — der Eintrag wird automatisch erstellt und in ein bestehendes `opencode.json` gemergt. PrĂŒfe es mit: ```bash opencode mcp list # -> ✓ yggdrasil connected ``` OpenCode *nach* Yggdrasil installiert? FĂŒhre einfach `ygg install` erneut aus. Willst du es lieber von Hand schreiben: OpenCodes Schema unterscheidet sich an gleich vier Stellen von dem von Claude — Server liegen unter `mcp` (nicht `mcpServers`), `type` ist erforderlich, `command` ist ein einzelnes Array (nicht `command` + `args`), und die Umgebung heißt `environment` (nicht `env`) — der Claude-Snippet lĂ€sst sich also nicht einfach ĂŒbertragen: ```jsonc // ~/.config/opencode/opencode.json { "$schema": "https://opencode.ai/config.json", "mcp": { "yggdrasil": { "type": "local", "command": ["/path/to/python3", "~/.yggdrasil/scripts/ygg_mcp_server.py"], "enabled": true, "environment": { "YGG_ENGINE_URL": "http://127.0.0.1:42069" } } } } ``` Kein Token landet in der Konfiguration — die Engine liest die 0600-Datei `~/.yggdrasil/token` selbst. FĂŒhre `ygg doctor` aus, falls die Tools nicht auftauchen.
FĂŒr jede Claude-OberflĂ€che gibt es außerdem einen [`yggdrasil-memory`-Skill](../skills/): MCP verbindet die *Tools*, der Skill lehrt den Agent, *wann* er sie nutzen soll. Verwende beides fĂŒr das beste Verhalten. Ausprobieren, ohne irgendetwas zu installieren — mit einer Wegwerf-DB: `uvx --from yggdrasil-memory ygg serve --reset --db /tmp/ygg.sqlite`.
Dann arbeite einfach: Bitte deinen Agent *„ruf ab, was wir ĂŒber dieses Projekt entschieden haben“*, sag ihm *„merk dir diese Entscheidung“* — in der nĂ€chsten Session ist es schon da. PrĂŒfe die Installation jederzeit mit `ygg doctor`. **Schon Historie vorhanden?** BefĂŒlle das GedĂ€chtnis aus deinen bestehenden Claude Code + Codex-Transkripten, Obsidian-Vaults und `CLAUDE.md`-Repos — lokal destilliert: ```bash ygg seed --dry-run # see what it would import; drop the flag to distill for real ``` **Du verlĂ€sst ein anderes Memory-Tool?** `ygg import --from mcp-memory --path memory.json` zieht dessen gesamten Speicher in Yggdrasil (dedupliziert, geheimnisgeschĂŒtzt) — danach kannst du es löschen. ## Warum - 🧠 **Persistent** — Entscheidungen, Erkenntnisse und Projektstatus ĂŒberdauern jede Session. - 🔌 **Ein Gehirn, jedes Tool** — Claude Code, Codex, OpenCode und jeder MCP-Host teilen sich dasselbe GedĂ€chtnis. - 🌐 **ProjektĂŒbergreifender Recall** — *„das sieht aus wie das, was du in Projekt B gemacht hast — wiederverwenden?“* - đŸ§č **Kuratiert statt mitgeschnitten** — dein Agent speichert die wenigen Dinge, die zĂ€hlen; die Governance dedupliziert und archiviert, löscht aber nie. - đŸŒ± **Selbstpflegend** *(opt-in)* — ein kleines lokales Modell konsolidiert das GedĂ€chtnis im Hintergrund. Null API-Tokens. - đŸȘȘ **Eine IdentitĂ€t ĂŒberall** — ein optionaler Name samt Persona, den jeder Agent ĂŒbernimmt — Claude Code und Codex fĂŒhlen sich wie derselbe Assistent an. - 🔒 **100 % lokal** — dein GedĂ€chtnis lebt auf deiner Maschine. Keine Cloud, kein Konto, keine Telemetrie. ## 🧠 So funktioniert es Yggdrasil ist **GedĂ€chtnis + Tools** — die *Intelligenz* ist dein LLM. Es sorgt nur dafĂŒr, dass das richtige GedĂ€chtnis im richtigen Moment vor dem richtigen Agent liegt. - đŸ›Žïž **Immer aktiver Daemon** — ein winziger lokaler Dienst (~21 MB RAM), den deine Agents ĂŒber MCP-Tools erreichen (`ygg_search`, `ygg_recall`, `ygg_remember` 
). - đŸȘ **Hooks** — der Session-Start injiziert automatisch IdentitĂ€t, Projektstatus und offene Follow-ups (~300 Tokens); ein optionaler Hook pro Prompt ruft automatisch das fĂŒr *jede Anfrage* relevante GedĂ€chtnis ab. - 📌 **Ranking** — angepinnte und hĂ€ufig abgerufene Erinnerungen erscheinen zuerst. - đŸ§č **Governance** — Duplikate und Konflikte landen zur ÜberprĂŒfung in einer Queue; Änderungen sind nicht-destruktiv (archivieren, nie löschen). - 📓 **Obsidian** — jede Erinnerung ist zugleich eine einfache Markdown-Notiz, die du lesen, bearbeiten und greppen kannst. ## đŸŽ›ïž GedĂ€chtnis-Tiers — standardmĂ€ĂŸig ohne Konfiguration Von Haus aus lĂ€uft Yggdrasil auf **SQLite + FTS5 mit null AbhĂ€ngigkeiten** — sofortige Stichwortsuche, keine Modelle, nichts herunterzuladen. Optionale **lokale** Modelle ĂŒber [Ollama](https://ollama.com) ergĂ€nzen zwei unabhĂ€ngige Tiers: | Tier | Du fĂŒgst hinzu | Du gewinnst | | --- | --- | --- | | **0 · Standard** | nichts — SQLite + FTS5 | Stichwortsuche, null AbhĂ€ngigkeiten, sofort — recall@1 = **0.77** | | **1 · semantisch** | ein **Embedding**-Modell (`all-minilm` 45 MB · `paraphrase-multilingual` ~560 MB) | Suche nach **Bedeutung**, ĂŒber Sprachen hinweg — recall@1 = **0.94**, recall@3 **1.00** | | **2 · selbstpflegend** | ein kleines **LLM** (`qwen2.5:1.5b` ~1 GB) | Dedup/Merge des GedĂ€chtnisses im Hintergrund (nur VorschlĂ€ge) | Ollama *berechnet* nur Vektoren und fĂŒhrt das Hintergrundmodell aus — jede Erinnerung und jeder Vektor bleibt in derselben lokalen SQLite. `ygg install` erkennt deine Hardware und empfiehlt eine passende Wahl (`ygg recommend` zeigt den vollstĂ€ndigen Katalog).
VollstĂ€ndiges Modell-MenĂŒ **Embeddings (semantische Suche):** | Modell | GrĂ¶ĂŸe | Gut fĂŒr | | --- | --- | --- | | `all-minilm` | 45 MB | Englisch, winzig & schnell | | `nomic-embed-text` | 274 MB | Englisch, bessere QualitĂ€t (768d) | | `mxbai-embed-large` | 670 MB | Englisch, hohe QualitĂ€t (1024d) | | `paraphrase-multilingual` | ~560 MB | mehrsprachig (EN/RU + 50 Sprachen, 768d) | | `bge-m3` | 1.2 GB | mehrsprachig, höchste QualitĂ€t (schwerer) | **Embedding-Backend** — standardmĂ€ĂŸig Ollama. Um stattdessen einen OpenAI-kompatiblen `/v1/embeddings`-Server zu nutzen (`llama-server --embeddings` aus llama.cpp, OpenRouter, LM Studio, vLLM), setze `embed_backend`: ```bash # local llama.cpp — no key needed ygg config set embed_backend openai ygg config set embed_url http://127.0.0.1:8080/v1 ygg config set embed_model bge-small-en-v1.5 ygg redeploy # OpenRouter — free embeddings, no GPU needed ygg config set embed_backend openai ygg config set embed_url https://openrouter.ai/api/v1 ygg config set embed_model nvidia/llama-nemotron-embed-vl-1b-v2:free ygg config set embed_api_key sk-or-... # or export YGG_EMBED_API_KEY ygg redeploy ``` Der Key wird in `~/.yggdrasil/embed_api_key` (0600) gespeichert statt in `config.json` und erreicht den Daemon als **Dateipfad** — so taucht er nie in `ps`, im launchd-plist oder in der systemd-Unit auf. `ygg config list` maskiert ihn. PrĂŒfe mit `ygg doctor`, ob es angekommen ist — `dense` sollte dein Modell nennen: ``` ✓ dense active (nvidia/llama-nemotron-embed-vl-1b-v2:free) ``` Mit LM Studio oder OpenRouter von Hand verbinden? Die Fallstricke (zwei URL-Formen, Modell-IDs, JIT-Laden, Inference- vs. Provisioning-Keys, Privacy-Filter) stehen in [docs/model-backends.md](../docs/model-backends.md). Lokal zu bleiben gewinnt weiterhin bei QualitĂ€t *und* PrivatsphĂ€re: Auf dem Korpus aus 232 Erinnerungen / 110 Abfragen erreicht das lokale `paraphrase-multilingual` recall@1 **0.964** gegenĂŒber **0.946** beim kostenlosen gehosteten Modell — und deine Erinnerungen verlassen nie die Maschine. Greif zu einem gehosteten Backend, wenn die Maschine kein Ollama stemmen kann, nicht auf der Jagd nach Genauigkeit. GrĂ¶ĂŸere Vektoren bringen hier **keine** bessere Genauigkeit — auf demselben Korpus erreicht `mxbai-embed-large` (1024d) 0.809 und `nomic-embed-text` (768d) 0.818, ein Unterschied, den ihre Konfidenzintervalle vollstĂ€ndig verschlucken. Was die Zahl wirklich bewegt, ist, ob das Modell *deine* Sprachen beherrscht: Beide sind rein englischsprachig und fallen bei sprachĂŒbergreifenden Abfragen auf 0.40–0.45 ab, wĂ€hrend das mehrsprachige Standardmodell 0.95 hĂ€lt. **Hintergrund-Konsolidierung (kleines LLM):** | Modell | GrĂ¶ĂŸe | Gut fĂŒr | | --- | --- | --- | | `qwen2.5:0.5b` | ~400 MB | winzig, schnell auf CPU | | `qwen2.5:1.5b` | ~1 GB | bester CPU-Standard | | `llama3.2:3b` | ~2 GB | bessere QualitĂ€t, langsamer auf CPU | Die Engine selbst ist austauschbar — jeder Dienst, der den `MemoryBackend`-Vertrag erfĂŒllt, lĂ€sst sich direkt einsetzen (`YGG_ENGINE_URL`); siehe [docs/backend-boundary.md](../docs/backend-boundary.md).
## 🔗 Ein GedĂ€chtnis ĂŒber all deine Maschinen Arbeitest du auf einem Laptop und einer stĂ€rkeren Kiste? Verbinde sie einmal, und sie hören auf, zwei Gehirne zu sein. ```text # on the laptop $ ygg link 🔗 pairing code valid 5 minutes · single use ygg://192.168.3.152:42070/a4e0df489737#FOucjgJ1FrUB
 # on the other machine — paste it $ ygg link ygg://192.168.3.152:42070/a4e0df489737#FOucjgJ1FrUB
 ✓ linked with laptop https://192.168.3.152:42070 ✓ laptop: fetch 84 · push 12 · delete 0 · tombstones 0 ``` Von dann an lĂ€uft alles von selbst: Eine auf einer Maschine geschriebene Erinnerung ist nach etwa einer Sekunde auf der anderen, `ygg delete` entfernt sie von **beiden**, und jede Maschine arbeitet mit ihrer eigenen lokalen Kopie weiter, wenn die andere schlĂ€ft — Lesezugriffe warten nie auf das Netzwerk. Wenn eine Maschine zurĂŒckkehrt, vergleichen die beiden ihre Fingerprints und holen nach, was sie verpasst haben, ohne dass du etwas tun musst. Es gibt **kein Polling**. Yggdrasil wird ein paar Mal am Tag aufgerufen, also werden SchreibvorgĂ€nge sofort ĂŒbertragen, und eine Synchronisation wird durch LesevorgĂ€nge ausgelöst; untĂ€tige Maschinen senden nichts. **Was das nicht ist:** eine Cloud. Es gibt kein Relay, kein Konto, keinen Server von uns im Pfad. Die Maschinen sprechen direkt ĂŒber dein eigenes Netzwerk miteinander, per TLS mit dem gepinnten Zertifikat der jeweils anderen, mit einem SchlĂŒsselpaar, das nur auf diesen beiden Maschinen existiert. Der Pairing-Code selbst nennt das Zertifikat der ausstellenden Maschine, sodass sogar die allererste Verbindung verifiziert wird — antwortet etwas anderes im Netzwerk an ihrer Stelle, wird es abgewiesen, bevor das Geheimnis des Codes gesendet wird. Ein Netzwerkport wird erst gebunden, wenn du `ygg link` ausfĂŒhrst — Yggdrasil zu installieren heißt, dass es wie bisher auf Loopback bleibt. ```text ygg link --list # what's linked, and whether writes are actually arriving ygg link --sync # reconcile now, don't wait for a read ygg unlink # revoke that machine's key here ```
Details: was ĂŒbertragen wird, was bleibt, und wann du stattdessen ygg sync nutzt **Übertragen wird:** Erinnerungen, ihre Relationen und Löschungen. **Bleibt lokal:** wie oft *du* eine Erinnerung geöffnet hast und auf welcher Maschine du sie gelesen hast — das ist lokales Ranking, kein Wissen. Embedding-Vektoren bleiben normalerweise ebenfalls lokal, mit einer Ausnahme: Wenn beide Maschinen dasselbe Embedding-Modell nutzen, wandert der Vektor mit, sodass eine Rechenkiste das Embedding fĂŒr den Laptop ĂŒbernehmen kann und der Laptop nie ein Modell laufen lassen muss. **Die neuere Bearbeitung gewinnt.** Bearbeitest du eine Erinnerung auf beiden Maschinen, bevor sie miteinander sprechen, wird die jĂŒngere Bearbeitung auf beiden behalten (auch eine kĂŒrzere Korrektur). **Löschungen gewinnen.** Löschst du eine Erinnerung auf einer Maschine und bearbeitest sie gleichzeitig auf der anderen, gewinnt die Löschung und die Bearbeitung geht verloren. Das ist bewusst: „Ich habe das geleakte Token gelöscht“ muss auch dann gelten, wenn zwei Uhren nicht ĂŒbereinstimmen. Wenn du *meine Meinung hat sich geĂ€ndert* meinst, archiviere stattdessen — nichts geht verloren, und `ygg unarchive` holt sie auf beiden Maschinen zurĂŒck (die spĂ€tere Entscheidung gewinnt). **Eine Firewall wird beim Pairing erkannt.** Die Maschine, die den Code ausgibt, ruft die andere sofort zurĂŒck; kommt sie nicht durch, meldet `ygg link` das und gibt den einen Befehl aus, der den Port nur fĂŒr diese Maschine öffnet (ufw, firewalld, Windows). `ygg link --list` und `ygg doctor` prĂŒfen danach weiter: Ein Peer zeigt ✓ erst, wenn SchreibvorgĂ€nge bestĂ€tigt zugestellt sind, andernfalls den Fehler und wie viele Änderungen warten. Eine Maschine, die per DHCP eine neue Adresse bekommt, wird beim nĂ€chsten Kontakt wiedergefunden. **`ygg sync` (Git) gibt es weiterhin** und erledigt eine andere Aufgabe: Maschinen, die einander nicht sehen, ein Arbeitslaptop hinter einem anderen Netzwerk, ein Bare-Repo auf einem USB-Stick, den du mit dir trĂ€gst. Nutze `ygg link` fĂŒr Maschinen im selben Netzwerk, `ygg sync` fĂŒr alles andere. Beide nutzen dieselben Merge-Regeln, du kannst also beide einsetzen. Wenn beide Maschinen in einem Tailscale-Tailnet sind, funktioniert `ygg link --tailscale` auch netzĂŒbergreifend. **Wenn der Pairing-Code die falsche Adresse zeigt** (er bevorzugt echtes Ethernet und WLAN gegenĂŒber VM-Bridges und VPNs, kann aber trotzdem danebenliegen), fixiere sie: `ygg config set sync_host 192.168.3.152` — oder lass den Code auf der anderen Maschine anzeigen: Die Seite, die ihn eingibt, nutzt immer die Adresse, ĂŒber die die Route tatsĂ€chlich lĂ€uft.
## 📊 Die Zahlen Gemessen mit [`eval/ygg_eval.py`](../eval/ygg_eval.py) — 232 Erinnerungen, 110 gelabelte Anfragen, die Ranking-Gewichte werden nur auf dem *dev*-Split abgestimmt, deshalb ist **holdout die unverzerrte Zahl** (recall@1, mit dem `paraphrase-multilingual`-Modell): | Suchansicht | holdout recall@1 | recall@3 | Null-Abh. lexikalisch | | --- | --- | --- | --- | | **Innerhalb eines Projekts** (der reale Pfad, Pool ~11) | **0.94** | **1.00** | 0.76 | | **Gesamter Speicher** (kein Filter, Pool 232) | 0.72 | **0.87** | 0.69 | **Innerhalb eines Projekts — dem Pfad, den du nutzt — ist die richtige Erinnerung bei 0.94 der Anfragen auf Platz 1 und jedes Mal in den Top 3 (recall@3 = 1.00).** Die Suche im gesamten Speicher ohne Filter ist schwieriger (recall@1 0.72, recall@3 0.87 ĂŒber alle 232). Der lexikalische Modus ohne AbhĂ€ngigkeiten löst Stichwort- und Code-Identifier-Anfragen bereits (1.00); das lokale Modell fĂŒgt Bedeutung und SprachĂŒbergreifendes hinzu (crosslingual 0.25 → 0.95). Die [vollstĂ€ndige AufschlĂŒsselung in BENCHMARKS.md](../BENCHMARKS.md) zeigt 95-%-Konfidenzintervalle, Pool-GrĂ¶ĂŸen und Werte je Klasse — und du kannst sie in einer Minute neu ausfĂŒhren: `python3 eval/ygg_eval.py --report`. **Die KorpusgrĂ¶ĂŸe ist Teil der Zahl.** Auf einem echten Speicher mit 4.799 Erinnerungen fĂ€llt das mehrsprachige Standard-Embedding auf die lexikalische Baseline zurĂŒck (recall@1 0.55); `bge-m3` hĂ€lt dort 0.775. WĂ€chst dein Speicher in den Tausenderbereich, wĂ€hle `bge-m3` — Details in [BENCHMARKS.md](../BENCHMARKS.md). ## 🆚 Yggdrasil im Vergleich Alle anderen schneiden entweder automatisch Transkripte mit oder verkaufen dir eine Cloud. Yggdrasils Wette: Behalte die **wenigen Dinge, die zĂ€hlen** — kuratiert und dedupliziert, in einfachen DatensĂ€tzen, die dir gehören — und teile sie ĂŒber **jedes** Tool und Projekt hinweg. | | **Yggdrasil** | Eingebautes GedĂ€chtnis (Claude Code · Codex) | [claude-mem](https://github.com/thedotmack/claude-mem) | [mem0](https://github.com/mem0ai/mem0) / OpenMemory | [basic-memory](https://github.com/basicmachines-co/basic-memory) | | --- | --- | --- | --- | --- | --- | | Kuratierte Entscheidungen / Erkenntnisse / Status (keine Transkripte) | ✅ | ⚠ Auto-Notizen | ❌ erfasst alles | ⚠ | ⚠ Freiform-Notizen | | Ein GedĂ€chtnis **ĂŒber Tools hinweg** | ✅ | ❌ Vendor-Silo | ✅ | ✅ | ✅ | | **ProjektĂŒbergreifender** Recall („in Projekt B gelöst“) | ✅ | ❌ auf das Repo begrenzt | ⚠ | ⚠ | ⚠ | | **100 % lokal** als Standard | ✅ | ✅ | ⚠ Cloud-Sync als Add-on | ❌ hosted-first | ✅ | | **Null AbhĂ€ngigkeiten** (stdlib + SQLite) | ✅ | — | ❌ Node + Bun + Worker-Daemon | ❌ Docker + Qdrant + LLM-Key | ❌ | | Funktioniert **ohne LLM & ohne API-Key** | ✅ | ✅ | ❌ KI-komprimiert | ❌ | ✅ | | **Semantische Suche, vollstĂ€ndig lokal** | ✅ opt-in ĂŒber Ollama | ❌ nur grep | ⚠ optional Chroma | ⚠ braucht API-Key oder Docker-Stack | ❌ | | Reines **Markdown, das dir gehört** (Obsidian-ready) | ✅ | ✅ | ❌ | ❌ | ✅ | **Der nĂ€chste Nachbar — claude-mem:** Alles-Erfassen-GedĂ€chtnis, das jede Session aufzeichnet und per KI komprimiert (Node 20+ *und* Bun, ein persistenter Worker-Daemon; Chroma optional). Yggdrasil ist die gegenteilige Wette: ein kleiner, signalstarker Speicher statt eines wachsenden Datenschwalls. **mem0** ist ein SDK plus gehostete Plattform, um *Apps* zu bauen, die sich an *ihre Nutzer* erinnern — selbst self-hosted braucht es einen LLM-API-Key. **Eingebaute Memories** sind wirklich nĂŒtzlich — und strukturell isoliert: ein Anbieter, ein Repo, eine Maschine, wörtliches grep. Yggdrasil ist die Ebene darĂŒber (und `ygg seed` kann sich aus genau diesen Transkripten selbst befĂŒllen). Eine ganz andere Ebene: [context-mode](https://github.com/mksglu/context-mode) (aktives Kontextfenster) und [Context7](https://github.com/upstash/context7) (frische Bibliotheks-Docs) — beide vertragen sich bestens mit Yggdrasil. ## 🧰 Befehle Agents sehen sechs MCP-Tools: `ygg_health`, `ygg_bootstrap`, `ygg_search`, `ygg_recall`, `ygg_remember`, `ygg_materialize` — automatisch registriert durch das Plugin oder `ygg install`.
VollstĂ€ndige ygg-CLI-Referenz **GedĂ€chtnis-Operationen** | Befehl | Was er macht | | --- | --- | | `ygg recall --query "
"` | **ProjektĂŒbergreifende** Suche — „habe ich das schon irgendwo gemacht?“ | | `ygg search --project P --query "
"` | Projektbezogene Suche (`--type`, `--tag`, `--limit`, `--json`) | | `ygg remember --project P --type lesson --content "
"` | Eine dauerhafte Erinnerung speichern (geheimnisgeschĂŒtzt, dedupliziert) | | `ygg bootstrap --project P` | Das GedĂ€chtnis eines Projekts laden, bevor die Arbeit beginnt | | `ygg pin --id ID` · `ygg unpin --id ID` | Eine Erinnerung anpinnen, damit sie zuverlĂ€ssig erscheint | | `ygg supersede --id ID` | Eine veraltete Erinnerung archivieren, die von einer neueren ersetzt wird | | `ygg unarchive --id ID` | Eine archivierte Erinnerung zurĂŒckholen (auch auf verbundenen Maschinen) | | `ygg materialize --id ID --project P` | Eine Erinnerung als Obsidian-Notiz exportieren | | `ygg export-native --project P` | Einen kuratierten Digest nach `AGENTS.md`/`MEMORY.md` schreiben — natives GedĂ€chtnis von Claude Code und Codex damit versorgen | | `ygg import --from TOOL --path P` | Den Speicher eines anderen Memory-Tools nach Yggdrasil migrieren (`mcp-memory`, `basic-memory`; zuerst `--dry-run`) | | `ygg review [--apply]` | Die Governance-Queue abarbeiten — Duplikate zusammenfĂŒhren, veraltete/widersprĂŒchliche Erinnerungen markieren (nur archivieren, umkehrbar) | | `ygg delete --id ID` · `ygg reset 
` | Eine Erinnerung endgĂŒltig löschen · einen missglĂŒckten `ygg seed` gesammelt rĂŒckgĂ€ngig machen (fragt zuerst nach BestĂ€tigung) | **Kaltstart** | Befehl | Was er macht | | --- | --- | | `ygg seed` | Destilliert Claude Code + Codex-Transkripte, Obsidian-Vaults, `CLAUDE.md`-Repos — inkrementell, dedupliziert, vollstĂ€ndig lokal | | `ygg seed --dry-run` · `--force` | Nur erkennen + abschĂ€tzen · alles neu destillieren | | `ygg link` · `ygg link ` | Zwei **deiner** Maschinen direkt im selben Netzwerk verbinden — gemeinsames GedĂ€chtnis live, gepinntes TLS, kein Relay | | `ygg link --list` · `ygg unlink ` | Verbundene Maschinen anzeigen · eine davon widerrufen | | `ygg distill --source PATH` | Ein Verzeichnis/eine Datei zu Lektionen destillieren | | `ygg reindex` | Fehlende Embeddings nachtragen (stellt den dichten Recall wieder her) | **Dienst & Einrichtung** | Befehl | Was er macht | | --- | --- | | `ygg install` · `ygg doctor` · `ygg update` | GefĂŒhrtes Setup · Diagnose mit umsetzbaren Korrekturen · Upgrade | | `ygg config` | Persistente Einstellungen anzeigen/setzen (`list` · `get` · `set` · `unset`) | | `ygg status` · `start` · `stop` · `restart` · `logs` | Den immer aktiven Daemon verwalten | | `ygg hooks` · `unhooks` · `register` | SessionStart-Hook ein/aus · MCP (neu) registrieren | | `ygg recommend` · `token` · `uninstall` | Modellkatalog · Auth-Token ausgeben · alles entfernen | Gib ihm eine Persönlichkeit — bearbeite `~/.yggdrasil/identity.json`: ```json { "name": "Jarvis", "persona": "concise, proactive, dry wit", "user_facts": ["prefers TypeScript", "ships small PRs"] } ``` Schweres Seeding, schwaches Laptop? Richte die Destillation auf *jede beliebige* Maschine in deinem LAN — einen Desktop mit Ollama, LM Studio, llama.cpp, **sogar ein iPhone mit einer lokalen LLM-Server-App**: `ygg config set distill_url http://:11434`. Yggdrasil erkennt den API-Dialekt automatisch (Ollama oder OpenAI-kompatibel); deine Daten verlassen weiterhin nie dein Netzwerk — Details in [docs/ygg-cli.md](../docs/ygg-cli.md).
## ❓ FAQ
Claude Code hat doch schon ein eingebautes GedĂ€chtnis — warum Yggdrasil? Eingebaute Memories sind pro Anbieter, pro Repo, pro Maschine — und werden per wörtlichem Textabgleich abgerufen. Yggdrasil ist die Ebene darĂŒber: dasselbe GedĂ€chtnis in Claude Code, Codex und jedem MCP-Host, Recall *ĂŒber* Projekte hinweg, optionale semantische Suche — weiterhin 100 % lokal. Beides ergĂ€nzt sich: Behalte das native GedĂ€chtnis und lass `ygg seed` deine bestehende Historie ins gemeinsame Gehirn destillieren.
Schickt es meinen Code oder mein GedĂ€chtnis in die Cloud? Nein. Die Engine, die Datenbank und die optionalen Modelle laufen alle lokal. Kein Konto, keine Telemetrie. Der einzige ausgehende Aufruf ist ein Versions-Check gegen PyPI. Wenn du zwei eigene Maschinen mit `ygg link` verbindest, reisen Erinnerungen **zwischen genau diesen beiden Maschinen** ĂŒber dein eigenes Netzwerk — direkt, per TLS mit gepinntem Zertifikat, ohne Relay und ohne einen Server von uns im Pfad. Bis du diesen Befehl ausfĂŒhrst, lauscht nichts ĂŒber Loopback hinaus.
Kann ein böswilliges Repo Anweisungen in mein GedĂ€chtnis schmuggeln? Abgerufene Erinnerungen werden als klar gerahmte *Referenznotizen, keine Anweisungen* eingespeist, mit Angabe, woher jede Notiz stammt, und einem Hinweis, wenn sie zu einem anderen Projekt gehört — der Agent behandelt sie also als Daten und fragt nach, bevor er etwas daraus umsetzt. Geheimnisse werden vor der Destillation aus Transkripten entfernt und beim Schreiben abgelehnt. Trotzdem gilt: Ein GedĂ€chtnis ist nur so vertrauenswĂŒrdig wie das, was es geschrieben hat — schau gelegentlich mit `ygg review` drĂŒber.
Merkt es sich automatisch alles? Nein — bewusst nicht. Das Abrufen ist automatisch; das *Schreiben* ist absichtlich (der Agent ruft `ygg_remember` fĂŒr dauerhafte Erkenntnisse auf). Alles-Erfassen verschmutzt das GedĂ€chtnis und verbrennt Tokens — also lassen wir es. Das optionale Hintergrundmodell konsolidiert nur, was bereits gespeichert ist (nur VorschlĂ€ge).
Brauche ich eine GPU oder einen API-Key? Nein. Der Standard ist reine lexikalische Suche — null AbhĂ€ngigkeiten, sofort. Die semantische Suche ist opt-in und nutzt ein *lokales* Modell ĂŒber Ollama. Der Installer empfiehlt eines, das zu deiner Hardware passt.
Wie schwergewichtig ist es, und wie viele Tokens kostet es? Die Engine lĂ€uft im Leerlauf mit **~21 MB RAM** (lexikalischer Standard) bei ~0 % CPU; auf der Platte sind es zig KB pro Erinnerung. Der Session-Start injiziert ~300 Tokens; jeder Tool-Aufruf liefert einen kleinen Ausschnitt zurĂŒck. Die ganze schwere Arbeit (Indexierung, Embeddings, Konsolidierung) lĂ€uft off-LLM auf deiner Maschine.
Kann ich Erinnerungen von Hand bearbeiten oder löschen? Ja. Erinnerungen materialisieren sich als Markdown-Notizen in einem Obsidian-Vault — lies, bearbeite oder entferne sie wie jede andere Datei. Governance und Review löschen nie etwas: Sie archivieren, und das ist umkehrbar. Nur du löschst hart und ausdrĂŒcklich, mit `ygg delete` (und auf verbundenen Maschinen erreicht diese Löschung beide).
## 🚩 Status & Roadmap **Alpha.** Der Happy Path und die Governance-Schleife sind gate-getestet (`scripts/run_gates.sh`); noch nicht gehĂ€rtet fĂŒr Multi-User- oder Produktionseinsatz. Heute macOS; die Linux/Windows-Dienst-Installer sind gebaut und in finalen Tests am GerĂ€t. Shipped recently: 🔗 Maschine-zu-Maschine-GedĂ€chtnis (`ygg link`) · Relationsgraph (`ygg relate`: `solves` / `supersedes` / `contradicts`). Next: đŸ›°ïž surface-ĂŒbergreifend (ein GedĂ€chtnis ĂŒber CLI, Web und Telefon — die HTTP-Fassade ist drin, siehe [docs/cross-surface.md](../docs/cross-surface.md)) · 🐧 Linux/Windows GA. ## đŸ€ Mitwirken Issues und PRs willkommen. FĂŒhre `scripts/run_gates.sh` und `python3 -m unittest discover -s tests` vor dem Einreichen aus — alle Gates mĂŒssen grĂŒn bleiben. ## 📜 Lizenz **GNU AGPL v3.0** — siehe [LICENSE](../LICENSE). Frei und quelloffen: nutzen, modifizieren, selbst hosten, weitergeben. Wenn du es modifizierst oder als Netzwerkdienst anbietest, musst du deinen Quellcode unter derselben Lizenz veröffentlichen.