┌─────────────────────────────────────────────────────────────────┐
│                    ลำดับชั้นหน่วยความจำของเอเจนต์              │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────┐                   │
│   │  หน่วยความจำระยะสั้น (หน้าต่างบริบท)   │                   │
│   │  - บริบทงานที่ใช้งานอยู่              │                   │
│   │  - 8K-200K token                      │                   │
│   │  - ระยะเวลา: เทิร์นเดียว               │                   │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  หน่วยความจำระยะสั้น (บัฟเฟอร์/แคช)    │                      │
│   │  - เทิร์นสนทนาล่าสุด                  │                      │
│   │  - ชุดข้อมูลที่กำลังใช้งาน           │                      │
│   │  - ระยะเวลา: นาทีถึงชั่วโมง          │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  ความจำเหตุการณ์ (ที่เก็บเหตุการณ์)    │                      │
│   │  - การโต้ตอบและผลลัพธ์ในอดีต         │                      │
│   │  - "เกิดอะไรขึ้นเมื่อ..."              │                      │
│   │  - ระยะเวลา: วันถึงเดือน               │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  ความจำเชิงความหมาย (ฐานความรู้)       │                      │
│   │  - ข้อเท็จจริง แนวคิด เอนทิตี          │                      │
│   │  - "สิ่งที่ฉันรู้เกี่ยวกับ..."          │                      │
│   │  - ระยะเวลา: ไม่จำกัด                 │                      │
│   └──────────────────┬──────────────────────┘                   │
│                      │                                           │
│   ┌──────────────────▼──────────────────────┐                      │
│   │  ความจำเชิงขั้นตอน (ทักษะ/รูปแบบ)     │                      │
│   │  - วิธีการดำเนินงาน                   │                      │
│   │  - กลยุทธ์ที่เรียนรู้                 │                      │
│   │  - ระยะเวลา: ถาวร                     │                      │
│   └─────────────────────────────────────────┘                   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

ข้อความ → โมเดล Embedding → เวกเตอร์ (1536 มิติ)

"ลูกค้าบ่นเกี่ยวกับการจัดส่งที่ช้า"
→ [0.023, -0.156, 0.892, ..., -0.034]  ← การแสดงผลหลายมิติ

"การจัดส่งใช้เวลานานเกินไป"
→ [0.031, -0.142, 0.867, ..., -0.041]  ← เวกเตอร์ที่คล้ายกัน (ใกล้กันในมิติ)

"วันนี้อากาศดี"
→ [-0.754, 0.623, -0.123, ..., 0.901]  ← เวกเตอร์ที่ต่างกัน (ไกลในมิติ)

# รูปแบบหน่วยความจำเวกเตอร์หลัก
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):
        """จัดเก็บความทรงจำใหม่"""
        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):
        """ดึงข้อมูลความทรงจำที่เกี่ยวข้อง"""
        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  # แปลงระยะห่างเป็น relevancy score
            }
            for doc, meta, dist in zip(
                results["documents"][0],
                results["metadatas"][0],
                results["distances"][0]
            )
        ]

# การใช้งาน
memory = VectorMemory()

# จัดเก็บความทรงจำ
memory.add_memory(
    "ลูกค้าชอบอีเมลมากกว่าโทรศัพท์สำหรับปัญหาที่เร่งด่วน",
    metadata={"category": "preference", "source": "interaction_123"}
)

memory.add_memory(
    "วิธีแก้ไขก่อนหน้านี้สำหรับ timeout ฐานข้อมูล: เพิ่ม connection pool",
    metadata={"category": "solution", "issue_type": "performance"}
)

# ดึงข้อมูล
results = memory.recall(
    "ฉันควรติดต่อลูกค้ารายนี้อย่างไร?",
    filters={"category": "preference"}
)
# ส่งคืน: ลูกค้าชอบอีเมลมากกว่าโทรศัพท์สำหรับปัญหาที่เร่งด่วน

┌─────────────────────────────────────────────────────────────────┐
│                        สถาปัตยกรรม MEM0                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                     ชั้น API                             │   │
│   │   add() | get() | update() | delete() | search()     │   │
│   └────────────────────────┬────────────────────────────────┘   │
│                            │                                     │
│   ┌────────────────────────▼────────────────────────────────┐   │
│   │              ชั้นการประมวลผลหน่วยความจำ               │   │
│   │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐      │   │
│   │  │ การแยก      │ │ การเสริม    │ │ การให้คะแนน │      │   │
│   │  │ (จาก LLM)   │ │ (Metadata)  │ │ ความสำคัญ  │      │   │
│   │  └─────────────┘ └─────────────┘ └─────────────┘      │   │
│   └────────────────────────┬────────────────────────────────┘   │
│                            │                                     │
│   ┌────────────────────────▼────────────────────────────────┐   │
│   │                    ชั้นที่เก็บข้อมูล                     │   │
│   │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐      │   │
│   │  │ Vector DB   │ │ Graph DB    │ │ Key-Value   │      │   │
│   │  │ (Semantic)  │ │ (Relations) │ │ (Metadata)  │      │   │
│   │  └─────────────┘ └─────────────┘ └─────────────┘      │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

