RemembrallMCP

👁 License: MIT
👁 Crates.io
👁 CI
👁 Docker

Persistenter Wissensspeicher und Code-Intelligenz für KI-Agenten. Rust-Kern, Postgres + pgvector, MCP-Protokoll.

Das Problem: KI-Coding-Agenten sind zustandslos. Jede Sitzung beginnt bei Null – kein Gedächtnis an vergangene Entscheidungen, kein Verständnis dafür, wie die Codebasis zusammenhängt, keine Möglichkeit zu wissen, was kaputt geht, wenn man etwas ändert.

Die Lösung: RemembrallMCP gibt Agenten zwei Dinge, die die meisten Speicher-Tools nicht bieten:

1. Persistenter Speicher – Entscheidungen, Muster und organisatorisches Wissen, die Sitzungen überdauern. Die hybride semantische + Volltextsuche findet sofort relevanten Kontext.

2. Code-Abhängigkeitsgraph – Eine Live-Karte Ihrer Codebasis, erstellt mit tree-sitter. Funktionen, Klassen, Importe und Aufrufbeziehungen über 8 Sprachen hinweg. Fragen Sie „Was geht kaputt, wenn ich das ändere?“ und erhalten Sie die Antwort in Millisekunden – bevor der Agent irgendetwas anfasst.

remembrall_recall("authentication middleware patterns")
-> 3 relevant memories from past sessions

remembrall_index("/path/to/project", "myapp")
-> Builds dependency graph: 847 symbols, 1,203 relationships

remembrall_impact("AuthMiddleware", direction="upstream")
-> 12 files depend on AuthMiddleware (with confidence scores)

remembrall_store("Switched from JWT to session tokens because...")
-> Decision stored for future sessions

Warum der Code-Graph wichtig ist

Ohne RemembrallMCP erkunden Agenten Ihre Codebasis in jeder Sitzung von Grund auf neu. Claude Code startet Explore-Agenten, Codex liest Dutzende von Dateien, Cursor durchsucht Verzeichnisse mit grep – alles verbraucht Token und Zeit, nur um zu verstehen, was was aufruft. Eine einzige Aufgabe wie „Finde alle Aufrufer dieser Funktion“ kann Tausende von Token über mehrere Tool-Aufrufe hinweg kosten.

Mit RemembrallMCP ist dieselbe Abfrage ein einziger remembrall_impact-Aufruf, der in <1ms ohne Erkundungs-Token zurückkehrt. Der Abhängigkeitsgraph ist bereits erstellt und wartet.

Die Einsparungen skalieren mit der Größe der Codebasis. Bei einem kleinen Projekt kann ein Agent sich durchgreppen und -lesen. Bei einem Monorepo mit 500 Dateien wird diese Erkundung zum Flaschenhals – Agenten stoßen an Kontextlimits, starten mehrere Unter-Agenten oder übersehen Abhängigkeiten zwischen Modulen komplett. Die Graph-Abfragen von RemembrallMCP bleiben unabhängig von der Projektgröße unter 10ms, da die Struktur in Postgres vorindiziert ist und nicht zur Laufzeit entdeckt werden muss.

Das ist der Unterschied zwischen einem Agenten, der Ihre Codebasis jedes Mal neu erkundet, und einem, der sie bereits versteht.

Benchmarks

RemembrallMCP wird derzeit auf zwei Ebenen gemessen:

• Agenten-Produktivität bei Code-Aufgaben – Getestet an pallets/click v8.1.7 (594 Symbole, 1.589 Beziehungen). Fünf identische Coding-Aufgaben wurden mit und ohne RemembrallMCP ausgeführt. Vollständiger Bericht.

• Qualität des Speicherabrufs – Lokale Abruf-Testumgebung, die gegen 31 Ground-Truth-Abfragen läuft, welche Suchqualität, Filterung, Grenzfälle, Ranking und Latenz abdecken.

