┌─────────────────────────────────────────────────────────────────┐
│                    AGENTEN-SPEICHERHIERARCHIE                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────┐                   │
│   │  ARBEITSGEDÄCHTNIS (Kontextfenster)     │                   │
│   │  - Unmittelbarer Aufgabenkontext        │                   │
│   │  - 8K-200K Token                        │                   │
│   │  - Dauer: Einzelner Turn                │                   │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  KURZZEITSPEICHER (Puffer/Cache)        │                      │
│   │  - Kürzliche Gesprächsturns             │                      │
│   │  - Arbeitssatz an Fakten                │                      │
│   │  - Dauer: Minuten bis Stunden           │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  EPISODISCHES GEDÄCHTNIS (Ereignisspeicher)│                   │
│   │  - Vergangene Interaktionen & Ergebnisse │                      │
│   │  - "Was passierte, als..."              │                      │
│   │  - Dauer: Tage bis Monate                 │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  SEMANTISCHES GEDÄCHTNIS (Wissensbasis) │                      │
│   │  - Fakten, Konzepte, Entitäten          │                      │
│   │  - "Was ich über... weiß"               │                      │
│   │  - Dauer: Unbegrenzt                    │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  PROZEDURALES GEDÄCHTNIS (Fähigkeiten/Muster)│                  │
│   │  - Wie man Aufgaben ausführt            │                      │
│   │  - Gelernte Strategien                  │                      │
│   │  - Dauer: Permanent                     │                      │
│   └─────────────────────────────────────────┘                   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Text → Embedding-Modell → Vektor (1536 Dimensionen)

"Kunde beschwerte sich über langsame Lieferung"
→ [0,023, -0,156, 0,892, ..., -0,034]  ← Hochdimensionale Repräsentation

"Lieferung dauerte zu lange"
→ [0,031, -0,142, 0,867, ..., -0,041]  ← Ähnlicher Vektor (nah im Raum)

"Das Wetter ist heute schön"
→ [-0,754, 0,623, -0,123, ..., 0,901]  ← Anderer Vektor (weit im Raum)

# Kerne Vektor-Speicher-Muster
from sentence_transformers import SentenceTransformer
import chromadb
from datetime import datetime
import uuid

class VektorSpeicher:
    def __init__(self, collection_name="agenten_speicher"):
        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
        self.client = chromadb.Client()
        self.collection = self.client.create_collection(
            name=collection_name,
            metadata={"hnsw:space": "cosine"}
        )
    
    def add_memory(self, text, metadata=None):
        """Neuen Speicher speichern"""
        embedding = self.encoder.encode(text).tolist()
        
        memory_id = str(uuid.uuid4())
        timestamp = datetime.now().isoformat()
        
        self.collection.add(
            ids=[memory_id],
            embeddings=[embedding],
            documents=[text],
            metadatas=[{
                **(metadata or {}),
                "timestamp": timestamp,
                "id": memory_id
            }]
        )
        
        return memory_id
    
    def recall(self, query, top_k=5, filters=None):
        """Relevante Erinnerungen abrufen"""
        query_embedding = self.encoder.encode(query).tolist()
        
        results = self.collection.query(
            query_embeddings=[query_embedding],
            n_results=top_k,
            where=filters,
            include=["documents", "metadatas", "distances"]
        )
        
        return [
            {
                "text": doc,
                "metadata": meta,
                "relevance": 1 - dist  # Distanz zu Relevanz-Score umwandeln
            }
            for doc, meta, dist in zip(
                results["documents"][0],
                results["metadatas"][0],
                results["distances"][0]
            )
        ]

# Verwendung
memory = VektorSpeicher()

# Erinnerungen speichern
memory.add_memory(
    "Kunde bevorzugt E-Mail gegenüber Telefon bei dringenden Anliegen",
    metadata={"category": "preference", "source": "interaction_123"}
)

memory.add_memory(
    "Vorherige Lösung für Datenbank-Timeout: Verbindungspool erhöhen",
    metadata={"category": "solution", "issue_type": "performance"}
)

# Abrufen
results = memory.recall(
    "Wie soll ich diesen Kunden kontaktieren?",
    filters={"category": "preference"}
)
# Gibt zurück: Kunde bevorzugt E-Mail gegenüber Telefon bei dringenden Anliegen

┌─────────────────────────────────────────────────────────────────┐
│                        MEM0-ARCHITEKTUR                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                     API-Schicht                          │   │
│   │   add() | get() | update() | delete() | search()     │   │
│   └────────────────────────┬────────────────────────────────┘   │
│                            │                                     │
│   ┌────────────────────────▼────────────────────────────────┐   │
│   │              Speicher-Verarbeitungsschicht              │   │
│   │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐      │   │
│   │  │ Extraktion  │ │ Anreicherung│ │ Wichtigkeit │      │   │
│   │  │(LLM-basiert)│ │ (Metadaten) │ │ Bewertung   │      │   │
│   │  └─────────────┘ └─────────────┘ └─────────────┘      │   │
│   └────────────────────────┬────────────────────────────────┘   │
│                            │                                     │
│   ┌────────────────────────▼────────────────────────────────┐   │
│   │                    Speicherschicht                        │   │
│   │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐      │   │
│   │  │ Vektor-DB   │ │ Graph-DB    │ │ Schlüssel-  │      │   │
│   │  │ (Semantisch)│ │ (Beziehungen)│ │Wert (Meta)  │      │   │
│   │  └─────────────┘ └─────────────┘ └─────────────┘      │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

import mem0

# Initialisieren
m = mem0.Memory()

# Nutzer-spezifischer Speicher (über Sitzungen hinweg bestehend)
m.add(
    "Ich bevorzuge prägnante technische Antworten ohne Schnörkel",
    user_id="alice",
    metadata={"type": "preference"}
)

# Agent-spezifischer Speicher (gelerntes Verhalten dieses Agenten)
m.add(
    "Code-Review-Kommentare sollten Zeilennummern enthalten",
    agent_id="code-reviewer-01",
    metadata={"type": "instruction"}
)

# Sitzungs-spezifischer Speicher (nur diese Konversation)
m.add(
    "Wir debuggen gerade das Authentifizierungsmodul",
    session_id="session_abc123",
    metadata={"type": "context"}
)

# Globaler Speicher (gilt für alle Nutzer/Agenten)
m.add(
    "Unternehmenston ist professionell aber freundlich",
    metadata={"type": "global", "scope": "all"}
)

# Mem0 extrahiert und kategorisiert automatisch
memories = m.add(
    """
    Der Datenbank-Verbindungspool war erschöpft und verursachte Timeouts.
    Lösung: max_connections von 100 auf 200 erhöhen und 
    Verbindungspooling in der Anwendungsschicht implementieren.
    Diese Lösung reduzierte die Latenz um 60%.
    """,
    user_id="devops-team",
    metadata={"project": "payment-service"}
)

