Memory & State -- לגרום לסוכנים לזכור

from collections import deque
from anthropic import Anthropic

class SlidingWindowMemory:
    """Keep the last N messages in the conversation."""

    def __init__(self, window_size: int = 20):
        self.messages = deque(maxlen=window_size)
        self.system_prompt = "You are a helpful assistant."

    def add_message(self, role: str, content: str):
        self.messages.append({"role": role, "content": content})

    def get_messages(self) -> list[dict]:
        return list(self.messages)

    def chat(self, user_input: str) -> str:
        self.add_message("user", user_input)

        client = Anthropic()
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=self.system_prompt,
            messages=self.get_messages()
        )

        assistant_reply = response.content[0].text
        self.add_message("assistant", assistant_reply)
        return assistant_reply

# Usage
memory = SlidingWindowMemory(window_size=10)
print(memory.chat("My name is Yael"))        # Knows the name
print(memory.chat("What is my name?"))        # "Your name is Yael"
# After 10+ exchanges, early messages are dropped

import { generateText } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';

interface Message {
  role: 'user' | 'assistant';
  content: string;
}

class SlidingWindowMemory {
  private messages: Message[] = [];
  private windowSize: number;

  constructor(windowSize: number = 20) {
    this.windowSize = windowSize;
  }

  addMessage(role: 'user' | 'assistant', content: string): void {
    this.messages.push({ role, content });
    // Trim to window size
    if (this.messages.length > this.windowSize) {
      this.messages = this.messages.slice(-this.windowSize);
    }
  }

  async chat(userInput: string): Promise<string> {
    this.addMessage('user', userInput);

    const { text } = await generateText({
      model: anthropic('claude-sonnet-4-20250514'),
      system: 'You are a helpful assistant.',
      messages: this.messages,
    });

    this.addMessage('assistant', text);
    return text;
  }
}

// Usage
const memory = new SlidingWindowMemory(10);
await memory.chat("My name is Yael");
await memory.chat("What is my name?"); // "Your name is Yael"

from anthropic import Anthropic

class SummaryMemory:
    """Periodically summarize old messages to save context space."""

    def __init__(self, max_messages: int = 10, summary_threshold: int = 8):
        self.messages: list[dict] = []
        self.summary: str = ""
        self.max_messages = max_messages
        self.summary_threshold = summary_threshold
        self.client = Anthropic()

    def _summarize(self):
        """Summarize old messages and replace them with the summary."""
        old_messages = self.messages[:self.summary_threshold]
        conversation_text = "\n".join(
            f"{m['role']}: {m['content']}" for m in old_messages
        )

        prompt = f"""Summarize this conversation concisely.
Keep: key facts, user preferences, decisions made, action items.
Drop: greetings, filler, repeated information.

Previous summary: {self.summary or 'None'}

New conversation:
{conversation_text}

Write a concise summary (max 200 words):"""

        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=300,
            messages=[{"role": "user", "content": prompt}]
        )
        self.summary = response.content[0].text
        # Keep only recent messages
        self.messages = self.messages[self.summary_threshold:]

    def get_messages(self) -> list[dict]:
        msgs = []
        if self.summary:
            msgs.append({
                "role": "user",
                "content": f"[Previous conversation summary: {self.summary}]"
            })
            msgs.append({
                "role": "assistant",
                "content": "I understand the context from our previous conversation. How can I help?"
            })
        msgs.extend(self.messages)
        return msgs

    def chat(self, user_input: str) -> str:
        self.messages.append({"role": "user", "content": user_input})

        # Summarize if we hit the threshold
        if len(self.messages) >= self.max_messages:
            self._summarize()

        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system="You are a helpful assistant. Use the conversation summary for context.",
            messages=self.get_messages()
        )

        reply = response.content[0].text
        self.messages.append({"role": "assistant", "content": reply})
        return reply

import tiktoken  # or anthropic's token counter

class TokenAwareMemory:
    """Keep messages within a token budget, prioritizing recent ones."""

    def __init__(self, max_tokens: int = 4000):
        self.messages: list[dict] = []
        self.max_tokens = max_tokens
        self.encoder = tiktoken.encoding_for_model("gpt-4")  # rough estimate

    def _count_tokens(self, messages: list[dict]) -> int:
        return sum(
            len(self.encoder.encode(m["content"])) + 4  # role overhead
            for m in messages
        )

    def _truncate(self) -> list[dict]:
        """Remove oldest messages until within token budget."""
        msgs = list(self.messages)
        while self._count_tokens(msgs) > self.max_tokens and len(msgs) > 2:
            # Always keep the first message (often contains key context)
            # and remove from position 1
            msgs.pop(1)
        return msgs

    def add_message(self, role: str, content: str):
        self.messages.append({"role": role, "content": content})

    def get_messages(self) -> list[dict]:
        return self._truncate()