Die Einsparungen summieren sich bei größeren Codebasen. Click besteht aus ca. 90 Dateien – bei einem Monorepo mit über 500 Dateien benötigen Agenten ohne RemembrallMCP proportional mehr Erkundungsaufrufe, während Graph-Abfragen unabhängig von der Größe unter 10ms bleiben.

Führen Sie die Benchmarks selbst aus: siehe benchmarks/ für die Testumgebung und Aufgabendefinitionen.

Für die breitere Benchmark-Strategie über Speicherabruf, Langzeitgedächtnis, Korrektheit des Code-Graphen und Agenten-Produktivität, siehe docs/benchmark-roadmap.md.

Anforderungen

• Docker (für die einfachste Einrichtung) oder PostgreSQL 16 mit pgvector

• Für GitHub-Ingestion: GitHub CLI (gh) installiert und authentifiziert

Related MCP server: smriti

Schnellstart

Option 1: Docker Compose (am einfachsten)

git clone https://github.com/cdnsteve/remembrallmcp.git
cd remembrallmcp

# Start Postgres + initialize schema + download embedding model
docker compose up -d

# Verify it's running
docker compose exec remembrall remembrall status

Das war's. Postgres mit pgvector, das Schema und das Embedding-Modell werden automatisch eingerichtet. Die Datenbank und der Modell-Cache bleiben über Neustarts hinweg erhalten.

Um den MCP-Server auszuführen:

docker compose run --rm remembrall

Option 2: Vorkompiliertes Binary herunterladen

# macOS (Apple Silicon)
curl -fsSL https://github.com/cdnsteve/remembrallmcp/releases/latest/download/remembrall-aarch64-apple-darwin.tar.gz | tar xz
sudo mv remembrall /usr/local/bin/

# Linux (x86_64)
curl -fsSL https://github.com/cdnsteve/remembrallmcp/releases/latest/download/remembrall-x86_64-unknown-linux-gnu.tar.gz | tar xz
sudo mv remembrall /usr/local/bin/

# Initialize (sets up Postgres via Docker, creates schema, downloads model)
remembrall init

Option 3: Aus Quellcode bauen (erfordert Rust 1.94+)

cargo build -p remembrall-server --release
# Binary is at target/release/remembrall

remembrall init

Verbindung zu Ihrem MCP-Client herstellen

Codex

Codex verwendet dasselbe MCP-Server-Definitionsformat. Registrieren Sie den Server als remembrall und verweisen Sie entweder auf das installierte Binary oder Ihren lokalen Release-Build.

Wenn remembrall im PATH installiert ist:

{
 "mcpServers": {
 "remembrall": {
 "command": "remembrall"
 }
 }
}

Wenn Sie aus einem lokalen Quellcode-Checkout ausführen:

{
 "mcpServers": {
 "remembrall": {
 "command": "/path/to/remembrallmcp/target/release/remembrall",
 "env": {
 "DATABASE_URL": "postgres://postgres:postgres@localhost:5450/remembrall"
 }
 }
 }
}

Wenn Sie Docker Compose von Codex aus verwenden:

{
 "mcpServers": {
 "remembrall": {
 "command": "docker",
 "args": ["compose", "-f", "/path/to/remembrallmcp/docker-compose.yml", "run", "--rm", "-T", "remembrall"]
 }
 }
}

Starten Sie Codex nach dem Hinzufügen des Servers neu, damit er die Verbindung wiederherstellt und die Tools lädt.

Claude Code, Cursor und andere MCP-Clients

Fügen Sie dies zur .mcp.json Ihres Projekts hinzu (funktioniert mit Claude Code, Cursor und jedem MCP-kompatiblen Client).

Wenn Sie ein vorkompiliertes Binary verwenden oder aus dem Quellcode gebaut haben:

{
 "mcpServers": {
 "remembrall": {
 "command": "remembrall"
 }
 }
}

Wenn Sie Docker Compose verwenden:

{
 "mcpServers": {
 "remembrall": {
 "command": "docker",
 "args": ["compose", "-f", "/path/to/remembrallmcp/docker-compose.yml", "run", "--rm", "-T", "remembrall"]
 }
 }
}