import mem0

# เริ่มต้น
m = mem0.Memory()

# หน่วยความจำตามผู้ใช้ (คงอยู่ข้ามเซสชั่น)
m.add(
    "ฉันชอบคำตอบทางเทคนิคที่กระชับไม่มีสาระแถม",
    user_id="alice",
    metadata={"type": "preference"}
)

# หน่วยความจำตามเอเจนต์ (พฤติกรรมที่เอเจนต์เรียนรู้)
m.add(
    "ความคิดเห็นการตรวจสอบโค้ดควรมีหมายเลขบรรทัด",
    agent_id="code-reviewer-01",
    metadata={"type": "instruction"}
)

# หน่วยความจำตามเซสชั่น (เฉพาะการสนทนานี้)
m.add(
    "เรากำลังดีบั๊กโมดูลยืนยันตัวตน",
    session_id="session_abc123",
    metadata={"type": "context"}
)

# หน่วยความจำทั่วไป (ใช้กับผู้ใช้/เอเจนต์ทั้งหมด)
m.add(
    "โทนของบริษัทเป็นมืออาชีพแต่เป็นมิตร",
    metadata={"type": "global", "scope": "all"}
)

# Mem0 แยกและจัดหมวดหมู่โดยอัตโนมัติ
memories = m.add(
    """
    กระบวนการ connection pool ของฐานข้อมูลหมดลงทำให้เกิด timeout
    วิธีแก้ไข: เพิ่ม max_connections จาก 100 เป็น 200 และ 
    ใช้ connection pooling ในชั้นแอปพลิเคชัน
    การแก้ไขนี้ลดความล่าช้าได้ 60%
    """,
    user_id="devops-team",
    metadata={"project": "payment-service"}
)

# Mem0 แยก:
# 1. ข้อเท็จจริง: "กระบวนการ connection pool ของฐานข้อมูลหมดลง" → ความจำเชิงความหมาย
# 2. วิธีแก้ไข: "เพิ่ม max_connections จาก 100 เป็น 200" → ความจำเชิงขั้นตอน  
# 3. ผลลัพธ์: "ลดความล่าช้า 60%" → ความจำเหตุการณ์
# 4. เมตริก: "การลดความล่าช้า 60%" → แยกเป็นข้อมูลโครงสร้าง

# Python
pip install mem0ai

# JavaScript/TypeScript
npm install mem0ai

# CLI
pip install mem0ai[cli]

# ตัวเลือก 1: Mem0 Cloud (จัดการ)
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)

# ตัวเลือก 2: Self-hosted กับ 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)

# ตัวเลือก 3: PostgreSQL (pgvector) สำหรับองค์กร
config = {
    "vector_store": {
        "provider": "pgvector",
        "config": {
            "collection_name": "agent_memory",
            "connection_string": "postgresql://user:pass@localhost/dbname"
        }
    }
}

# Mem0 กำหนดคะแนนความสำคัญโดยอัตโนมัติ
# และสามารถลดความทรงจำที่สำคัญน้อยลงตามเวลา

config = {
    "memory": {
        "importance_threshold": 0.7,  # จัดเก็บเฉพาะความทรงจำที่มีคะแนนเหนือค่านี้
        "decay_enabled": True,
        "decay_factor": 0.95,  # ลดลง 5% ต่อวันสำหรับความทรงจำที่สำคัญน้อย
        "max_memories_per_user": 10000,
        "cleanup_interval": 86400  # การทำความสะอาดรายวัน
    }
}

m = mem0.Memory.from_config(config)

# การให้คะแนนความสำคัญด้วยตนเอง
memories = m.add(
    "รหัสผ่านฐานข้อมูลการผลิตของลูกค้าคือ 'TempPass123!'",
    user_id="support",
    metadata={"security_level": "high"}
)
# Mem0 จะทำเครื่องหมายว่ามีความสำคัญสูง (เกี่ยวกับความปลอดภัย)
# แต่คุณอาจต้องการยกเว้นจากหน่วยความจำมาตรฐาน

# การค้นหาหลายเกณฑ์
results = m.search(
    query="ปัญหาฐานข้อมูลคืออะไร?",
    user_id="alice",
    filters={
        "metadata": {
            "category": "technical",
            "priority": {"gte": 3}
        },
        "created_at": {
            "gte": "2026-01-01",
            "lte": "2026-06-26"
        }
    },
    limit=10
)

# การค้นหาด้วยเกณฑ์ความเกี่ยวข้อง
results = m.search(
    query="กลยุทธ์การปรับใช้",
    user_id="alice",
    min_relevance=0.8  # เฉพาะผลลัพธ์ที่มีความเกี่ยวข้องสูง
)

