YourMemory

+16pp bessere Erinnerungsleistung als Mem0 auf LoCoMo. 100 % Präzision bei veralteten Speichern. Biologisch inspirierter Speicherzerfall für KI-Agenten.

Persistenter Speicher für Claude und jede MCP-kompatible KI — funktioniert wie das menschliche Gedächtnis. Wichtige Dinge bleiben haften, vergessene Dinge verblassen, veraltete Fakten werden automatisch bereinigt. Verwandte Erinnerungen bleiben durch eine Graphenschicht, die Verbindungen zwischen ihnen versteht, länger aktiv.

Frühes Stadium — Feedback und Ideen sind willkommen.

Benchmarks

Bewertet gegen Mem0 (Free Tier) auf dem öffentlichen LoCoMo-Datensatz (Snap Research) — 10 Konversationspaare, insgesamt 200 QA-Paare.

Die vollständige Methodik und die Ergebnisse pro Stichprobe finden Sie in BENCHMARKS.md. Lesen Sie den Bericht: I built memory decay for AI agents using the Ebbinghaus forgetting curve

Funktionsweise

Ebbinghaus-Vergessenskurve

base_λ      = DECAY_RATES[category]
effective_λ = base_λ × (1 - importance × 0.8)
strength    = importance × e^(-effective_λ × days) × (1 + recall_count × 0.2)
score       = cosine_similarity × strength

Die Zerfallsrate variiert je nach Kategorie — Fehlererinnerungen verblassen schnell, Strategien bleiben länger bestehen:

Wichtigkeit moduliert zusätzlich die Zerfallsrate innerhalb jeder Kategorie. Häufig abgerufene Erinnerungen erhalten recall_count-Boosts, die dem Zerfall entgegenwirken. Erinnerungen unter einer Stärke von 0.05 werden automatisch bereinigt.

Hybride Vektor- + Graphen-Engine (v1.3.0)

Der Abruf erfolgt in zwei Runden:

Runde 1 — Vektorsuche: Kosinus-Ähnlichkeit gegenüber allen Speichern. Gibt die Top-k über dem Ähnlichkeitsschwellenwert zurück.

Runde 2 — Graphen-Erweiterung: BFS-Durchlauf ausgehend von den Ergebnissen aus Runde 1. Bringt Erinnerungen zum Vorschein, die verwandt mit den Top-Ergebnissen sind, aber unter dem Ähnlichkeits-Cut-off lagen — Erinnerungen, die Kontext, aber nicht das Vokabular teilen.

recall("Python backend")
  Round 1 → [1] Python/MongoDB (sim=0.61), [2] DuckDB/spaCy (sim=0.19)
  Round 2 → [5] Docker/Kubernetes (sim=0.29, below cut-off but graph neighbour of [1])
            surfaced via graph even though vector search missed it

Chain-aware Pruning (kettenbewusste Bereinigung): Eine Erinnerung bleibt aktiv, wenn einer ihrer Graphen-Nachbarn noch über dem Bereinigungsschwellenwert liegt. Verwandte Erinnerungen altern gemeinsam — eine starke Erinnerung schützt ein ganzes verbundenes Cluster vor der Löschung.

Recall-Propagierung: Das Abrufen einer Erinnerung erhöht automatisch den recall_count ihrer Graphen-Nachbarn. Häufig aufgerufene Erinnerungen halten ihren verwandten Kontext frisch.

Semantische Kanten: Graphenkanten werden basierend auf der Kosinus-Ähnlichkeit (Schwellenwert ≥ 0.4) erstellt, nicht nach der Einfügereihenfolge. Kantengewicht = similarity × verb_weight aus dem von spaCy extrahierten SVO-Prädikat.

Einrichtung

Keine Infrastruktur erforderlich — nutzt DuckDB direkt nach der Installation. Zwei Befehle und Sie sind fertig.

Unterstützt Python 3.11, 3.12, 3.13 und 3.14.

1. Installation

