YourMemory

Deine KI hat das Gedächtnis eines Goldfisches. Nicht länger.

Persistentes, sich selbst verbesserndes Gedächtnis für KI-Agenten – basierend auf der Wissenschaft des menschlichen Erinnerns.

▶ Lebendige interaktive Demo testen · Webseite · Benchmarks

Das Problem

Jeden Morgen behandelt dich dein KI-Agent wie einen Fremden. Der gleiche Kontext wird immer wieder erklärt. Die gleichen Vorlieben werden vergessen. Jede Sitzung beginnt bei Null.

Die meisten „Gedächtnis“-Werkzeuge knallen eine Vektordatenbank an einen Agenten und nennen es erledigt – aber das ist nur Speicher. Es hortet jedes Fast-Duplikat, bis die Abfrage im Rauschen untergeht. Ein Goldfisch mit einer größeren Schüssel.

YourMemory ist anders: ein Gedächtnis, das wie ein Gehirn funktioniert, nicht wie eine Datenbank.

flowchart LR
    A["🧠 Du sagst deiner<br/>KI etwas"] --> B["Dauerhafte Fakten<br/>extrahieren"]
    B --> C["Entduplizieren + Einbetten<br/>+ Graph-Verknüpfung"]
    C --> D[("Gedächtnis-<br/>speicher")]
    D -->|"verwandte Fakten häufen sich"| E["✨ Konsolidieren<br/>N → 1 Zusammenfassung"]
    D -->|"veraltet + ungenutzt"| F["📉 Zerfall<br/>+ Bereinigung"]
    D -->|"neue Sitzung"| G["♻️ Abruf<br/>Hybrid + Graph"]
    E --> D
    G --> H["🤖 Dein Agent<br/>setzt dort an,<br/>wo er aufgehört hat"]
    style D fill:#0a2540,stroke:#19cdff,color:#fff
    style E fill:#0c2b3a,stroke:#5eead4,color:#fff
    style H fill:#0c2b3a,stroke:#19cdff,color:#fff

✨ Was es anders macht

Ein Befehl zur Installation. DuckDB standardmäßig (keine Einrichtung), Postgres + pgvector für Teams.

Inhaltsverzeichnis

• 🏆 Benchmarks
• 🚀 Schnellstart
• 🧠 Wie das Gedächtnis funktioniert
  • Konsolidierung
  • Zerfall
  • Hybrider Abruf
• 🔒 Vertrauen & Prüfpfad
• 👥 Team-Gedächtnispools
• 🛡️ Datenrechte & Compliance
• 🎛️ Dashboards
• 🔧 MCP-Werkzeuge
• ⚡ Fragen ohne LLM-Aufruf
• 🔀 API-Proxy – Garantiertes Gedächtnis
• 🏗️ Architektur & Stack
• 🩺 Fehlerbehebung
• 🤝 Mitwirken

🏆 Benchmarks

Drei externe Datensätze. Jede Zahl ist unabhängig reproduzierbar – Benchmark-Code befindet sich im Repository. Vollständige Methodik in BENCHMARKS.md.

LoCoMo-10 – Mehr-Sitzungs-Konversationsgedächtnis

xychart-beta
    title "Recall@5 · LoCoMo-10 (höher ist besser)"
    x-axis ["Mem0", "Zep Cloud", "Supermemory", "YourMemory"]
    y-axis "Recall@5 Prozent" 0 --> 70
    bar [18, 28, 31, 59]

2× bessere Erinnerung als Zep Cloud über alle 10 Stichproben. *Supermemory und Mem0 haben während des Benchmarks die kostenlosen Kontingente erschöpft; die Werte wurden über die vollständigen 1.534 Paare berechnet.

LongMemEval-S – 500 Fragen, ~53 Ablenkungssitzungen pro Frage

Der härteste Standard-Benchmark für Langzeitgedächtnis. Jede Frage ist in ~53 Sitzungen vergraben.