# ความทรงจำสามารถอัปเดตและเวอร์ชันได้
m.add(
    "ช่องทางการติดต่อที่ลูกค้าชอบคืออีเมล",
    user_id="alice",
    memory_id="contact_pref_001"
)

# ภายหลัง: ความชอบเปลี่ยน
m.update(
    memory_id="contact_pref_001",
    data="ช่องทางการติดต่อที่ลูกค้าชอบคือ Slack สำหรับปัญหาที่เร่งด่วน มิฉะนั้นอีเมล"
)

# ดูประวัติ
history = m.history(memory_id="contact_pref_001")
# ส่งคืนเวอร์ชันทั้งหมดพร้อม timestamp

// Node: "จัดเก็บใน Mem0"
// เชื่อมต่อกับ 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: "ดึงข้อมูลจาก Mem0"

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

// ดึงข้อมูลความทรงจำที่เกี่ยวข้อง
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
  }
});

// จัดรูปแบบสำหรับบริบท LLM
const memoryContext = memories.results
  .map(m => `[${m.category}] ${m.memory}`)
  .join("\n");

return [{
  json: {
    userId,
    message: currentMessage,
    memoryContext: memoryContext || "ไม่พบความทรงจำที่เกี่ยวข้อง",
    relevantMemories: memories.results.length
  }
}];

┌─────────────────────────────────────────────────────────────────┐
│                     สถาปัตยกรรม GRAPHITI                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Input: "Alice นำทีม Bob. Bob ทำงานใน Engineering."           │
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │              การสร้าง Knowledge Graph                    │   │
│   │                                                          │   │
│   │   ┌─────────┐        leads        ┌─────────┐           │   │
│   │   │  Alice  │ ───────────────────▶ │   Bob   │           │   │
│   │   └────┬────┘                     └────┬────┘           │   │
│   │        │                               │               │   │
│   │        │                               │               │   │
│   │        │                       works_in│               │   │
│   │        │                               ▼               │   │
│   │        │                         ┌──────────┐          │   │
│   │        └─────────────────────────▶ │Engineering│          │   │
│   │                                  └──────────┘          │   │
│   │                                                          │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │              มิติตามเวลา                               │   │
│   │                                                          │   │
│   │   ข้อเท็จจริง: "Alice นำทีม Bob"                        │   │
│   │   ใช้ตั้งแต่: 15.01.2026                                 │   │
│   │   ใช้จนถึง: 01.06.2026 (Alice ย้ายไปทีมอื่น)              │   │
│   │   ปัจจุบัน: FALSE                                        │   │
│   │                                                          │   │
│   │   ข้อเท็จจริง: "Charlie นำทีม Bob" (ใหม่)                │   │
│   │   ใช้ตั้งแต่: 01.06.2026                                 │   │
│   │   ปัจจุบัน: TRUE                                         │   │
│   │                                                          │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Python SDK
pip install graphiti-core

# Docker Compose สำหรับ Self-Hosting
curl -L https://zep.ai/install.sh | bash

from graphiti_core import Graphiti
from datetime import datetime

# เริ่มต้น
graphiti = Graphiti(
    uri="bolt://localhost:7687",  # Neo4j
    user="neo4j",
    password="password"
)

# สร้างกราฟจาก episode
episode = """
บันทึกการประชุม - 26 มิถุนายน 2026

ผู้เข้าร่วม: Alice (หัวหน้าโครงการ), Bob (วิศวกรรม), Charlie (ผลิตภัณฑ์)

การอภิปราย:
- Alice ประกาศว่าแผนงาน Q3 จะเน้นที่คุณสมบัติ AI
- Bob แสดงความกังวลเกี่ยวกับหนี้เทคนิคในโมดูล auth
- Charlie ขอ engineer เพิ่มอีก 2 คนสำหรับทีม
- การตัดสินใจ: ให้ความสำคัญกับการปรับโครงสร้าง auth ก่อนคุณสมบัติใหม่
- รายการสิ่งที่ต้องทำ:
  * Bob: เตรียมการตรวจสอบ auth ภายในวันที่ 5 กรกฎาคม
  * Alice: จัดสรรงบประมาณสำหรับ engineer 2 คน
  * Charlie: อัปเดตกำหนดเวลาผลิตภัณฑ์
"""

# เพิ่ม episode (แยกเอนทิตี้และความสัมพันธ์โดยอัตโนมัติ)
await graphiti.add_episode(
    name="การประชุมวางแผน Q3",
    episode_body=episode,
    source_description="บันทึกการประชุม",
    reference_time=datetime.now()
)

# สืบค้นกราฟ
# หาว่าใครต้องเตรียมการตรวจสอบ auth
results = await graphiti.search(
    "ใครต้องเตรียมการตรวจสอบ auth?"
)
# ส่งคืน: Bob พร้อมความสัมพันธ์ "responsible_for: auth audit"

