Skip to main content
Glama

agentmem

Gemeinsamer Speicher für Claude Code, Cursor und Codex, der weiß, was noch aktuell ist. Speichere Sitzungen, erkenne veraltete und widersprüchliche Regeln und verhindere, dass dein Agent alte Fehler wiederholt.

PyPI Python License: MIT Tests

Das Problem

Dein KI-Coding-Assistent vergisst alles zwischen den Sitzungen. Er wiederholt alte Fehler. Er kann aktuelle Regeln nicht von veralteten unterscheiden. Der Kontext komprimiert sich und die Wiederherstellung ist mühsam.

Die meisten Speicher-Tools lösen das Problem der Speicherung. agentmem löst das Problem des Vertrauens.

Erste Schritte (Claude Code / Cursor / Codex)

pip install quilmem[mcp]
agentmem init --tool claude --project myapp

Das war's. Starte deinen Editor neu. Dein Agent verfügt nun über 13 Speicher-Tools. Führe memory_health aus, um dies zu bestätigen.

Nur Python? pip install quilmem funktioniert ohne das MCP-Extra. Siehe die Python API unten.

60-Sekunden-Demo

from agentmem import Memory

mem = Memory()

# Store typed memories
mem.add(type="bug", title="loudnorm undoes SFX levels",
        content="Never apply loudnorm to final mix. It re-normalizes everything.",
        status="validated")

mem.add(type="decision", title="Use per-line atempo",
        content="Bake speed into per-line TTS. No global pass.",
        status="active")

# Something you're not sure about yet
hypothesis = mem.add(type="decision", title="Maybe try 2-second gaps before CTA",
        content="Hypothesis from last session. Needs testing.",
        status="hypothesis")

# Search — validated and active memories rank highest.
# Deprecated and superseded memories are excluded automatically.
results = mem.search("audio mixing")

# Context-budgeted recall — fits the best memories into your token limit
context = mem.recall("building a narration track", max_tokens=2000)

# Lifecycle — promote what's proven, deprecate what's not
mem.promote(hypothesis.id)                # hypothesis -> active -> validated
mem.deprecate(hypothesis.id, reason="Disproven by data")

# Supersede: replace an outdated memory with a newer one
replacement = mem.add(type="decision", title="Use 1-second gaps before CTA",
        content="Confirmed by A/B test.", status="active")
mem.supersede(hypothesis.id, replacement.id)  # old points to replacement

# Health check — is your memory system trustworthy?
from agentmem import health_check
report = health_check(mem._conn)
# Health: 85/100 | Conflicts: 0 | Stale: 2 | Validated: 14

Was macht dies anders?

Andere Speicher-Tools speichern Dinge. agentmem weiß, was noch wahr ist.

Mem0

Letta

Mengram

agentmem

Speicherort

Ja

Ja

Ja

Ja

Volltextsuche

Vektor

Agent-gesteuert

Wissensgraph

FTS5

Speicher-Lebenszyklus-Status

Nein

Teilweise

Nein

Hypothese -> aktiv -> validiert -> veraltet -> ersetzt

Konflikterkennung

Nein

Nein

Teilweise

Eingebaut

Veraltungs-Erkennung

Nein

Nein

Nein

Eingebaut

Gesundheitsbewertung

Nein

Nein

Nein

Eingebaut

Herkunfts-Tracking

Nein

Nein

Nein

source_path + source_hash

Vertrauens-Ranking beim Abruf

Nein

Nein

Nein

Validiert > aktiv > Hypothese

Menschenlesbare Quelldateien

Nein

Nein

Nein

Kanonisches Markdown

Lokal-zuerst, null Infrastruktur

Nein

Selbst-Host-Option

Selbst-Host-Option

Ja, immer

MCP-Server

Separat

Separat

Ja

Eingebaut

Wahrheits-Governance

Die Kernidee: Jede Erinnerung hat einen Status, der nachverfolgt, wie sehr man ihr vertrauen sollte.

hypothesis    New observation. Not yet confirmed. Lowest trust in recall.
    |
  active      Default. Currently believed true. Normal trust.
    |
 validated    Explicitly confirmed. Highest trust in recall.

 deprecated   Was true, no longer. Excluded from recall. Kept for history.
 superseded   Replaced by a newer memory. Points to replacement.