# Mem0 extrahiert:
# 1. FAKT: "Datenbank-Verbindungspool war erschöpft" → semantisches Gedächtnis
# 2. LÖSUNG: "max_connections von 100 auf 200 erhöhen" → prozedurales Gedächtnis  
# 3. ERGEBNIS: "Latenz um 60% reduziert" → episodisches Gedächtnis
# 4. METRIK: "60% Latenz-Reduktion" → extrahiert als strukturierte Daten

# Python
pip install mem0ai

# JavaScript/TypeScript
npm install mem0ai

# CLI
pip install mem0ai[cli]

# Option 1: Mem0 Cloud (managed)
import mem0

config = {
    "llm": {
        "provider": "openai",
        "config": {
            "model": "gpt-4o",
            "temperature": 0.1
        }
    },
    "vector_store": {
        "provider": "mem0",  # Mem0 managed vector store
        "config": {
            "collection_name": "agent_memory"
        }
    }
}

m = mem0.Memory.from_config(config)

# Option 2: Self-hosted mit Qdrant
config = {
    "llm": {
        "provider": "ollama",
        "config": {
            "model": "llama3.1",
            "ollama_base_url": "http://localhost:11434"
        }
    },
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "collection_name": "agent_memory",
            "host": "localhost",
            "port": 6333
        }
    },
    "graph_store": {
        "provider": "neo4j",
        "config": {
            "url": "bolt://localhost:7687",
            "username": "neo4j",
            "password": "password"
        }
    }
}

m = mem0.Memory.from_config(config)

# Option 3: PostgreSQL (pgvector) für Enterprise
config = {
    "vector_store": {
        "provider": "pgvector",
        "config": {
            "collection_name": "agent_memory",
            "connection_string": "postgresql://user:pass@localhost/dbname"
        }
    }
}

# Mem0 weist automatisch Wichtigkeits-Scores zu
# und kann weniger wichtige Erinnerungen im Laufe der Zeit abbauen

config = {
    "memory": {
        "importance_threshold": 0.7,  # Nur Erinnerungen über diesem Score speichern
        "decay_enabled": True,
        "decay_factor": 0.95,  # 5% Abfall pro Tag für niedrig-wichtige Erinnerungen
        "max_memories_per_user": 10000,
        "cleanup_interval": 86400  # Tägliche Bereinigung
    }
}

m = mem0.Memory.from_config(config)

# Manuelle Wichtigkeits-Bewertung
memories = m.add(
    "Kundes Produktions-Datenbank-Passwort ist 'TempPass123!'",
    user_id="support",
    metadata={"security_level": "high"}
)
# Mem0 wird dies als hochwichtig markieren (sicherheitsrelevant)
# aber Sie möchten es möglicherweise vom Standard-Speicher ausschließen

# Multi-Kriterien-Suche
results = m.search(
    query="Was war das Datenbank-Problem?",
    user_id="alice",
    filters={
        "metadata": {
            "category": "technical",
            "priority": {"gte": 3}
        },
        "created_at": {
            "gte": "2026-01-01",
            "lte": "2026-06-26"
        }
    },
    limit=10
)

# Suche mit Relevanz-Schwelle
results = m.search(
    query="Deployment-Strategie",
    user_id="alice",
    min_relevance=0.8  # Nur hoch-relevante Ergebnisse
)

# Erinnerungen können aktualisiert und versioniert werden
m.add(
    "Kundes bevorzugter Kontakt ist E-Mail",
    user_id="alice",
    memory_id="contact_pref_001"
)

# Später: Präferenz ändert sich
m.update(
    memory_id="contact_pref_001",
    data="Kundes bevorzugter Kontakt ist Slack bei dringenden Anliegen, sonst E-Mail"
)

# Historie anzeigen
history = m.history(memory_id="contact_pref_001")
# Gibt alle Versionen mit Zeitstempeln zurück

// Node: "In Mem0 speichern"
// Mit Mem0 API verbinden

const mem0ApiKey = $env.MEM0_API_KEY;

const memoryData = {
  messages: [
    {
      role: "user",
      content: $json.input.userMessage
    },
    {
      role: "assistant",
      content: $json.input.aiResponse
    }
  ],
  user_id: $json.input.userId,
  agent_id: $json.input.agentId || "n8n-agent",
  metadata: {
    workflow_id: $execution.id,
    category: $json.input.category || "interaction",
    sentiment: $json.input.sentiment
  }
};

const response = await $httpRequest({
  method: "POST",
  url: "https://api.mem0.ai/v1/memories/",
  headers: {
    "Authorization": `Token ${mem0ApiKey}`,
    "Content-Type": "application/json"
  },
  body: memoryData
});

return [{ json: { stored: true, memoryId: response.id } }];

// Node: "Aus Mem0 abrufen"

const mem0ApiKey = $env.MEM0_API_KEY;
const userId = $json.userId;
const currentMessage = $json.message;

// Relevante Erinnerungen abrufen
const memories = await $httpRequest({
  method: "POST",
  url: "https://api.mem0.ai/v1/memories/search/",
  headers: {
    "Authorization": `Token ${mem0ApiKey}`,
    "Content-Type": "application/json"
  },
  body: {
    query: currentMessage,
    user_id: userId,
    limit: 10
  }
});

// Für LLM-Kontext formatieren
const memoryContext = memories.results
  .map(m => `[${m.category}] ${m.memory}`)
  .join("\n");

return [{
  json: {
    userId,
    message: currentMessage,
    memoryContext: memoryContext || "Keine relevanten Erinnerungen gefunden",
    relevantMemories: memories.results.length
  }
}];

┌─────────────────────────────────────────────────────────────────┐
│                     GRAPHITI-ARCHITEKTUR                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Input: "Alice führt Bob. Bob arbeitet in Engineering."        │
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │              Wissensgraph-Konstruktion                  │   │
│   │                                                          │   │
│   │   ┌─────────┐        führt           ┌─────────┐        │   │
│   │   │  Alice  │ ──────────────────────▶ │   Bob   │        │   │
│   │   └────┬────┘                         └────┬────┘        │   │
│   │        │                                   │             │   │
│   │        │                                   │             │   │
│   │        │                         arbeitet_in │             │   │
│   │        │                                   ▼             │   │
│   │        │                            ┌──────────┐        │   │
│   │        └─────────────────────────────▶ │Engineering│        │   │
│   │                                      └──────────┘        │   │
│   │                                                          │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │              Zeitliche Dimension                       │   │
│   │                                                          │   │
│   │   Fakt: "Alice führt Bob"                               │   │
│   │   Gültig von: 15.01.2026                                │   │
│   │   Gültig bis: 01.06.2026 (Alice wechselte Team)          │   │
│   │   Aktuell: FALSCH                                        │   │
│   │                                                          │   │
│   │   Fakt: "Charlie führt Bob" (neu)                       │   │
│   │   Gültig von: 01.06.2026                                │   │
│   │   Aktuell: WAHR                                          │   │
│   │                                                          │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Python SDK
pip install graphiti-core