# การสืบค้นหลายขั้น: หาบุคคลทั้งหมดที่เกี่ยวข้องกับแผนงาน Q3
results = await graphiti.search(
    "ใครเกี่ยวข้องกับการวางแผนแผนงาน Q3?",
    search_type="traversal"
)
# ส่งคืน: Alice, Bob, Charlie พร้อมบทบาทที่เกี่ยวข้องของแต่ละคน

# การสืบค้นตามเวลา
results = await graphiti.search(
    "ใครเป็นหัวหน้าโครงการในเดือนพฤษภาคม 2026?",
    reference_time=datetime(2026, 5, 15)
)
# ส่งคืนสถานะในอดีต (แม้ว่า Alice จะเปลี่ยนบทบาท)

# การสืบค้นความสัมพันธ์
results = await graphiti.search(
    "ความรับผิดชอบปัจจุบันของ Bob คืออะไร?",
    search_type="neighborhood"
)
# ส่งคืน: auth module (maintains), auth audit (responsible_for)

# การตรวจจับความขัดแย้ง
new_episode = "Alice ประกาศว่าเธอกำลังลาออกจากตำแหน่งหัวหน้าโครงการ"
await graphiti.add_episode(...)

# Graphiti โดยอัตโนมัติ:
# 1. สร้างโหนดใหม่: "Alice → status → ลาออก"
# 2. อัปเดตความถูกต้องตามเวลาของ "Alice เป็นหัวหน้าโครงการ" (ตั้งค่าวันที่สิ้นสุด)
# 3. รักษาทั้งสองข้อเท็จจริงพร้อมระยะเวลาความถูกต้อง

# การประมวลผลแบบ batch สำหรับชุดข้อมูลขนาดใหญ่
episodes = [
    {"name": "การประชุม 1", "body": "...", "time": t1},
    {"name": "การประชุม 2", "body": "...", "time": t2},
    # ... หลายร้อย episode
]

# ประมวลผลเป็น batch แบบขนาน
await graphiti.add_episode_bulk(episodes, batch_size=10)

# การตัดแต่งกราฟเพื่อประสิทธิภาพ
await graphiti.maintain()
# - ลบขอบที่ล้าสมัย
# - บีบอัดโหนดที่ซ้ำซ้อน
# - รักษาความสมบูรณ์ของกราฟ

# การโหลดกราฟแบบเลือก
results = await graphiti.search(
    "แผนงาน Q3",
    nodes_to_exclude=["historical_projects"],
    max_depth=3  # จำกัดความลึกของการวิ่งผ่าน
)

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

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

# การผสานรวมง่ายๆ กับ LangChain
llm = ChatOpenAI(model="gpt-4o")

# ห่อ LLM ด้วยหน่วยความจำ
from langmem import bind_memory

llm_with_memory = bind_memory(
    llm,
    memory=memory,
    strategy="retrieve_and_update"  # อัปเดตหน่วยความจำอัตโนมัติหลังจากการโต้ตอบแต่ละครั้ง
)

# ใช้เหมือน LLM ปกติ
response = await llm_with_memory.ainvoke(
    "วิธีที่ดีที่สุดสำหรับการจัดการข้อผิดพลาดใน code base ของเราคืออะไร?"
)
# ดึงข้อมูลการตัดสินใจที่เกี่ยวข้องจากอดีตจากหน่วยความจำโดยอัตโนมัติ

from langmem import SemanticMemory, EpisodicMemory, ProceduralMemory

# ความจำเชิงความหมาย - ข้อเท็จจริงและแนวคิด
semantic = SemanticMemory()
semantic.add("Tech stack ของเราคือ Python, FastAPI และ PostgreSQL")
semantic.add("เราปฏิบัติตามแนวทาง PEP 8")

# ความจำเหตุการณ์ - เหตุการณ์ในอดีต
episodic = EpisodicMemory()
episodic.add_episode(
    event="เหตุการณ์การผลิตเมื่อวันที่ 15 มิถุนายน 2026",
    outcome="การหมดลงของ connection pool ฐานข้อมูล",
    resolution="เพิ่มขนาด pool จาก 100 เป็น 200",
    lessons_learned="ตรวจสอบเมตริกการเชื่อมต่อแบบขั้นตอน"
)

# ความจำเชิงขั้นตอน - วิธีการทำสิ่งต่างๆ
procedural = ProceduralMemory()
procedural.add_procedure(
    name="deploy_to_production",
    steps=[
        "รัน test suite แบบเต็ม",
        "สร้าง backup ฐานข้อมูล",
        "ปรับใช้ใน staging",
        "รัน smoke tests",
        "ปรับใช้ใน production",
        "ตรวจสอบเป็นเวลา 30 นาที"
    ],
    context="กระบวนการปรับใช้มาตรฐานสำหรับ 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):
    """ดึงข้อมูลความทรงจำที่เกี่ยวข้องสำหรับบริบทปัจจุบัน"""
    recent_messages = state["messages"][-3:]  # 3 ข้อความล่าสุด
    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):
    """อัปเดตหน่วยความจำด้วยการโต้ตอบใหม่"""
    user_message = state["messages"][-2]["content"]  # ข้อความผู้ใช้
    ai_response = state["messages"][-1]["content"]   # คำตอบ AI
    
    memory.add_interaction(
        user_message=user_message,
        ai_response=ai_response,
        user_id=state["user_id"],
        extract_facts=True  # แยกข้อเท็จจริงอัตโนมัติ
    )
    
    return {}

