Agent Memory Bridge

Vereinfachtes Chinesisch

Eine MCP-native Speicherschicht für Coding-Agenten, die echte Sitzungen in wiederverwendbares technisches Gedächtnis verwandelt.

Zuerst für Codex gebaut.

Agent Memory Bridge erfasst, was im Chat-Verlauf normalerweise verloren geht:

• dauerhafte Entscheidungen

• bekannte Korrekturen

• Übergaben zwischen Sitzungen

• wiederverwendbare Fallstricke

• kompaktes Domänenwissen

Die Grundidee ist einfach: Halte die Speicherschicht klein, zuverlässig und überprüfbar. Lass die Orchestrierung auf höherer Ebene obenauf sitzen.

Der interessante Teil ist nicht nur die Persistenz. Es ist die automatische Speicherformung:

• Sitzungen werden zu wiederverwendbarem learn

• wiederholte Fehler werden zu gotcha

• Cluster von Lektionen werden zu kompakten domain-note

Warum existiert dies?

Die meisten Agenten-Speichersysteme driften in eines von drei Mustern ab:

• Speicher, der in einer App oder einem Modell gefangen ist

• schwerere gehostete Infrastruktur, bevor die Grundlagen des Abrufs bewiesen sind

• Transkript-Dumping statt wiederverwendbarem operativen Wissen

Agent Memory Bridge schlägt einen engeren Pfad ein:

• MCP-nativ vom ersten Tag an

• Lokal-zuerst-Laufzeit

• SQLite + FTS5 statt schwererer Infrastruktur

• automatische Beförderung von Sitzungs-Traces in wiederverwendbares Gedächtnis

Es ist nicht nur Speicher. Es ist eine Pipeline zur Speicherformung:

session -> summary -> learn -> gotcha -> domain-note

Positionierung

Agent Memory Bridge ist bewusst eng gefasst.

Wenn Sie eine breitere Speicherplattform mit SDKs, Dashboards, Connectors und Unterstützung für mehrere Oberflächenanwendungen wünschen, sind Projekte wie OpenMemory oder Mem0 näher an dieser Form.

Dieses Projekt ist absichtlich anders:

1. Es ist für Coding-Agenten-Workflows gebaut, nicht für allgemeine Notizspeicherung.

2. Es hält die MCP-Oberfläche bewusst klein: store und recall.

3. Es befördert rohe Sitzungsausgaben in kompaktes, maschinenlesbares Gedächtnis, anstatt Zusammenfassungen als das endgültige Artefakt zu behandeln.

4. Es ist standardmäßig lokal-zuerst und überprüfbar.

Für eine längere Positionierungsnotiz siehe docs/COMPARISON.md.

Wie es funktioniert

Die Laufzeitumgebung besteht aus vier Hauptteilen:

1. MCP-Server

   • stellt store und recall bereit

2. Watcher

   • beobachtet Codex-Rollout-Dateien

   • schreibt session-seen, checkpoint und closeout

3. Reflex

   • befördert Zusammenfassungen in learn, gotcha und signal

4. Konsolidierung

   • synthetisiert wiederkehrende learn- und gotcha-Datensätze zu Domänennotizen

Dies hält das System verständlich:

• rohe Sitzungen sind kein endgültiges Gedächtnis

• Zusammenfassungen sind kein endgültiges Gedächtnis

• dauerhaftes Gedächtnis ist maschinenorientiert

• Synthese geschieht nach der Beförderung

Schnellstart

Anforderungen:

• Python 3.11+

• Codex mit aktiviertem MCP

• SQLite mit FTS5-Unterstützung

1. Installieren

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install -e .[dev]

2. Bridge-Konfiguration erstellen

Kopieren Sie config.example.toml nach:

$CODEX_HOME/mem-bridge/config.toml

Empfohlene Einrichtung:

• halten Sie die Live-SQLite-Datenbank lokal auf jedem Rechner

• halten Sie geteilte Profile oder Quell-Tresore bei Bedarf auf NAS oder gemeinsam genutztem Speicher

• wechseln Sie später zu einem gehosteten Backend, wenn Sie echtes Live-Schreiben auf mehreren Rechnern wünschen

3. Registrieren Sie den MCP-Server in Codex

Fügen Sie dies zu $CODEX_HOME/config.toml hinzu:

[mcp_servers.agentMemoryBridge]
command = "D:\\path\\to\\agent-memory-bridge\\.venv\\Scripts\\python.exe"
args = ["-m", "agent_mem_bridge"]
cwd = "D:\\path\\to\\agent-memory-bridge"

[mcp_servers.agentMemoryBridge.env]
CODEX_HOME = "%USERPROFILE%\\.codex"
AGENT_MEMORY_BRIDGE_HOME = "%USERPROFILE%\\.codex\\mem-bridge"
AGENT_MEMORY_BRIDGE_CONFIG = "%USERPROFILE%\\.codex\\mem-bridge\\config.toml"

4. Starten Sie den Dienst

Starten Sie den MCP-Server:

.\.venv\Scripts\python.exe -m agent_mem_bridge

Führen Sie den Hintergrund-Bridge-Dienst aus:

.\.venv\Scripts\python.exe .\scripts\run_mem_bridge_service.py

Führen Sie nur einen Zyklus aus:

$env:AGENT_MEMORY_BRIDGE_RUN_ONCE = "1"
.\.venv\Scripts\python.exe .\scripts\run_mem_bridge_service.py

Optionale Startup-Installation:

.\scripts\install_startup_watcher.ps1

Optional: Erstellen Sie ein lokales Docker-Image

docker build -t agent-memory-bridge:local .
docker --context desktop-linux run --rm -i agent-memory-bridge:local

Der Container-Entrypoint startet den stdio MCP-Server mit python -m agent_mem_bridge.

Kern-API

Die MCP-Oberfläche ist bewusst klein:

• store

• recall

Allgemeine store-Felder:

• namespace

• content

• kind

• tags

• session_id

• actor

• title

• correlation_id

• source_app

Allgemeine recall-Felder:

• namespace

• query

• kind

• tags_any

• session_id

• actor

• correlation_id

• since

• limit

Typische Namespaces

• project:<workspace>

• global

• domain:<name>

• importierte Profil-Namespaces, wenn ein Team sie wünscht

Das Framework ist profil-agnostisch. Ein spezifisches Bedienerprofil kann obenauf gelegt werden, aber die Bridge selbst ist nicht an eine Person oder ein Protokoll gebunden.

Tägliche Nutzung

Die beabsichtigte Schichtung ist:

• systemweites Bedienerprofil

• systemweites Speichersubstrat: agentMemoryBridge

• projektlokale Überschreibungen: AGENTS.md

Das Startup-Protokoll ist in docs/STARTUP-PROTOCOL.md dokumentiert.

Kurz gesagt:

1. globales Betriebsgedächtnis abrufen

2. relevantes Spezialisierungsgedächtnis abrufen

3. wenn ein Arbeitsbereich existiert, project:<workspace> abrufen

4. für problemähnliche Arbeit, lokales Gedächtnis und Fallstricke vor der externen Suche prüfen

5. Live-Code überprüfen, bevor abgerufenen Implementierungsdetails vertraut wird

Nützliche Befehle

Tests ausführen:

.\.venv\Scripts\python.exe -m pytest

Den stdio-Rauchtest ausführen:

.\.venv\Scripts\python.exe .\scripts\verify_stdio.py

Den Benchmark ausführen:

.\.venv\Scripts\python.exe .\scripts\run_benchmark.py

Den Bridge-Gesundheitscheck ausführen:

.\.venv\Scripts\python.exe .\scripts\run_healthcheck.py --report-path .\examples\healthcheck-report.json

Erzwingen Sie einen Checkpoint vom neuesten Rollout:

.\.venv\Scripts\python.exe .\scripts\sync_now.py

Projektstruktur

Das Repo ist bewusst klein:

src/agent_mem_bridge/   canonical implementation
scripts/                operational entrypoints
tests/                  verification
docs/                   design and roadmap
examples/               sanitized demo artifacts

Die Dateien, die am wichtigsten sind:

• src/agent_mem_bridge/server.py

• src/agent_mem_bridge/storage.py

• src/agent_mem_bridge/watcher.py

• src/agent_mem_bridge/reflex.py

• src/agent_mem_bridge/consolidation.py

• src/agent_mem_bridge/service.py

Designentscheidungen

Kleine MCP-Oberfläche

Die Bridge stellt nur store und recall bereit. Dies hält den Vertrag stabil und einfach zu integrieren.

Lokal-zuerst-Laufzeit

Die Live-DB bleibt standardmäßig lokal, da SQLite auf gemeinsam genutztem Netzwerkspeicher eine Zuverlässigkeitsfalle ist.

Maschinenorientiertes Gedächtnis

Agenten sind die primären Leser, daher bevorzugt das Gedächtnis:

• kompakte Felder

• stabile Tags

• niedrige Token-Kosten

gegenüber polierter Prosa.

Gestufte Beförderung

Das System versucht, sich nach oben zu bewegen:

• summary

• learn

• gotcha

• domain-note

statt rohe Zusammenfassungen als das endgültige Artefakt zu behandeln.

Status

Das aktuelle Fundament funktioniert:

• MCP-Autoload funktioniert in Codex

• Projekt- und Sitzungssynchronisierung funktionieren

• Recall-zuerst-Workflows funktionieren

• Reflex-Beförderung funktioniert

• Domänenkonsolidierung im ersten Durchgang funktioniert

Realitätscheck und Roadmap:

• docs/PRODUCTION-STATUS.md

• docs/ROADMAP.md

Profil-Importe

Das Framework kann importierte Bedienerprofile hosten, aber das Framework selbst bleibt profil-agnostisch.

Dokumentation

• README.zh-CN.md

• CONTRIBUTING.md

• AGENTS.md

• docs/COMPARISON.md

• docs/STARTUP-PROTOCOL.md

• docs/MEMORY-TAXONOMY.md

• docs/PROMOTION-RULES.md

• docs/MODEL-ROUTING.md

• docs/ROADMAP.md

Lizenz

MIT. Siehe LICENSE.