Blog

Persistent Memory für KI Agenten: Wie Ihr Agent sich an gestern erinnert

Ashley Innocent

Ashley Innocent

19 March 2026

Persistent Memory für KI Agenten: Wie Ihr Agent sich an gestern erinnert

enterprise.banner.title

enterprise.banner.feature1

enterprise.banner.feature2

enterprise.banner.feature3

enterprise.banner.ctaB

Kurz gesagt

Füge KI-Agenten in 4 Schritten persistenten Speicher hinzu: (1) Richte einen MCP-Speicherserver mit den Tools remember, recall, search und rollback ein, (2) Füge Speicheranweisungen zu Agenten-Prompts hinzu, (3) Konfiguriere ~/.claude/settings.json für Claude Code oder .cursor/mcp.json für Cursor, (4) Verwende Speichermuster für Entscheidungsprotokollierung, Agentenübergaben und Sitzungs-Checkpoints. Agenten behalten den Kontext über mehrere Sitzungen hinweg – kein lästiges Kopieren und Einfügen früherer Konversationen mehr.

Löse das Problem „Ich erinnere mich nicht an gestern“. Füge KI-Agenten persistenten Speicher hinzu, der das MCP-Protokoll verwendet, und sie werden Entscheidungen, Ergebnisse und Kontext aus früheren Sitzungen abrufen können.

Du kennst das Spielchen:

Day 1: "Build the user authentication system"
Agent: [Builds JWT auth, creates users table, implements refresh tokens]

Day 2: "Continue from yesterday"
Agent: "I don't have context from previous sessions. Can you paste what we did?"

Du kopierst und fügst die vorherige Konversation ein. Der Agent liest 2000 Zeilen Kontext. Ihr beide verliert 15 Minuten, um wieder auf dem neuesten Stand zu sein.

Persistenter Speicher behebt dies. Mit MCP (Model Context Protocol)-Speicher speichern Agenten Entscheidungen automatisch und rufen sie bei Bedarf ab. Kein Kopieren und Einfügen. Keine erneuten Erklärungen.

In diesem Tutorial richtest du MCP-Speicher für KI-Agenten ein. Du lernst, wie du Entscheidungen aus Backend-Architekt-Sitzungen speicherst, Kontext abrufst, wenn du zu einem Datenbank-Optimierer wechselst, und Ergebnisse an einen Frontend-Entwickler übergibst – alles ohne Kontextverlust. Dieselben Speichermuster funktionieren, egal ob du APIs mit Apidog-Integration erstellst oder mehrtägige Entwicklungs-Sprints verwaltest.

Schaltfläche

Was ist MCP-Speicher?

MCP-Speicher ermöglicht es KI-Agenten, Informationen sitzungsübergreifend zu speichern und abzurufen. Stell dir das wie ein gemeinsames Notizbuch vor, in das Agenten schreiben und aus dem sie lesen können.

Vier Tools treiben den MCP-Speicher an:

Tool Zweck Beispiel
remember Informationen mit Tags speichern Speichere „users table with UUID, bcrypt“
recall Nach Schlüsselwort oder Tag suchen Finde „auth decisions“
rollback Auf vorherigen Zustand wiederherstellen Mache schlechte Schemaänderungen rückgängig
search Sitzungsübergreifend suchen „Was hat der Backend-Architekt entschieden?“ 
┌─────────────────┐         ┌──────────────────┐         ┌─────────────┐
│  AI Agent       │         │  MCP Memory      │         │  Storage    │
│  (Claude Code)  │◄───────►│  Server          │◄───────►│  (SQLite)   │
└─────────────────┘   JSON  └──────────────────┘  I/O    └─────────────┘

Schritt 1: Einrichten eines MCP-Speicherservers

Du benötigst einen MCP-Server, der Speicher-Tools bereitstellt. Es gibt mehrere Open-Source-Implementierungen.

Option A: Einen gehosteten Speicherserver verwenden

npm install -g @example/mcp-memory-server

Option B: Einen einfachen lokalen Server ausführen

Erstelle memory-server.js:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs/promises";
import path from "path";

const MEMORY_FILE = path.join(process.env.HOME, ".mcp-memory", "memories.json");

const server = new McpServer({
  name: "memory",
  version: "1.0.0"
});

// Ensure memory file exists
async function initMemory() {
  await fs.mkdir(path.dirname(MEMORY_FILE), { recursive: true });
  try {
    await fs.access(MEMORY_FILE);
  } catch {
    await fs.writeFile(MEMORY_FILE, JSON.stringify([]));
  }
}