Wenn Sie aus dem Quellcode ausführen (nicht im PATH installiert):

{
 "mcpServers": {
 "remembrall": {
 "command": "/path/to/remembrallmcp/target/release/remembrall",
 "env": {
 "DATABASE_URL": "postgres://postgres:postgres@localhost:5450/remembrall"
 }
 }
 }
}

Starten Sie Ihren MCP-Client neu. Alle 9 Tools sind automatisch verfügbar.

Ausprobieren

> "Store a memory: We chose Postgres over MongoDB because our query patterns
 are relational. Type: decision, tags: database, architecture"

> "Recall what we know about database decisions"

> "Index this project and show me the impact of changing UserService"

MCP-Tools

Speicher

Code-Intelligenz

Unterstützte Sprachen

Scores gemessen an echten Open-Source-Projekten (Click, Gson, Axios, bat, Cobra, Sidekiq, Hono, Exposed) unter Verwendung automatisierter Ground-Truth-Tests.

Kaltstart

Eine neue RemembrallMCP-Instanz hat kein Wissen. Verwenden Sie die Ingestion-Tools, um aus der bestehenden Projekthistorie zu booten.

Aus der GitHub PR-Historie:

> remembrall_ingest_github repo="myorg/myrepo" limit=100

Ruft zusammengeführte PRs über gh ab, verarbeitet Titel und Texte zu Speichern und taggt sie nach Projekt. PRs mit weniger als 50 Zeichen Text werden übersprungen. Deduplizierung durch Inhalts-Fingerabdruck verhindert erneute Ingestion bei wiederholten Ausführungen.

Aus Markdown-Dokumenten:

> remembrall_ingest_docs path="/path/to/project"

Durchläuft den Verzeichnisbaum, findet alle .md-Dateien, teilt sie anhand von H2-Überschriften auf und speichert jeden Abschnitt als durchsuchbaren Speicher. Überspringt node_modules, .git, target und ähnliche Verzeichnisse. Gut für README, ARCHITECTURE, ADRs und alle schriftlichen Dokumente.

Führen Sie beides einmal pro Projekt aus. Nach der Ingestion hat remembrall_recall sofortigen Kontext.

Architektur

Source Code Organizational Knowledge
 | |
 v v
Tree-sitter Parsers Ingestion Pipeline
(8 languages) (GitHub PRs, Markdown docs)
 | |
 v v
+--------------------------------------------------+
| Postgres + pgvector |
| |
| memories (text + embeddings + metadata) |
| symbols (functions, classes, methods) |
| relationships (calls, imports, inherits) |
+--------------------------------------------------+
 |
 MCP Server (stdio)
 |
 Any MCP-compatible AI agent

• Parsing: tree-sitter (Rust-Bindings, keine Python-Pipeline)

• Embeddings: fastembed (all-MiniLM-L6-v2, 384-dim, In-Process ONNX Runtime)

• Suche: Hybrides RRF (semantische Kosinus-Ähnlichkeit + Volltext-tsvector)

• Graph-Abfragen: Rekursive CTEs mit Zykluserkennung und Vertrauensabfall

• Transport: stdio via rmcp

CLI-Befehle

Konfiguration

Konfigurationsdatei: ~/.remembrall/config.toml (erstellt durch remembrall init)

Umgebungsvariablen überschreiben Werte der Konfigurationsdatei:

Projektstruktur

crates/
 remembrall-core/ # Library - parsers, memory store, graph store, embedder
 remembrall-server/ # MCP server + CLI binary
 remembrall-test-harness/ # Parser quality testing against ground truth
 remembrall-recall-test/ # Search quality testing
docs/ # Architecture and test plan docs
test-fixtures/ # Ground truth TOML files for 8 languages
tests/ # Recall test fixtures

Leistung

Lizenz

MIT

Maintenance

Resources

• NPM Package
• GitHub Repository
Need Help?Related Servers