HotpotQA – 200 Multi-Hop-Fragen

Entitätsgraph-Kanten verbessern um +12 Prozentpunkte – sie navigieren von Fakt 1 zu Fakt 2, selbst wenn Fakt 2 eine geringe Einbettungsähnlichkeit zur Abfrage hat.

Bericht: Ich habe Gedächtniszerfall für KI-Agenten mit der Ebbinghaus-Vergessenskurve entwickelt

🚀 Schnellstart

Python 3.11–3.14. Kein Docker, keine Datenbankeinrichtung. Der gesamte Speicher wird lokal in ~/.yourmemory/ abgelegt.

pip install yourmemory
yourmemory-register <dein-token>
yourmemory-setup

Hol dir dein Token: Besuche yourmemoryai.xyz → gib deine E-Mail ein → verifiziere mit einem 6-stelligen Code → kopiere dein Token.

yourmemory-setup erkennt und verdrahtet automatisch Claude Code, Claude Desktop, Cursor, Windsurf und Cline und fragt dann, welches Backend verwendet werden soll:

• DuckDB – keine Einrichtung, einzelne lokale Datei (Standard)
• Postgres – gemeinsam genutzt / Produktion; du gibst eine DATABASE_URL an (benötigt die pgvector-Erweiterung)

Optional – intelligentere lokale Extraktion: YourMemory funktioniert sofort mit eingebauten Heuristiken. Für eine höherwertige, vollständig lokale Faktenextraktion installiere Ollama, und yourmemory-setup lädt das Modell (qwen2.5:7b, ~4,7 GB) automatisch herunter. Bevorzugst du die Cloud? Setze YOURMEMORY_EXTRACT_BACKEND=anthropic.

Oder Installation aus einer Binärdatei – kein Python erforderlich

Du möchtest pip nicht anfassen? Hol dir die eigenständige Binärdatei für deine Plattform aus dem neuesten Release:

# macOS / Linux – herunterladen, entpacken, ausführen
tar -xzf yourmemory-macos-arm64.tar.gz
./yourmemory-macos-arm64 register <dein-token>
./yourmemory-macos-arm64 setup
./yourmemory-macos-arm64            # Server starten

Eine ausführbare Datei erledigt jeden Befehl: register, setup, ask "<frage>", path und (ohne Argumente) startet den Server.

Vollständig in sich geschlossen & offline – die Binärdatei bündelt Python, jede Abhängigkeit und beide ML-Modelle (das Einbettungsmodell + spaCy). Beim ersten Start wird nichts heruntergeladen. Der Nachteil ist die Größe (~2 GB). Erstelle deine eigene mit einem einzigen Befehl – ./build-binary.sh – und plattformübergreifende Release-Binärdateien werden automatisch vom Build-Workflow erstellt.

🧠 Wie das Gedächtnis funktioniert

YourMemory behandelt das Gedächtnis als lebendiges System – es wächst, konsolidiert, vergisst und verbindet, wie ein Gehirn es tut.

Konsolidierung — N → 1

Die meisten Gedächtniswerkzeuge werden einfach immer größer. YourMemory beobachtet Cluster verwandter Fakten und sobald genug zusammenkommen, komprimiert es sie zu einer einzigen sauberen Zusammenfassung – die Originale werden archiviert (niemals gelöscht, also geht nichts verloren).

flowchart LR
    subgraph before [Verwandte Fakten häufen sich]
        A1["Railway verwendet Nixpacks"]
        A2["Railway im Pro-Tarif"]
        A3["Railway-Umgebungsvariablen<br/>enthalten die Postgres-URL"]
        A4["Wird auf Railway mit<br/>Postgres bereitgestellt"]
    end
    before --> C{"Cluster +<br/>LLM zusammenfassen"}
    C --> S["✨ Zusammenfassung<br/>Bereitstellung auf Railway (Pro,<br/>Nixpacks) mit Postgres<br/>über Umgebungsvariablen"]
    C -.->|"archiviert, wiederherstellbar"| ARC[("Archiv")]
    style S fill:#0a2540,stroke:#5eead4,color:#fff
    style C fill:#0c2b3a,stroke:#19cdff,color:#fff