# สร้าง graph
workflow = StateGraph(AgentState)

workflow.add_node("retrieve_memory", retrieve_memory)
workflow.add_node("agent", call_llm)  # โหนด LLM ของคุณ
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: การสนับสนุนลูกค้าที่เพิ่มประสิทธิภาพด้วยหน่วยความจำ │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐                                               │
│  │ Webhook      │ ◄── ข้อความลูกค้า                            │
│  │ (Chat Input) │                                               │
│  └──────┬───────┘                                               │
│         │                                                        │
│         ▼                                                        │
│  ┌────────────────────────────────────────┐                     │
│  │ HTTP Request: ดึงข้อมูลหน่วยความจำ   │                     │
│  │ POST https://api.mem0.ai/v1/search   │                     │
│  │ Body: {                                │                     │
│  │   query: {{$json.message}},            │                     │
│  │   user_id: {{$json.customerId}},       │                     │
│  │   limit: 5                             │                     │
│  │ }                                      │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ Function: สร้างบริบท                   │                     │
│  │ Code:                                  │                     │
│  │ const memories = $json.results;       │                     │
│  │ const context = memories.map(m =>     │                     │
│  │   `[${m.category}] ${m.memory}`        │                     │
│  │ ).join('\n');                          │                     │
│  │ return { context, memories };         │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ OpenAI: สร้างคำตอบ                     │                     │
│  │ Model: gpt-4o                        │                     │
│  │ System Prompt:                         │                     │
│  │ "คุณเป็นตัวแทนสนับสนุนที่เป็นประโยชน์ │                     │
│  │  ใช้บริบทต่อไปนี้เกี่ยวกับ           │                     │
│  │  ลูกค้ารายนี้: {{$json.context}}"      │                     │
│  │                                        │                     │
│  │ User: {{$json.message}}               │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌────────────────────────────────────────┐                     │
│  │ HTTP Request: จัดเก็บหน่วยความจำ       │                     │
│  │ POST /v1/memories/                     │                     │
│  │ Body: {                                │                     │
│  │   messages: [                          │                     │
│  │     {role: "user", content: "..."},    │                     │
│  │     {role: "assistant", content:"..."} │                     │
│  │   ],                                   │                     │
│  │   user_id: "..."                       │                     │
│  │ }                                      │                     │
│  └──────────┬─────────────────────────────┘                     │
│             │                                                      │
│             ▼                                                      │
│  ┌──────────────┐                                               │
│  │ ส่งคำตอบ     │ ──► กลับไปยังลูกค้า                          │
│  └──────────────┘                                               │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// n8n Function Node: การวิจัยด้วยหน่วยความจำ

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;
  
  // ขั้นตอนที่ 1: ดึงข้อมูลการวิจัยก่อนหน้านี้เกี่ยวกับหัวข้อนี้
  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" } }
    }
  });
  
  // ขั้นตอนที่ 2: สร้างแผนการวิจัย
  const planPrompt = `หัวข้อ: ${topic}
ผลการวิจัยก่อนหน้า: ${JSON.stringify(previousResearch.results)}

สร้างแผนการวิจัยที่มุ่งเน้นไปที่แง่มุมใหม่ที่ยังไม่ได้ครอบคลุม`;

  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 }]
    }
  });
  
  // ขั้นตอนที่ 3: ดำเนินการวิจัย (การค้นหาเว็บ การเรียก API ฯลฯ)
  const researchSteps = plan.choices[0].message.content;
  const findings = [];
  
  // ... ดำเนินการวิจัย ...
  
  // ขั้นตอนที่ 4: จัดเก็บผลการวิจัยใหม่
  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 ด้วยหน่วยความจำ

// โหนดนี้ทำงานเมื่อเกิดข้อผิดพลาด
async function errorRecovery() {
  const error = $json.error;
  const workflowId = $execution.workflowId;
  const MEM0_API_KEY = $env.MEM0_API_KEY;
  
  // ขั้นตอนที่ 1: ค้นหาข้อผิดพลาดที่คล้ายกันในอดีต
  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
        }
      }
    }
  });
  
  // ขั้นตอนที่ 2: ลองวิธีแก้ไขก่อนหน้านี้
  for (const solution of similarErrors.results) {
    try {
      const result = await applySolution(solution);
      if (result.success) {
        // บันทึกการกู้คืนที่ประสบความสำเร็จ
        await $httpRequest({
          method: "POST",
          url: "https://api.mem0.ai/v1/memories/",
          headers: { "Authorization": `Token ${MEM0_API_KEY}` },
          body: {
            messages: [{
              role: "assistant",
              content: `ข้อผิดพลาด "${error.message}" แก้ไขแล้วด้วยวิธี: ${solution}`
            }],
            metadata: { 
              type: "successful_recovery",
              error_type: error.type,
              workflow_id: workflowId
            }
          }
        });
        return { json: { recovered: true, method: solution } };
      }
    } catch (e) {
      continue;
    }
  }
  
  // ขั้นตอนที่ 3: ไม่พบวิธีแก้ไข - ส่งต่อไปยังผู้เชี่ยวชาญ
  return { json: { recovered: false, needsEscalation: true } };
}