# pip install chromadb openai anthropic

import chromadb
from openai import OpenAI
from anthropic import Anthropic

# 1. Setup: Create vector store and add documents
chroma_client = chromadb.Client()
collection = chroma_client.create_collection(
    name="knowledge_base",
    metadata={"hnsw:space": "cosine"}
)

# 2. Add documents (chunked)
documents = [
    "AI agents use tools to interact with external systems. "
    "Tools are functions the agent can call with specific parameters.",

    "The ReAct pattern combines reasoning and acting. "
    "The agent thinks about what to do, acts, observes the result, "
    "and repeats until the task is complete.",

    "MCP (Model Context Protocol) is an open standard for connecting "
    "AI agents to tools and data sources. It works like USB-C for AI.",

    "Vector databases store embeddings -- numerical representations "
    "of text. Similar texts produce similar vectors, enabling "
    "semantic search beyond keyword matching.",

    "RAG (Retrieval-Augmented Generation) retrieves relevant documents "
    "and adds them to the prompt before generating an answer. "
    "This grounds the response in actual data."
]

# Add with auto-generated embeddings (ChromaDB uses its own by default)
collection.add(
    documents=documents,
    ids=[f"doc_{i}" for i in range(len(documents))]
)

# 3. RAG query function
def rag_query(question: str, n_results: int = 3) -> str:
    """Search knowledge base and generate answer."""

    # Retrieve relevant chunks
    results = collection.query(
        query_texts=[question],
        n_results=n_results
    )

    # Build context from retrieved documents
    context = "\n\n".join(results["documents"][0])

    # Generate answer with retrieved context
    client = Anthropic()
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system="""Answer the user's question based on the provided context.
If the context doesn't contain the answer, say so honestly.
Always indicate which parts of your answer come from the context.""",
        messages=[{
            "role": "user",
            "content": f"""Context from knowledge base:
---
{context}
---

Question: {question}"""
        }]
    )
    return response.content[0].text

# Usage
answer = rag_query("What is the ReAct pattern?")
print(answer)

answer = rag_query("How does MCP work?")
print(answer)

// npm install ai @ai-sdk/anthropic @supabase/supabase-js

import { generateText, embed } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { openai } from '@ai-sdk/openai';
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_KEY!
);

// 1. Embed and store a document chunk
async function addDocument(content: string, metadata: Record<string, any>) {
  const { embedding } = await embed({
    model: openai.embedding('text-embedding-3-small'),
    value: content,
  });

  await supabase.from('documents').insert({
    content,
    metadata,
    embedding,
  });
}

// 2. Search for relevant documents
async function searchDocuments(query: string, limit = 3) {
  const { embedding } = await embed({
    model: openai.embedding('text-embedding-3-small'),
    value: query,
  });

  const { data } = await supabase.rpc('match_documents', {
    query_embedding: embedding,
    match_threshold: 0.7,
    match_count: limit,
  });

  return data;
}

// 3. RAG query
async function ragQuery(question: string): Promise<string> {
  const docs = await searchDocuments(question);
  const context = docs.map((d: any) => d.content).join('\n\n');

  const { text } = await generateText({
    model: anthropic('claude-sonnet-4-20250514'),
    system: `Answer based on the provided context.
If the context doesn't cover the question, say so.`,
    prompt: `Context:\n${context}\n\nQuestion: ${question}`,
  });

  return text;
}

import sqlite3
import json
from anthropic import Anthropic

