Mnemo: Eine portable Langzeit-Memory-Schicht für lokale LLMs

Ihr Ollama-Modell kann schon Fragen beantworten, aber jedes Gespräch beginnt wieder bei null. Die Projektentscheidung von gestern, die Präferenz von heute und die Einschränkung, die morgen noch gelten soll, sind weg.

Das ist die Memory-Lücke lokaler LLMs. Ollama stellt einen Modellservice bereit, der antworten kann. Was er antwortet und ob er Ihre früheren Vorgaben kennt, hängt davon ab, was Sie jedes Mal wieder in den Prompt schreiben.

Mnemo ist kein weiteres RAG. Es nutzt einen Knowledge Graph plus Entity-Extraktion, um Langzeit-Memory zu verwalten. So kann Ihr lokales LLM Projektentscheidungen und Entitätsbeziehungen erinnern, statt Sie jedes Mal zu fragen: „Wofür ist diese API?“

1. Was Mnemo ist: Positionierung und Kernfunktionen

1.1 Die Positionierung lesen

In „local-first AI memory layer“ stecken zwei wichtige Teile:

• local-first: Die Daten liegen lokal, gehen nicht in die Cloud, sind portabel und hängen nicht vom Überleben eines SaaS-Anbieters ab
• memory layer: Es ist weder ein neues RAG-Framework noch ein neues Agent-Framework. Es kümmert sich um Memory selbst: Entity-Extraktion, Graph-Aufbau und semantisches Retrieval

Ein Beispiel: Sie fragen „Was ist die API-Basis-URL dieses Projekts?“. Reine Vektorsuche gibt möglicherweise mehrere Dokumentfragmente mit „API“ zurück, weiß aber nicht, welches Projekt gemeint ist. Graph-Retrieval kann die Kette „Projekt -> API -> baseUrl“ verfolgen und den früher gesetzten Konfigurationswert zurückgeben.

Das setzt korrekte Entity-Extraktion voraus. Wenn das LLM „API-Basis-URL“ fälschlich in zwei Entitäten zerlegt, also „API“ und „Basis-URL“, splittert der Graph. Retrieval verliert dann die Verbindung. Hier beginnt Noise-Akkumulation.

Ist die Positionierung klar, lassen sich die Kernfunktionen leichter einordnen.

1.2 Matrix der Kernfunktionen

Die Mnemo-README nennt vier Kernfunktionen:

1. persistent knowledge graph (persistenter Knowledge Graph)

   • Entitäten und Beziehungen werden in SQLite gespeichert, nicht als einmalige Vektoren
   • Die Graph-Struktur kann abgefragt, exportiert und migriert werden

2. entity extraction (Entity-Extraktion)

   • Erkennt automatisch Entitäten aus Gesprächen, etwa Personen, Projektnamen, API-Namen und Entscheidungen
   • Es ist keine reine Vektorsuche. Es macht aus „Wofür ist diese API?“ eine abfragbare Entitäts-Beziehungsstruktur
   • Die Qualität der Entity-Extraktion hängt vom Verständnis des LLMs ab. Lokale LLMs wie llama3 können in komplexen Gesprächen falsch erkennen. Noise-Akkumulation bleibt ein laufendes Risiko. Die README beschreibt keine automatische Bereinigung, also müssen Sie die Graph-Qualität regelmäßig prüfen

3. semantic retrieval (semantisches Retrieval)

   • Kombiniert Graph und Vektoren und bevorzugt beim Retrieval Entitätsbeziehungen statt reiner Ähnlichkeit
   • Vermeidet typischen Vektorsuch-Noise: Dokumente mit hoher Ähnlichkeit, aber falscher Bedeutung, sollen nicht dominieren

4. graph-first vs pure vector search

Reine Vektorsuche fragt: „Was ist ähnlich?“ Graph-Retrieval fragt: „Was ist verbunden?“ Ersteres kann semantisch ähnliche, aber irrelevante Ergebnisse liefern. Letzteres folgt Beziehungen zwischen Entitäten.

Der Unterschied wird in der Tabelle klarer:

1.3 Tech-Stack und Lizenz

Tech-Stack:

Railway - Moderne Deployment-Plattform, ohne DevOps-Aufwand, in Minuten live

Jetzt starten →Anzeige

• Rust, aufgeteilt in vier Crates, siehe nächster Abschnitt
• SQLite für lokale Speicherung im WAL-Modus
• petgraph für den In-Memory-Graph
• OpenAI-, Ollama- oder Anthropic-API als LLM-Backend

Lizenz: MIT License. Nutzung, Änderung und Weiterverteilung sind erlaubt.

Risiken:

• Frühes Projekt, Stand GitHub README vom 2026-06-05
• APIs und Architektur können sich ändern
• Keine breit dokumentierte Produktionsvalidierung
• README-Performancewerte sind Selbstmessungen, kein unabhängiger Nachweis

2. Architektur: Vier Rust-Crates

Mnemo ist in Rust geschrieben und in vier Crates mit klaren Zuständigkeiten aufgeteilt:

mnemo-core: Kernlogik

• Entity-Extraktion, Graph-Aufbau und Retrieval-Logik
• Hängt nicht von einem konkreten LLM-Backend ab, sondern definiert Interfaces

mnemo-api: Server

• Stellt eine HTTP-API bereit, standardmäßig auf Port 8080
• Nimmt Gespräche an, ruft core auf und gibt Ergebnisse zurück
• Health-Check: curl http://localhost:8080/health

mnemo-cli: Kommandozeilentool

• Debugging, Verwaltung und Abfragen
• Arbeitet direkt auf der lokalen SQLite-Datenbank, ohne HTTP

mnemo-bench: Performance-Benchmarks

• Die in der README genannten 122 Rust tests, 21 Python tests und 12 benchmarks liegen hier
• Quelle der Selbstmessungen

Vorteile dieser Aufteilung:

• core kann unabhängig von der API getestet werden
• cli erleichtert lokales Debugging, ohne den Service zu starten
• bench bleibt getrennt und beeinflusst Produktionscode nicht

Nachteile:

• Ohne Docker brauchen Sie die vollständige Rust-Toolchain
• Wenn sich Crate-APIs ändern, müssen oft mehrere Stellen gleichzeitig angepasst werden

3. Installation und Deployment: Drei Wege

Mnemo bietet drei Deployment-Wege, nach Komplexität sortiert:

3.1 Docker + Ollama: Der schnellste Einstieg

Voraussetzung: Docker und Ollama sind installiert.

# 1. Projekt klonen
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. Docker starten
docker compose up -d

# 3. Modell in Docker ziehen
docker exec mnemo-ollama ollama pull llama3

# 4. Health-Check
curl http://localhost:8080/health

Hinweis: Befehle können sich ändern. Die GitHub-README ist die Quelle der Wahrheit.

Erklärung: Docker compose startet zwei Container: mnemo-api als Server und mnemo-ollama als Ollama-Service. Letzterer ist optional. Wenn Ollama bereits lokal läuft, können Sie nur den mnemo-api-Container nutzen und mit MNEMO_LLM_BASE_URL=http://host.docker.internal:11434/v1 Ihr lokales Ollama anbinden.

LLM-Verbindung prüfen: Wenn der Health-Check {"status":"ok"} zurückgibt, läuft die API. Die LLM-Verbindung ist damit noch nicht bewiesen. Senden Sie einen Test-Request mit curl:

curl -X POST http://localhost:8080/v1/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Was ist die API-Basis-URL dieses Projekts?"}'

Wenn eine Entity-Extraktion zurückkommt, funktioniert die LLM-Verbindung.

Vorteile:

Vultr - Hochleistungs-NVMe-Cloud-Server mit 32 Standorten weltweit, Docker per Klick

Preise ansehen →Anzeige

• Keine Rust-Toolchain nötig
• Docker behandelt Abhängigkeiten automatisch
• Ollama und Mnemo liegen im selben compose-Netzwerk, daher ist die Netzwerkkonfiguration einfach

Nachteile:

• Docker verbraucht Ressourcen
• Debugging ist unbequemer, weil Sie für SQLite in den Container müssen
• Logs verteilen sich auf zwei Container

3.2 Binary: Lokal kompilieren

Voraussetzung: Rust-Toolchain ist installiert, inklusive cargo und rustc, und Ollama ist installiert.

# 1. Projekt klonen
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. API-Crate kompilieren
cargo install --path crates/mnemo-api

# 3. Ollama-Adresse konfigurieren
export MNEMO_LLM_BASE_URL=http://localhost:11434/v1

# 4. Service starten
mnemo-api

Hinweis: Befehle können sich ändern. Die GitHub-README ist die Quelle der Wahrheit; dieser Weg braucht eine Rust-Toolchain.

Erklärung: Die Kompilierzeit hängt von Ihrer Hardware ab. Auf einem Apple M2 dauert sie etwa 2 bis 3 Minuten, unter Windows oder Linux eventuell länger. Wenn die Kompilierung fehlschlägt, prüfen Sie die Rust-Version, die die README verlangt. Nach erfolgreichem Build erzeugt mnemo-api im aktuellen Verzeichnis eine SQLite-Datei, standardmäßig mnemo.db, und speichert dort die Graph-Struktur.