return [await errorRecovery()];

# skills/memory-agent/SKILL.md
---
name: memory-agent
version: "1.0.0"
memory:
  # ประกาศความต้องการหน่วยความจำ
  stores:
    - name: episodic
      type: vector
      provider: mem0
      scope: user  # หน่วยความจำตามผู้ใช้
      
    - name: semantic
      type: graph
      provider: graphiti
      scope: session  # แชร์ในเซสชั่น
      
    - name: short_term
      type: cache
      provider: redis
      ttl: 3600  # 1 ชั่วโมง

  # กลยุทธ์การดึงข้อมูลหน่วยความจำ
  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) {
      // ขั้นตอนที่ 1: ดึงข้อมูลความทรงจำที่เกี่ยวข้อง
      const memories = await context.memory.retrieve({
        query: message.content,
        userId: message.user_id,
        strategy: "hierarchical"
      });
      
      // ขั้นตอนที่ 2: สร้างคำตอบด้วยบริบทหน่วยความจำ
      const response = await context.llm.generate({
        messages: [
          {
            role: "system",
            content: `บริบทก่อนหน้า:\n${memories.formatted}`
          },
          { role: "user", content: message.content }
        ]
      });
      
      // ขั้นตอนที่ 3: จัดเก็บการโต้ตอบ
      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 โดยใช้ 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) {
    // ลบความทรงจำเฉพาะ
    const memories = await this.retrieve(query, options);
    for (const memory of memories.items) {
      await this.client.delete(memory.id);
    }
  }
}

module.exports = Mem0MemoryProvider;

# ระบบ multi-agent ด้วยหน่วยความจำที่ใช้ร่วมกัน
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]

# การค้นหาความรู้เชิงความหมาย
async def retrieve_knowledge(query, user_id):
    # เข้ารหัส query เป็นเวกเตอร์
    query_embedding = encoder.encode(query)
    
    # ค้นหาหน่วยความจำเชิงความหมาย
    results = vector_db.search(
        vector=query_embedding,
        filter={"memory_type": "semantic"},
        top_k=5
    )
    
    # จัดลำดับใหม่ตามความเกี่ยวข้องกับบริบทปัจจุบัน
    reranked = rerank_by_context(
        results, 
        current_conversation
    )
    
    return reranked

# ตัวอย่าง: "เราใช้ฐานข้อมูลอะไร?"
# ส่งคืน: "Tech stack ของเรารวมถึง PostgreSQL 15 พร้อมส่วนขยาย pgvector"

# ความจำเหตุการณ์ - "เกิดอะไรขึ้น"
async def retrieve_episodes(query, user_id, temporal_filters=None):
    # ค้นหาด้วยการถ่วงน้ำหนักตามเวลา
    results = vector_db.search(
        query=query,
        filter={
            "memory_type": "episodic",
            "user_id": user_id,
            **temporal_filters
        },
        top_k=10
    )
    
    # จัดเรียงตามความใหม่และความเกี่ยวข้อง
    scored = [
        {
            **result,
            "score": relevance_score * recency_decay(result.timestamp)
        }
        for result in results
    ]
    
    return sorted(scored, key=lambda x: x["score"], reverse=True)[:5]

# ตัวอย่าง: "เราพบปัญหาฐานข้อมูลครั้งล่าสุดเมื่อไหร่?"
# ส่งคืน: "15 มิถุนายน: การหมดลงของ connection pool ฐานข้อมูล..."

# ความจำเชิงขั้นตอน - ทักษะและขั้นตอน
async def retrieve_procedure(task_description):
    # จับคู่กับขั้นตอนที่รู้จัก
    procedures = procedure_library.search(
        task_description,
        threshold=0.8
    )
    
    if procedures:
        # ส่งคืนขั้นตอนที่ตรงกันที่สุด
        return {
            "type": "procedure",
            "steps": procedures[0].steps,
            "context": procedures[0].context
        }
    
    # ไม่มีการจับคู่ที่แน่นอน - ลองประกอบจาก sub-procedures
    sub_procedures = decompose_task(task_description)
    composed = compose_procedure(sub_procedures)
    
    return {
        "type": "composed_procedure",
        "steps": composed.steps
    }

# ตัวอย่าง: "ฉันจะปรับใช้ใน production ได้อย่างไร?"
# ส่งคืนขั้นตอนโครงสร้างพร้อมขั้นตอน