Echtes Beispiel aus einem Produktionsspeicher: 444 Erinnerungen → 16 Zusammenfassungen – gleiches Wissen, ein Bruchteil des Rauschens. Die Konsolidierung ist ereignisgesteuert (ausgelöst, wenn sich verwandte Erinnerungen häufen), kein blinder nächtlicher Job.

Zerfall — die Vergessenskurve

Die Gedächtnisstärke nimmt exponentiell ab. Wichtigkeit und Abrufhäufigkeit verlangsamen diesen Zerfall:

effective_λ  = base_λ × (1 − importance × 0.8)
strength     = clamp(importance × e^(−effective_λ × active_days) × (1 + recall_count × 0.2), 0, 1)

active_days zählt nur Tage, an denen du aktiv warst – Urlaub führt nicht zu Gedächtnisverlust. Erinnerungen unter einer Stärke von 0.05 werden automatisch entfernt. Jede Kategorie altert in ihrem eigenen Tempo:

Kettenbewusste Bereinigung: Eine zerfallene Erinnerung bleibt erhalten, wenn mindestens ein Graph-Nachbar noch stark ist – tragender Kontext überlebt, selbst wenn er selten direkt abgefragt wird.

Hybrider Abruf — Vektor + BM25 + Graph

Der Abruf erfolgt in zwei Runden, sodass sowohl das abgefragte als auch das, was du zu fragen vergessen hast, sichtbar wird:

flowchart LR
    Q["Abfrage"] --> R1["Vektor + BM25<br/>Hybrid-Suche"]
    R1 --> R2["Grapherweiterung<br/>(was du zu fragen vergessen hast)"]
    R2 --> S["Sortieren nach<br/>Ähnlichkeit × Stärke"]
    S --> OUT["🎯 Rangfolge der Erinnerungen"]
    style OUT fill:#0a2540,stroke:#19cdff,color:#fff

Subjektbewusste Entduplizierung läuft vor jedem Speichern – sie bettet das Subjekt jedes Satzes ein, sodass "Sachit verwendet DuckDB" und "YourMemory verwendet DuckDB" getrennt bleiben (verschiedene Entitäten), während "YourMemory verwendet DuckDB" und "YourMemory speichert Daten in DuckDB" zusammengeführt werden (gleiche Entität). Keine fest codierten Wortlisten; funktioniert mit jeder Sprache.

🔒 Vertrauen & Prüfpfad

Unternehmen werden einer undurchsichtigen Blackbox nicht ihre Daten anvertrauen. Deshalb wird jeder Vorgang – Lesen, Schreiben, Aktualisieren, Löschen, Konsolidieren – an ein hash-verkettetes, manipulationssicheres Prüfjournal angehängt.

flowchart LR
    E0["GENESIS"] --> E1
    subgraph E1 [Ereignis 1]
        H1["row_hash =<br/>sha256(prev + data)"]
    end
    E1 --> E2
    subgraph E2 [Ereignis 2]
        H2["row_hash =<br/>sha256(#1.hash + data)"]
    end
    E2 --> E3
    subgraph E3 [Ereignis 3]
        H3["row_hash =<br/>sha256(#2.hash + data)"]
    end
    E3 --> V{"GET /audit/verify"}
    V -->|Kette intakt| OK["✅ verifiziert"]
    V -->|Zeile geändert| BAD["❌ Kette reißt<br/>an dieser Zeile"]
    style OK fill:#0a2540,stroke:#5eead4,color:#fff
    style BAD fill:#3a0c14,stroke:#fb7185,color:#fff

Jede Zeile speichert den Zeitstempel, den Akteur (Benutzer + Agent), Aktion, Operation, Zielspeicher, Quelle (http vs mcp) und den Hash der vorherigen Zeile. Wird ein historischer Datensatz geändert, zeigt verify_chain() genau an, wo die Kette gerissen ist.

GET  /audit            # Pfad durchsuchen (nach Benutzer / Aktion / Operation filtern)
GET  /audit/verify     # Kryptografisch verifizieren, dass die Kette unverfälscht ist
POST /audit/prune      # Aufbewahrungsbasierte Bereinigung (mindestens 90 Tage, nie weniger)

Die Prüfprotokollierung ist fail-open – sie blockiert niemals eine Gedächtnisoperation – und Lese-/Auflistungsereignisse aus dem eigenen Rendering-Zyklus des Dashboards werden ausgeschlossen, sodass der Pfad Signal und nicht Rauschen bleibt.

👥 Team-Gedächtnispools

Gib den Agenten eines gesamten Teams ein gemeinsames Gehirn – ohne dass jemandes privater Kontext preisgegeben wird. Erinnerungen sind entweder geteilt (für den Pool sichtbar) oder privat (nur für ihren Besitzer sichtbar).

flowchart TB
    P(("🧠 Team-Pool<br/>geteiltes Gedächtnis"))
    A["Alices Agent"] <-->|geteilt| P
    B["Bobs Agent"] <-->|geteilt| P
    C["Carols Agent"] <-->|geteilt| P
    A -. privat .-> AP["🔒 Nur Alice"]
    B -. privat .-> BP["🔒 Nur Bob"]
    style P fill:#0a2540,stroke:#19cdff,color:#fff
    style AP fill:#0c1424,stroke:#5a6b80,color:#8294a8
    style BP fill:#0c1424,stroke:#5a6b80,color:#8294a8

Der rollenbasierte Zugriff wird pro Agent durchgesetzt – was der Agent eines Entwicklers lernt, kommt sofort dem gesamten Team zugute; sensibler Kontext bleibt auf seinen Besitzer beschränkt.

POST   /pools                          # Pool erstellen
POST   /pools/{id}/members             # Mitglied hinzufügen (mit Rolle)
POST   /pools/{id}/memories            # Geteilte Erinnerung beitragen
POST   /pools/{id}/retrieve            # Über den Pool abrufen

🛡️ Datenrechte & Compliance

Weil ein Gedächtnis, das echte Daten speichert, die Kontrollen benötigt, um damit betraut zu werden:

In Kombination mit dem hash-verketteten Prüfpfad und der Aufbewahrungsuntergrenze von 90 Tagen bilden diese direkt die in SECURITY.md dokumentierten Kontrollen ab (SOC 2-konform).

🎛️ Dashboards

Zwei integrierte Browser-Oberflächen – keine zusätzliche Einrichtung, sie starten automatisch mit dem Server.

Gedächtnis-Dashboard — http://localhost:3033/ui

Eine vollständige Lese-/Schreibansicht mit den Registerkarten Erinnerungen · Prüfpfad · Pools: Statistikleiste (Stark / Verblassend / Kurz vor Bereinigung), Pro-Agent-Registerkarten, Erinnerungskarten mit Live-Stärkebalken, Kategoriefilter, der Prüfpfad und Pool-Verwaltung.

Graph-Visualisierer — http://localhost:3033/graph

Eine interaktive, kraftbasierte Karte, die zeigt, wie Erinnerungen verbunden sind – Wurzelerinnerung als heller Knoten, Nachbarn farbcodiert nach Kategorie, Kantenstärke = Verbindungsstärke. Ziehen, Zoomen und Klicken auf jeden Knoten für den vollständigen Inhalt.

http://localhost:3033/graph?memoryId=42&userId=alex&depth=2

🔧 MCP-Werkzeuge

Drei Werkzeuge, die von deiner KI automatisch aufgerufen werden.

# Speichern mit räumlichem Kontext
store_memory(
    "Alex bevorzugt Tabs gegenüber Leerzeichen in Python",
    importance=0.9, category="fact",
    context_paths=["/projects/backend"],
)

