Agent Memory

Einfach erklärt

Agent Memory ermöglicht KI-Agenten, sich an Dinge zu erinnern – innerhalb eines Gesprächs, über Gespräche hinweg, und über lange Zeiträume.

Die drei Memory-Typen:

┌─────────────────────────────────────────────────────┐
│                   Agent Memory                       │
├─────────────────┬─────────────────┬─────────────────┤
│  Short-term     │  Working        │  Long-term      │
│  Memory         │  Memory         │  Memory         │
├─────────────────┼─────────────────┼─────────────────┤
│ Aktuelle        │ Aktive Aufgabe  │ Persistente     │
│ Konversation    │ und Zwischener- │ Informationen   │
│                 │ gebnisse        │                 │
├─────────────────┼─────────────────┼─────────────────┤
│ Minuten         │ Minuten-Stunden │ Tage-Jahre      │
├─────────────────┼─────────────────┼─────────────────┤
│ Context Window  │ Scratchpad      │ Vektordatenbank │
└─────────────────┴─────────────────┴─────────────────┘

Beispiel – Persönlicher Assistent:

Session 1 (Montag):
User: "Ich bin Vegetarier und mag italienisch."
Agent: [Speichert in Long-term Memory]

Session 2 (Freitag):
User: "Empfiehl mir ein Restaurant für heute Abend."
Agent: [Ruft ab: Vegetarier, italienisch]
       "Wie wäre es mit dem 'Verde' – vegetarisch-italienisch, 
        hat heute Abend noch Plätze."

Ohne Memory müsste der User jedes Mal seine Präferenzen wiederholen.

Technischer Deep Dive

Memory-Architekturen

1. Buffer Memory (einfachste Form):

class BufferMemory:
    def __init__(self, max_messages=10):
        self.messages = []
        self.max = max_messages
    
    def add(self, message):
        self.messages.append(message)
        if len(self.messages) > self.max:
            self.messages.pop(0)  # FIFO
    
    def get_context(self):
        return "\n".join(self.messages)

2. Summary Memory:

class SummaryMemory:
    def __init__(self, llm):
        self.summary = ""
        self.llm = llm
    
    def add(self, conversation):
        # LLM fasst zusammen
        self.summary = self.llm.summarize(
            f"Bisherige Zusammenfassung: {self.summary}\n"
            f"Neue Konversation: {conversation}"
        )

3. Vector Memory (Long-term):

class VectorMemory:
    def __init__(self, vector_db):
        self.db = vector_db
    
    def store(self, text, metadata):
        embedding = embed(text)
        self.db.upsert(embedding, text, metadata)
    
    def recall(self, query, k=5):
        query_embedding = embed(query)
        return self.db.search(query_embedding, top_k=k)

Memory-Strategien

Was speichern?

Information	Speichern?	Warum
User-Präferenzen	✓ Long-term	Personalisierung
Fakten über User	✓ Long-term	Kontext
Aufgaben-Ergebnisse	✓ Working	Aktuelle Arbeit
Small Talk	✗	Irrelevant
Sensible Daten	⚠️ Vorsicht	DSGVO

Wann abrufen?

def should_recall(query):
    # Semantische Relevanz prüfen
    if is_personal_question(query):
        return recall_user_preferences()
    if references_past(query):
        return recall_conversation_history()
    if is_task_continuation(query):
        return recall_working_memory()
    return None

Memory mit RAG kombinieren

User Query
    │
    ├──→ Long-term Memory (User-spezifisch)
    │         │
    ├──→ Knowledge Base (RAG, allgemein)
    │         │
    └──→ Working Memory (aktuelle Aufgabe)
              │
              ▼
        Kombinierter Kontext
              │
              ▼
           LLM Response

Vergessens-Mechanismen

Zeitbasiert:

def decay_memory(memories, decay_rate=0.1):
    for memory in memories:
        memory.relevance *= (1 - decay_rate)
        if memory.relevance < threshold:
            delete(memory)

Relevanzbasiert:

def prune_memory(memories, max_size):
    if len(memories) > max_size:
        # Niedrigste Relevanz löschen
        memories.sort(key=lambda m: m.relevance)
        memories = memories[-max_size:]

Zusammenfassung:

def consolidate_memory(old_memories):
    # Ähnliche Erinnerungen zusammenfassen
    summary = llm.summarize(old_memories)
    delete(old_memories)
    store(summary)

Herausforderungen

Problem	Lösung
Memory Bloat	Vergessens-Mechanismen
Falsche Erinnerungen	Confidence Scores, Verification
Langsamer Abruf	Indexierung, Caching
Datenschutz	Encryption, Retention Policies
Inkonsistenz	Konflikt-Resolution