# Docker Compose für Self-Hosting
curl -L https://zep.ai/install.sh | bash

from graphiti_core import Graphiti
from datetime import datetime

# Initialisieren
graphiti = Graphiti(
    uri="bolt://localhost:7687",  # Neo4j
    user="neo4j",
    password="password"
)

# Graph aus Episode aufbauen
episode = """
Besprechungsnotizen - 26. Juni 2026

Teilnehmer: Alice (Projektleiter), Bob (Engineering), Charlie (Produkt)

Diskussion:
- Alice kündigte Q3-Roadmap an, die sich auf KI-Funktionen konzentriert
- Bob äußerte Bedenken zur technischen Schuld im Auth-Modul
- Charlie beantragte 2 weitere Engineer für das Team
- Entscheidung: Auth-Refactoring vor neuen Features priorisieren
- Aufgaben:
  * Bob: Auth-Audit bis 5. Juli vorbereiten
  * Alice: Budget für 2 Engineer bereitstellen
  * Charlie: Produkt-Zeitplan aktualisieren
"""

# Episode hinzufügen (extrahiert automatisch Entitäten und Beziehungen)
await graphiti.add_episode(
    name="Q3 Planungsbesprechung",
    episode_body=episode,
    source_description="Besprechungsnotizen",
    reference_time=datetime.now()
)

# Den Graph abfragen
# Finden wer für Auth-Audit verantwortlich ist
results = await graphiti.search(
    "Wer muss das Auth-Audit vorbereiten?"
)
# Gibt zurück: Bob, mit Beziehung "verantwortlich_für: auth audit"

# Multi-Hop-Abfrage: Alle Personen finden, die in Q3-Roadmap involviert sind
results = await graphiti.search(
    "Wer ist in der Q3-Roadmap-Planung involviert?",
    search_type="traversal"
)
# Gibt zurück: Alice, Bob, Charlie mit ihren jeweiligen Rollen

# Zeitliche Abfragen
results = await graphiti.search(
    "Wer war der Projektleiter im Mai 2026?",
    reference_time=datetime(2026, 5, 15)
)
# Gibt historischen Zustand zurück (selbst wenn Alice Rollen gewechselt hat)

# Beziehungsabfragen
results = await graphiti.search(
    "Was sind Bobs aktuelle Verantwortlichkeiten?",
    search_type="neighborhood"
)
# Gibt zurück: auth module (maintains), auth audit (verantwortlich_für)

# Widerspruchserkennung
new_episode = "Alice kündigte an, dass sie als Projektleiterin zurücktritt."
await graphiti.add_episode(...)

# Graphiti automatisch:
# 1. Erstellt neuen Knoten: "Alice → status → zurücktreten"
# 2. Aktualisiert zeitliche Gültigkeit von "Alice ist Projektleiter" (setzt Enddatum)
# 3. Behält beide Fakten mit ihren Gültigkeitsperioden bei

# Batch-Verarbeitung für große Datensätze
episodes = [
    {"name": "Besprechung 1", "body": "...", "time": t1},
    {"name": "Besprechung 2", "body": "...", "time": t2},
    # ... Hunderte von Episoden
]

# Parallel in Batches verarbeiten
await graphiti.add_episode_bulk(episodes, batch_size=10)

# Graph-Bereinigung für Effizienz
await graphiti.maintain()
# - Entfernt veraltete Kanten
# - Kompaktiert redundante Knoten
# - Behält Graph-Integrität bei

# Selektives Graph-Laden
results = await graphiti.search(
    "Q3 Roadmap",
    nodes_to_exclude=["historische_projekte"],
    max_depth=3  # Traversierungstiefe begrenzen
)

from langmem import create_memory_store
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph

# Speicher-Store erstellen
memory = create_memory_store(
    kind="semantic",  # semantic | episodic | procedural
    backend="chroma",  # chroma | postgres | memory
    embedding_model="openai:text-embedding-3-small"
)

# Einfache Integration mit LangChain
llm = ChatOpenAI(model="gpt-4o")

# LLM mit Speicher wrappen
from langmem import bind_memory

llm_with_memory = bind_memory(
    llm,
    memory=memory,
    strategy="retrieve_and_update"  # Speicher nach jeder Interaktion auto-aktualisieren
)

# Wie normales LLM verwenden
response = await llm_with_memory.ainvoke(
    "Was ist der beste Ansatz für Fehlerbehandlung in unserer Codebasis?"
)
# Ruft automatisch relevante vergangene Entscheidungen aus dem Speicher ab

from langmem import SemanticMemory, EpisodicMemory, ProceduralMemory

# Semantisches Gedächtnis - Fakten und Konzepte
semantic = SemanticMemory()
semantic.add("Unser Tech-Stack ist Python, FastAPI und PostgreSQL")
semantic.add("Wir folgen PEP 8 Style-Guidelines")

# Episodisches Gedächtnis - Vergangene Ereignisse
episodic = EpisodicMemory()
episodic.add_episode(
    event="Produktionsvorfall am 15.06.2026",
    outcome="Datenbank-Verbindungspool-Überlastung",
    resolution="Pool-Größe von 100 auf 200 erhöht",
    lessons_learned="Verbindungsmetriken proaktiv überwachen"
)

# Prozedurales Gedächtnis - Wie man Dinge macht
procedural = ProceduralMemory()
procedural.add_procedure(
    name="in_produktion_bringen",
    steps=[
        "Vollständige Testsuite ausführen",
        "Datenbank-Backup erstellen",
        "In Staging deployen",
        "Smoke-Tests ausführen",
        "In Produktion deployen",
        "30 Minuten überwachen"
    ],
    context="Standard-Deployment-Prozess für Web-Services"
)

from langgraph.graph import StateGraph, END
from typing import TypedDict, List
from langmem import SemanticMemory

class AgentState(TypedDict):
    messages: List[dict]
    memory_context: str
    user_id: str

memory = SemanticMemory()

def retrieve_memory(state: AgentState):
    """Relevante Erinnerungen für aktuellen Kontext abrufen"""
    recent_messages = state["messages"][-3:]  # Letzte 3 Nachrichten
    query = " ".join([m["content"] for m in recent_messages])
    
    relevant_memories = memory.search(
        query,
        user_id=state["user_id"],
        limit=5
    )
    
    return {
        "memory_context": "\n".join([m.content for m in relevant_memories])
    }