async def hybrid_retrieval(query, user_id):
    # ดึงข้อมูลแบบขนานจากทุกประเภทหน่วยความจำ
    [semantic_results, episodic_results, procedural_results] = await Promise.all([
        retrieve_semantic(query),
        retrieve_episodic(query, user_id),
        retrieve_procedural(query)
    ])
    
    # ถ่วงน้ำหนักตามประเภทหน่วยความจำตาม 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]
    
    # รวมและจัดลำดับใหม่
    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):
        """ลงทะเบียนเอเจนต์ในระบบ"""
        self.agent_directory[agent_id] = {
            "expertise": expertise,
            "memory_store": memory_store,
            "last_active": datetime.now()
        }
    
    def store_memory(self, agent_id, content, metadata):
        """เอเจนต์จัดเก็บใน store ส่วนตัวของตน"""
        memory_id = self.agent_directory[agent_id]["memory_store"].add(
            content, metadata
        )
        
        # อัปเดต meta-memory เกี่ยวกับสิ่งที่เอเจนต์นี้รู้
        self._update_meta_memory(agent_id, metadata.get("topics", []))
        
        return memory_id
    
    def retrieve_memory(self, query, requesting_agent):
        """ดึงข้อมูลหน่วยความจำจากแหล่งที่ดีที่สุด"""
        # ขั้นตอนที่ 1: ตรวจสอบว่าเอเจนต์ที่ขอมีหน่วยความจำที่เกี่ยวข้องหรือไม่
        local = self._query_agent_memory(requesting_agent, query)
        if local and max(r.score for r in local) > 0.9:
            return local
        
        # ขั้นตอนที่ 2: สืบค้น meta-memory ว่าเอเจนต์ใดอาจรู้
        relevant_agents = self._find_experts(query)
        
        # ขั้นตอนที่ 3: สืบค้นเอเจนต์ที่เกี่ยวข้อง
        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
                ])
        
        # ขั้นตอนที่ 4: ส่งคืนผลลัพธ์ที่รวมกัน
        return sorted(results, key=lambda x: x["score"], reverse=True)
    
    def _find_experts(self, query):
        """หาเอเจนต์ที่มีความเชี่ยวชาญที่เกี่ยวข้อง"""
        # การใช้งานอย่างง่าย: ตรวจสอบความซ้อนทับของความเชี่ยวชาญ
        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:
        """รับความทรงจำใหม่เข้าสู่ pipeline"""
        
        # ขั้นตอนที่ 1: สร้าง ID ที่ไม่ซ้ำ
        memory_id = self._generate_id(content, metadata)
        
        # ขั้นตอนที่ 2: ทำความสะอาดและตรวจสอบ
        clean_content = self._sanitize(content)
        if not self._validate(clean_content):
            raise ValueError("Content validation failed")
        
        # ขั้นตอนที่ 3: แยกเอนทิตี้และความสัมพันธ์ (สำหรับ graph)
        entities = self.processor.extract_entities(clean_content)
        relationships = self.processor.extract_relationships(clean_content, entities)
        
        # ขั้นตอนที่ 4: คำนวณคะแนนความสำคัญ
        importance = self.processor.score_importance(clean_content, metadata)
        
        # ขั้นตอนที่ 5: สร้าง embedding
        embedding = await self.embedder.embed(clean_content)
        
        # ขั้นตอนที่ 6: สร้าง 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
        )
        
        # ขั้นตอนที่ 7: จัดเก็บแบบขนาน
        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]:
        """ดึงข้อมูลความทรงจำที่เกี่ยวข้อง"""
        
        # ขั้นตอนที่ 1: ตรวจสอบ cache ก่อน
        cache_key = self._cache_key(query, filters)
        cached = await self.cache.get(cache_key)
        if cached:
            return cached
        
        # ขั้นตอนที่ 2: สร้าง query embedding
        query_embedding = await self.embedder.embed(query)
        
        # ขั้นตอนที่ 3: ค้นหาเวกเตอร์
        vector_results = await self.vector_store.search(
            query_embedding,
            filters=filters,
            top_k=top_k * 2  # Over-fetch สำหรับ re-ranking
        )
        
        # ขั้นตอนที่ 4: จัดลำดับใหม่ตามความเกี่ยวข้องและความใหม่
        ranked = self._rerank(vector_results, query)
        
        # ขั้นตอนที่ 5: เสริมด้วยความสัมพันธ์ของกราฟ
        enriched = await self._enrich_with_graph(ranked[:top_k])
        
        # ขั้นตอนที่ 6: Cache ผลลัพธ์
        await self.cache.set(cache_key, enriched, ttl=300)
        
        return enriched
    
    async def forget(self, query: str, filters: Optional[dict] = None):
        """ลืม (ลบ) ความทรงจำที่ตรงกัน"""
        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:
        """สร้าง ID แบบ deterministic"""
        key = f"{content}:{json.dumps(metadata, sort_keys=True)}"
        return hashlib.sha256(key.encode()).hexdigest()[:16]
    
    def _sanitize(self, content: str) -> str:
        """ลบ PII และเนื้อหาที่เป็นอันตราย"""
        # ใช้งานการตรวจจับและลบ PII
        # นี่คือเวอร์ชันที่ง่าย
        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]:
        """จัดลำดับผลลัพธ์ตามความเกี่ยวข้องและความใหม่"""
        scored = []
        for r in results:
            # รวมคะแนนเชิงความหมายกับความใหม่และความสำคัญ
            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]