class PersistentAgent:
    """Agent that remembers user preferences across sessions."""

    def __init__(self, db_path: str = "agent_memory.db"):
        self.db = sqlite3.connect(db_path)
        self._init_db()
        self.client = Anthropic()

    def _init_db(self):
        self.db.execute("""
            CREATE TABLE IF NOT EXISTS preferences (
                user_id TEXT,
                key TEXT,
                value TEXT,
                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                PRIMARY KEY (user_id, key)
            )
        """)
        self.db.execute("""
            CREATE TABLE IF NOT EXISTS interactions (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                user_id TEXT,
                role TEXT,
                content TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        """)
        self.db.commit()

    def get_preferences(self, user_id: str) -> dict:
        rows = self.db.execute(
            "SELECT key, value FROM preferences WHERE user_id = ?",
            (user_id,)
        ).fetchall()
        return {k: v for k, v in rows}

    def save_preference(self, user_id: str, key: str, value: str):
        self.db.execute(
            """INSERT OR REPLACE INTO preferences (user_id, key, value)
               VALUES (?, ?, ?)""",
            (user_id, key, value)
        )
        self.db.commit()

    def chat(self, user_id: str, message: str) -> str:
        # Load user preferences
        prefs = self.get_preferences(user_id)
        prefs_text = "\n".join(f"- {k}: {v}" for k, v in prefs.items())

        # Build system prompt with preferences
        system = f"""You are a helpful assistant with memory.

User preferences (learned from past interactions):
{prefs_text or "No preferences saved yet."}

IMPORTANT: When the user expresses a preference, respond to their
message AND output a JSON block to save it:
SAVE_PREFERENCE: {{"key": "preference_name", "value": "preference_value"}}

Examples of preferences to save:
- Language preference, response style, name, interests, timezone"""

        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            system=system,
            messages=[{"role": "user", "content": message}]
        )

        reply = response.content[0].text

        # Extract and save any preferences from the response
        if "SAVE_PREFERENCE:" in reply:
            lines = reply.split("\n")
            for line in lines:
                if "SAVE_PREFERENCE:" in line:
                    json_str = line.split("SAVE_PREFERENCE:")[1].strip()
                    try:
                        pref = json.loads(json_str)
                        self.save_preference(user_id, pref["key"], pref["value"])
                    except json.JSONDecodeError:
                        pass
            # Clean the response
            reply = reply.split("SAVE_PREFERENCE:")[0].strip()

        return reply

# Usage -- Session 1
agent = PersistentAgent()
agent.chat("user_123", "Hi! I'm Yael, I prefer responses in Hebrew")
agent.chat("user_123", "I'm a data engineer at a startup in Tel Aviv")

# Session 2 (even after restart!)
agent2 = PersistentAgent()  # new instance, same DB
response = agent2.chat("user_123", "Can you help me?")
# Agent knows: name=Yael, language=Hebrew, role=data engineer, location=Tel Aviv

from langgraph.graph import StateGraph, MessagesState
from langgraph.checkpoint.sqlite import SqliteSaver

# Create a checkpointer -- state saved to SQLite automatically
checkpointer = SqliteSaver.from_conn_string("agent_state.db")

# Define your graph
graph = StateGraph(MessagesState)
# ... add nodes and edges ...
app = graph.compile(checkpointer=checkpointer)

# Every invocation automatically saves state
config = {"configurable": {"thread_id": "user_123_session_1"}}

# First interaction
result = app.invoke(
    {"messages": [{"role": "user", "content": "Start a research task"}]},
    config=config
)

# Later -- even after restart -- resume from where we stopped
result = app.invoke(
    {"messages": [{"role": "user", "content": "Continue the research"}]},
    config=config  # same thread_id = resume state
)

import os
from anthropic import Anthropic

class ClaudeMdAgent:
    """Agent that uses a memory file, like Claude Code's CLAUDE.md."""

    def __init__(self, memory_file: str = "AGENT_MEMORY.md"):
        self.memory_file = memory_file
        self.client = Anthropic()

    def _read_memory(self) -> str:
        if os.path.exists(self.memory_file):
            with open(self.memory_file, "r") as f:
                return f.read()
        return "# Agent Memory\n\nNo memories saved yet.\n"

    def _write_memory(self, content: str):
        with open(self.memory_file, "w") as f:
            f.write(content)

    def chat(self, user_message: str) -> str:
        memory = self._read_memory()

        system = f"""You are a helpful assistant with persistent memory.

Your memory file contains what you've learned about this user and project:
---
{memory}
---

When you learn something new and important, include a MEMORY_UPDATE block:
MEMORY_UPDATE:
```
[Updated markdown content for the memory file]
```

Only update memory for genuinely important things:
- User preferences and personal info
- Project context and decisions
- Learned rules ("user doesn't like X")
- Important outcomes and results

Do NOT update memory for trivial exchanges."""

        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            system=system,
            messages=[{"role": "user", "content": user_message}]
        )

        reply = response.content[0].text

        # Extract and save memory updates
        if "MEMORY_UPDATE:" in reply:
            parts = reply.split("```")
            for i, part in enumerate(parts):
                if i > 0 and i % 2 == 1:  # content between ``` markers
                    self._write_memory(part.strip())
                    break
            reply = reply.split("MEMORY_UPDATE:")[0].strip()

        return reply