Warum das wichtig ist: Ohne Governance sammelt der Speicher deines Agenten veraltete Regeln, Widersprüche und überholte Entscheidungen an. Er weiß nicht, dass die Stimmeinstellung vom Januar im März überschrieben wurde. Er ruft beides ab und die LLM wählt zufällig. Gesteuerter Speicher löst dies.

Konflikterkennung

from agentmem import detect_conflicts

conflicts = detect_conflicts(mem._conn)
# Found 2 conflict(s):
#   !! [decision] "Always apply loudnorm to voice"
#      vs [decision] "NEVER apply loudnorm to voice"
#      Contradiction on shared topic (voice, loudnorm, audio)

agentmem findet Erinnerungen, die sich gegenseitig widersprechen:

  • Erkennt Themenüberschneidungen (Jaccard-Ähnlichkeit)

  • Trennt Duplikate von Widersprüchen

  • Satzbasierter Negationsabgleich (nicht nur Keyword-Scanning)

  • Schweregrad: critical (beide aktiv) vs warning (eine veraltet)

Veraltungs-Erkennung

from agentmem import detect_stale

stale = detect_stale(mem._conn, stale_days=30)
# [decision] "Use atempo 0.90" — Source changed since import (hash mismatch)
# [bug] "Firewall blocks port" — Not updated in 45 days

Findet veraltete Erinnerungen durch:

  • Alter (nicht in N Tagen aktualisiert)

  • Fehlende Quelldatei (referenzierte Datei wurde gelöscht)

  • Hash-Drift (Inhalt der Quelldatei geändert, aber Erinnerung nicht aktualisiert)

Gesundheits-Check

from agentmem import health_check

report = health_check(mem._conn)
print(f"Health: {report.health_score}/100")
print(f"Conflicts: {len(report.conflicts)}")
print(f"Stale: {len(report.stale)}")

Bewertet dein Speichersystem von 0-100 basierend auf: Konflikten, Veraltungs-Prozentsatz, verwaisten Referenzen, veraltetem Gewicht und ob du validierte Erinnerungen hast.

Herkunfts-bewusste Synchronisierung

Synchronisiere kanonische Markdown-Dateien in die DB mit Herkunfts-Tracking:

# Each memory tracks where it came from
mem.add(type="bug", title="loudnorm lifts noise",
        content="...",
        source_path="/docs/errors.md",
        source_section="Audio Bugs",
        source_hash="a1b2c3d4e5f6")

Die Sync-Engine:

  • Gleicher Hash = überspringen (idempotent, erneutes Ausführen ändert nichts)

  • Anderer Hash = aktualisieren (Quelldatei geändert)

  • Abschnitt entfernt = veralten (mit Grund)

  • Abschnitt wiederhergestellt = reaktivieren (reaktiviert veraltete Erinnerung)

Drei Schnittstellen

Python API

from agentmem import Memory

mem = Memory("./my-agent.db", project="frontend")

# CRUD
record = mem.add(type="decision", title="Use TypeScript", content="...")
mem.get(record.id)
mem.update(record.id, content="Updated reasoning.")
mem.delete(record.id)
mem.list(type="bug", limit=20)

# Search + recall
results = mem.search("typescript migration", type="decision")
context = mem.recall("setting up the build", max_tokens=3000)

# Governance
mem.promote(record.id)              # hypothesis -> active -> validated
mem.deprecate(record.id, reason="No longer relevant")
replacement = mem.add(type="decision", title="Use v2 approach", content="...")
mem.supersede(record.id, replacement.id)  # links old to replacement

# Session persistence
mem.save_session("Working on auth refactor. Blocked on token refresh.")
mem.load_session()                  # picks up where last instance left off

# Health
mem.stats()

CLI

# Get started in 30 seconds
agentmem init --tool claude --project myapp

# Check if everything's working
agentmem doctor

# Core
agentmem add --type bug --title "CSS grid issue" "Flexbox fallback needed"
agentmem search "grid layout"
agentmem recall "frontend styling" --tokens 2000

# Governance
agentmem promote <id>
agentmem deprecate <id> --reason "Fixed in v2.3"
agentmem health
agentmem conflicts
agentmem stale --days 14