def update_memory(state: AgentState):
    """Speicher mit neuer Interaktion aktualisieren"""
    user_message = state["messages"][-2]["content"]  # Nutzer-Nachricht
    ai_response = state["messages"][-1]["content"]   # KI-Antwort
    
    memory.add_interaction(
        user_message=user_message,
        ai_response=ai_response,
        user_id=state["user_id"],
        extract_facts=True  # Fakten auto-extrahieren
    )
    
    return {}

# Graph aufbauen
workflow = StateGraph(AgentState)

workflow.add_node("retrieve_memory", retrieve_memory)
workflow.add_node("agent", call_llm)  # Ihr LLM-Node
workflow.add_node("update_memory", update_memory)

workflow.set_entry_point("retrieve_memory")
workflow.add_edge("retrieve_memory", "agent")
workflow.add_edge("agent", "update_memory")
workflow.add_edge("update_memory", END)

app = workflow.compile()

┌─────────────────────────────────────────────────────────────────┐
│       n8n Workflow: Speicher-verbesserter Kundenservice       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐                                               │
│  │ Webhook      │ ◄── Kunden-Nachricht                         │
│  │ (Chat Input) │                                               │
│  └──────┬───────┘                                               │
│         │                                                        │
│         ▼                                                        │
│  ┌────────────────────────────────────────┐                     │
│  │ HTTP Request: Speicher abrufen         │                     │
│  │ POST https://api.mem0.ai/v1/search   │                     │
│  │ Body: {                                │                     │
│  │   query: {{$json.message}},            │                     │
│  │   user_id: {{$json.customerId}},       │                     │
│  │   limit: 5                             │                     │
│  │ }                                      │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ Function: Kontext aufbauen             │                     │
│  │ Code:                                  │                     │
│  │ const memories = $json.results;       │                     │
│  │ const context = memories.map(m =>     │                     │
│  │   `[${m.category}] ${m.memory}`        │                     │
│  │ ).join('\n');                          │                     │
│  │ return { context, memories };         │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ OpenAI: Antwort generieren             │                     │
│  │ Model: gpt-4o                        │                     │
│  │ System Prompt:                         │                     │
│  │ "Sie sind ein hilfreicher Support-    │                     │
│  │  Agent. Verwenden Sie den folgenden   │                     │
│  │  Kontext über diesen Kunden:         │                     │
│  │  {{$json.context}}"                    │                     │
│  │                                        │                     │
│  │ User: {{$json.message}}               │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ HTTP Request: Speicher speichern       │                     │
│  │ POST /v1/memories/                     │                     │
│  │ Body: {                                │                     │
│  │   messages: [                          │                     │
│  │     {role: "user", content: "..."},    │                     │
│  │     {role: "assistant", content:"..."} │                     │
│  │   ],                                   │                     │
│  │   user_id: "..."                       │                     │
│  │ }                                      │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌──────────────┐                                               │
│  │ Antwort      │ ──► Zurück an Kunden                         │
│  │ senden       │                                               │
│  └──────────────┘                                               │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// n8n Function Node: Recherche mit Speicher

async function researchWithMemory() {
  const OPENAI_API_KEY = $env.OPENAI_API_KEY;
  const MEM0_API_KEY = $env.MEM0_API_KEY;
  
  const topic = $json.topic;
  const sessionId = $json.sessionId;
  
  // Schritt 1: Vorherige Recherche zu diesem Thema abrufen
  const previousResearch = await $httpRequest({
    method: "POST",
    url: "https://api.mem0.ai/v1/memories/search/",
    headers: { "Authorization": `Token ${MEM0_API_KEY}` },
    body: {
      query: topic,
      session_id: sessionId,
      filters: { metadata: { type: "research_finding" } }
    }
  });
  
  // Schritt 2: Recherche-Plan generieren
  const planPrompt = `Thema: ${topic}
Vorherige Ergebnisse: ${JSON.stringify(previousResearch.results)}

Generieren Sie einen Recherche-Plan, der sich auf neue, noch nicht abgedeckte Aspekte konzentriert.`;

  const plan = await $httpRequest({
    method: "POST",
    url: "https://api.openai.com/v1/chat/completions",
    headers: { "Authorization": `Bearer ${OPENAI_API_KEY}` },
    body: {
      model: "gpt-4o",
      messages: [{ role: "user", content: planPrompt }]
    }
  });
  
  // Schritt 3: Recherche durchführen (Web-Suche, API-Aufrufe, etc.)
  const researchSteps = plan.choices[0].message.content;
  const findings = [];
  
  // ... Recherche durchführen ...
  
  // Schritt 4: Neue Ergebnisse speichern
  for (const finding of findings) {
    await $httpRequest({
      method: "POST",
      url: "https://api.mem0.ai/v1/memories/",
      headers: { "Authorization": `Token ${MEM0_API_KEY}` },
      body: {
        messages: [{ role: "assistant", content: finding }],
        session_id: sessionId,
        metadata: { type: "research_finding", topic }
      }
    });
  }
  
  return {
    json: {
      topic,
      newFindings: findings.length,
      totalFindings: previousResearch.results.length + findings.length
    }
  };
}

return [await researchWithMemory()];

// n8n Error Handler mit Speicher

// Dieser Node läuft, wenn ein Fehler auftritt
async function errorRecovery() {
  const error = $json.error;
  const workflowId = $execution.workflowId;
  const MEM0_API_KEY = $env.MEM0_API_KEY;
  
  // Schritt 1: Nach ähnlichen vergangenen Fehlern suchen
  const similarErrors = await $httpRequest({
    method: "POST",
    url: "https://api.mem0.ai/v1/memories/search/",
    headers: { "Authorization": `Token ${MEM0_API_KEY}` },
    body: {
      query: error.message,
      filters: { 
        metadata: { 
          type: "error_resolution",
          workflow_id: workflowId
        }
      }
    }
  });
  
  // Schritt 2: Vorherige Lösungen ausprobieren
  for (const solution of similarErrors.results) {
    try {
      const result = await applySolution(solution);
      if (result.success) {
        // Erfolgreiche Wiederherstellung loggen
        await $httpRequest({
          method: "POST",
          url: "https://api.mem0.ai/v1/memories/",
          headers: { "Authorization": `Token ${MEM0_API_KEY}` },
          body: {
            messages: [{
              role: "assistant",
              content: `Fehler "${error.message}" gelöst mit Lösung: ${solution}`
            }],
            metadata: { 
              type: "successful_recovery",
              error_type: error.type,
              workflow_id: workflowId
            }
          }
        });
        return { json: { recovered: true, method: solution } };
      }
    } catch (e) {
      continue;
    }
  }
  
  // Schritt 3: Keine Lösung gefunden - eskalieren
  return { json: { recovered: false, needsEscalation: true } };
}

return [await errorRecovery()];