# ระบบจัดหมวดหมู่หน่วยความจำ
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:
        """จัดหมวดหมู่เนื้อหาหน่วยความจำสำหรับการจัดการที่ปลอดภัย"""
        
        classification = {
            "pii_detected": [],
            "sensitivity": "low",
            "encryption_required": False,
            "retention_days": 365,
            "access_controls": ["owner"]
        }
        
        # ตรวจสอบ PII
        for pattern, pii_type in self.pii_patterns:
            if re.search(pattern, content):
                classification["pii_detected"].append(pii_type)
        
        # ตรวจสอบความละเอียดอ่อน
        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
        
        # ปรับตาม PII
        if classification["pii_detected"]:
            classification["sensitivity"] = "high"
            classification["access_controls"].append("gdpr_compliant")
        
        return classification
    
    def sanitize(self, content: str) -> str:
        """ลบหรือซ่อนข้อมูลที่ละเอียดอ่อน"""
        sanitized = content
        
        # ซ่อน PII
        for pattern, pii_type in self.pii_patterns:
            sanitized = pattern.sub(f"[{pii_type}_REDACTED]", sanitized)
        
        return sanitized

# ใช้ใน memory pipeline
classifier = MemoryClassifier()

async def secure_ingest(content, metadata):
    # จัดหมวดหมู่ก่อนจัดเก็บ
    classification = classifier.classify(content)
    
    if classification["sensitivity"] == "high":
        # ทำความสะอาดหรือปฏิเสธ
        if "password" in content.lower():
            raise SecurityError("ไม่สามารถจัดเก็บรหัสผ่านในหน่วยความจำได้")
        
        content = classifier.sanitize(content)
        metadata["classification"] = classification
        
        # เข้ารหัสก่อนจัดเก็บ
        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):
        # เข้ารหัสเนื้อหา
        encrypted = self.cipher.encrypt(content.encode()).decode()
        
        # จัดเก็บแบบเข้ารหัส
        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
        
        # ถอดรหัส
        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
    ):
        # รับสิทธิ์หน่วยความจำของผู้ใช้
        permissions = await self.auth.get_permissions(user_id)
        
        # สร้างตัวกรองตามสิทธิ์
        access_filter = {
            "$or": [
                {"owner": user_id},
                {"shared_with": user_id},
                {"visibility": "public"}
            ]
        }
        
        # ใช้ตัวกรองของผู้ใช้
        combined_filters = {"$and": [access_filter, filters or {}]}
        
        # บันทึกการเข้าถึง
        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]:
        # ลอง L1 ก่อน
        if key in self.l1:
            return self.l1[key]
        
        # ลอง L2
        l2_value = await self.l2.get(key)
        if l2_value:
            # ส่งขึ้นไป L1
            self.l1[key] = l2_value
            return l2_value
        
        # ลอง L3
        l3_value = await self.l3.get(key)
        if l3_value:
            # ส่งขึ้นไป L1 และ 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:
        # กำหนดกลยุทธ์การดึงข้อมูลที่เหมาะสมที่สุด
        strategy = self._select_strategy(query)
        
        if strategy == "cached":
            # ตรวจสอบการตรงกันใน cache
            return {"use_cache": True, "cache_key": query}
        
        elif strategy == "hybrid":
            # ใช้ทั้ง keyword และ vector search
            return {
                "vector_weight": 0.7,
                "keyword_weight": 0.3,
                "top_k": 10
            }
        
        elif strategy == "graph":
            # สำหรับการสืบค้นความสัมพันธ์
            return {
                "use_graph": True,
                "max_hops": 2
            }
        
        else:
            # การค้นหาเวกเตอร์มาตรฐาน
            return {"top_k": 5, "min_score": 0.8}
    
    def _select_strategy(self, query: str) -> str:
        # ใช้การวิเคราะห์แบบง่าย
        if "who" in query.lower() and "manager" in query.lower():
            return "graph"  # อาจต้องการการวิ่งผ่านความสัมพันธ์
        
        if len(query) < 20:
            return "cached"  # query สั้นมักถูกทำซ้ำ
        
        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()
        }

# การกำหนดค่าหน่วยความจำเอเจนต์สนับสนุน
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"
    }
}

# ความจำทางการแพทย์ด้วยการปฏิบัติตามที่เข้มงวด
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_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": [...]
    }
}