# Import + sessions
agentmem import ./errors.md --type bug
agentmem save-session "Finished auth module, starting tests"
agentmem load-session

# MCP server
agentmem serve

MCP Server

Eingebauter Model Context Protocol Server für Claude Code, Cursor und jeden MCP-Client.

pip install quilmem[mcp]

Claude Code Konfiguration (.claude/settings.json):

{
  "mcpServers": {
    "agentmem": {
      "command": "agentmem",
      "args": ["--db", "./memory.db", "--project", "myproject", "serve"],
      "type": "stdio"
    }
  }
}

MCP-Tools: add_memory, search_memory, recall_memory, update_memory, delete_memory, list_memories, save_session, load_session, promote_memory, deprecate_memory, supersede_memory, memory_health, memory_conflicts

Sage deinem Agenten, wie er den Speicher nutzen soll: Kopiere die Agenten-Anweisungen in deine CLAUDE.md, .cursorrules oder AGENTS.md. Dies bringt deinem Agenten das Sitzungsprotokoll, die Vertrauenshierarchie und das Wann-Suchen-vs-Hinzufügen bei.

Typisierter Speicher

Sieben Typen, die echte Agenten-Workflows abdecken:

Typ

Was er speichert

Beispiel

setting

Konfiguration, Parameter

"Voice speed: atempo 1.08"

bug

Fehler und deren Korrekturen

"loudnorm lifts noise floor"

decision

Regeln, Richtlinien, Entscheidungen

"3rd-person narration banned"

procedure

Workflows, Pipelines

"TTS -> speed -> 48kHz -> mix"

context

Hintergrundwissen

"Project uses FFmpeg + Python 3.11"

feedback

Benutzerkorrekturen

"Always pick, don't ask"

session

Aktueller Arbeitsstatus

"Working on auth. Blocked on tokens."

Vertrauens-Ranking beim Abruf

recall() findet nicht nur relevante Erinnerungen. Er findet die vertrauenswürdigsten relevanten Erinnerungen:

  1. FTS5-Suche liefert Kandidaten

  2. Jeder bewertet: Relevanz (25%) + Vertrauensstatus (20%) + Herkunft (20%) + Aktualität (15%) + Häufigkeit (10%) + Konfidenz (10%)

  3. Validierte kanonische Erinnerungen rangieren über Hypothesen-Erinnerungen ohne Herkunft

  4. Veraltete und ersetzte Erinnerungen werden vollständig ausgeschlossen

  5. Gierig in dein Token-Budget gepackt

Projekt-Scoping

frontend = Memory("./shared.db", project="frontend")
backend = Memory("./shared.db", project="backend")

frontend.search("bug")  # Only frontend bugs
backend.search("bug")   # Only backend bugs

Kampferprobt

Dies ist nicht theoretisch. agentmem wurde unter Produktionsdruck über 2+ Monate täglicher Nutzung entwickelt:

  • 65+ YouTube Shorts produziert mit null wiederholten Produktionsfehlern

  • 330+ Erinnerungen, die Stimmgenerierung, FFmpeg-Assemblierung, Bild-Prompting, Upload-Workflows steuern

  • Jeder Fehler einmal gefunden, einmal behoben, nie wiederholt

  • Governance-Engine reduzierte Konflikte von 1.848 Fehlalarmen auf 11 echte Befunde

Wie es funktioniert

  • Speicherung: SQLite mit WAL-Modus (gleichzeitige Lesezugriffe, thread-sicher)

  • Suche: FTS5 mit Porter-Stemming und unicode61-Tokenizer

  • Ranking: Zusammengesetzter Score: Textrelevanz + Vertrauensstatus + Herkunft + Aktualität + Häufigkeit + Konfidenz

  • Governance: Status-Lebenszyklus, Konflikterkennung, Veraltungs-Erkennung, Gesundheitsbewertung

  • Sync: Herkunfts-bewusst mit Quell-Hashing und Wiederbelebung

  • Null Infrastruktur: Keine API-Keys, keine Cloud, keine Vektor-DB. Nur eine .db-Datei.

Lizenz

MIT

Install Server
A
security – no known vulnerabilities
A
license - permissive license
A
quality - A tier

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Thezenmonster/agentmem'

If you have feedback or need assistance with the MCP directory API, please join our Discord server