pip install yourmemory

Alle Abhängigkeiten werden automatisch installiert. Kein Klonen, kein Docker, keine Datenbankeinrichtung.

2. Setup ausführen (einmalig)

yourmemory-setup

Lädt das spaCy-Sprachmodell herunter und initialisiert die Datenbank. Führen Sie dies nach der Installation einmal aus.

3. Konfiguration abrufen

yourmemory-path

Gibt Ihren vollständigen Pfad zur ausführbaren Datei und eine sofort kopierbare Konfiguration für jeden MCP-Client aus. Kopieren Sie diese.

4. In Ihren KI-Client einbinden

Die Datenbank wird bei der ersten Verwendung automatisch unter ~/.yourmemory/memories.duckdb erstellt.

Claude Code

Hinzufügen zu ~/.claude/settings.json:

{
  "mcpServers": {
    "yourmemory": {
      "command": "yourmemory"
    }
  }
}

Claude Code neu laden (Cmd+Shift+P → Developer: Reload Window).

Cline (VS Code)

VS Code übernimmt nicht Ihren Shell-PATH. Führen Sie dies im Terminal aus, um die exakte Konfiguration zum Einfügen zu erhalten:

yourmemory-path

Dann in Cline → MCP Servers → Edit MCP Settings die Ausgabe einfügen. Sie sieht so aus:

{
  "mcpServers": {
    "yourmemory": {
      "command": "/full/path/to/yourmemory",
      "args": [],
      "env": {
        "YOURMEMORY_USER": "your_name",
        "DATABASE_URL": ""
      }
    }
  }
}

Starten Sie Cline nach dem Speichern neu.

Cursor

Hinzufügen zu ~/.cursor/mcp.json:

{
  "mcpServers": {
    "yourmemory": {
      "command": "/full/path/to/yourmemory",
      "args": [],
      "env": {
        "YOURMEMORY_USER": "your_name",
        "DATABASE_URL": ""
      }
    }
  }
}

Claude Desktop

Hinzufügen zu ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "yourmemory": {
      "command": "yourmemory"
    }
  }
}

Starten Sie Claude Desktop neu.

Jeder MCP-kompatible Client

YourMemory ist ein Standard-stdio-MCP-Server. Funktioniert mit Claude Code, Claude Desktop, Cline, Cursor, Windsurf, Continue und Zed. Verwenden Sie den vollständigen Pfad von yourmemory-path, falls der Client den Shell-PATH nicht übernimmt.

5. Speicheranweisungen zu Ihrem Projekt hinzufügen

Kopieren Sie sample_CLAUDE.md als CLAUDE.md in Ihr Projektstammverzeichnis und ersetzen Sie:

• YOUR_NAME — Ihr Name (z. B. Alice)

• YOUR_USER_ID — wird zur Namensraumtrennung der Speicher verwendet (z. B. alice)

Claude folgt nun automatisch bei jeder Aufgabe dem Workflow: Abrufen → Speichern → Aktualisieren.

Multi-Agent Shared und Private Memory

Mehrere KI-Agenten können dieselbe YourMemory-Instanz teilen — jeder mit seiner eigenen Identität, isolierten privaten Speichern und kontrolliertem Zugriff auf geteilten Kontext.

Funktionsweise

Jede Erinnerung hat zwei Felder, die die Sichtbarkeit steuern:

Agenten authentifizieren sich mit einem API-Schlüssel (Präfix ym_). Ohne Schlüssel wird der Aufrufer als Benutzer behandelt und kann nur shared Erinnerungen lesen/schreiben.

Einen Agenten registrieren

from src.services.api_keys import register_agent

result = register_agent(
    agent_id="coding-agent",
    user_id="sachit",
    description="Handles code review and refactoring tasks",
    can_read=["shared", "private"],   # what this agent can read
    can_write=["shared", "private"],  # what it can write
)

print(result["api_key"])  # ym_xxxx — save this, shown once only