# skills/memory-agent/SKILL.md
---
name: memory-agent
version: "1.0.0"
memory:
  # Speicheranforderungen deklarieren
  stores:
    - name: episodic
      type: vector
      provider: mem0
      scope: user  # pro-Nutzer Speicher
      
    - name: semantic
      type: graph
      provider: graphiti
      scope: session  # in Sitzung geteilt
      
    - name: short_term
      type: cache
      provider: redis
      ttl: 3600  # 1 Stunde

  # Speicherabruf-Strategie
  retrieval:
    strategy: hierarchical
    steps:
      - store: short_term
        limit: 10
        threshold: 0.7
      - store: episodic
        limit: 5
        threshold: 0.8
      - store: semantic
        limit: 3
        threshold: 0.75
---

execution:
  javascript: |
    async function execute(message, context) {
      // Schritt 1: Relevante Erinnerungen abrufen
      const memories = await context.memory.retrieve({
        query: message.content,
        userId: message.user_id,
        strategy: "hierarchical"
      });
      
      // Schritt 2: Antwort mit Speicher-Kontext generieren
      const response = await context.llm.generate({
        messages: [
          {
            role: "system",
            content: `Vorheriger Kontext:\n${memories.formatted}`
          },
          { role: "user", content: message.content }
        ]
      });
      
      // Schritt 3: Interaktion speichern
      await context.memory.add({
        messages: [
          { role: "user", content: message.content },
          { role: "assistant", content: response.content }
        ],
        userId: message.user_id,
        metadata: {
          timestamp: new Date().toISOString(),
          sentiment: response.sentiment
        }
      });
      
      return { content: response.content };
    }

// OpenClaw Skill mit Mem0
// skills/mem0-integration/SKILL.md

const mem0 = require('mem0ai');

class Mem0MemoryProvider {
  constructor(config) {
    this.client = new mem0.Memory({
      apiKey: config.apiKey,
      ...config.options
    });
  }
  
  async retrieve(query, options) {
    const results = await this.client.search({
      query,
      user_id: options.userId,
      agent_id: options.agentId,
      limit: options.limit || 10
    });
    
    return {
      items: results.map(r => ({
        content: r.memory,
        relevance: r.score,
        timestamp: r.created_at,
        metadata: r.metadata
      })),
      formatted: results.map(r => r.memory).join('\n')
    };
  }
  
  async add(data, options) {
    return await this.client.add({
      messages: data.messages,
      user_id: options.userId,
      agent_id: options.agentId,
      session_id: options.sessionId,
      metadata: data.metadata
    });
  }
  
  async forget(query, options) {
    // Spezifische Erinnerungen löschen
    const memories = await this.retrieve(query, options);
    for (const memory of memories.items) {
      await this.client.delete(memory.id);
    }
  }
}

module.exports = Mem0MemoryProvider;

# Multi-Agenten-System mit geteiltem Speicher
agents:
  - name: researcher
    skills:
      - memory-reader
      - web-search
    memory:
      read: [shared-research]
      write: [shared-research]
      
  - name: analyst
    skills:
      - memory-reader
      - data-analysis
    memory:
      read: [shared-research, shared-insights]
      write: [shared-insights]
      
  - name: writer
    skills:
      - memory-reader
      - content-generation
    memory:
      read: [shared-research, shared-insights, shared-drafts]
      write: [shared-drafts]

shared_memory:
  - name: shared-research
    type: vector
    access: [researcher:write, analyst:read, writer:read]
    
  - name: shared-insights
    type: graph
    access: [analyst:write, writer:read]
    
  - name: shared-drafts
    type: document
    access: [writer:write, all:read]

# Semantische Suche nach Wissen
async def retrieve_knowledge(query, user_id):
    # Query zu Vektor kodieren
    query_embedding = encoder.encode(query)
    
    # Semantischen Speicher durchsuchen
    results = vector_db.search(
        vector=query_embedding,
        filter={"memory_type": "semantic"},
        top_k=5
    )
    
    # Nach Relevanz für aktuellen Kontext neu ordnen
    reranked = rerank_by_context(
        results, 
        current_conversation
    )
    
    return reranked

# Beispiel: "Welche Datenbank verwenden wir?"
# Gibt zurück: "Unser Tech-Stack umfasst PostgreSQL 15 mit pgvector-Erweiterung"

# Episodisches Gedächtnis - "was passierte"
async def retrieve_episodes(query, user_id, temporal_filters=None):
    # Suche mit zeitlicher Gewichtung
    results = vector_db.search(
        query=query,
        filter={
            "memory_type": "episodic",
            "user_id": user_id,
            **temporal_filters
        },
        top_k=10
    )
    
    # Nach Aktualität und Relevanz sortieren
    scored = [
        {
            **result,
            "score": relevance_score * recency_decay(result.timestamp)
        }
        for result in results
    ]
    
    return sorted(scored, key=lambda x: x["score"], reverse=True)[:5]

# Beispiel: "Wann hatten wir zuletzt ein Datenbank-Problem?"
# Gibt zurück: "15. Juni: Datenbank-Verbindungspool-Überlastung..."

# Prozedurales Gedächtnis - Fähigkeiten und Prozeduren
async def retrieve_procedure(task_description):
    # Gegen bekannte Prozeduren matchen
    procedures = procedure_library.search(
        task_description,
        threshold=0.8
    )
    
    if procedures:
        # Best passende Prozedur zurückgeben
        return {
            "type": "procedure",
            "steps": procedures[0].steps,
            "context": procedures[0].context
        }
    
    # Keine exakte Übereinstimmung - versuchen aus Sub-Prozeduren zu komponieren
    sub_procedures = decompose_task(task_description)
    composed = compose_procedure(sub_procedures)
    
    return {
        "type": "composed_procedure",
        "steps": composed.steps
    }

# Beispiel: "Wie bringe ich in Produktion?"
# Gibt strukturierte Prozedur mit Schritten zurück

async def hybrid_retrieval(query, user_id):
    # Paralleles Abrufen von allen Speichertypen
    [semantic_results, episodic_results, procedural_results] = await Promise.all([
        retrieve_semantic(query),
        retrieve_episodic(query, user_id),
        retrieve_procedural(query)
    ])
    
    # Nach Speichertyp basierend auf Query gewichten
    query_type = classify_query_type(query)
    
    weights = {
        "factual": {"semantic": 0.7, "episodic": 0.2, "procedural": 0.1},
        "historical": {"semantic": 0.1, "episodic": 0.8, "procedural": 0.1},
        "how_to": {"semantic": 0.2, "episodic": 0.1, "procedural": 0.7}
    }[query_type]
    
    # Zusammenführen und neu ordnen
    combined = []
    for results, weight in [
        (semantic_results, weights["semantic"]),
        (episodic_results, weights["episodic"]),
        (procedural_results, weights["procedural"])
    ]:
        for r in results:
            combined.append({**r, "weighted_score": r.score * weight})
    
    return sorted(combined, key=lambda x: x["weighted_score"], reverse=True)

