Memory Bank MCP MCP — Anwendungsfälle, Installieren & Live-Demo

Warum nutzen

Hauptfunktionen

Fünf Tools: Memory_bank_read, Memory_bank_write, Memory_bank_update, List_Projects, List_Project_Files
Isolation mehrerer Projekte – jedes Projekt hat seinen eigenen Ordner unter MEMORY_BANK_ROOT
Integrierte Path-Traversal-Verhinderung – beschränkt auf das von Ihnen konfigurierte Stammverzeichnis
Typsichere Operationen mit expliziten Fehlermeldungen
Funktioniert mit jedem MCP-Client; keine Cline-Abhängigkeit

Live-Demo

In der Praxis

memory-bank-mcp.replay ▶ bereit

0/0

Installieren

Wählen Sie Ihren Client

~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "memory-bank-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@allpepper/memory-bank-mcp"
      ],
      "env": {
        "MEMORY_BANK_ROOT": "/path/to/memory/banks"
      }
    }
  }
}

Öffne Claude Desktop → Settings → Developer → Edit Config. Nach dem Speichern neu starten.

~/.cursor/mcp.json · .cursor/mcp.json

{
  "mcpServers": {
    "memory-bank-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@allpepper/memory-bank-mcp"
      ],
      "env": {
        "MEMORY_BANK_ROOT": "/path/to/memory/banks"
      }
    }
  }
}

Cursor nutzt das gleiche mcpServers-Schema wie Claude Desktop. Projektkonfiguration schlägt die globale.

VS Code → Cline → MCP Servers → Edit

{
  "mcpServers": {
    "memory-bank-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@allpepper/memory-bank-mcp"
      ],
      "env": {
        "MEMORY_BANK_ROOT": "/path/to/memory/banks"
      }
    }
  }
}

Klicken Sie auf das MCP-Servers-Symbol in der Cline-Seitenleiste, dann "Edit Configuration".

~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "memory-bank-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@allpepper/memory-bank-mcp"
      ],
      "env": {
        "MEMORY_BANK_ROOT": "/path/to/memory/banks"
      }
    }
  }
}

Gleiche Struktur wie Claude Desktop. Windsurf neu starten zum Übernehmen.

~/.continue/config.json

{
  "mcpServers": [
    {
      "name": "memory-bank-mcp",
      "command": "npx",
      "args": [
        "-y",
        "@allpepper/memory-bank-mcp"
      ]
    }
  ]
}

Continue nutzt ein Array von Serverobjekten statt einer Map.

~/.config/zed/settings.json

{
  "context_servers": {
    "memory-bank-mcp": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "@allpepper/memory-bank-mcp"
        ]
      }
    }
  }
}

In context_servers hinzufügen. Zed lädt beim Speichern neu.

claude mcp add memory-bank-mcp -- npx -y @allpepper/memory-bank-mcp

Einzeiler. Prüfen mit claude mcp list. Entfernen mit claude mcp remove.

Anwendungsfälle

Praxisnahe Nutzung: Memory Bank MCP

Geben Sie einem neuen Agenten sofort Kontext zu einem lang laufenden Projekt

👤 Teams, die mehrere Agenten auf derselben Codebasis ausführen ⏱ ~10 min beginner

Wann einsetzen: Ein neuer Chat benötigt denselben Hintergrund (Konventionen, frühere Entscheidungen, bekannte Fehler), den Ihr letzter Chat bereits gelernt hat.

Voraussetzungen

Vorhandene Speicherbank für dieses Projekt — Füllen Sie es während der normalen Arbeit mit „memory_bank_write“.

Ablauf

Listen Sie die Dateien auf, über die die Projektbank bereits verfügt

Rufen Sie list_project_files für project=acme-api auf.✓ Kopiert

→ Architektur.md, Entscheidungen.md, open-questions.md usw.
Laden Sie die relevante Teilmenge

Lesen Sie „entscheidungen.md“ und „open-questions.md“, bevor Sie mit der Aufgabe beginnen.✓ Kopiert

→ Der Agent verweist auf frühere Entscheidungen, anstatt noch einmal nachzufragen

Ergebnis: Neue Sitzungen beginnen warm statt kalt; Sie zahlen jedes Mal keine Onboarding-Steuer mehr.

Fallstricke

Die Bank zu einer riesigen Datei zusammenwachsen lassen — Aufteilung nach Anliegen – Entscheidungen, Architektur, offene Fragen, Runbook –, sodass der Agent nur das lädt, was er benötigt

Kombinieren mit: codebase-memory

Versionieren Sie Ihren Agentenspeicher in Git wie jedes andere Projektdokument

👤 Teams, die möchten, dass der Speicher über Maschinen und Mitwirkende hinweg erhalten bleibt ⏱ ~20 min intermediate

Wann einsetzen: Sie möchten, dass Speicherdateien überprüft, differenziert und mit Teamkollegen geteilt werden.

Voraussetzungen

Git-Repo zum Hosten der Bank — git init innerhalb von MEMORY_BANK_ROOT oder einem Projektunterordner

Ablauf

Machen Sie den Root zu einem Repo

Verwandeln Sie ~/ai-memory in ein Git-Repo; Fügen Sie eine .gitignore-Datei für alles Sensible hinzu.✓ Kopiert