Ollama-Verbindung prüfen: Bestätigen Sie vor dem Start, dass Ollama auf localhost:11434 läuft und das Modell mit ollama pull llama3 gezogen wurde. Testen Sie nach dem Start mit curl:

curl -X POST http://localhost:8080/v1/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Test"}'

Vorteile:

• Keine Docker-Abhängigkeit
• Einfacheres Debugging, weil es ein lokaler Prozess ist und Logs in einem Terminal bleiben
• mnemo-cli kann direkt auf die lokale SQLite-Datenbank zugreifen
• Port und Datenbankpfad lassen sich über Umgebungsvariablen anpassen

Nachteile:

• Vollständige Rust-Toolchain erforderlich
• Erster Build kann dauern
• Abhängigkeiten können Probleme machen, etwa wenn cargo.lock veraltet ist

3.3 OpenAI-compatible: Cloud-LLM

Voraussetzung: Sie haben einen API-Key für OpenAI, Anthropic oder ein anderes OpenAI-kompatibles Backend.

Umgebungsvariablen, gegen die GitHub-README von 2026-06 geprüft:

export MNEMO_LLM_BASE_URL=https://api.openai.com/v1
export MNEMO_LLM_API_KEY=sk-...
export MNEMO_LLM_MODEL=gpt-4o-mini
export MNEMO_LLM_PROVIDER=openai

Danach starten:

mnemo-api

Hinweis: Namen von Umgebungsvariablen können sich ändern. Die GitHub-README ist die Quelle der Wahrheit.

Geeignete Fälle:

• Die lokale Rechenleistung reicht nicht, Sie nutzen ein Cloud-LLM
• Sie haben bereits OpenAI-API-Kontingent
• Sie akzeptieren, dass Gesprächsinhalte in die Cloud hochgeladen werden. Bei einem Cloud-LLM gilt der Local-first-Privatsphärevorteil nur für lokale Speicherung, nicht für den Inferenzverkehr

Wählen Sie einen der drei Wege nach Ihrer Lage. Danach geht es um die Performance.

4. Performance: Selbstmessungen aus der README

Mnemos README nennt Performance-Selbstmessungen für die Version vom 2026-06-05:

Testbedingungen:

• Apple M2, debug build
• SQLite WAL-Modus
• petgraph im Speicher

Performancewerte:

🔥 Verschwende keine Monate für ungenutzte Produkte! Teste deine SaaS-Nutzenversprechen mit Adsterra bei kleinem Budget →

Jetzt testen →Anzeige

• Vollständige Retrieval-Pipeline: etwa 4,2 ms
• Release build soll 3-5x schneller sein, also grob 0,8-1,4 ms

Hinweis: Das ist README-Selbstmessung, kein unabhängiger Nachweis. Performance ändert sich mit Hardware, Datenmenge und LLM-Backend.

So sollten Sie die Zahlen lesen:

• 4,2 ms ist Retrieval-Zeit, nicht LLM-Inferenz. Die LLM-Inferenz ist der Flaschenhals
• SQLite WAL plus In-Memory-Graph kann Retrieval tatsächlich schnell machen
• Gemessen wird nur Retrieval, nicht die Gesprächsgeschwindigkeit

Die tatsächliche Erfahrung hängt ab von:

• LLM-Inferenzzeit, die deutlich langsamer ist als Retrieval
• Gesprächslänge, weil Entity-Extraktion LLM-Inferenz braucht
• Datenmenge, weil größere Graphen das Retrieval verlangsamen können

Empfehlung: Führen Sie mnemo-bench auf der Zielhardware aus. Die README-Zahlen sind Referenzwerte, keine Zusage.

5. Local-first-Eigenschaften und Grenzen

5.1 Vorteile von Local-first

Der Kern von Local-first: Die Daten bleiben auf Ihrer Maschine.

Konkrete Vorteile:

1. Privatsphäre

   • Gespräche, Entitäten und Beziehungen liegen in lokaler SQLite
   • Sie werden nicht an ein Drittanbieter-SaaS hochgeladen, solange Sie ein lokales LLM nutzen

2. Datenkontrolle

   • Die SQLite-Datei kann exportiert, gesichert und migriert werden
   • Sie hängen nicht vom Überleben eines SaaS ab. Ihre Daten bleiben bei Ihnen

3. Portabilität

   • Beim Maschinenwechsel kopieren Sie die SQLite-Datei
   • Sie müssen die Memory nicht neu „trainieren“

4. Debugbarkeit

   • SQLite ist ein Standardformat und lässt sich mit jedem SQLite-Tool prüfen
   • Die Graph-Struktur ist sichtbar, anders als ein Blackbox-Vektorraum