┌─────────────────────────────────────────────────────────────────┐
│                    GEMEINSAMER SPEICHER-POOL                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐        ┌─────────────────┐        ┌──────────┐│
│  │   Agent A    │◄──────►│                 │◄──────►│ Agent B  ││
│  │  (Forscher)  │        │    Gemeinsamer  │        │(Analyst) ││
│  └──────────────┘        │    Speicher     │        └──────────┘│
│                          │    Store        │                   │
│  ┌──────────────┐        │                 │        ┌──────────┐│
│  │   Agent C    │◄──────►│  - Fakten       │◄──────►│ Agent D  ││
│  │   (Autor)    │        │  - Erkenntnisse │        │(Prüfer)  ││
│  └──────────────┘        │  - Entscheidungen│        └──────────┘│
│                          │  - Kontext      │                   │
│  Alle Agenten lesen/     │                 │                   │
│  schreiben gemeinsamen   └─────────────────┘                   │
│  Speicher                                                       │
│                                                                  │
│  Vorteile: Einfach, alle Agenten abgestimmt                     │
│  Nachteile: Konkurrenz, keine Privatsphäre zwischen Agenten     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                  TRANSAKTIVES GEDÄCHTNIS-SYSTEM                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Agent A (Forscher)                                            │
│   ├─ Expertise: ["web_search", "data_collection"]               │
│   ├─ Speicher: Persönliches Arbeitsgedächtnis                 │
│   └─ Weiß über: Agent B ist der Analyst                         │
│                                                                  │
│   Agent B (Analyst)                                             │
│   ├─ Expertise: ["data_analysis", "pattern_recognition"]          │
│   ├─ Speicher: Persönliches Arbeitsgedächtnis                 │
│   └─ Weiß über: Agent A hat Rohdaten, Agent C schreibt          │
│                                                                  │
│   Agent C (Autor)                                               │
│   ├─ Expertise: ["content_creation", "editing"]                 │
│   ├─ Speicher: Persönliches Arbeitsgedächtnis                 │
│   └─ Weiß über: Agent B produziert Erkenntnisse                 │
│                                                                  │
│   Meta-Gedächtnis: Wer was weiß                                │
│   ├─ researcher@a weiß: [rohdaten, quellen]                    │
│   ├─ analyst@b weiß: [erkenntnisse, muster]                     │
│   └─ writer@c weiß: [entwürfe, finale_inhalte]                  │
│                                                                  │
│   Wenn Agent C Daten braucht: "Frag Agent B"                    │
│   Wenn Agent B Quellen braucht: "Frag Agent A"                    │
│                                                                  │
│  Vorteile: Effizient, skalierbar, spiegelt menschliche Teams   │
│  Nachteile: Komplexe Koordination, Latenz                       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

class TransaktivesGedächtnisSystem:
    def __init__(self):
        self.agent_directory = {}
        self.meta_memory = {}
    
    def register_agent(self, agent_id, expertise, memory_store):
        """Agent im System registrieren"""
        self.agent_directory[agent_id] = {
            "expertise": expertise,
            "memory_store": memory_store,
            "last_active": datetime.now()
        }
    
    def store_memory(self, agent_id, content, metadata):
        """Agent speichert in seinem persönlichen Store"""
        memory_id = self.agent_directory[agent_id]["memory_store"].add(
            content, metadata
        )
        
        # Meta-Gedächtnis aktualisieren über was dieser Agent weiß
        self._update_meta_memory(agent_id, metadata.get("topics", []))
        
        return memory_id
    
    def retrieve_memory(self, query, requesting_agent):
        """Speicher von bester(n) Quelle(n) abrufen"""
        # Schritt 1: Prüfen ob anfragender Agent relevanten Speicher hat
        local = self._query_agent_memory(requesting_agent, query)
        if local and max(r.score for r in local) > 0.9:
            return local
        
        # Schritt 2: Meta-Gedächtnis abfragen welcher Agent wissen könnte
        relevant_agents = self._find_experts(query)
        
        # Schritt 3: Relevante Agenten abfragen
        results = []
        for agent_id in relevant_agents:
            if agent_id != requesting_agent:
                agent_results = self._query_agent_memory(agent_id, query)
                results.extend([
                    {**r, "source": agent_id} for r in agent_results
                ])
        
        # Schritt 4: Kombinierte Ergebnisse zurückgeben
        return sorted(results, key=lambda x: x["score"], reverse=True)
    
    def _find_experts(self, query):
        """Agenten mit relevanter Expertise finden"""
        # Einfache Implementierung: Überschneidung von Expertise prüfen
        experts = []
        query_topics = self._extract_topics(query)
        
        for agent_id, info in self.agent_directory.items():
            overlap = set(info["expertise"]) & query_topics
            if overlap:
                experts.append(agent_id)
        
        return experts

┌─────────────────────────────────────────────────────────────────┐
│                 PRODUKTIONS-SPEICHER-PIPELINE                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  INGESTION                    VERARBEITUNG                 SPEICHER│
│  ──────────                   ─────────────                   ───────│
│                                                                  │
│  ┌─────────┐                 ┌─────────────┐             ┌──────────┐│
│  │ Webhook │───────────────▶│  Sanitizer  │────────────▶│ Raw-Queue││
│  └─────────┘                 └─────────────┘             └────┬─────┘│
│                                                                  │     │
│  ┌─────────┐                 ┌─────────────┐                    │     │
│  │ API     │───────────────▶│  Validator  │───────────────────┘     │
│  └─────────┘                 └─────────────┘                          │
│                                                                  │     │
│  ┌─────────┐                 ┌─────────────┐             ┌──────────▼───┐│
│  │ Datei   │───────────────▶│  Extraktor  │────────────▶│ Verarbeitung││
│  │ Upload  │                 └─────────────┘             │ Workers     ││
│  └─────────┘                                              └─────────────┘│
│                                                                  │     │
│                                                         ┌────────▼────┐│
│                                                         │  Embedding  ││
│                                                         │  Generierung││
│                                                         └──────┬──────┘│
│                                                                  │     │
│  ┌──────────────────────────────────────────────────────────────┼─────┐│
│  │                         SPEICHER-SCHICHT                     │     ││
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │     ││
│  │  │ Vektor-DB   │  │ Graph-DB    │  │ Cache       │◄───────┘     ││
│  │  │ (Pinecone)  │  │ (Neo4j)     │  │ (Redis)     │              ││
│  │  └─────────────┘  └─────────────┘  └─────────────┘              ││
│  └─────────────────────────────────────────────────────────────────┘│
│                                                                  │
│  ┌──────────────────────────────────────────────────────────────┐│
│  │                      ABRUF-SCHICHT                          ││
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            ││
│  │  │ Semantisch  │  │ Zeitlich    │  │ Multi-Hop   │            ││
│  │  │ Suche       │  │ Filter      │  │ Traversal   │            ││
│  │  └─────────────┘  └─────────────┘  └─────────────┘            ││
│  └──────────────────────────────────────────────────────────────┘│
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Produktions-Speicher-Pipeline
import asyncio
from dataclasses import dataclass
from typing import List, Optional
import hashlib