Der Schlüssel wird vor der Speicherung mit SHA-256 gehasht. Der Klartext wird niemals gespeichert — bei Verlust widerrufen und neu registrieren.

Den API-Schlüssel in MCP-Aufrufen verwenden

Übergeben Sie api_key an jeden MCP-Tool-Aufruf:

# Store a private memory — only this agent can recall it
store_memory(
    content="The auth service on staging uses a self-signed cert — skip SSL verify",
    importance=0.7,
    category="failure",
    api_key="ym_xxxx",
    visibility="private"
)

# Store shared context — any agent can recall it
store_memory(
    content="Production database is on PostgreSQL 16, us-east-1",
    importance=0.8,
    category="fact",
    api_key="ym_xxxx",
    visibility="shared"
)

# Recall — returns shared memories + this agent's private memories
recall_memory(
    query="database production",
    api_key="ym_xxxx"
)

Ohne api_key gibt der Abruf nur geteilte Erinnerungen zurück.

Zugriffskontrolle

Bei der Registrierung eines Agenten steuert can_read, auf welche Sichtbarkeitsebenen der Agent zugreifen kann:

# Read-only agent — can see shared context but cannot store private memories
register_agent(
    agent_id="readonly-summarizer",
    user_id="sachit",
    can_read=["shared"],
    can_write=["shared"],
)

# Isolated agent — private memory only, cannot read shared context
register_agent(
    agent_id="isolated-agent",
    user_id="sachit",
    can_read=["private"],
    can_write=["private"],
)

Beispiel: Zwei Agenten teilen Kontext

coding-agent stores:
  → "Sachit uses pytest for all Python tests"  (shared, importance=0.8)
  → "Staging API key is sk-staging-xxx"         (private, importance=0.9)

review-agent recalls "Python testing":
  ← "Sachit uses pytest for all Python tests"   ✓ (shared — visible)
  ← "Staging API key is sk-staging-xxx"          ✗ (private — hidden)

coding-agent recalls "Python testing":
  ← "Sachit uses pytest for all Python tests"   ✓ (shared)
  ← "Staging API key is sk-staging-xxx"          ✓ (private — owns it)

Einen Agenten widerrufen

from src.services.api_keys import revoke_agent

revoke_agent(agent_id="coding-agent", user_id="sachit")
# Key is invalidated immediately — all future calls with it return 401

MCP-Tools

store_memory akzeptiert einen optionalen category-Parameter, um die Zerfallsrate zu steuern:

# Failure — decays in ~11 days (environment changes fast)
store_memory(
    content="OAuth for client X fails — redirect URI must be app.example.com",
    importance=0.6,
    category="failure"
)

# Strategy — decays in ~38 days (successful patterns stay relevant)
store_memory(
    content="Cursor pagination fixed the 30s timeout on large user queries",
    importance=0.7,
    category="strategy"
)

Beispiel-Sitzung

User: "I prefer tabs over spaces in all my Python projects"

Claude:
  → recall_memory("tabs spaces Python preferences")   # nothing found
  → store_memory("Sachit prefers tabs over spaces in Python", importance=0.9, category="fact")

Next session:
  → recall_memory("Python formatting")
  ← {"content": "Sachit prefers tabs over spaces in Python", "strength": 0.87}
  → Claude now knows without being told again

Bereinigungs-Job (Decay Job)

Wird automatisch alle 24 Stunden beim Start ausgeführt — kein Cron erforderlich. Erinnerungen unter einer Stärke von 0.05 werden bereinigt.

Chain-aware Pruning (v1.3.0): Vor dem Löschen einer zerfallenen Erinnerung prüft der Bereinigungs-Job deren Graphen-Nachbarn. Wenn ein Nachbar noch über dem Bereinigungsschwellenwert liegt, bleibt die Erinnerung aktiv. Dies verhindert die isolierte Löschung von Fakten, die Teil eines verwandten Clusters sind.

Stack