→ Standard-Git-Repo-Struktur
Lassen Sie den Agenten den Speicher während der Sitzungen aktualisieren

Rufen Sie nach der Behebung des Fehlers „memory_bank_update“ auf, um die Grundursache in „bugs.md“ aufzuzeichnen.✓ Kopiert

→ Neues Commit-fähiges Diff
Commit und Push

Überprüfen Sie den Speicherunterschied, schreiben Sie ihn fest und drücken Sie ihn.✓ Kopiert

→ Teamkollegen ziehen und ihre Agenten teilen sofort den Kontext

Ergebnis: Der Agentenspeicher wird zu einem erstklassigen Projektartefakt.

Fallstricke

Der Agent hat Geheimnisse notiert — Fügen Sie einen Pre-Commit-Scanner (z. B. Gitleaks) hinzu, bevor Sie das Speicher-Repo übertragen

Kombinieren mit: github · git

Kombinationen

Mit anderen MCPs für 10-fache Wirkung

memory-bank-mcp + filesystem

In der Speicherbank werden Agentennotizen gespeichert. Das Dateisystem liest den Code, auf den sie verweisen

Lesen Sie „entscheidungen.md“ aus der Speicherbank und öffnen Sie dann die Dateien, auf die es verweist, in „src/“.✓ Kopiert

memory-bank-mcp + github

Nachdem eine PR zusammengeführt wurde, notieren Sie das Ergebnis im Speicher des Projekts

Fassen Sie die zusammengeführte PR #412 zusammen und aktualisieren Sie „memory-bank/acme-api/decisions.md“.✓ Kopiert

memory-bank-mcp + codebase-memory

Zwei komplementäre Speicherschichten – Code-Graph-Speicher + für Menschen lesbare Notizen

Kombinieren Sie das Codebase-Memory-Symboldiagramm mit der Erzählung in „memory-bank/architecture.md“.✓ Kopiert

Werkzeuge

Was dieses MCP bereitstellt

Werkzeug	Eingaben	Wann aufrufen
memory_bank_read	project: str, file: str	Ziehen Sie vor der Planung den vorhandenen Speicher ab
memory_bank_write	project: str, file: str, content: str	Erstellen Sie eine brandneue Speicherdatei
memory_bank_update	project: str, file: str, content: str	Eine vorhandene Speicherdatei ändern (schlägt bei Fehlen fehl)
list_projects	(none)	Entdecken Sie, welche Projekte bereits über Speicherbänke verfügen
list_project_files	project: str	Sehen Sie vor dem Lesen, welche Speicherdateien verfügbar sind

Kosten & Limits

Was der Betrieb kostet

API-Kontingent: Keine externe API
Tokens pro Aufruf: Hängt von der Dateigröße ab; typische Note 200–2000 Token
Kosten in €: Kostenlos – läuft lokal
Tipp: Halten Sie die Speicherdateien kurz und themenbezogen; Durch das Laden einer 50-KB-Datei wird bei jedem Aufruf Kontext verschwendet.

Sicherheit

Rechte, Secrets, Reichweite

Credential-Speicherung: Keine Anmeldeinformationen. Der MEMORY_BANK_ROOT-Pfad ist die einzige Konfiguration.

Datenabfluss: Keine Netzwerkaufrufe – Lese- und Schreibvorgänge bleiben im lokalen Dateisystem unter MEMORY_BANK_ROOT.

Legen Sie MEMORY_BANK_ROOT nicht auf Ihr Home- oder Projektstammverzeichnis fest, sondern beschränken Sie es auf einen dedizierten Ordner, damit Agenten keine nicht zugehörigen Dateien lesen können.
Überprüfen Sie, was Agenten in den Speicher schreiben, bevor Sie es an Git übergeben. Chat-Transkripte können Geheimnisse enthalten, die der Agent zuvor gesehen hat.

Fehlerbehebung

Häufige Fehler und Lösungen

Fehler: MEMORY_BANK_ROOT ist nicht festgelegt

Legen Sie die Umgebungsvariable in Ihrer MCP-Client-Konfiguration fest und starten Sie den Client neu.

Prüfen: echo $MEMORY_BANK_ROOT

ENOENT beim Lesen einer Datei

Rufen Sie zuerst list_project_files auf – der Dateiname muss genau existieren.

Prüfen: ls $MEMORY_BANK_ROOT/<project>/

EACCES beim Schreiben

Stellen Sie sicher, dass der MCP-Prozess über Schreibberechtigung für MEMORY_BANK_ROOT verfügt.

Prüfen: touch $MEMORY_BANK_ROOT/.probe && rm $MEMORY_BANK_ROOT/.probe

Alternativen

Memory Bank MCP vs. andere

Alternative	Wann stattdessen	Kompromiss
memory (official)	Sie möchten ein Wissensdiagramm und keine dateibasierten Notizen	Das Diagramm ist strukturiert, aber weniger bearbeitbar
memory-service	Sie möchten eine semantische Suche über dem Speicher	Schwereres Setup; Einbettungen erforderlich
Cline Memory Bank (inline)	Sie verwenden nur Cline und benötigen keine IDE-übergreifende Freigabe	An Cline gebunden

Mehr

Ressourcen

📖 Offizielle README auf GitHub lesen

🐙 Offene Issues ansehen

🔍 Alle 400+ MCP-Server und Skills durchsuchen