5.2 Risiken und Grenzen

Local-first hat Vorteile, aber auch Risiken:

1. Noise-Akkumulation

   • Entity-Extraktion ist nicht perfekt und erkennt falsch
   • Falsch erkannte Entitäten beeinflussen späteres Retrieval
   • Regelmäßiges Aufräumen ist nötig, aber Mnemo bietet keine automatische Bereinigung
   • Noise-Akkumulation ist kein Mnemo-spezifisches Problem, sondern betrifft alle automatischen Memory-Systeme. Der Unterschied: Mnemos Graph ist sichtbar. Sie können noisy Entitäten und falsche Beziehungen sehen. In Vektorsystemen steckt der Noise unsichtbar in Vektoren. Das ist ein Vorteil des Graphs, aber auch Arbeit

2. Rollback-Grenzen

   • SQLite WAL bietet Rollback-Fähigkeiten, aber Mnemo stellt keine High-Level-Schnittstelle „Memory rückgängig machen“ bereit
   • Falsch gespeicherte Memories manuell zu löschen ist umständlich
   • Schlimmer wird es, wenn eine falsche Entscheidung gespeichert wird, etwa „Redis als Cache nutzen“. Spätere Gespräche können auf dieser falschen Entscheidung aufbauen. Um sie rückgängig zu machen, müssen alle zugehörigen Entitäten und Beziehungen im Graph manuell entfernt werden. Das kann aufwendiger sein als ein Neuaufbau
   • Prüfen Sie bei wichtigen Entscheidungen vor dem Speichern in einer Testumgebung, ob die Entity-Extraktion stimmt

3. Hidden State

   • Die Graph-Struktur kann komplexe Beziehungen enthalten, die Sie übersehen
   • Retrieval kann Ergebnisse liefern, ohne dass sofort klar ist, warum sie zurückkamen

4. Einsatzgrenzen

   • Bei großer Datenmenge geraten SQLite und In-Memory-Graph unter Druck
   • In Teamarbeit ist lokale SQLite nicht für parallele Schreibzugriffe mehrerer Personen ausgelegt

5.3 Entscheidungstabelle: Geeignet vs. nicht geeignet

Einschätzung: Wenn Ihr Szenario „persönliches Projekt, hohe Privatsphäre, vorhandenes Ollama, moderate Datenmenge“ lautet, ist Mnemo einen Versuch wert. Wenn es um „große Datenmengen, Teamarbeit, global geteilte Memory“ geht, warten Sie auf mehr Reife oder wählen Sie einen anderen Ansatz.

Konkrete Empfehlungen:

• Führen Sie den Docker-Pfad zuerst in einer Testumgebung aus und prüfen Sie Graph-Struktur, Entity-Extraktionsqualität und Retrieval-Ergebnisse
• Testen Sie Noise-Risiko mit Testgesprächen. Sagen Sie absichtlich irrelevante Dinge und prüfen Sie, ob Mnemo sie falsch als Entitäten erkennt
• Bereiten Sie eine Bereinigung vor. Machen Sie sich früh mit der SQLite-Struktur vertraut, damit Sie falsche Entitäten manuell löschen können
• Beobachten Sie README-Updates. Das Projekt ist jung; APIs, Architektur und Deployment-Befehle können sich ändern

6. Nächster Schritt: Navigation in der Serie

Wenn Sie die früheren Artikel der Ollama-Serie zu lokalen LLMs noch nicht gelesen haben, gehen Sie am besten der Reihe nach:

1. Ollama-Einstieg: Der erste Schritt zu lokalen großen Sprachmodellen

   • Beginnen Sie hier, wenn Ollama noch nicht installiert ist

2. Ollama-API-Aufruf: Von curl zur OpenAI-SDK-kompatiblen Schnittstelle

   • Mnemo nutzt eine OpenAI-kompatible API. Daher lohnt es sich, die Ollama-API zu verstehen

3. Ollama Embedding in der Praxis: Lokale Vektorsuche und RAG aufbauen

   • Mnemos semantisches Retrieval hängt von Embeddings ab. Dieser Artikel erklärt die Grundlagen

4. KI-Agent-Memory-Management: Langzeit-Memory und Wissens-Governance in der Praxis

   • Mnemo ist ein Tool für die Memory-Schicht. Dieser Artikel behandelt Governance für Agent-Memory

Nach diesen vier Artikeln ist Mnemo leichter einzuordnen. Der nächste praktische Schritt: den Docker-Pfad lokal ausführen und ansehen, wie der Knowledge Graph tatsächlich aussieht.