import { generateText, tool } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { z } from 'zod';
import fs from 'fs/promises';

// Memory storage (could be Redis, DB, etc.)
const memoryStore = new Map<string, string>();

const memoryTools = {
  save_memory: tool({
    description: `Save an important fact or preference to long-term memory.
Use this when the user shares something worth remembering across sessions:
names, preferences, project context, important decisions.
Do NOT save trivial conversation details.`,
    parameters: z.object({
      key: z.string().describe('A descriptive key, e.g., "user_name" or "preferred_language"'),
      value: z.string().describe('The value to remember'),
      category: z.enum(['preference', 'fact', 'decision', 'rule']),
    }),
    execute: async ({ key, value, category }) => {
      memoryStore.set(key, JSON.stringify({ value, category, savedAt: new Date() }));
      return `Saved: ${key} = ${value}`;
    },
  }),

  recall_memory: tool({
    description: `Retrieve a specific memory by key, or list all memories.
Use this at the start of a conversation or when you need context.`,
    parameters: z.object({
      key: z.string().optional().describe('Specific key to retrieve, or omit for all'),
    }),
    execute: async ({ key }) => {
      if (key) {
        const val = memoryStore.get(key);
        return val ? JSON.parse(val) : `No memory found for key: ${key}`;
      }
      // Return all memories
      const all: Record<string, any> = {};
      for (const [k, v] of memoryStore) {
        all[k] = JSON.parse(v);
      }
      return Object.keys(all).length > 0 ? all : 'No memories saved yet.';
    },
  }),

  forget_memory: tool({
    description: `Delete a specific memory. Use when the user asks you to forget something.`,
    parameters: z.object({
      key: z.string().describe('The key to forget'),
    }),
    execute: async ({ key }) => {
      memoryStore.delete(key);
      return `Forgotten: ${key}`;
    },
  }),
};

// Usage
const { text } = await generateText({
  model: anthropic('claude-sonnet-4-20250514'),
  tools: memoryTools,
  maxSteps: 5,
  system: `You have memory tools. At the start of each conversation,
recall all memories to understand the user's context.
Save important new information as you learn it.`,
  prompt: 'Hi! I\'m Yael, a data engineer. I prefer Hebrew responses.',
});

from anthropic import Anthropic
from datetime import datetime

class AutoSummarizer:
    """Automatically summarize and store session history."""

    def __init__(self):
        self.client = Anthropic()
        self.summaries: list[dict] = []  # In production: use a database

    def summarize_session(self, messages: list[dict]) -> str:
        conversation = "\n".join(
            f"{m['role']}: {m['content']}" for m in messages
        )

        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=500,
            messages=[{
                "role": "user",
                "content": f"""Summarize this conversation session.
Extract:
1. Key topics discussed
2. Decisions made
3. User preferences learned
4. Action items / next steps
5. Important facts mentioned

Conversation:
{conversation}

Structured summary:"""
            }]
        )

        summary = response.content[0].text
        self.summaries.append({
            "date": datetime.now().isoformat(),
            "summary": summary,
            "message_count": len(messages)
        })
        return summary

    def get_context_for_new_session(self, last_n: int = 3) -> str:
        """Get recent session summaries for a new session."""
        recent = self.summaries[-last_n:]
        return "\n\n".join(
            f"[Session {s['date']}]\n{s['summary']}" for s in recent
        )

from dataclasses import dataclass
from anthropic import Anthropic
import json

@dataclass
class Triple:
    subject: str
    relation: str
    object: str

class SimpleKnowledgeGraph:
    """Lightweight knowledge graph for agent memory."""

    def __init__(self):
        self.triples: list[Triple] = []
        self.client = Anthropic()

    def add(self, subject: str, relation: str, obj: str):
        # Update existing or add new
        for t in self.triples:
            if t.subject == subject and t.relation == relation:
                t.object = obj  # Update
                return
        self.triples.append(Triple(subject, relation, obj))

    def query(self, subject: str = None, relation: str = None) -> list[Triple]:
        results = self.triples
        if subject:
            results = [t for t in results if t.subject.lower() == subject.lower()]
        if relation:
            results = [t for t in results if t.relation == relation]
        return results

    def extract_triples_from_text(self, text: str) -> list[Triple]:
        """Use LLM to extract entities and relationships from text."""
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            messages=[{
                "role": "user",
                "content": f"""Extract entity relationships from this text.
Return JSON array of triples: [{{"subject": "...", "relation": "...", "object": "..."}}]
Use simple relation names: works_at, located_in, manages, knows, prefers, etc.

Text: {text}

JSON:"""
            }]
        )
        try:
            triples_data = json.loads(response.content[0].text)
            return [Triple(**t) for t in triples_data]
        except (json.JSONDecodeError, KeyError):
            return []

    def to_context_string(self) -> str:
        """Format graph as context for the agent's prompt."""
        if not self.triples:
            return "No relationships stored yet."
        return "\n".join(
            f"- {t.subject} --[{t.relation}]--> {t.object}"
            for t in self.triples
        )

# Usage
kg = SimpleKnowledgeGraph()
new_triples = kg.extract_triples_from_text(
    "Yael is a data engineer at TechCo in Tel Aviv. Dan manages Yael."
)
for t in new_triples:
    kg.add(t.subject, t.relation, t.object)

# Query
print(kg.query(subject="Yael"))
# [Triple(subject='Yael', relation='works_at', object='TechCo'),
#  Triple(subject='Yael', relation='located_in', object='Tel Aviv')]

print(kg.to_context_string())
# - Yael --[works_at]--> TechCo
# - Yael --[located_in]--> Tel Aviv
# - TechCo --[located_in]--> Tel Aviv
# - Dan --[manages]--> Yael

# pip install letta

from letta import create_client

# Create Letta client
client = create_client()

# Create an agent with memory
agent = client.create_agent(
    name="memory_agent",
    memory_human="User name: unknown. Preferences: unknown.",
    memory_persona="I am a helpful assistant with persistent memory.",
    model="claude-sonnet-4-20250514"
)

# Chat -- Letta manages memory automatically
response = client.send_message(
    agent_id=agent.id,
    message="Hi, I'm Yael! I work in data engineering."
)
# Letta automatically updates core memory:
# memory_human now includes "User name: Yael. Work: data engineering."

# Later session -- memory persists
response = client.send_message(
    agent_id=agent.id,
    message="What do you remember about me?"
)
# "I remember you're Yael and you work in data engineering!"

# pip install mem0ai

from mem0 import Memory

# Initialize Mem0
m = Memory()

# Add memories (Mem0 extracts and manages them automatically)
m.add(
    "I'm Yael, a data engineer in Tel Aviv. "
    "I prefer Hebrew responses and concise answers.",
    user_id="yael_123"
)

m.add(
    "We decided to use PostgreSQL for the project, "
    "not MongoDB. The team agreed on March 15.",
    user_id="yael_123"
)

# Search memories
results = m.search("What database did we choose?", user_id="yael_123")
# Returns: "PostgreSQL, decided on March 15"

# Get all memories for a user
all_memories = m.get_all(user_id="yael_123")
# Returns structured list of all stored memories

# Memories evolve -- if you add contradicting info, Mem0 updates
m.add("Actually, we switched from PostgreSQL to Supabase", user_id="yael_123")
# Previous PostgreSQL memory is updated, not duplicated

from anthropic import Anthropic
import chromadb
import json

# Setup vector store (same as before)
chroma = chromadb.Client()
kb = chroma.get_or_create_collection("knowledge_base")

# Define tools for the agent
tools = [
    {
        "name": "search_knowledge_base",
        "description": """Search the internal knowledge base for relevant information.
Use this when the user asks about topics that might be in our documents.
Do NOT use this for general knowledge questions you can answer directly.""",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "The search query"
                },
                "n_results": {
                    "type": "integer",
                    "description": "Number of results to retrieve (default: 3)",
                    "default": 3
                }
            },
            "required": ["query"]
        }
    },
    {
        "name": "search_again_with_refinement",
        "description": """Search the knowledge base again with a refined query.
Use this when the first search didn't return good results.
Rephrase the query to find what you need.""",
        "input_schema": {
            "type": "object",
            "properties": {
                "original_query": {"type": "string"},
                "refined_query": {"type": "string"},
                "reason": {
                    "type": "string",
                    "description": "Why you're refining the search"
                }
            },
            "required": ["original_query", "refined_query"]
        }
    }
]