• DuckDB — Standard-Backend, keine Einrichtung, native Vektorähnlichkeit (gleiche Qualität wie pgvector)

• NetworkX — Standard-Graphen-Backend, keine Einrichtung, persistiert unter ~/.yourmemory/graph.pkl

• Neo4j — optionales Graphen-Backend für Skalierung: pip install 'yourmemory[neo4j]', setzen Sie GRAPH_BACKEND=neo4j

• sentence-transformers — lokale Embeddings (all-mpnet-base-v2, 768 Dimensionen, kein externer Dienst erforderlich)

• spaCy 3.8.13+ — lokales NLP für Deduplizierung, Kategorisierung und SVO-Tripel-Extraktion (Python 3.11–3.14 kompatibel)

• APScheduler — automatischer 24h-Bereinigungs-Job

• MCP — Claude-Integration über das Model Context Protocol

• PostgreSQL + pgvector — optional, für Teams / große Datensätze

Architektur

Claude / Cline / Cursor / Any MCP client
    │
    ├── recall_memory(query, api_key?)
    │       └── embed → cosine similarity (Round 1)
    │           → graph BFS expansion (Round 2)
    │           → score = sim × strength → top-k
    │           → recall propagation → boost graph neighbours
    │
    ├── store_memory(content, importance, category?, api_key?, visibility?)
    │       └── is_question? → reject
    │           contradiction check → update existing if conflict
    │           embed() → INSERT memories
    │           → index_memory() → upsert graph node + semantic edges
    │
    └── update_memory(id, new_content, importance)
            └── embed(new_content) → UPDATE memories
                → update graph node strength

Vector DB (Round 1)          Graph DB (Round 2)
DuckDB (default)             NetworkX (default)
  memories.duckdb              graph.pkl
  ├── embedding FLOAT[768]     ├── nodes: memory_id, strength
  ├── importance FLOAT         └── edges: sim × verb_weight ≥ 0.4
  ├── recall_count INTEGER
  ├── visibility VARCHAR     Neo4j (opt-in, GRAPH_BACKEND=neo4j)
  └── agent_id VARCHAR         └── bolt://localhost:7687

Agent Registry
  agent_registrations
  ├── agent_id VARCHAR
  ├── api_key_hash VARCHAR   ← SHA-256, plaintext never stored
  ├── can_read  []           ← ["shared"] | ["private"] | both
  ├── can_write []
  └── revoked_at TIMESTAMP

PostgreSQL (optional — für Teams oder große Datensätze)

Installation mit Postgres-Unterstützung:

pip install yourmemory[postgres]

Dann eine .env-Datei erstellen:

DATABASE_URL=postgresql://YOUR_USER@localhost:5432/yourmemory

Das Backend wird automatisch ausgewählt — postgresql:// in DATABASE_URL → Postgres + pgvector, alles andere → DuckDB.

macOS

brew install postgresql@16 pgvector && brew services start postgresql@16
createdb yourmemory

Ubuntu / Debian

sudo apt install postgresql postgresql-contrib postgresql-16-pgvector
createdb yourmemory

Datensatz-Referenz

Benchmarks verwenden den LoCoMo-Datensatz von Snap Research — ein öffentlicher Long-Context-Speicher-Benchmark für Multi-Session-Dialoge.

Maharana et al. (2024). LoCoMo: Long Context Multimodal Benchmark for Dialogue. Snap Research.

Lizenz

Copyright 2026 Sachit Misra

Lizenziert unter CC-BY-NC-4.0 (Creative Commons Attribution-NonCommercial 4.0).

Kostenlos für: persönlichen Gebrauch, Bildung, akademische Forschung, Open-Source-Projekte.

Nicht gestattet: Kommerzielle Nutzung jeglicher Art — einschließlich SaaS, interne Tools in gewinnorientierten Unternehmen oder kostenpflichtige Dienste — ohne eine separate schriftliche Vereinbarung.

Für kommerzielle Lizenzierung: mishrasachit1@gmail.com