// Tool: remember
server.tool(
  "remember",
  {
    content: z.string().describe("Information to store"),
    tags: z.array(z.string()).describe("Tags for retrieval (e.g., ['backend', 'auth'])"),
    agent: z.string().optional().describe("Agent name for tagging")
  },
  async ({ content, tags, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const memory = {
      id: Date.now().toString(),
      content,
      tags,
      agent,
      timestamp: new Date().toISOString()
    };
    memories.push(memory);
    await fs.writeFile(MEMORY_FILE, JSON.stringify(memories, null, 2));
    return { content: [{ type: "text", text: `Stored memory with tags: ${tags.join(", ")}` }] };
  }
);

// Tool: recall
server.tool(
  "recall",
  {
    query: z.string().describe("Search query or tag to find"),
    agent: z.string().optional().describe("Filter by agent name")
  },
  async ({ query, agent }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories.filter(m => {
      const matchesQuery = m.content.toLowerCase().includes(query.toLowerCase()) ||
                          m.tags.some(t => t.toLowerCase().includes(query.toLowerCase()));
      const matchesAgent = !agent || m.agent === agent;
      return matchesQuery && matchesAgent;
    });
    return {
      content: [{
        type: "text",
        text: results.length === 0
          ? "No memories found"
          : results.map(m => `[${m.timestamp}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: search
server.tool(
  "search",
  {
    tags: z.array(z.string()).describe("Tags to search for"),
    limit: z.number().optional().default(10)
  },
  async ({ tags, limit }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const results = memories
      .filter(m => tags.some(t => m.tags.includes(t)))
      .slice(0, limit);
    return {
      content: [{
        type: "text",
        text: results.map(m => `[${m.agent || "unknown"}] ${m.content}`).join("\n\n")
      }]
    };
  }
);

// Tool: rollback
server.tool(
  "rollback",
  {
    agent: z.string().describe("Agent name to rollback"),
    timestamp: z.string().describe("Rollback to this timestamp")
  },
  async ({ agent, timestamp }) => {
    await initMemory();
    const memories = JSON.parse(await fs.readFile(MEMORY_FILE, "utf-8"));
    const rolledBack = memories.filter(m =>
      m.agent !== agent || new Date(m.timestamp) <= new Date(timestamp)
    );
    await fs.writeFile(MEMORY_FILE, JSON.stringify(rolledBack, null, 2));
    return {
      content: [{
        type: "text",
        text: `Rolled back ${agent} to ${timestamp}`
      }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Server starten:

node memory-server.js

Schritt 2: Speicheranweisungen zu jedem Agenten hinzufügen

Du musst keine Agentendateien ändern. Füge Speicheranweisungen in deinem Prompt hinzu:

Du hast Zugriff auf MCP-Speicher-Tools: remember, recall, search, rollback.

Befolge diese Speicherprotokolle:

**Wenn du eine Sitzung startest:**
1. Kontext abrufen: recall(query="ecommerce-api", agent="Backend Architect")
2. Überprüfe ausstehende Aufgaben aus der letzten Sitzung

**Wenn du die Arbeit abgeschlossen hast:**
1. Ergebnisse mit Tags speichern:
   - remember(content="Created users table with UUID primary key, bcrypt password hashing, JWT auth with refresh tokens", tags=["ecommerce-api", "database", "auth"], agent="Backend Architect")
2. Füge getroffene Entscheidungen und ausstehende Aufgaben hinzu

**Bei der Übergabe an einen anderen Agenten:**
1. Hinterlasse Kontext für den empfangenden Agenten:
   - remember(content="API endpoints: /auth/login, /auth/register, /products, /orders. Auth flow: JWT access token (15min) + refresh token (7 days). Known issue: rate limiting not yet implemented", tags=["ecommerce-api", "handoff"], agent="Backend Architect", for="Frontend Developer")

**Wenn etwas fehlschlägt:**
1. Suche nach dem letzten bekannten guten Zustand
2. Verwende rollback zum Wiederherstellen

Beispiel in Aktion:

Du: „Aktiviere den Backend-Architekten-Modus. Entwerfe das Benutzersystem für unsere E-Commerce-API.“

[Agent baut JWT-Authentifizierung, erstellt Benutzertabelle, implementiert Refresh-Tokens]

Agent: „Benutzersystem abgeschlossen. Speichere Informationen...“
→ Ruft auf: remember("users table with UUID, bcrypt, JWT + refresh tokens", tags: ["ecommerce-api", "auth", "database"])

[Sitzung endet]

[Nächster Tag]

Du: „Fahre von gestern fort“

Agent: „Rufe Kontext ab...“
→ Ruft auf: recall(query="ecommerce-api")
→ Gibt zurück: "users table with UUID, bcrypt, JWT + refresh tokens"

Agent: „Gestern habe ich die Benutzertabelle mit UUID-Primärschlüsseln entworfen, bcrypt-Passwort-Hashing implementiert und die JWT-Authentifizierung mit Refresh-Tokens eingerichtet. Nächster Schritt: Produktkatalogschema. Bereit zum Fortfahren.“

Schritt 3: Für Claude Code konfigurieren

Füge den Speicherserver deiner MCP-Konfiguration hinzu:

Bearbeite ~/.claude/settings.json:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"],
      "env": {
        "HOME": "/Users/your-username"
      }
    }
  }
}

Starte Claude Code neu. Die Speicher-Tools sollten nun verfügbar sein.

Teste es:

Verwende das remember-Tool, um zu speichern: "Test-Speicher für E-Commerce-Projekt"
Tags: ["test", "ecommerce-api"]

Verwende das recall-Tool, um Erinnerungen über "test" zu finden

Schritt 4: Für Cursor konfigurieren

Erstelle .cursor/mcp.json in deinem Projekt:

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["/absolute/path/to/memory-server.js"]
    }
  }
}

Teste es:

@memory remember "Starte E-Commerce-API-Projekt mit PostgreSQL"
Tags: ["ecommerce-api", "setup"]

@memory recall query="ecommerce"

Speichermuster für reale Workflows

Muster 1: Entscheidungsprotokollierung

Jedes Mal, wenn du eine technische Entscheidung triffst, protokolliere sie:

remember({
  content: "PostgreSQL gegenüber MySQL gewählt für: (1) JSONB-Unterstützung für flexible Produktattribute, (2) bessere Volltextsuche, (3) native UUID-Unterstützung",
  tags: ["ecommerce-api", "database", "decision"],
  agent: "Backend Architect"
})

Später, wenn jemand fragt „Warum PostgreSQL?“:

recall(query="PostgreSQL MySQL decision")

Muster 2: Agentenübergaben

Beim Wechsel des Agenten hinterlasse eine Übergabenotiz:

remember({
  content: "Backend abgeschlossen. Endpunkte: POST /auth/login, POST /auth/register, GET /products, POST /orders. Auth: JWT 15min Zugriff + 7 Tage Refresh. Ausstehend: Ratenbegrenzung, E-Mail-Verifizierung. Frontend benötigt: Anmeldeformular, Produktliste, Warenkorb, Kasse.",
  tags: ["ecommerce-api", "handoff", "backend-complete"],
  agent: "Backend Architect",
  for: "Frontend Developer"
})

Der Frontend-Entwickler beginnt mit:

recall(query="handoff", agent="Backend Architect")

Muster 3: Sitzungs-Checkpoints

Am Ende jeder Arbeitssitzung:

remember({
  content: "Sitzung abgeschlossen. Erledigt: Benutzertabelle, Authentifizierungs-Endpunkte, Produktschema. Nächste Sitzung: Bestellsystem, Zahlungs-Webhook. Blocker: Warte auf Stripe API-Schlüssel.",
  tags: ["ecommerce-api", "checkpoint", "session-1"],
  agent: "Backend Architect"
})

Nächste Sitzung fortsetzen:

recall(query="checkpoint session-1")

Muster 4: Fehlerverfolgung

Wenn du einen Fehler findest:

remember({
  content: "BUG: Refresh-Token läuft nach Abmeldung nicht ab. Token im Speicher, nicht persistent. Behebung: Umzug nach Redis mit TTL.",
  tags: ["ecommerce-api", "bug", "auth"],
  agent: "Code Reviewer",
  severity: "high"
})

Später nach Fehlern suchen:

search(tags=["bug", "ecommerce-api"])

Fehlerbehebung

Speicher nicht persistent:

Zu viele Ergebnisse beim Abruf:

Speicherdatei wird zu groß:

Was du erstellt hast

Komponente Zweck
MCP-Speicherserver Speichert/ruft Informationen sitzungsübergreifend ab
remember-Tool Protokolliert Entscheidungen, Ergebnisse, Übergaben
recall-Tool Findet Kontext aus früheren Sitzungen
search-Tool Abfrage nach Tags über alle Erinnerungen hinweg
rollback-Tool Stellt bei Bedarf den vorherigen Zustand wieder her
Speichermuster Entscheidungsprotokollierung, Übergaben, Checkpoints, Fehlerverfolgung

Nächste Schritte

Erweitere den Speicherserver:

Baue Teamspeicher auf:

Integration mit Tools:

Fehlerbehebung häufiger Probleme

Speicher nicht persistent zwischen Sitzungen:

Abruf liefert leere Ergebnisse:

Speicherdatei wird zu groß:

Server startet nicht:

Mehrere Agenten überschreiben sich gegenseitig die Erinnerungen:

Sicherheitsaspekte des Speicherservers

Speicherung von API-Schlüsseln:Wenn dein Speicherserver sensible Daten (API-Schlüssel, Passwörter) speichert, implementiere Verschlüsselung:

import crypto from 'crypto';

const ENCRYPTION_KEY = process.env.MEMORY_ENCRYPTION_KEY;
const ALGORITHM = 'aes-256-gcm';

function encrypt(text) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(ALGORITHM, Buffer.from(ENCRYPTION_KEY), iv);
  const encrypted = cipher.update(text, 'utf8', 'hex');
  return {
    encryptedData: encrypted + cipher.final('hex'),
    iv: iv.toString('hex'),
    authTag: cipher.getAuthTag().toString('hex')
  };
}

function decrypt(encrypted) {
  const decipher = crypto.createDecipheriv(
    ALGORITHM,
    Buffer.from(ENCRYPTION_KEY),
    Buffer.from(encrypted.iv, 'hex')
  );
  decipher.setAuthTag(Buffer.from(encrypted.authTag, 'hex'));
  return decipher.update(encrypted.encryptedData, 'hex', 'utf8') + decipher.final('utf8');
}

Zugriffssteuerung:Für Team-Speicherserver füge Authentifizierung hinzu:

Deine KI-Agenten haben jetzt einen persistenten Speicher. Sie erinnern sich an gestern. Sie rufen Entscheidungen ab. Sie übergeben Kontext ohne Kopieren und Einfügen.

Nie wieder „Ich habe keinen Kontext aus früheren Sitzungen.“ Nie wieder erneute Erklärungen. Nie wieder verschwendete Zeit.

Das ist die Stärke des MCP-Speichers: Gib deinen Agenten ein gemeinsames Notizbuch und beobachte, wie sie über mehrtägige Projekte hinweg tatsächlich nützlich werden.

Schaltfläche

FAQ

Was ist MCP-Speicher?MCP-Speicher ist eine Protokollimplementierung, die es KI-Agenten ermöglicht, Informationen sitzungsübergreifend zu speichern und abzurufen. Stell dir das wie ein gemeinsames Notizbuch vor, in das Agenten schreiben und aus dem sie lesen können, wodurch der Kontext über einzelne Konversationen hinaus erhalten bleibt.

Wie richte ich persistenten Speicher für Claude Code ein?Installiere einen MCP-Speicherserver und füge ihn dann zu ~/.claude/settings.json mit dem Serverbefehl und -pfad hinzu. Starte Claude Code neu und die Speicher-Tools (remember, recall, search, rollback) werden verfügbar.

Welche KI-Agenten unterstützen MCP-Speicher?Jeder Agent, der auf MCP-kompatiblen Clients (Claude Code, Cursor, Windsurf) läuft, kann Speicher-Tools verwenden. Du musst keine Agentendateien ändern – füge einfach Speicheranweisungen zu deinen Prompts hinzu.

Was sind die besten Speichermuster für Agentenübergaben?Verwende remember mit Tags wie ["handoff", "project-name"], um Kontext für den nächsten Agenten zu hinterlassen. Füge abgeschlossene Arbeiten, ausstehende Aufgaben und bekannte Probleme hinzu. Der empfangende Agent ruft recall(query="handoff") auf, um diese abzurufen.

Wie viel Speicher können MCP-Server speichern?Hängt von der Implementierung ab. Der Referenzserver verwendet eine JSON-Datei, die unbegrenzt wächst. Produktionsserver sollten Ablaufrichtlinien, automatische Archivierung oder Datenbank-Backends für den groß angelegten Einsatz hinzufügen.

Können Teams einen zentralen Speicherserver teilen?Ja. Betreibe den Speicherserver auf einer gemeinsam genutzten Maschine oder Cloud-Instanz, konfiguriere die Clients aller Teammitglieder so, dass sie sich damit verbinden, und tagge Erinnerungen nach Projekt und Entwickler für einen organisierten Abruf.

Was, wenn der Speicherabruf zu viele Ergebnisse liefert?Füge spezifischere Tags hinzu, wenn du Erinnerungen speicherst. Filtere in deinen Abruf-Anfragen nach Agentennamen. Verwende exakte Phrasen in Anführungszeichen. Erwäge die Implementierung einer semantischen Suche mit Embeddings für einen intelligenteren Abruf.

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenHerunterladen