┌─────────────────────────────────────────────────────────────────┐
│                    AGENT MEMORY HIERARCHY                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────┐                   │
│   │  WORKING MEMORY (Context Window)        │                   │
│   │  - Immediate task context               │                   │
│   │  - 8K-200K tokens                       │                   │
│   │  - Duration: Single turn                │                   │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  SHORT-TERM MEMORY (Buffer/Cache)     │                      │
│   │  - Recent conversation turns          │                      │
│   │  - Working set of facts               │                      │
│   │  - Duration: Minutes to hours         │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  EPISODIC MEMORY (Event Store)        │                      │
│   │  - Past interactions & outcomes         │                      │
│   │  - "What happened when..."              │                      │
│   │  - Duration: Days to months             │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  SEMANTIC MEMORY (Knowledge Base)         │                      │
│   │  - Facts, concepts, entities              │                      │
│   │  - "What I know about..."                 │                      │
│   │  - Duration: Indefinite                    │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  PROCEDURAL MEMORY (Skills/Patterns)    │                      │
│   │  - How to perform tasks                   │                      │
│   │  - Learned strategies                     │                      │
│   │  - Duration: Permanent                     │                      │
│   └─────────────────────────────────────────┘                   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Text → Embedding Model → Vector (1536 dimensions)

"Customer complained about slow shipping"
→ [0.023, -0.156, 0.892, ..., -0.034]  ← High-dimensional representation

"Delivery took too long"
→ [0.031, -0.142, 0.867, ..., -0.041]  ← Similar vector (close in space)

"The weather is nice today"
→ [-0.754, 0.623, -0.123, ..., 0.901]  ← Different vector (far in space)

# Core vector memory pattern
from sentence_transformers import SentenceTransformer
import chromadb
from datetime import datetime
import uuid

class VectorMemory:
    def __init__(self, collection_name="agent_memory"):
        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):
        """Store a new memory"""
        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):
        """Retrieve relevant memories"""
        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  # Convert distance to relevance score
            }
            for doc, meta, dist in zip(
                results["documents"][0],
                results["metadatas"][0],
                results["distances"][0]
            )
        ]

# Usage
memory = VectorMemory()

# Store memories
memory.add_memory(
    "Customer prefers email over phone for urgent issues",
    metadata={"category": "preference", "source": "interaction_123"}
)

memory.add_memory(
    "Previous solution for database timeout: increase connection pool",
    metadata={"category": "solution", "issue_type": "performance"}
)

# Recall
results = memory.recall(
    "How should I contact this customer?",
    filters={"category": "preference"}
)
# Returns: Customer prefers email over phone for urgent issues

┌─────────────────────────────────────────────────────────────────┐
│                        MEM0 ARCHITECTURE                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                     API Layer                          │   │
│   │   add() | get() | update() | delete() | search()     │   │
│   └────────────────────────┬────────────────────────────────┘   │
│                            │                                     │
│   ┌────────────────────────▼────────────────────────────────┐   │
│   │              Memory Processing Layer                    │   │
│   │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐      │   │
│   │  │ Extraction  │ │ Enrichment  │ │ Importance  │      │   │
│   │  │ (LLM-based) │ │ (Metadata)  │ │ Scoring     │      │   │
│   │  └─────────────┘ └─────────────┘ └─────────────┘      │   │
│   └────────────────────────┬────────────────────────────────┘   │
│                            │                                     │
│   ┌────────────────────────▼────────────────────────────────┐   │
│   │                    Storage Layer                        │   │
│   │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐      │   │
│   │  │  Vector DB  │ │  Graph DB   │ │  Key-Value  │      │   │
│   │  │ (Semantic)  │ │ (Relations) │ │ (Metadata)  │      │   │
│   │  └─────────────┘ └─────────────┘ └─────────────┘      │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

import mem0

# Initialize
m = mem0.Memory()

# User-scoped memory (persists across sessions)
m.add(
    "I prefer concise technical responses without fluff",
    user_id="alice",
    metadata={"type": "preference"}
)

# Agent-scoped memory (this agent's learned behavior)
m.add(
    "Code review comments should include line numbers",
    agent_id="code-reviewer-01",
    metadata={"type": "instruction"}
)

# Session-scoped memory (this conversation only)
m.add(
    "We're debugging the authentication module",
    session_id="session_abc123",
    metadata={"type": "context"}
)

# Global memory (applies to all users/agents)
m.add(
    "Company tone is professional but friendly",
    metadata={"type": "global", "scope": "all"}
)

# Mem0 extracts and categorizes automatically
memories = m.add(
    """
    The database connection pool was exhausted causing timeouts.
    Solution: Increase max_connections from 100 to 200 and 
    implement connection pooling in the application layer.
    This fix reduced latency by 60%.
    """,
    user_id="devops-team",
    metadata={"project": "payment-service"}
)

# Mem0 extracts:
# 1. FACT: "Database connection pool was exhausted" → semantic memory
# 2. SOLUTION: "Increase max_connections from 100 to 200" → procedural memory  
# 3. OUTCOME: "Reduced latency by 60%" → episodic memory
# 4. METRIC: "60% latency reduction" → extracted as structured data

# 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 with 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) for enterprise
config = {
    "vector_store": {
        "provider": "pgvector",
        "config": {
            "collection_name": "agent_memory",
            "connection_string": "postgresql://user:pass@localhost/dbname"
        }
    }
}

# Mem0 automatically assigns importance scores
# and can decay less important memories over time

config = {
    "memory": {
        "importance_threshold": 0.7,  # Only store memories above this score
        "decay_enabled": True,
        "decay_factor": 0.95,  # 5% decay per day for low-importance memories
        "max_memories_per_user": 10000,
        "cleanup_interval": 86400  # Daily cleanup
    }
}

m = mem0.Memory.from_config(config)

# Manual importance scoring
memories = m.add(
    "Customer's production database password is 'TempPass123!'",
    user_id="support",
    metadata={"security_level": "high"}
)
# Mem0 will flag this as high-importance (security sensitive)
# but you might want to exclude it from standard memory

# Multi-criteria search
results = m.search(
    query="What was the database issue?",
    user_id="alice",
    filters={
        "metadata": {
            "category": "technical",
            "priority": {"gte": 3}
        },
        "created_at": {
            "gte": "2026-01-01",
            "lte": "2026-06-26"
        }
    },
    limit=10
)

# Search with relevance threshold
results = m.search(
    query="deployment strategy",
    user_id="alice",
    min_relevance=0.8  # Only highly relevant results
)

# Memories can be updated and versioned
m.add(
    "Customer's preferred contact is email",
    user_id="alice",
    memory_id="contact_pref_001"
)

# Later: preference changes
m.update(
    memory_id="contact_pref_001",
    data="Customer's preferred contact is Slack for urgent issues, email otherwise"
)

# View history
history = m.history(memory_id="contact_pref_001")
# Returns all versions with timestamps

// Node: "Store in Mem0"
// Connect to Mem0 API

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: "Retrieve from Mem0"

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

// Get relevant memories
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
  }
});

// Format for LLM context
const memoryContext = memories.results
  .map(m => `[${m.category}] ${m.memory}`)
  .join("\n");

return [{
  json: {
    userId,
    message: currentMessage,
    memoryContext: memoryContext || "No relevant memories found",
    relevantMemories: memories.results.length
  }
}];

┌─────────────────────────────────────────────────────────────────┐
│                     GRAPHITI ARCHITECTURE                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Input: "Alice manages Bob. Bob works in Engineering."        │
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │              Knowledge Graph Construction               │   │
│   │                                                          │   │
│   │   ┌─────────┐        manages         ┌─────────┐        │   │
│   │   │  Alice  │ ──────────────────────▶ │   Bob   │        │   │
│   │   └────┬────┘                         └────┬────┘        │   │
│   │        │                                   │             │   │
│   │        │                                   │             │   │
│   │        │                          works_in │             │   │
│   │        │                                   ▼             │   │
│   │        │                            ┌──────────┐        │   │
│   │        └───────────────────────────▶ │Engineering│        │   │
│   │                                      └──────────┘        │   │
│   │                                                          │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │              Temporal Dimension                         │   │
│   │                                                          │   │
│   │   Fact: "Alice manages Bob"                             │   │
│   │   Valid From: 2026-01-15                               │   │
│   │   Valid To: 2026-06-01 (Alice moved to different team)  │   │
│   │   Current: FALSE                                         │   │
│   │                                                          │   │
│   │   Fact: "Charlie manages Bob" (new)                    │   │
│   │   Valid From: 2026-06-01                               │   │
│   │   Current: TRUE                                          │   │
│   │                                                          │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Python SDK
pip install graphiti-core

# Docker Compose for self-hosting
curl -L https://zep.ai/install.sh | bash

from graphiti_core import Graphiti
from datetime import datetime

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

# Build graph from episode
episode = """
Meeting Notes - June 26, 2026

Attendees: Alice (Project Lead), Bob (Engineering), Charlie (Product)

Discussion:
- Alice announced the Q3 roadmap will focus on AI features
- Bob raised concerns about technical debt in the auth module
- Charlie requested 2 more engineers for the team
- Decision: Prioritize auth refactoring before new features
- Action Items:
  * Bob: Prepare auth audit by July 5
  * Alice: Allocate budget for 2 engineers
  * Charlie: Update product timeline
"""

# Add episode (automatically extracts entities and relationships)
await graphiti.add_episode(
    name="Q3 Planning Meeting",
    episode_body=episode,
    source_description="Meeting notes",
    reference_time=datetime.now()
)

# Query the graph
# Find who is responsible for auth audit
results = await graphiti.search(
    "Who needs to prepare the auth audit?"
)
# Returns: Bob, with relationship "responsible_for: auth audit"

# Multi-hop query: Find all people involved in Q3 roadmap
results = await graphiti.search(
    "Who is involved in the Q3 roadmap planning?",
    search_type="traversal"
)
# Returns: Alice, Bob, Charlie with their respective roles

# Temporal queries
results = await graphiti.search(
    "Who was the project lead in May 2026?",
    reference_time=datetime(2026, 5, 15)
)
# Returns historical state (even if Alice moved roles)

# Relationship queries
results = await graphiti.search(
    "What are Bob's current responsibilities?",
    search_type="neighborhood"
)
# Returns: auth module (maintains), auth audit (responsible_for)

# Contradiction detection
new_episode = "Alice announced she is stepping down as Project Lead."
await graphiti.add_episode(...)

# Graphiti automatically:
# 1. Creates new node: "Alice → status → stepping down"
# 2. Updates temporal validity of "Alice is Project Lead" (sets end date)
# 3. Maintains both facts with their validity periods

# Batch processing for large datasets
episodes = [
    {"name": "Meeting 1", "body": "...", "time": t1},
    {"name": "Meeting 2", "body": "...", "time": t2},
    # ... hundreds of episodes
]

# Process in parallel batches
await graphiti.add_episode_bulk(episodes, batch_size=10)

# Graph pruning for efficiency
await graphiti.maintain()
# - Removes obsolete edges
# - Compacts redundant nodes
# - Maintains graph integrity

# Selective graph loading
results = await graphiti.search(
    "Q3 roadmap",
    nodes_to_exclude=["historical_projects"],
    max_depth=3  # Limit traversal depth
)

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

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

# Simple integration with LangChain
llm = ChatOpenAI(model="gpt-4o")

# Wrap LLM with memory
from langmem import bind_memory

llm_with_memory = bind_memory(
    llm,
    memory=memory,
    strategy="retrieve_and_update"  # auto-update memory after each interaction
)

# Use like normal LLM
response = await llm_with_memory.ainvoke(
    "What's the best approach for error handling in our codebase?"
)
# Automatically retrieves relevant past decisions from memory

from langmem import SemanticMemory, EpisodicMemory, ProceduralMemory

# Semantic Memory - Facts and concepts
semantic = SemanticMemory()
semantic.add("Our tech stack is Python, FastAPI, and PostgreSQL")
semantic.add("We follow PEP 8 style guidelines")

# Episodic Memory - Past events
episodic = EpisodicMemory()
episodic.add_episode(
    event="Production incident on 2026-06-15",
    outcome="Database connection pool exhaustion",
    resolution="Increased pool size from 100 to 200",
    lessons_learned="Monitor connection metrics proactively"
)

# Procedural Memory - How to do things
procedural = ProceduralMemory()
procedural.add_procedure(
    name="deploy_to_production",
    steps=[
        "Run full test suite",
        "Create database backup",
        "Deploy to staging",
        "Run smoke tests",
        "Deploy to production",
        "Monitor for 30 minutes"
    ],
    context="Standard deployment process for 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):
    """Retrieve relevant memories for current context"""
    recent_messages = state["messages"][-3:]  # Last 3 messages
    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):
    """Update memory with new interaction"""
    user_message = state["messages"][-2]["content"]  # User message
    ai_response = state["messages"][-1]["content"]   # AI response
    
    memory.add_interaction(
        user_message=user_message,
        ai_response=ai_response,
        user_id=state["user_id"],
        extract_facts=True  # Auto-extract facts
    )
    
    return {}

# Build graph
workflow = StateGraph(AgentState)

workflow.add_node("retrieve_memory", retrieve_memory)
workflow.add_node("agent", call_llm)  # Your 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: Memory-Enhanced Customer Support          │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐                                               │
│  │ Webhook      │ ◄── Customer message                         │
│  │ (Chat Input) │                                               │
│  └──────┬───────┘                                               │
│         │                                                        │
│         ▼                                                        │
│  ┌────────────────────────────────────────┐                     │
│  │ HTTP Request: Retrieve Memory          │                     │
│  │ POST https://api.mem0.ai/v1/search   │                     │
│  │ Body: {                                │                     │
│  │   query: {{$json.message}},            │                     │
│  │   user_id: {{$json.customerId}},       │                     │
│  │   limit: 5                             │                     │
│  │ }                                      │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ Function: Build Context                │                     │
│  │ Code:                                  │                     │
│  │ const memories = $json.results;       │                     │
│  │ const context = memories.map(m =>     │                     │
│  │   `[${m.category}] ${m.memory}`        │                     │
│  │ ).join('\n');                          │                     │
│  │ return { context, memories };         │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ OpenAI: Generate Response            │                     │
│  │ Model: gpt-4o                        │                     │
│  │ System Prompt:                         │                     │
│  │ "You are a helpful support agent.    │                     │
│  │  Use the following context about     │                     │
│  │  this customer: {{$json.context}}"     │                     │
│  │                                        │                     │
│  │ User: {{$json.message}}               │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ HTTP Request: Store Memory             │                     │
│  │ POST /v1/memories/                     │                     │
│  │ Body: {                                │                     │
│  │   messages: [                          │                     │
│  │     {role: "user", content: "..."},    │                     │
│  │     {role: "assistant", content:"..."} │                     │
│  │   ],                                   │                     │
│  │   user_id: "..."                       │                     │
│  │ }                                      │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌──────────────┐                                               │
│  │ Respond      │ ──► Send back to customer                   │
│  │ to Customer  │                                               │
│  └──────────────┘                                               │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// n8n Function Node: Research with Memory

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;
  
  // Step 1: Retrieve previous research on this topic
  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" } }
    }
  });
  
  // Step 2: Generate research plan
  const planPrompt = `Topic: ${topic}
Previous findings: ${JSON.stringify(previousResearch.results)}

Generate a research plan focusing on new aspects not yet covered.`;

  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 }]
    }
  });
  
  // Step 3: Execute research (web search, API calls, etc.)
  const researchSteps = plan.choices[0].message.content;
  const findings = [];
  
  // ... perform research ...
  
  // Step 4: Store new findings
  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 with Memory

// This node runs when an error occurs
async function errorRecovery() {
  const error = $json.error;
  const workflowId = $execution.workflowId;
  const MEM0_API_KEY = $env.MEM0_API_KEY;
  
  // Step 1: Search for similar past errors
  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
        }
      }
    }
  });
  
  // Step 2: Try previous solutions
  for (const solution of similarErrors.results) {
    try {
      const result = await applySolution(solution);
      if (result.success) {
        // Log successful recovery
        await $httpRequest({
          method: "POST",
          url: "https://api.mem0.ai/v1/memories/",
          headers: { "Authorization": `Token ${MEM0_API_KEY}` },
          body: {
            messages: [{
              role: "assistant",
              content: `Error "${error.message}" resolved using solution: ${solution}`
            }],
            metadata: { 
              type: "successful_recovery",
              error_type: error.type,
              workflow_id: workflowId
            }
          }
        });
        return { json: { recovered: true, method: solution } };
      }
    } catch (e) {
      continue;
    }
  }
  
  // Step 3: No solution found - escalate
  return { json: { recovered: false, needsEscalation: true } };
}

return [await errorRecovery()];

# skills/memory-agent/SKILL.md
---
name: memory-agent
version: "1.0.0"
memory:
  # Declare memory requirements
  stores:
    - name: episodic
      type: vector
      provider: mem0
      scope: user  # per-user memory
      
    - name: semantic
      type: graph
      provider: graphiti
      scope: session  # shared in session
      
    - name: short_term
      type: cache
      provider: redis
      ttl: 3600  # 1 hour

  # Memory retrieval strategy
  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) {
      // Step 1: Retrieve relevant memories
      const memories = await context.memory.retrieve({
        query: message.content,
        userId: message.user_id,
        strategy: "hierarchical"
      });
      
      // Step 2: Generate response with memory context
      const response = await context.llm.generate({
        messages: [
          {
            role: "system",
            content: `Previous context:\n${memories.formatted}`
          },
          { role: "user", content: message.content }
        ]
      });
      
      // Step 3: Store interaction
      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 using 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) {
    // Delete specific memories
    const memories = await this.retrieve(query, options);
    for (const memory of memories.items) {
      await this.client.delete(memory.id);
    }
  }
}

module.exports = Mem0MemoryProvider;

# Multi-agent system with shared memory
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]

# Semantic search for knowledge
async def retrieve_knowledge(query, user_id):
    # Encode query to vector
    query_embedding = encoder.encode(query)
    
    # Search semantic memory
    results = vector_db.search(
        vector=query_embedding,
        filter={"memory_type": "semantic"},
        top_k=5
    )
    
    # Rerank by relevance to current context
    reranked = rerank_by_context(
        results, 
        current_conversation
    )
    
    return reranked

# Example: "What database do we use?"
# Returns: "Our tech stack includes PostgreSQL 15 with pgvector extension"

# Episodic memory - "what happened"
async def retrieve_episodes(query, user_id, temporal_filters=None):
    # Search with temporal weighting
    results = vector_db.search(
        query=query,
        filter={
            "memory_type": "episodic",
            "user_id": user_id,
            **temporal_filters
        },
        top_k=10
    )
    
    # Sort by recency and relevance
    scored = [
        {
            **result,
            "score": relevance_score * recency_decay(result.timestamp)
        }
        for result in results
    ]
    
    return sorted(scored, key=lambda x: x["score"], reverse=True)[:5]

# Example: "When did we last have a database issue?"
# Returns: "June 15: Database connection pool exhaustion..."

# Procedural memory - skills and procedures
async def retrieve_procedure(task_description):
    # Match against known procedures
    procedures = procedure_library.search(
        task_description,
        threshold=0.8
    )
    
    if procedures:
        # Return best matching procedure
        return {
            "type": "procedure",
            "steps": procedures[0].steps,
            "context": procedures[0].context
        }
    
    # No exact match - try to compose from sub-procedures
    sub_procedures = decompose_task(task_description)
    composed = compose_procedure(sub_procedures)
    
    return {
        "type": "composed_procedure",
        "steps": composed.steps
    }

# Example: "How do I deploy to production?"
# Returns structured procedure with steps

async def hybrid_retrieval(query, user_id):
    # Parallel retrieval from all memory types
    [semantic_results, episodic_results, procedural_results] = await Promise.all([
        retrieve_semantic(query),
        retrieve_episodic(query, user_id),
        retrieve_procedural(query)
    ])
    
    # Weight by memory type based on query
    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]
    
    # Merge and rerank
    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)

┌─────────────────────────────────────────────────────────────────┐
│                    SHARED MEMORY POOL                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐        ┌─────────────────┐        ┌──────────┐│
│  │   Agent A    │◄──────►│                 │◄──────►│ Agent B  ││
│  │  (Researcher)│        │    Shared       │        │(Analyst) ││
│  └──────────────┘        │    Memory       │        └──────────┘│
│                          │    Store        │                   │
│  ┌──────────────┐        │                 │        ┌──────────┐│
│  │   Agent C    │◄──────►│  - Facts        │◄──────►│ Agent D  ││
│  │   (Writer)   │        │  - Insights     │        │(Reviewer)││
│  └──────────────┘        │  - Decisions    │        └──────────┘│
│                          │  - Context      │                   │
│  All agents read/write   │                 │                   │
│  to common memory        └─────────────────┘                   │
│                                                                  │
│  Pros: Simple, all agents aligned                                │
│  Cons: Contention, no privacy between agents                     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                  TRANSACTIVE MEMORY SYSTEM                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   Agent A (Researcher)                                          │
│   ├─ Expertise: ["web_search", "data_collection"]               │
│   ├─ Memory: Personal working memory                           │
│   └─ Knows about: Agent B is the analyst                        │
│                                                                  │
│   Agent B (Analyst)                                             │
│   ├─ Expertise: ["data_analysis", "pattern_recognition"]         │
│   ├─ Memory: Personal working memory                             │
│   └─ Knows about: Agent A has raw data, Agent C writes          │
│                                                                  │
│   Agent C (Writer)                                              │
│   ├─ Expertise: ["content_creation", "editing"]               │
│   ├─ Memory: Personal working memory                             │
│   └─ Knows about: Agent B produces insights                      │
│                                                                  │
│   Meta-Memory: Who knows what                                  │
│   ├─ researcher@a knows: [raw_data, sources]                    │
│   ├─ analyst@b knows: [insights, patterns]                      │
│   └─ writer@c knows: [drafts, final_content]                    │
│                                                                  │
│   When Agent C needs data: "Ask Agent B"                        │
│   When Agent B needs sources: "Ask Agent A"                     │
│                                                                  │
│  Pros: Efficient, scalable, mirrors human teams                 │
│  Cons: Complex coordination, latency                            │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

class TransactiveMemorySystem:
    def __init__(self):
        self.agent_directory = {}
        self.meta_memory = {}
    
    def register_agent(self, agent_id, expertise, memory_store):
        """Register an agent with the system"""
        self.agent_directory[agent_id] = {
            "expertise": expertise,
            "memory_store": memory_store,
            "last_active": datetime.now()
        }
    
    def store_memory(self, agent_id, content, metadata):
        """Agent stores memory in their personal store"""
        memory_id = self.agent_directory[agent_id]["memory_store"].add(
            content, metadata
        )
        
        # Update meta-memory about what this agent knows
        self._update_meta_memory(agent_id, metadata.get("topics", []))
        
        return memory_id
    
    def retrieve_memory(self, query, requesting_agent):
        """Retrieve memory from best source(s)"""
        # Step 1: Check if requesting agent has relevant memory
        local = self._query_agent_memory(requesting_agent, query)
        if local and max(r.score for r in local) > 0.9:
            return local
        
        # Step 2: Query meta-memory for which agent might know
        relevant_agents = self._find_experts(query)
        
        # Step 3: Query relevant agents
        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
                ])
        
        # Step 4: Return combined results
        return sorted(results, key=lambda x: x["score"], reverse=True)
    
    def _find_experts(self, query):
        """Find agents with relevant expertise"""
        # Simple implementation: check expertise overlap
        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

┌─────────────────────────────────────────────────────────────────┐
│                 PRODUCTION MEMORY PIPELINE                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  INGESTION                    PROCESSING                   STORAGE│
│  ─────────                   ──────────                   ───────│
│                                                                  │
│  ┌─────────┐                 ┌─────────────┐             ┌──────────┐│
│  │ Webhook │───────────────▶│  Sanitizer  │────────────▶│ Raw Queue││
│  └─────────┘                 └─────────────┘             └────┬─────┘│
│                                                                  │     │
│  ┌─────────┐                 ┌─────────────┐                    │     │
│  │ API     │───────────────▶│  Validator  │───────────────────┘     │
│  └─────────┘                 └─────────────┘                          │
│                                                                  │     │
│  ┌─────────┐                 ┌─────────────┐             ┌──────────▼───┐│
│  │ File    │───────────────▶│  Extractor  │────────────▶│ Processing  ││
│  │ Upload  │                 └─────────────┘             │ Workers     ││
│  └─────────┘                                              └─────────────┘│
│                                                                  │     │
│                                                         ┌────────▼────┐│
│                                                         │  Embedding  ││
│                                                         │  Generation ││
│                                                         └──────┬──────┘│
│                                                                  │     │
│  ┌──────────────────────────────────────────────────────────────┼─────┐│
│  │                         STORAGE LAYER                      │     ││
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐        │     ││
│  │  │ Vector DB   │  │ Graph DB    │  │ Cache       │◄───────┘     ││
│  │  │ (Pinecone)  │  │ (Neo4j)     │  │ (Redis)     │              ││
│  │  └─────────────┘  └─────────────┘  └─────────────┘              ││
│  └─────────────────────────────────────────────────────────────────┘│
│                                                                  │
│  ┌──────────────────────────────────────────────────────────────┐│
│  │                      RETRIEVAL LAYER                          ││
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            ││
│  │  │ Semantic    │  │ Temporal    │  │ Multi-hop   │            ││
│  │  │ Search      │  │ Filter      │  │ Traversal   │            ││
│  │  └─────────────┘  └─────────────┘  └─────────────┘            ││
│  └──────────────────────────────────────────────────────────────┘│
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Production memory 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 ProductionMemoryPipeline:
    def __init__(self, config):
        self.vector_store = config.vector_store
        self.graph_store = config.graph_store
        self.cache = config.cache
        self.processor = MemoryProcessor()
        self.embedder = config.embedder
    
    async def ingest(self, content: str, metadata: dict) -> MemoryEntry:
        """Ingest new memory into the pipeline"""
        
        # Step 1: Generate unique ID
        memory_id = self._generate_id(content, metadata)
        
        # Step 2: Sanitize and validate
        clean_content = self._sanitize(content)
        if not self._validate(clean_content):
            raise ValueError("Content validation failed")
        
        # Step 3: Extract entities and relationships (for graph)
        entities = self.processor.extract_entities(clean_content)
        relationships = self.processor.extract_relationships(clean_content, entities)
        
        # Step 4: Calculate importance score
        importance = self.processor.score_importance(clean_content, metadata)
        
        # Step 5: Generate embedding
        embedding = await self.embedder.embed(clean_content)
        
        # Step 6: Create memory entry
        entry = MemoryEntry(
            id=memory_id,
            content=clean_content,
            embedding=embedding,
            metadata={
                **metadata,
                "entities": entities,
                "importance": importance
            },
            timestamp=datetime.utcnow().isoformat(),
            importance_score=importance
        )
        
        # Step 7: Store in parallel
        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]:
        """Retrieve relevant memories"""
        
        # Step 1: Check cache first
        cache_key = self._cache_key(query, filters)
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        
        # Step 2: Generate query embedding
        query_embedding = await self.embedder.embed(query)
        
        # Step 3: Vector search
        vector_results = await self.vector_store.search(
            query_embedding,
            filters=filters,
            top_k=top_k * 2  # Over-fetch for reranking
        )
        
        # Step 4: Rerank by relevance and recency
        ranked = self._rerank(vector_results, query)
        
        # Step 5: Enrich with graph relationships
        enriched = await self._enrich_with_graph(ranked[:top_k])
        
        # Step 6: Cache results
        await self.cache.set(cache_key, enriched, ttl=300)
        
        return enriched
    
    async def forget(self, query: str, filters: Optional[dict] = None):
        """Forget (delete) matching memories"""
        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:
        """Generate deterministic ID"""
        key = f"{content}:{json.dumps(metadata, sort_keys=True)}"
        return hashlib.sha256(key.encode()).hexdigest()[:16]
    
    def _sanitize(self, content: str) -> str:
        """Remove PII and harmful content"""
        # Implement PII detection and removal
        # This is a simplified 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]:
        """Rerank results by relevance and recency"""
        scored = []
        for r in results:
            # Combine semantic score with recency and importance
            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]

# Memory classification system
class MemoryClassifier:
    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 = [
            "password", "secret", "token", "api_key",
            "private key", "credential", "authentication"
        ]
    
    def classify(self, content: str) -> dict:
        """Classify memory content for security handling"""
        
        classification = {
            "pii_detected": [],
            "sensitivity": "low",
            "encryption_required": False,
            "retention_days": 365,
            "access_controls": ["owner"]
        }
        
        # Check for PII
        for pattern, pii_type in self.pii_patterns:
            if re.search(pattern, content):
                classification["pii_detected"].append(pii_type)
        
        # Check sensitivity
        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
        
        # Adjust based on PII
        if classification["pii_detected"]:
            classification["sensitivity"] = "high"
            classification["access_controls"].append("gdpr_compliant")
        
        return classification
    
    def sanitize(self, content: str) -> str:
        """Remove or mask sensitive information"""
        sanitized = content
        
        # Mask PII
        for pattern, pii_type in self.pii_patterns:
            sanitized = pattern.sub(f"[{pii_type}_REDACTED]", sanitized)
        
        return sanitized

# Usage in memory pipeline
classifier = MemoryClassifier()

async def secure_ingest(content, metadata):
    # Classify before storing
    classification = classifier.classify(content)
    
    if classification["sensitivity"] == "high":
        # Sanitize or reject
        if "password" in content.lower():
            raise SecurityError("Cannot store passwords in memory")
        
        content = classifier.sanitize(content)
        metadata["classification"] = classification
        
        # Encrypt before storage
        content = await encrypt(content)
    
    return await pipeline.ingest(content, metadata)

from cryptography.fernet import Fernet
import hashlib

class EncryptedMemoryStore:
    def __init__(self, master_key: str):
        self.cipher = Fernet(master_key)
        self.inner_store = MemoryStore()
    
    async def store(self, memory_id: str, content: str, metadata: dict):
        # Encrypt content
        encrypted = self.cipher.encrypt(content.encode()).decode()
        
        # Store encrypted
        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
        
        # Decrypt
        encrypted = result["content"]
        return self.cipher.decrypt(encrypted.encode()).decode()

class AccessControlledMemory:
    def __init__(self, memory_store, auth_service):
        self.store = memory_store
        self.auth = auth_service
    
    async def retrieve(
        self,
        query: str,
        user_id: str,
        filters: Optional[dict] = None
    ):
        # Get user's memory permissions
        permissions = await self.auth.get_permissions(user_id)
        
        # Build filter based on permissions
        access_filter = {
            "$or": [
                {"owner": user_id},
                {"shared_with": user_id},
                {"visibility": "public"}
            ]
        }
        
        # Apply user filters
        combined_filters = {"$and": [access_filter, filters or {}]}
        
        # Log access
        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 TieredCache:
    def __init__(self):
        # L1: In-memory (sub-millisecond)
        self.l1 = {}
        
        # L2: Redis (< 5ms)
        self.l2 = RedisClient()
        
        # L3: CDN/Edge cache (< 50ms)
        self.l3 = EdgeCache()
    
    async def get(self, key: str) -> Optional[Any]:
        # Try L1 first
        if key in self.l1:
            return self.l1[key]
        
        # Try L2
        l2_value = await self.l2.get(key)
        if l2_value:
            # Promote to L1
            self.l1[key] = l2_value
            return l2_value
        
        # Try L3
        l3_value = await self.l3.get(key)
        if l3_value:
            # Promote to L1 and L2
            self.l1[key] = l3_value
            await self.l2.set(key, l3_value)
            return l3_value
        
        return None

class QueryOptimizer:
    def optimize(self, query: str, context: dict) -> dict:
        # Determine optimal retrieval strategy
        strategy = self._select_strategy(query)
        
        if strategy == "cached":
            # Check for exact match in cache
            return {"use_cache": True, "cache_key": query}
        
        elif strategy == "hybrid":
            # Use both keyword and vector search
            return {
                "vector_weight": 0.7,
                "keyword_weight": 0.3,
                "top_k": 10
            }
        
        elif strategy == "graph":
            # For relationship queries
            return {
                "use_graph": True,
                "max_hops": 2
            }
        
        else:
            # Standard vector search
            return {"top_k": 5, "min_score": 0.8}
    
    def _select_strategy(self, query: str) -> str:
        # Simple heuristics
        if "who" in query.lower() and "manager" in query.lower():
            return "graph"  # Likely needs relationship traversal
        
        if len(query) < 20:
            return "cached"  # Short queries often repeated
        
        return "hybrid"

class MemoryMetrics:
    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 memory configuration
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"
    }
}

# Medical memory with strict 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
    }
}

# Developer assistant memory
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": [...]
    }
}