def handle_tool_call(name: str, input_data: dict) -> str:
    if name == "search_knowledge_base":
        results = kb.query(
            query_texts=[input_data["query"]],
            n_results=input_data.get("n_results", 3)
        )
        return json.dumps({
            "documents": results["documents"][0],
            "distances": results["distances"][0]
        })
    elif name == "search_again_with_refinement":
        results = kb.query(
            query_texts=[input_data["refined_query"]],
            n_results=3
        )
        return json.dumps({
            "documents": results["documents"][0],
            "distances": results["distances"][0],
            "refinement_reason": input_data.get("reason", "")
        })

def agentic_rag(question: str) -> str:
    client = Anthropic()
    messages = [{"role": "user", "content": question}]

    # Agentic loop -- agent decides whether/when to search
    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            system="""You are a knowledgeable assistant with access to a knowledge base.
For questions about specific internal topics, search the knowledge base first.
For general knowledge questions, answer directly.
If search results are poor, try refining your query.
Always be honest about what you found vs what you already know.""",
            tools=tools,
            messages=messages
        )

        # If the agent wants to use a tool
        if response.stop_reason == "tool_use":
            tool_block = next(
                b for b in response.content if b.type == "tool_use"
            )
            result = handle_tool_call(tool_block.name, tool_block.input)

            messages.append({"role": "assistant", "content": response.content})
            messages.append({
                "role": "user",
                "content": [{
                    "type": "tool_result",
                    "tool_use_id": tool_block.id,
                    "content": result
                }]
            })
        else:
            # Agent is done -- return the final answer
            return response.content[0].text

import sqlite3
import json
from datetime import datetime

class PrivacyAwareMemory:
    """Memory store with built-in privacy controls."""

    def __init__(self, db_path: str = "agent_memory.db"):
        self.db = sqlite3.connect(db_path)
        self.db.execute("""
            CREATE TABLE IF NOT EXISTS memories (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                user_id TEXT NOT NULL,
                key TEXT NOT NULL,
                value TEXT NOT NULL,
                source TEXT DEFAULT 'user',  -- 'user', 'agent', 'document'
                pii_level TEXT DEFAULT 'none',  -- 'none', 'low', 'high'
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                expires_at TIMESTAMP,  -- TTL for auto-cleanup
                UNIQUE(user_id, key)
            )
        """)
        self.db.commit()

    def save(self, user_id: str, key: str, value: str,
             source: str = "user", pii_level: str = "none",
             ttl_days: int = None):
        expires = None
        if ttl_days:
            from datetime import timedelta
            expires = (datetime.now() + timedelta(days=ttl_days)).isoformat()

        self.db.execute(
            """INSERT OR REPLACE INTO memories
               (user_id, key, value, source, pii_level, expires_at)
               VALUES (?, ?, ?, ?, ?, ?)""",
            (user_id, key, value, source, pii_level, expires)
        )
        self.db.commit()

    def delete_all_for_user(self, user_id: str) -> int:
        """GDPR Right to Deletion -- delete all memories for a user."""
        cursor = self.db.execute(
            "DELETE FROM memories WHERE user_id = ?", (user_id,)
        )
        self.db.commit()
        return cursor.rowcount

    def export_for_user(self, user_id: str) -> list[dict]:
        """GDPR Data Export -- return all memories as JSON."""
        rows = self.db.execute(
            "SELECT key, value, source, pii_level, created_at FROM memories WHERE user_id = ?",
            (user_id,)
        ).fetchall()
        return [
            {"key": r[0], "value": r[1], "source": r[2],
             "pii_level": r[3], "created_at": r[4]}
            for r in rows
        ]

    def cleanup_expired(self) -> int:
        """Remove memories past their TTL."""
        cursor = self.db.execute(
            "DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?",
            (datetime.now().isoformat(),)
        )
        self.db.commit()
        return cursor.rowcount

# Usage
mem = PrivacyAwareMemory()
mem.save("user_123", "name", "Yael", pii_level="low")
mem.save("user_123", "temp_context", "working on report",
         ttl_days=7)  # Auto-expires in 7 days

# GDPR compliance
all_data = mem.export_for_user("user_123")  # Data export
mem.delete_all_for_user("user_123")         # Right to deletion