v0.3.0python 3.10+mcpMIT321 Tests

Agent Recall

Persistentes Gedächtnis für KI-Coding-Agenten

Dein KI-Agent vergisst zwischen Sessions alles

PyPI GitHub GitHub Sponsors ☕ Spendier mir einen Kaffee

Agent Recall gibt deinen Coding-Agenten ein persistentes Gedächtnis. Fakten, Personen, Entscheidungen, über jede Session hinweg gemerkt. Open Source, läuft lokal, MCP-nativ.

shell

pip install 'agent-recall[mcp]'

agent-recall generate acme-project

--- Agent Briefing: acme-project ---

Key People:
  Alice — Lead Engineer, prefers async
  Bob — Product Manager, owns roadmap

Recent Decisions:
  API migration approved (Feb 12)
  Auth service blocked — waiting on Alice

Active Context:
  Sprint 14, 3 days remaining
  Focus: auth service unblock

MCP-nativ. Getestet mit Claude Code, Cursor, Windsurf und Cline

Claude CodeErprobtCursorWindsurfCline

Kontext, der sich aufbaut

01
Ohne Gedächtnis
> Wer ist Alice?Ich habe keinen Kontext zu Alice.Jede Session fängt bei null an.
02
Session 1 speichert Fakten
create_entities: Alice (person)set_slot: role = "Lead Engineer"add_observation: "prefers async"Der Agent speichert, was er lernt, über MCP-Tools.
03
Session 2 startet schon mit Wissen
Agent Briefing geladenAlice. Lead EngineerBevorzugt asynchrone KommunikationAPI-Migration am 12. Februar genehmigtKontext wächst. Jede Session baut auf der letzten auf.

So funktioniert es

01
Agent speichert Fakten
Dein Agent ruft MCP-Tools auf, um beim Arbeiten Entities, Observations und Relations zu speichern. Neun Tools für vollständiges CRUD.
02
In SQLite gespeichert
Alles bleibt in einer lokalen SQLite-Datenbank im WAL-Modus erhalten. Nach Projekt skopiert: dieselbe Person, je Scope ein anderer Kontext.
03
Briefing beim Start
In der nächsten Session lädt automatisch ein KI-generiertes Briefing. Wichtige Personen, jüngste Entscheidungen, aktueller Kontext, zusammengefasst statt einfach abgekippt.

Schnellstart

1. Installieren

pip install 'agent-recall[mcp]'
agent-recall init

.mcp.json (Claude Code, Cline) oder Editor-Einstellungen (Cursor, Windsurf)

2. In den Editor einbinden

{
  "mcpServers": {
    "memory": {
      "command": "python3",
      "args": ["-m", "agent_recall.mcp_server"]
    }
  }
}

.claude/settings.json. Lädt das Briefing beim Session-Start.

3. Auto-Briefing-Hook

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "agent-recall-session-start"
      }]
    }],
    "PostToolUse": [{
      "matcher": "mcp__memory__.*",
      "hooks": [{
        "type": "command",
        "command": "agent-recall-post-tool-use"
      }]
    }]
  }
}

4. Prüfen

agent-recall status

Database: ~/.agent-recall/frames.db
Entities: 27
  client: 11, person: 8, company: 1
  concept: 2, entity: 3, topic: 2

Funktionen von Agent Recall

Scoped Memory
Dieselbe Person, unterschiedliche Kontexte je Projekt. Alice ist bei Acme „Engineer“, bei BetaCorp „Consultant“. Daten bleiben über die Scope-Hierarchie isoliert.
KI-Briefings
Zusammenfassungen statt Datenmüll. Liest 147 Fakten und liefert Key People, aktuelle Aufgaben, jüngste Entscheidungen. Bring dein eigenes LLM mit.
Multi-Agent-tauglich
Für Agenturen gebaut. Die Scope-Hierarchie lässt jeden Agenten innerhalb seiner Scope-Kette lesen und schreiben, alle teilen sich eine Wissensbasis.
Local-First
SQLite auf deinem Rechner. WAL-Modus für gleichzeitigen Zugriff. Deine Daten gehören dir, keine Cloud, kein Vendor Lock-in.
MCP-nativ
Neun Tools über das Model Context Protocol. Für MCP-kompatible Clients konzipiert. Getestete Konfigurationen für Claude Code, Cursor, Windsurf und Cline.
Volle Historie
Bitemporales Tracking. Du weißt, was wann galt, nicht nur, was jetzt gilt. Volle zeitliche Historie pro Slot.

Code-Beispiele

Python API

from agent_recall import MemoryStore, ScopedView