@dataclass
class MemoryEntry:
    id: str
    content: str
    embedding: List[float]
    metadata: dict
    timestamp: str
    importance_score: float

class ProduktionsSpeicherPipeline:
    def __init__(self, config):
        self.vector_store = config.vector_store
        self.graph_store = config.graph_store
        self.cache = config.cache
        self.processor = SpeicherProzessor()
        self.embedder = config.embedder
    
    async def ingest(self, content: str, metadata: dict) -> MemoryEntry:
        """Neuen Speicher in die Pipeline aufnehmen"""
        
        # Schritt 1: Eindeutige ID generieren
        memory_id = self._generate_id(content, metadata)
        
        # Schritt 2: Bereinigen und validieren
        clean_content = self._sanitize(content)
        if not self._validate(clean_content):
            raise ValueError("Inhaltsvalidierung fehlgeschlagen")
        
        # Schritt 3: Entitäten und Beziehungen extrahieren (für Graph)
        entities = self.processor.extract_entities(clean_content)
        relationships = self.processor.extract_relationships(clean_content, entities)
        
        # Schritt 4: Wichtigkeits-Score berechnen
        importance = self.processor.score_importance(clean_content, metadata)
        
        # Schritt 5: Embedding generieren
        embedding = await self.embedder.embed(clean_content)
        
        # Schritt 6: Speicher-Eintrag erstellen
        entry = MemoryEntry(
            id=memory_id,
            content=clean_content,
            embedding=embedding,
            metadata={
                **metadata,
                "entities": entities,
                "importance": importance
            },
            timestamp=datetime.utcnow().isoformat(),
            importance_score=importance
        )
        
        # Schritt 7: Parallel speichern
        await asyncio.gather(
            self._store_vector(entry),
            self._store_graph(entry, entities, relationships),
            self._update_cache(entry)
        )
        
        return entry
    
    async def retrieve(
        self,
        query: str,
        filters: Optional[dict] = None,
        top_k: int = 10
    ) -> List[MemoryEntry]:
        """Relevante Erinnerungen abrufen"""
        
        # Schritt 1: Zuerst Cache prüfen
        cache_key = self._cache_key(query, filters)
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        
        # Schritt 2: Query-Embedding generieren
        query_embedding = await self.embedder.embed(query)
        
        # Schritt 3: Vektor-Suche
        vector_results = await self.vector_store.search(
            query_embedding,
            filters=filters,
            top_k=top_k * 2  # Über-holen für Re-Ranking
        )
        
        # Schritt 4: Nach Relevanz und Aktualität neu ordnen
        ranked = self._rerank(vector_results, query)
        
        # Schritt 5: Mit Graph-Beziehungen anreichern
        enriched = await self._enrich_with_graph(ranked[:top_k])
        
        # Schritt 6: Ergebnisse cachen
        await self.cache.set(cache_key, enriched, ttl=300)
        
        return enriched
    
    async def forget(self, query: str, filters: Optional[dict] = None):
        """Vergessen (löschen) passender Erinnerungen"""
        memories = await self.retrieve(query, filters, top_k=100)
        
        for memory in memories:
            await asyncio.gather(
                self.vector_store.delete(memory.id),
                self.graph_store.delete(memory.id),
                self.cache.delete(f"memory:{memory.id}")
            )
    
    def _generate_id(self, content: str, metadata: dict) -> str:
        """Deterministische ID generieren"""
        key = f"{content}:{json.dumps(metadata, sort_keys=True)}"
        return hashlib.sha256(key.encode()).hexdigest()[:16]
    
    def _sanitize(self, content: str) -> str:
        """PII und schädliche Inhalte entfernen"""
        # PII-Erkennung und -Entfernung implementieren
        # Dies ist eine vereinfachte Version
        sanitized = content
        for pattern, replacement in self.pii_patterns:
            sanitized = pattern.sub(replacement, sanitized)
        return sanitized.strip()
    
    def _rerank(self, results: List[MemoryEntry], query: str) -> List[MemoryEntry]:
        """Ergebnisse nach Relevanz und Aktualität neu ordnen"""
        scored = []
        for r in results:
            # Semantischen Score mit Aktualität und Wichtigkeit kombinieren
            semantic_score = r.metadata.get("semantic_score", 0)
            recency_score = self._recency_score(r.timestamp)
            importance_score = r.importance_score
            
            combined = (
                semantic_score * 0.5 +
                recency_score * 0.3 +
                importance_score * 0.2
            )
            scored.append((r, combined))
        
        scored.sort(key=lambda x: x[1], reverse=True)
        return [r for r, _ in scored]