# Nächste Sitzung – räumliche Verstärkung greift, wenn in diesem Verzeichnis gearbeitet wird
recall_memory("Python-Formatierung", current_path="/projects/backend")
# → {"content": "Alex bevorzugt Tabs gegenüber Leerzeichen in Python", "strength": 0.87}

⚡ Fragen ohne LLM-Aufruf

Das einzige Gedächtnissystem, das Fragen ohne einen einzigen LLM-API-Aufruf beantworten kann:

yourmemory ask "welche Datenbank verwendet dieses Projekt"
# → YourMemory verwendet lokal DuckDB und in der Produktion Postgres.

yourmemory ask "wie behebe ich ein Kubernetes-Deployment"
# → Nicht genügend Gedächtniskontext, um ohne LLM zu antworten.

Wenn das Gedächtnis stark genug ist, antwortet es sofort – null Tokens, null Cloud-Kosten, null Latenz. Wenn nicht, lehnt es sauber ab, anstatt zu halluzinieren. Deine Abfrage verlässt niemals deinen Rechner.

🔀 API-Proxy – Garantiertes Gedächtnis

MCP-Werkzeuge werden nach Ermessen der KI aufgerufen. Der API-Proxy beseitigt diese Unsicherheit – er fängt jeden LLM-Aufruf ab, fügt automatisch relevante Erinnerungen ein und erledigt store_memory / update_memory ohne Modellkonfiguration.

Starte den Server (yourmemory), weise dann deinen Client auf localhost:3033:

from anthropic import Anthropic

client = Anthropic(
    api_key="sk-ant-...",
    base_url="http://localhost:3033/proxy/anthropic",
    default_headers={"X-YourMemory-User": "alex"},  # benutzerspezifisches Gedächtnis
)

# Erinnerungen werden automatisch eingefügt – keine weiteren Änderungen nötig
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Welche Datenbank verwende ich?"}],
)

OpenAI funktioniert identisch über base_url="http://localhost:3033/proxy/openai".

🏗️ Architektur & Stack

flowchart LR
    C["Dein KI-Client<br/>Claude · Cursor · beliebiges MCP"] <--> Y["🧠 YourMemory"]
    Y --> M[("Gedächtnis-<br/>speicher")]
    Y --> A[("Prüf-<br/>journal")]
    style Y fill:#0a2540,stroke:#19cdff,color:#fff
    style M fill:#0c1a2c,stroke:#5eead4,color:#fff
    style A fill:#0c1a2c,stroke:#5eead4,color:#fff

🩺 Fehlerbehebung

Schreibvorgänge hängen / Zeitüberschreitung (DuckDB Single-Writer-Lock). Wenn der MCP-Server und der HTTP-Server gleichzeitig laufen, konkurrieren sie um die DuckDB-Schreibsperre. Behebung:

pkill -f yourmemory 2>/dev/null || true
rm -f ~/.yourmemory/memories.duckdb.wal ~/.yourmemory/memories.duckdb.lock 2>/dev/null || true
# Client neu starten

Laufen Claude Desktop (MCP) und Claude Code (Hooks) gleichzeitig? Verwende stattdessen SQLite – es behandelt gleichzeitige Lese-/Schreibvorgänge sauber: DATABASE_URL=sqlite:///~/.yourmemory/memories.db

🤝 Mitwirken

PRs willkommen – siehe CONTRIBUTORS.md.

📚 Datenquellen

• LoCoMo – Maharana et al. (2024)
• LongMemEval – Wu et al. (2024)
• HotpotQA – Yang et al. (2018)

📄 Lizenz

Copyright 2026 Sachit Misra – Lizenziert unter CC-BY-NC-4.0.

Kostenlos für den persönlichen Gebrauch, Bildung, akademische Forschung und Open-Source-Projekte. Kommerzielle Nutzung erfordert eine separate schriftliche Vereinbarung → [email protected]