with MemoryStore() as store:
    alice = store.resolve_entity("Alice", "person")
    store.set_slot(alice, "role", "Lead Engineer", scope="acme")
    store.add_observation(alice, "Prefers async", scope="acme")

    view = ScopedView(store, ["global", "acme"])
    entity = view.get_entity("Alice")
    print(entity["slots"]["role"])  # "Lead Engineer"

    # Suche, Historie, Transaktionen
    results = store.search("engineer")
    store.set_slot(alice, "role", "Staff Engineer", scope="acme")
    history = store.get_slot_history(alice, "role")

    with store.transaction():
        bob = store.resolve_entity("Bob", "person")
        store.set_slot(bob, "role", "PM")

CLI

$ agent-recall set Alice role Engineer --type person
Alice.role = Engineer

$ agent-recall list --type person
  Alice (person)  Bob (person)

$ agent-recall entity Alice --scope global --scope acme
  role: Lead Engineer (acme)

$ agent-recall logs Alice
  [2026-02-26] Joined the team

$ agent-recall generate my-agent --force
Generated: ~/.agent-recall/context_cache/my-agent.md

9 MCP-Tools für deinen Agenten

create_entitiesadd_observationscreate_relationssearch_nodesopen_nodesread_graphdelete_entitiesdelete_relationsdelete_observations

YAML-Konfiguration für mehrere Agenten

hierarchy:
  agency:
    - client-a
    - client-b

briefing:
  backend: cli
  model: opus
  adaptive: true
  auto_discover: true

agents:
  coordinator:
    model: opus
    output_budget: 12000
  client-a:
    template: client
    context_files:
      - docs/client-a-brief.md

Bring Your Own LLM

from agent_recall import generate_briefing, LLMResult

def my_llm(prompt, model, timeout):
    response = call_your_api(prompt)
    return LLMResult(
        text=response.text,
        input_tokens=0,
        output_tokens=0
    )

generate_briefing(
    "my-agent",
    llm_caller=my_llm,
    force=True
)

Warum agent-recall?

Andere Memory-Lösungen gibt es (Mem0, Zep/Graphiti, LangMem). Was agent-recall anders macht:

Scope-Hierarchie · Kein flaches Gedächtnis. Scope-Ketten mit Vererbung, gebaut für Agenten, die mit mehreren Kunden, Projekten und verschachtelten Kontexten arbeiten. Dieselbe Person kann in verschiedenen Projekten unterschiedliche Rollen haben.
KI-Briefings · Rohe Datendumps funktionieren nicht. Ein LLM fasst hunderte Fakten zu strukturiertem, handlungsrelevantem Kontext zusammen, der beim Session-Start eingespielt wird.
Local-First · Eine einzige SQLite-Datei. Keine Cloud, keine Vector-DB, kein Docker, kein Neo4j. Deine Daten bleiben auf deinem Rechner.
MCP-nativ · 9 Tools mit Anweisungen zum proaktiven Speichern. Konzipiert für MCP-kompatible Clients.
Bitemporal · Alte Werte werden archiviert, nicht gelöscht. Du kannst abfragen, was zu jedem Zeitpunkt galt.
Minimale Abhängigkeiten · Nur pyyaml plus click. MCP und das Anthropic SDK sind optionale Extras.

In Produktion entstanden

Aus einem realen System extrahiert, das 30+ KI-Agenten parallel in Produktion betreibt. Kein Wochenend-Experiment, sondern erprobte Infrastruktur, die täglich echte Lasten trägt.

321

Tests

Module

WAL

SQLite-Modus

30+

Agenten in Produktion

Troubleshooting

Der Agent speichert keine Fakten automatisch: Prüfe, ob der MCP-Server verbunden ist. Dein Agent sollte create_entities, search_nodes usw. als verfügbare Tools auflisten. Prüfe, ob der Server fehlerfrei startet: python3 -m agent_recall.mcp_server
Briefings sind leer oder die Generierung schlägt fehl: Prüfe, ob Daten vorhanden sind: agent-recall status sollte Entities zeigen. Das Standard-Backend cli braucht Claude Code installiert. Probier das api-Backend mit ANTHROPIC_API_KEY.
Windows: python3 nicht gefunden: Unter Windows heißt Python meist python und nicht python3. Aktualisiere "command": "python".

Tech-Stack

PythonSQLiteMCPFastMCPYAMLClickpy.typed

Gib deinen Agenten ein persistentes Gedächtnis

Open Source. Läuft lokal. MIT-Lizenz. Ein pip install entfernt.

shell

pip install 'agent-recall[mcp]'

PyPI-Paket Auf GitHub ansehen GitHub Sponsors ☕ Spendier mir einen Kaffee

Ohne Gedächtnis

Session 1 speichert Fakten

Session 2 startet schon mit Wissen

Agent speichert Fakten

In SQLite gespeichert

Briefing beim Start

Scoped Memory

KI-Briefings

Multi-Agent-tauglich

Local-First

MCP-nativ

Volle Historie