# Speicher-Klassifizierungssystem
class SpeicherKlassifizierer:
    def __init__(self):
        self.pii_patterns = [
            (r'\b\d{3}-\d{2}-\d{4}\b', 'SSN'),  # US SSN
            (r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b', 'CREDIT_CARD'),
            (r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', 'EMAIL'),
            (r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b', 'IP_ADDRESS'),
        ]
        
        self.sensitive_keywords = [
            "passwort", "geheimnis", "token", "api_key",
            "private key", "credential", "authentication"
        ]
    
    def classify(self, content: str) -> dict:
        """Speicherinhalt für sichere Handhabung klassifizieren"""
        
        classification = {
            "pii_detected": [],
            "sensitivity": "low",
            "encryption_required": False,
            "retention_days": 365,
            "access_controls": ["owner"]
        }
        
        # Nach PII suchen
        for pattern, pii_type in self.pii_patterns:
            if re.search(pattern, content):
                classification["pii_detected"].append(pii_type)
        
        # Sensitivität prüfen
        content_lower = content.lower()
        for keyword in self.sensitive_keywords:
            if keyword in content_lower:
                classification["sensitivity"] = "high"
                classification["encryption_required"] = True
                classification["retention_days"] = 30
                break
        
        # Basierend auf PII anpassen
        if classification["pii_detected"]:
            classification["sensitivity"] = "high"
            classification["access_controls"].append("gdpr_compliant")
        
        return classification
    
    def sanitize(self, content: str) -> str:
        """Sensible Informationen entfernen oder maskieren"""
        sanitized = content
        
        # PII maskieren
        for pattern, pii_type in self.pii_patterns:
            sanitized = pattern.sub(f"[{pii_type}_REDACTED]", sanitized)
        
        return sanitized

# Verwendung in Speicher-Pipeline
klassifizierer = SpeicherKlassifizierer()

async def secure_ingest(content, metadata):
    # Vor dem Speichern klassifizieren
    classification = klassifizierer.classify(content)
    
    if classification["sensitivity"] == "high":
        # Bereinigen oder ablehnen
        if "passwort" in content.lower():
            raise SecurityError("Passwörter können nicht im Speicher gespeichert werden")
        
        content = klassifizierer.sanitize(content)
        metadata["classification"] = classification
        
        # Vor Speicherung verschlüsseln
        content = await encrypt(content)
    
    return await pipeline.ingest(content, metadata)

from cryptography.fernet import Fernet
import hashlib

class VerschlüsselterSpeicherStore:
    def __init__(self, master_key: str):
        self.cipher = Fernet(master_key)
        self.inner_store = SpeicherStore()
    
    async def store(self, memory_id: str, content: str, metadata: dict):
        # Inhalt verschlüsseln
        encrypted = self.cipher.encrypt(content.encode()).decode()
        
        # Verschlüsselt speichern
        await self.inner_store.store(
            memory_id,
            encrypted,
            {**metadata, "encrypted": True}
        )
    
    async def retrieve(self, memory_id: str) -> Optional[str]:
        result = await self.inner_store.retrieve(memory_id)
        if not result:
            return None
        
        # Entschlüsseln
        encrypted = result["content"]
        return self.cipher.decrypt(encrypted.encode()).decode()

class ZugriffsKontrollierterSpeicher:
    def __init__(self, speicher_store, auth_service):
        self.store = speicher_store
        self.auth = auth_service
    
    async def retrieve(
        self,
        query: str,
        user_id: str,
        filters: Optional[dict] = None
    ):
        # Speicherberechtigungen des Nutzers abrufen
        permissions = await self.auth.get_permissions(user_id)
        
        # Filter basierend auf Berechtigungen aufbauen
        access_filter = {
            "$or": [
                {"owner": user_id},
                {"shared_with": user_id},
                {"visibility": "public"}
            ]
        }
        
        # Nutzer-Filter anwenden
        combined_filters = {"$and": [access_filter, filters or {}]}
        
        # Zugriff loggen
        await self._audit_log("memory_retrieve", user_id, query)
        
        return await self.store.retrieve(query, combined_filters)
    
    async def _audit_log(self, action: str, user_id: str, details: str):
        await self.store.add_to_audit_log({
            "action": action,
            "user_id": user_id,
            "details": details,
            "timestamp": datetime.utcnow().isoformat(),
            "ip_address": self._get_client_ip()
        })

class AbgestuftesCache:
    def __init__(self):
        # L1: In-Memory (sub-Millisekunde)
        self.l1 = {}
        
        # L2: Redis (< 5ms)
        self.l2 = RedisClient()
        
        # L3: CDN/Edge-Cache (< 50ms)
        self.l3 = EdgeCache()
    
    async def get(self, key: str) -> Optional[Any]:
        # Zuerst L1 versuchen
        if key in self.l1:
            return self.l1[key]
        
        # L2 versuchen
        l2_value = await self.l2.get(key)
        if l2_value:
            # Zu L1 befördern
            self.l1[key] = l2_value
            return l2_value
        
        # L3 versuchen
        l3_value = await self.l3.get(key)
        if l3_value:
            # Zu L1 und L2 befördern
            self.l1[key] = l3_value
            await self.l2.set(key, l3_value)
            return l3_value
        
        return None

class AbfrageOptimierer:
    def optimize(self, query: str, context: dict) -> dict:
        # Optimale Abruf-Strategie bestimmen
        strategy = self._select_strategy(query)
        
        if strategy == "cached":
            # Auf exakte Übereinstimmung im Cache prüfen
            return {"use_cache": True, "cache_key": query}
        
        elif strategy == "hybrid":
            # Sowohl Keyword- als auch Vektor-Suche verwenden
            return {
                "vector_weight": 0.7,
                "keyword_weight": 0.3,
                "top_k": 10
            }
        
        elif strategy == "graph":
            # Für Beziehungs-Abfragen
            return {
                "use_graph": True,
                "max_hops": 2
            }
        
        else:
            # Standard-Vektor-Suche
            return {"top_k": 5, "min_score": 0.8}
    
    def _select_strategy(self, query: str) -> str:
        # Einfache Heuristiken
        if "wer" in query.lower() and "manager" in query.lower():
            return "graph"  # Wahrscheinlich Beziehungs-Traversierung nötig
        
        if len(query) < 20:
            return "cached"  # Kurze Abfragen oft wiederholt
        
        return "hybrid"

class SpeicherMetriken:
    def __init__(self):
        self.metrics = {
            "retrieval_latency": Histogram(),
            "ingest_latency": Histogram(),
            "cache_hit_rate": Gauge(),
            "memory_size": Gauge(),
            "query_count": Counter()
        }
    
    async def record_retrieval(self, duration: float, cache_hit: bool):
        self.metrics["retrieval_latency"].observe(duration)
        
        if cache_hit:
            self.metrics["cache_hit_rate"].inc()
        
        self.metrics["query_count"].inc()
    
    def get_dashboard_data(self) -> dict:
        return {
            "avg_retrieval_latency": self.metrics["retrieval_latency"].mean(),
            "p95_retrieval_latency": self.metrics["retrieval_latency"].p95(),
            "cache_hit_rate": self.metrics["cache_hit_rate"].value(),
            "total_memories": self.metrics["memory_size"].value(),
            "queries_per_minute": self.metrics["query_count"].rate()
        }

# Support-Agent Speicher-Konfiguration
config = {
    "memory": {
        "provider": "mem0",
        "scopes": ["user", "session"],
        "retention": {
            "order_history": "1_year",
            "preferences": "indefinite",
            "conversations": "90_days"
        }
    },
    "retrieval": {
        "strategies": ["semantic", "episodic"],
        "context_window": "last_5_interactions"
    }
}

# Medizinisches Gedächtnis mit strikter Compliance
config = {
    "memory": {
        "provider": "graphiti",
        "features": {
            "temporal_tracking": True,
            "entity_extraction": ["medication", "condition", "procedure"],
            "contradiction_detection": True
        }
    },
    "security": {
        "encryption": "AES-256",
        "access_controls": "role_based",
        "audit_logging": True,
        "hipaa_compliant": True
    }
}

# Entwickler-Assistent Speicher
developer_memory = {
    "semantic": {
        "tech_stack": ["python", "fastapi", "postgresql"],
        "architectures": ["microservices", "event_driven"],
        "coding_standards": "pep8_with_modifications"
    },
    "episodic": {
        "past_incidents": [...],
        "deployment_history": [...],
        "decision_log": [...]
    },
    "procedural": {
        "deployment_steps": [...],
        "debugging_procedures": [...],
        "code_review_checklist": [...]
    }
}