┌─────────────────────────────────────────────────────────────────┐
│                 โหมดหน่วยความจำ AI Agent ของ n8n               │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐         │
│  │    Window    │  │    Buffer    │  │    Session   │         │
│  │    Memory    │  │    Memory    │  │    Memory    │         │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘         │
│         │                 │                 │                  │
│         ▼                 ▼                 ▼                  │
│  จำนวนข้อความ      ประวัติไม่จำกัด    คงทนข้ามการดำเนิน      │
│  ล่าสุดคงที่       ด้วยขีดจำกัด token  การงานหลายครั้ง       │
│                                                                  │
│  เหมาะสำหรับ:      เหมาะสำหรับ:      เหมาะสำหรับ:               │
│  - Chatbots        - บทสนทนา        - กระบวนการ               │
│  - ระบบ Q&A         - ยาวนาน          - หลายวัน                  │
│  - การสอบถาม       - งานวิเคราะห์      - เวิร์กโฟลว์ผู้ใช้      │
│    รวดเร็ว                                                       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    รูปแบบ Window Memory                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ขนาดหน้าต่าง: 10 ข้อความ                                     │
│                                                                  │
│  เวลา ──────────────────────────────────────────▶              │
│                                                                  │
│  [M1] [M2] [M3] [M4] [M5] [M6] [M7] [M8] [M9] [M10]           │
│   ✓    ✓    ✓    ✓    ✓    ✓    ✓    ✓    ✓    ✓               │
│                                                                  │
│  [M2] [M3] [M4] [M5] [M6] [M7] [M8] [M9] [M10] [M11]          │
│   ✗    ✓    ✓    ✓    ✓    ✓    ✓    ✓    ✓    ✓               │
│        ▲                                                       │
│        M1 ถูกลบเมื่อ M11 มาถึง                                  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

{
  "memoryMode": "window",
  "windowSize": 10,        // จำนวนคู่ข้อความที่จะเก็บไว้
  "sessionKey": "{{ $json.userId }}",  // ตัวระบุที่ไม่ซ้ำกัน
  "storage": "redis"       // หรือ "postgres", "memory"
}

{
  "windowSize": 10,
  "sessionKey": "{{ $json.userId }}",
  "storage": "redis",
  "contextCompression": true,     // สรุปบริบทที่เก่ากว่า
  "includeSystemMessages": true,  // เก็บ system prompts ไว้
  "tokenBudget": 4000             // ทางเลือกแทนการนับข้อความ
}

{
  "name": "Window Memory Node",
  "type": "@n8n/n8n-nodes-langchain.memoryManager",
  "typeVersion": 1.2,
  "position": [420, 340],
  "parameters": {
    "mode": "window",
    "options": {
      "sessionId": "={{ $json.userId }}",
      "sessionKey": "={{ $json.userId }}",
      "windowLength": 10
    }
  },
  "credentials": {
    "redis": {
      "id": "redis-prod-credentials",
      "name": "Redis Production"
    }
  }
}

{
  "name": "Customer Support กับ Window Memory",
  "nodes": [
    {
      "parameters": {
        "sessionKey": "={{ $json.body.userId }}",
        "windowSize": 8,
        "storage": "redis"
      },
      "type": "@n8n/n8n-nodes-langchain.memoryManager",
      "typeVersion": 1.2,
      "position": [420, 240]
    },
    {
      "parameters": {
        "model": "gpt-4o",
        "options": {
          "temperature": 0.7
        }
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "typeVersion": 1.1,
      "position": [620, 240]
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "คุณเป็นตัวแทนสนับสนุนลูกค้าที่เป็นประโยชน์ ใช้ประวัติการสนทนาเพื่อให้คำตอบที่ตระหนักถึงบริบท เมื่อผู้ใช้อ้างถึง 'มัน' หรือ 'ปัญหานี้' ให้ใช้บริบทปัจจุบันเพื่อเข้าใจว่าหมายถึงอะไร"
        }
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7,
      "position": [820, 240]
    },
    {
      "parameters": {
        "documentId": "={{ $json.body.userId }}_chat_history",
        "content": "={{ JSON.stringify($json.conversation) }}"
      },
      "type": "n8n-nodes-base.redis",
      "typeVersion": 1.1,
      "position": [1020, 240]
    }
  ],
  "connections": {
    "When webhook received": {
      "main": [
        [
          {
            "node": "Window Memory Node",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

// ปัญหา: หน้าต่าง 2 ข้อความสูญเสียบริบททันที
"windowSize": 2

// ผู้ใช้: "ฉันมีปัญหากับการสมัครสมาชิก"
// ผู้ช่วย: "ฉันสามารถช่วยได้ หมายเลขการสมัครสมาชิกของคุณคืออะไร?"
// ผู้ใช้: "คือ SUB-12345"
// ผู้ช่วย: "เรากำลังพูดถึงการสมัครสมาชิกใด?" // บริบทหาย!

// ปัญหา: ผู้ใช้หลายคนแชร์เซสชันเดียวกัน
"sessionKey": "chat_session"

// วิธีแก้: Session keys ที่ไม่ซ้ำกัน
"sessionKey": "={{ $json.userId || $json.sessionId }}"

// ปัญหา: 20 ข้อความ × 500 tokens = 10K tokens
// เกินขีดจำกัดจริง 8K ของ GPT-4o สำหรับการตอบสนอง

// วิธีแก้: ใช้งบ token
"tokenBudget": 6000,
"windowSize": "auto" // คำนวณตามงบ token

┌─────────────────────────────────────────────────────────────────┐
│                    รูปแบบ Buffer Memory                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Buffer รักษาประวัติที่สมบูรณ์ด้วยการจัดการที่ชาญฉลาด:         │
│                                                                  │
│  ประวัติต้นฉบับ:                                                │
│  [M1] [M2] [M3] [M4] [M5] ... [M47] [M48] [M49] [M50]         │
│                                                                  │
│  ถึงขีดจำกัด Token ──────────────────────────▶                │
│                                                                  │
│  กลยุทธ์:                                                         │
│                                                                  │
│  1. สรุปข้อความที่เก่าที่สุด:                                 │
│     [สรุป(M1-M40)] [M41] [M42] [M43] [M44] [M45] [M46]         │
│     [M47] [M48] [M49] [M50]                                      │
│                                                                  │
│  2. เก็บระบบ + N ล่าสุด:                                        │
│     [SYSTEM] [M40] [M41] [M42] [M43] [M44] [M45] [M46] [M47]   │
│     [M48] [M49] [M50]                                            │
│                                                                  │
│  3. ลบคู่ผู้ใช้/ผู้ช่วยที่เก่าที่สุด:                          │
│     [M10] [M11] [M12] ... [M50]                                  │
│     [M1-M9 ถูกลบเพื่อให้พอดีกับงบ token]                       │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

{
  "memoryMode": "buffer",
  "returnAllMessages": true,  // ดึงประวัติทั้งหมด
  "sessionKey": "{{ $json.userId }}",
  "storage": "postgres"
}

{
  "memoryMode": "buffer",
  "returnAllMessages": true,
  "sessionKey": "={{ $json.userId }}",
  "storage": "postgres",
  "bufferStrategy": "summarize",     // "truncate", "summarize", "compress"
  "maxTokenLimit": 12000,
  "summarizationModel": "gpt-4o-mini", // สำหรับสรุป
  "keepSystemMessages": true,
  "compressionThreshold": 8000       // เริ่มบีบอัดที่จำนวน token นี้
}

{
  "name": "Buffer Memory พร้อมการสรุป",
  "type": "@n8n/n8n-nodes-langchain.memoryManager",
  "typeVersion": 1.2,
  "parameters": {
    "mode": "buffer",
    "options": {
      "returnAllMessages": true,
      "sessionId": "={{ $json.sessionId }}",
      "sessionKey": "={{ $json.sessionId }}",
      "bufferStrategy": "summarize",
      "maxTokenLimit": 10000,
      "postgresOptions": {
        "tableName": "conversation_buffer",
        "schema": "ai_memory"
      }
    }
  },
  "credentials": {
    "postgres": {
      "id": "postgres-prod-credentials",
      "name": "PostgreSQL Production"
    }
  }
}

{
  "name": "ผู้ช่วยการวิจัยกับ Buffer Memory",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "research-chat",
        "responseMode": "responseNode"
      },
      "id": "webhook-trigger",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1.1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "mode": "buffer",
        "options": {
          "sessionId": "={{ $('Webhook').item.json.body.sessionId }}",
          "returnAllMessages": true,
          "bufferStrategy": "summarize",
          "maxTokenLimit": 12000
        }
      },
      "type": "@n8n/n8n-nodes-langchain.memoryManager",
      "typeVersion": 1.2,
      "position": [440, 300]
    },
    {
      "parameters": {
        "model": "claude-sonnet-4.6",
        "options": {
          "temperature": 0.3,
          "maxTokens": 4000
        }
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatAnthropic",
      "typeVersion": 1.1,
      "position": [640, 300]
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "คุณเป็นผู้ช่วยการวิจัยที่จดจำบทสนทนาทั้งหมดของเราได้อย่างสมบูรณ์แบบ รักษาบันทึกรายละเอียดเกี่ยวกับข้อค้นพบสำคัญ สมมติฐานที่อภิปราย และทิศทางการวิจัย อ้างอิงถึงจุดก่อนหน้าเฉพาะเมื่อเกี่ยวข้อง",
          "maxIterations": 5
        }
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7,
      "position": [840, 300]
    },
    {
      "parameters": {
        "mode": "runOnceForAllItems",
        "jsCode": "// เก็บถาวรบทสนทนาใน PostgreSQL\nconst { Pool } = require('pg');\n\nconst pool = new Pool({\n  connectionString: $credentials.postgres.connectionString\n});\n\nconst result = await pool.query(\n  `INSERT INTO research_conversations (session_id, messages, updated_at)\n   VALUES ($1, $2, NOW())\n   ON CONFLICT (session_id)\n   DO UPDATE SET messages = $2, updated_at = NOW()`,\n  [$input.first().json.sessionId, JSON.stringify($input.first().json.messages)]\n);\n\nreturn { success: true, rowsAffected: result.rowCount };"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [1040, 300]
    }
  ]
}

// ลบข้อความที่เก่าที่สุดเพื่อให้พอดีกับงบ token
{
  "bufferStrategy": "truncate",
  "maxTokenLimit": 8000,
  "preserveSystemMessages": true  // เก็บ system prompts เสมอ
}

// กระบวนการ: ถ้าประวัติเกิน 8000 tokens ให้ลบคู่ที่เก่าที่สุด
// จนกว่าจะต่ำกว่าขีดจำกัด

// สร้างสรุป AI ของส่วนบทสนทนาที่เก่ากว่า
{
  "bufferStrategy": "summarize",
  "maxTokenLimit": 10000,
  "summarizationThreshold": 6000,  // เริ่มสรุปที่ 6K tokens
  "summarizationModel": "gpt-4o-mini"  // ถูกกว่าสำหรับสรุป
}

// กระบวนการ:
// 1. เก็บ N ข้อความล่าสุดตามตัวอักษร (บริบทล่าสุด)
// 2. สรุปส่วนที่เก่ากว่าด้วย LLM
// 3. นำเสนอ: [สรุป] + [ข้อความล่าสุด]

// ใช้เทคนิคการบีบอัดเวกเตอร์
{
  "bufferStrategy": "compress",
  "compressionModel": "embedding-model",
  "decompressionOnRetrieval": true
}

// กระบวนการ:
// 1. บีบอัดข้อความที่เก่ากว่าเป็นการแสดงเวกเตอร์
// 2. เก็บพร้อม metadata
// 3. ดึงและคลายการบีบอัดเมื่อเกี่ยวข้อง

// คำนวณขีดจำกัด token ที่ปลอดภัย
const modelMaxTokens = 128000; // Claude Sonnet 4.6
const systemPromptTokens = 1500;
const safetyBuffer = 4000; // สำหรับการสร้างคำตอบ
const maxHistoryTokens = modelMaxTokens - systemPromptTokens - safetyBuffer;

// ผลลัพธ์: ~122K tokens สำหรับประวัติ
// แต่ขีดจำกัดจริงต่ำกว่ามากสำหรับความหน่วง
const practicalLimit = 15000; // 15K tokens สำหรับเวลาตอบสนอง <3 วินาที

-- สกีมาที่ปรับให้เหมาะสมสำหรับ Buffer Memory
CREATE SCHEMA IF NOT EXISTS ai_memory;

CREATE TABLE ai_memory.buffer_conversations (
    id SERIAL PRIMARY KEY,
    session_key VARCHAR(255) UNIQUE NOT NULL,
    user_id VARCHAR(255),
    conversation_json JSONB NOT NULL,
    token_count INTEGER,
    message_count INTEGER,
    last_message_at TIMESTAMP DEFAULT NOW(),
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW()
);

-- ดัชนีเพื่อประสิทธิภาพ
CREATE INDEX idx_buffer_session ON ai_memory.buffer_conversations(session_key);
CREATE INDEX idx_buffer_user ON ai_memory.buffer_conversations(user_id);
CREATE INDEX idx_buffer_updated ON ai_memory.buffer_conversations(updated_at);

-- การล้างข้อมูลอัตโนมัติของเซสชันเก่า
CREATE INDEX idx_buffer_cleanup ON ai_memory.buffer_conversations(last_message_at);

┌─────────────────────────────────────────────────────────────────┐
│                   รูปแบบ Session Memory                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  การทำงาน Workflow 1 (วันที่ 1, 09:00 น.):                    │
│  ┌────────────────────────────────────────┐                    │
│  │  ผู้ใช้: "เริ่มกระบวนการ onboarding"    │                    │
│  │  → สถานะเซสชัน: {                      │                    │
│  │      stage: "personal_info",            │                    │
│  │      data: { name: "สมชาย" },           │                    │
│  │      startedAt: "2026-06-20T09:00:00"   │                    │
│  │    }                                    │                    │
│  └────────────────────────────────────────┘                    │
│                              │                                   │
│                              ▼                                   │
│                    ┌─────────────────┐                         │
│                    │  Redis/Postgres │                         │
│                    │  Session Store    │                         │
│                    └────────┬────────┘                         │
│                             │                                    │
│  การทำงาน Workflow 2 (วันที่ 1, 14:00 น.):                    │
│  ┌────────────────────────────────────────┐                    │
│  │  ผู้ใช้: "ดำเนินการ onboarding ต่อ"     │                    │
│  │  → ดึงสถานะจากที่เก็บข้อมูล         │                    │
│  │  → สถานะเซสชัน: {                      │                    │
│  │      stage: "employment_info",          │                    │
│  │      data: {                            │                    │
│  │        name: "สมชาย",                   │                    │
│  │        email: "[email protected]"     │                    │
│  │      },                                 │                    │
│  │      startedAt: "2026-06-20T09:00:00"   │                    │
│  │    }                                    │                    │
│  └────────────────────────────────────────┘                    │
│                                                                  │
│  การทำงาน Workflow 3 (วันที่ 3, 10:00 น.):                    │
│  ┌────────────────────────────────────────┐                    │
│  │  ผู้ใช้: "เสร็จสิ้นการสมัครของฉัน"       │                    │
│  │  → ดึงสถานะ (5 ชั่วโมงต่อมา)          │                    │
│  │  → สถานะเซสชัน: {                      │                    │
│  │      stage: "complete",                 │                    │
│  │      data: { ...การสมัครที่สมบูรณ์... }, │                    │
│  │      startedAt: "2026-06-20T09:00:00",   │                    │
│  │      completedAt: "2026-06-22T10:00:00"   │                    │
│  │    }                                    │                    │
│  └────────────────────────────────────────┘                    │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

{
  "memoryMode": "session",
  "sessionKey": "{{ $json.userId }}_{{ $json.processType }}",
  "ttl": 2592000,  // 30 วันเป็นวินาที
  "storage": "redis",
  "stateSchema": {
    "stage": "string",
    "data": "object",
    "metadata": "object"
  }
}

{
  "memoryMode": "session",
  "sessionKey": "={{ $json.userId }}_onboarding",
  "ttl": 604800,  // 7 วัน
  "storage": "redis",
  "stateSchema": {
    "type": "object",
    "properties": {
      "currentStep": { "type": "string" },
      "collectedData": { "type": "object" },
      "validationStatus": { "type": "object" },
      "timestamp": { "type": "string" },
      "version": { "type": "number" }
    },
    "required": ["currentStep", "collectedData"]
  },
  "autoCheckpoint": true,  // บันทึกสถานะหลังจากแต่ละ node
  "checkpointInterval": 300,  // ทุก 5 นาที
  "encryption": {
    "enabled": true,
    "keyId": "session-encryption-key"
  }
}

{
  "name": "Onboarding Session Memory",
  "type": "@n8n/n8n-nodes-langchain.memoryManager",
  "typeVersion": 1.2,
  "parameters": {
    "mode": "session",
    "options": {
      "sessionId": "={{ $json.userId }}_onboarding",
      "sessionKey": "={{ $json.userId }}_onboarding",
      "ttl": 604800,
      "storage": "redis",
      "stateKey": "onboarding_state"
    }
  },
  "credentials": {
    "redis": {
      "id": "redis-session-store",
      "name": "Redis Session Store"
    }
  }
}

{
  "name": "การสมัครหลายวันกับ Session Memory",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "application",
        "responseMode": "responseNode"
      },
      "id": "webhook-trigger",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1.1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "jsCode": "// สร้างหรือดึง session ID\nconst userId = $('Webhook').item.json.body.userId;\nconst action = $('Webhook').item.json.body.action;\n\n// ตรวจสอบเซสชันที่มีอยู่\nconst sessionKey = `${userId}_application`;\n\nreturn [{\n  json: {\n    userId,\n    action,\n    sessionKey,\n    input: $('Webhook').item.json.body.data\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [440, 300]
    },
    {
      "parameters": {
        "command": "get",
        "key": "={{ $json.sessionKey }}",
        "options": {}
      },
      "type": "n8n-nodes-base.redis",
      "typeVersion": 1.1,
      "position": [640, 300]
    },
    {
      "parameters": {
        "mode": "runOnceForAllItems",
        "jsCode": "// กำหนดขั้นตอนถัดไปตามสถานะปัจจุบัน\nconst action = $('Code').item.json.action;\nconst existingSession = $('Redis').item.json.value;\n\nlet sessionState = existingSession ? JSON.parse(existingSession) : {\n  currentStep: 'welcome',\n  data: {},\n  startedAt: new Date().toISOString(),\n  history: []\n};\n\n// ตรรกะ state machine\nconst stateMachine = {\n  welcome: { next: 'personal_info', required: [] },\n  personal_info: { next: 'employment_info', required: ['name', 'email'] },\n  employment_info: { next: 'documents', required: ['company', 'role'] },\n  documents: { next: 'review', required: ['resume_url'] },\n  review: { next: 'complete', required: ['confirmed'] },\n  complete: { next: null, required: [] }\n};\n\n// ประมวลผลการดำเนินการปัจจุบัน\nif (action === 'submit') {\n  const currentStep = sessionState.currentStep;\n  const input = $('Code').item.json.input;\n  \n  // ตรวจสอบฟิลด์ที่จำเป็น\n  const stepConfig = stateMachine[currentStep];\n  const missingFields = stepConfig.required.filter(f => !input[f]);\n  \n  if (missingFields.length === 0) {\n    // ดำเนินการไปยังขั้นตอนถัดไป\n    sessionState.data = { ...sessionState.data, ...input };\n    sessionState.history.push({\n      step: currentStep,\n      data: input,\n      timestamp: new Date().toISOString()\n    });\n    \n    if (stepConfig.next) {\n      sessionState.currentStep = stepConfig.next;\n    } else {\n      sessionState.completed = true;\n      sessionState.completedAt = new Date().toISOString();\n    }\n  } else {\n    sessionState.error = `ฟิลด์ที่จำเป็นขาดหายไป: ${missingFields.join(', ')}`;\n  }\n}\n\nreturn [{ json: sessionState }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [840, 300]
    },
    {
      "parameters": {
        "command": "set",
        "key": "={{ $('Code').item.json.sessionKey }}",
        "value": "={{ JSON.stringify($json) }}",
        "options": {
          "expire": true,
          "ttl": 604800
        }
      },
      "type": "n8n-nodes-base.redis",
      "typeVersion": 1.1,
      "position": [1040, 300]
    },
    {
      "parameters": {
        "model": "gpt-4o",
        "options": {
          "temperature": 0.7
        }
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "typeVersion": 1.1,
      "position": [1240, 300]
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "คุณเป็นผู้ช่วยการสมัคร ให้คำแนะนำที่เป็นประโยชน์ตามขั้นตอนปัจจุบันในกระบวนการสมัครของผู้ใช้ และถามข้อมูลที่จำเป็นถัดไป"
        }
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7,
      "position": [1440, 300]
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify({\n  success: true,\n  currentStep: $('Code1').item.json.currentStep,\n  completed: $('Code1').item.json.completed || false,\n  message: $input.first().json.output,\n  progress: calculateProgress($('Code1').item.json)\n}) }}"
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1,
      "position": [1640, 300]
    }
  ]
}

// บันทึก checkpoints ที่ขั้นตอนที่สำคัญ
{
  "checkpointStrategy": "step_completion",
  "checkpointsToKeep": 5,  // เก็ checkpoints ล่าสุด 5 รายการ
  "autoRollback": true    // ย้อนกลับเมื่อล้มเหลว
}

// โครงสร้างเซสชันพร้อม checkpoints
{
  "currentStep": "documents",
  "data": { ... },
  "checkpoints": [
    { "step": "welcome", "data": {}, "timestamp": "..." },
    { "step": "personal_info", "data": {...}, "timestamp": "..." },
    { "step": "employment_info", "data": {...}, "timestamp": "..." }
  ],
  "currentCheckpoint": 2
}

// TTL แบบไดนามิกตามระยะกระบวนการ
const getTTL = (step) => {
  const ttls = {
    welcome: 3600,        // 1 ชั่วโมง - เริ่มต้นอย่างรวดเร็ว
    personal_info: 86400, // 24 ชั่วโมง - รวบรวมข้อมูล
    documents: 604800,      // 7 วัน - อัปโหลดภายนอก
    review: 172800,       // 48 ชั่วโมง - เวลาตัดสินใจ
    complete: 3600        // 1 ชั่วโมง - การล้างข้อมูลสุดท้าย
  };
  return ttls[step] || 86400;
};

// อัปเดต TTL ในแต่ละการโต้ตอบ
"ttl": "={{ getTTL($json.currentStep) }}"

// สำหรับเวิร์กโฟลว์การอนุมัติที่มีผู้มีส่วนได้ส่วนเสียหลายคน
{
  "sessionKey": "approval_{{ $json.processId }}",
  "participantTracking": true,
  "participants": {
    "requester": "user_123",
    "approver": "user_456",
    "reviewer": "user_789"
  },
  "requiredApprovals": 2,
  "currentApprovals": 1
}

// เทมเพลตสำหรับ session keys ที่สอดคล้องกัน
const sessionKeyTemplates = {
  // กระบวนการเฉพาะผู้ใช้
  onboarding: (userId) => `${userId}_onboarding`,
  
  // กระบวนการที่แชร์กัน
  approval: (processId) => `approval_${processId}`,
  
  // เซสชันที่มีขอบเขตเวลา
  dailyReport: (userId, date) => `${userId}_daily_${date}`,
  
  // หลายมิติ
  project: (userId, projectId) => `${userId}_${projectId}_context`
};

// ตรวจสอบโครงสร้างสถานะเซสชัน
const validateState = (state) => {
  const required = ['currentStep', 'data', 'startedAt'];
  const missing = required.filter(f => !(f in state));
  
  if (missing.length > 0) {
    throw new Error(`สถานะเซสชันไม่ถูกต้อง ขาด: ${missing.join(', ')}`);
  }
  
  return true;
};

// การจัดการเซสชันที่หมดอายุอย่างสง่างาม
const recoverSession = async (sessionKey) => {
  try {
    const session = await redis.get(sessionKey);
    if (!session) {
      return {
        recovered: false,
        message: "เซสชันหมดอายุ เริ่มต้นใหม่",
        newSession: initializeSession()
      };
    }
    return { recovered: true, session: JSON.parse(session) };
  } catch (error) {
    return {
      recovered: false,
      error: error.message,
      newSession: initializeSession()
    };
  }
};

┌─────────────────────────────────────────────────────────────────┐
│                 Backend การจัดเก็บหน่วยความจำ                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    IN-MEMORY                           │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │  การคงทน: ❌ ไม่มี (ต่อการดำเนินการเดียว)            │   │
│  │  ประสิทธิภาพ: ⚡ เร็วที่สุด (ไม่มีการเรียกเครือข่าย)  │   │
│  │  ความจุ: จำกัดตามหน่วยความจำ container                │   │
│  │  กรณีใช้งาน: การสร้างต้นแบบ, workflows ครั้งเดียว     │   │
│  │  ต้นทุน: $ (รวมอยู่แล้ว)                                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                              │                                   │
│                              ▼                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                      REDIS                              │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │  การคงทน: ✅ เป็นตัวเลือก (RDB/AOF)                    │   │
│  │  ประสิทธิภาพ: ⚡ เร็วมาก (ความหน่วง sub-ms)          │   │
│  │  ความจุ: จำกัดตามหน่วยความจำ Redis                    │   │
│  │  กรณีใช้งาน: Production, แชทเรียลไทม์, เซสชัน         │   │
│  │  ต้นทุน: $$ (managed service)                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                              │                                   │
│                              ▼                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                   POSTGRESQL                            │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │  การคงทน: ✅ สอดคล้องกับ ACID                        │   │
│  │  ประสิทธิภาพ: 🟡 ดี (เครือข่าย + ดิสก์)               │   │
│  │  ความจุ: บนดิสก์ (ไม่จำกัดทางปฏิบัติ)              │   │
│  │  กรณีใช้งาน: Audit trails, การปฏิบัติตาม, การวิเคราะห์│   │
│  │  ต้นทุน: $$ (managed service)                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

{
  "storage": "memory",
  "options": {
    "maxSize": "100mb"  // ขีดจำกัดหน่วยความจำตัวเลือก
  }
}

// In-Memory สูญเสียข้อมูลเมื่อเสร็จสมบูรณ์
const workflow = {
  trigger: "webhook",
  memory: { mode: "window", storage: "memory" },
  // หลังจากส่งการตอบสนองแล้ว memory จะถูกลบ
  // คำขอถัดไปเริ่มต้นใหม่
};

{
  "storage": "redis",
  "credentials": {
    "redis": {
      "host": "redis.internal",
      "port": 6379,
      "database": 0,
      "password": "{{ $env.REDIS_PASSWORD }}"
    }
  },
  "options": {
    "ttl": 86400,  // TTL เริ่มต้น 24 ชั่วโมง
    "keyPrefix": "n8n_memory:",
    "compression": true
  }
}

// การกำหนดค่า Redis ที่ปรับให้เหมาะสม
{
  "redisOptions": {
    "poolSize": 10,          // ขนาด connection pool
    "maxRetries": 3,         // ลองการดำเนินการที่ล้มเหลวอีกครั้ง
    "retryDelay": 100,       // ms ระหว่างความพยายาม
    "enableOfflineQueue": false,  // ล้มเหลวอย่างรวดเร็วหาก Redis down
    "lazyConnect": true      // เชื่อมต่อเมื่อใช้ครั้งแรก
  }
}

{
  "storage": "postgres",
  "credentials": {
    "postgres": {
      "host": "postgres.internal",
      "port": 5432,
      "database": "n8n_memory",
      "user": "n8n_user",
      "password": "{{ $env.POSTGRES_PASSWORD }}"
    }
  },
  "options": {
    "tableName": "conversation_memory",
    "schema": "ai_memory",
    "jsonbColumn": "data",
    "indexJson": true
  }
}

-- โครงสร้างตารางที่ปรับให้เหมาะสมสำหรับ n8n memory
CREATE SCHEMA IF NOT EXISTS ai_memory;

CREATE TABLE ai_memory.conversations (
    id BIGSERIAL PRIMARY KEY,
    session_key VARCHAR(512) NOT NULL,
    memory_type VARCHAR(50) NOT NULL,  -- 'window', 'buffer', 'session'
    conversation_data JSONB NOT NULL,
    metadata JSONB DEFAULT '{}',
    token_count INTEGER,
    message_count INTEGER DEFAULT 0,
    created_at TIMESTAMP DEFAULT NOW(),
    updated_at TIMESTAMP DEFAULT NOW(),
    expires_at TIMESTAMP,
    
    -- Constraints
    CONSTRAINT unique_session UNIQUE (session_key)
);

-- ดัชนีประสิทธิภาพ
CREATE INDEX idx_conversations_session ON ai_memory.conversations(session_key);
CREATE INDEX idx_conversations_type ON ai_memory.conversations(memory_type);
CREATE INDEX idx_conversations_updated ON ai_memory.conversations(updated_at);
CREATE INDEX idx_conversations_expires ON ai_memory.conversations(expires_at);

-- ดัชนี GIN สำหรับการ query JSONB
CREATE INDEX idx_conversations_data_gin ON ai_memory.conversations 
USING GIN (conversation_data);

-- การแบ่งพาร์ติชันสำหรับการ deploy ขนาดใหญ่
CREATE TABLE ai_memory.conversations_2026_06 PARTITION OF ai_memory.conversations
    FOR VALUES FROM ('2026-06-01') TO ('2026-07-01');

// เข้าถึงได้อย่างรวดเร็วสำหรับข้อมูลล่าสุด (Redis)
// การเก็บระยะกลาง (PostgreSQL)
// เก็บถาวรสำหรับการปฏิบัติตาม (S3/ Glacier)

const hybridStorage = {
  hot: {
    backend: "redis",
    ttl: 86400,  // 24 ชั่วโมง
    maxSize: "1gb"
  },
  warm: {
    backend: "postgres",
    retention: 90,  // วัน
    compression: true
  },
  cold: {
    backend: "s3",
    archiveAfter: 90,  // วัน
    glacierAfter: 365    // วัน
  }
};

{
  "name": "ตัวจัดการ Memory แบบไฮบริด",
  "type": "n8n-nodes-base.code",
  "parameters": {
    "jsCode": "// ตรวจสอบ Redis ก่อน (hot)\nconst redis = require('redis');\nconst { Pool } = require('pg');\n\nconst sessionKey = $input.first().json.sessionKey;\n\n// ลอง Redis\nconst redisClient = redis.createClient($credentials.redis);\nlet data = await redisClient.get(sessionKey);\n\nif (data) {\n  return [{\n    json: {\n      source: 'redis',\n      data: JSON.parse(data),\n      latency: 'low'\n    }\n  }];\n}\n\n// ตกกลับไปที่ PostgreSQL (warm)\nconst pool = new Pool($credentials.postgres);\nconst result = await pool.query(\n  'SELECT conversation_data FROM ai_memory.conversations WHERE session_key = $1',\n  [sessionKey]\n);\n\nif (result.rows.length > 0) {\n  // ส่งเสริมไปยัง Redis สำหรับการเข้าถึงครั้งถัดไป\n  await redisClient.setex(sessionKey, 86400, JSON.stringify(result.rows[0].conversation_data));\n  \n  return [{\n    json: {\n      source: 'postgres',\n      data: result.rows[0].conversation_data,\n      latency: 'medium'\n    }\n  }];\n}\n\n// ไม่พบข้อมูล\nreturn [{\n  json: {\n    source: null,\n    data: null,\n    message: 'ไม่พบเซสชัน'\n  }\n}];"
  }
}

{
  "name": "E-commerce Support Bot",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "support-chat",
        "responseMode": "responseNode"
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "mode": "window",
        "options": {
          "sessionId": "={{ $('Webhook').item.json.body.userId }}",
          "sessionKey": "={{ $('Webhook').item.json.body.userId }}_support",
          "windowLength": 12
        }
      },
      "type": "@n8n/n8n-nodes-langchain.memoryManager",
      "typeVersion": 1.2,
      "credentials": {
        "redis": {
          "id": "redis-prod"
        }
      }
    },
    {
      "parameters": {
        "model": "gpt-4o",
        "options": {
          "temperature": 0.6,
          "maxTokens": 1500
        }
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "คุณเป็นตัวแทนสนับสนุนลูกค้าที่เป็นประโยชน์สำหรับแพลตฟอร์ม E-commerce คุณมีการเข้าถึงประวัติการสนทนา เมื่อผู้ใช้อ้างถึง 'คำสั่งซื้อของฉัน' หรือ 'สินค้านั้น' ให้ใช้ประวัติการสนทนาเพื่อเข้าใจว่าพวกเขาหมายถึงอะไร",
          "maxIterations": 3
        }
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify({ response: $input.first().json.output, sessionId: $('Webhook').item.json.body.userId }) }}"
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1
    }
  ],
  "connections": {
    "Webhook": {
      "main": [
        [
          {
            "node": "Window Memory",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

{
  "name": "ผู้ช่วยการวิจัย",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "research",
        "responseMode": "responseNode"
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "mode": "buffer",
        "options": {
          "sessionId": "={{ $('Webhook').item.json.body.sessionId }}",
          "returnAllMessages": true,
          "bufferStrategy": "summarize",
          "maxTokenLimit": 12000
        }
      },
      "type": "@n8n/n8n-nodes-langchain.memoryManager",
      "typeVersion": 1.2,
      "credentials": {
        "postgres": {
          "id": "postgres-prod"
        }
      }
    },
    {
      "parameters": {
        "model": "claude-sonnet-4.6",
        "options": {
          "temperature": 0.3,
          "maxTokens": 4000
        }
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatAnthropic",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "คุณเป็นผู้ช่วยการวิจัยที่จดจำบทสนทนาทั้งหมดของเราได้อย่างสมบูรณ์แบบ รักษาบันทึกรายละเอียดเกี่ยวกับข้อค้นพบสำคัญ",
          "maxIterations": 5
        }
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7
    },
    {
      "parameters": {
        "jsCode": "// เก็บถาวรใน PostgreSQL พร้อม metadata\nconst { Pool } = require('pg');\nconst pool = new Pool($credentials.postgres);\n\nconst sessionId = $('Webhook').item.json.body.sessionId;\nconst messages = $input.first().json.messages;\n\nawait pool.query(\n  `INSERT INTO research_sessions (session_id, messages, updated_at)\n   VALUES ($1, $2, NOW())\n   ON CONFLICT (session_id) DO UPDATE\n   SET messages = $2, updated_at = NOW()`,\n  [sessionId, JSON.stringify(messages)]\n);\n\nreturn [{ json: { persisted: true, messageCount: messages.length } }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify({ response: $input.first().json.output, summary: generateSummary($input.first().json.messages) }) }}"
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1
    }
  ]
}

{
  "name": "SaaS Onboarding",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "onboarding",
        "responseMode": "responseNode"
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "jsCode": "// ตรรกะการจัดการเซสชัน\nconst userId = $('Webhook').item.json.body.userId;\nconst sessionKey = `onboarding_${userId}`;\n\nreturn [{\n  json: {\n    userId,\n    sessionKey,\n    action: $('Webhook').item.json.body.action,\n    input: $('Webhook').item.json.body.data\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2
    },
    {
      "parameters": {
        "command": "get",
        "key": "={{ $json.sessionKey }}",
        "options": {}
      },
      "type": "n8n-nodes-base.redis",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "mode": "runOnceForAllItems",
        "jsCode": "// การประมวลผล state machine\nconst action = $('Code').item.json.action;\nconst existingData = $('Redis').item.json.value;\n\nlet state = existingData ? JSON.parse(existingData) : {\n  step: 'welcome',\n  data: {},\n  progress: 0,\n  startedAt: new Date().toISOString()\n};\n\n// ตรรกaja state machine\nconst steps = ['welcome', 'account', 'team', 'integration', 'complete'];\n\nif (action === 'advance') {\n  const currentIndex = steps.indexOf(state.step);\n  if (currentIndex < steps.length - 1) {\n    state.step = steps[currentIndex + 1];\n    state.progress = ((currentIndex + 1) / (steps.length - 1)) * 100;\n  }\n} else if (action === 'data') {\n  state.data = { ...state.data, ...$('Code').item.json.input };\n}\n\nstate.lastActivity = new Date().toISOString();\n\nreturn [{ json: state }];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2
    },
    {
      "parameters": {
        "command": "set",
        "key": "={{ $('Code').item.json.sessionKey }}",
        "value": "={{ JSON.stringify($json) }}",
        "options": {
          "expire": true,
          "ttl": 604800
        }
      },
      "type": "n8n-nodes-base.redis",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "model": "gpt-4o",
        "options": {
          "temperature": 0.7
        }
      },
      "type": "@n8n/n8n-nodes-langchain.lmChatOpenAi",
      "typeVersion": 1.1
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "คุณเป็นผู้ช่วย onboarding แนะนำผู้ใช้ผ่านกระบวนการตั้งค่า SaaS"
        }
      },
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7
    },
    {
      "parameters": {
        "respondWith": "json",
        "responseBody": "={{ JSON.stringify({ message: $input.first().json.output, progress: $('Code1').item.json.progress, step: $('Code1').item.json.step }) }}"
      },
      "type": "n8n-nodes-base.respondToWebhook",
      "typeVersion": 1.1
    }
  ]
}

┌─────────────────────────────────────────────────────────────────┐
│              ต้นไม้การตัดสินใจเลือก Memory-Modus                │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  เริ่มต้น                                                        │
│    │                                                             │
│    ▼                                                             │
│  การสนทนาจำเป็นต้องคงทนข้ามการดำเนินการหรือไม่?              │
│    │                                                             │
│    ├─ ใช่ ───────────────────────┐                              │
│    │                              ▼                              │
│    │                    ใช้ SESSION MEMORY                       │
│    │                    ├─ กระบวนการหลายขั้นตอน               │
│    │                    ├─ Workflows ข้ามวัน                  │
│    │                    ├─ การจัดการสถานะผู้ใช้               │
│    │                              │                              │
│    │                              ▼                              │
│    │                    กำหนดค่า: PostgreSQL หรือ Redis          │
│    │                    TTL ตามระยะเวลากระบวนการ               │
│    │                                                             │
│    ไม่                                                           │
│    │                                                             │
│    ▼                                                             │
│  ประวัติการสนทนาสำคัญหรือไม่นอกเหนือจากการแลกเปลี่ยนล่าสุด?  │
│    │                                                             │
│    ├─ ใช่ ───────────────────────┐                              │
│    │                              ▼                              │
│    │                    ใช้ BUFFER MEMORY                       │
│    │                    ├─ ผู้ช่วยการวิจัย                       │
│    │                    ├─ งานวิเคราะห์ที่ซับซ้อน              │
│    │                    ├─ การสร้างเนื้อหาหลายตอน            │
│    │                              │                              │
│    │                              ▼                              │
│    │                    กำหนดค่า: กลยุทธ์การสรุป                   │
│    │                    PostgreSQL สำหรับการเก็บระยะยาว          │
│    │                                                             │
│    ไม่                                                           │
│    │                                                             │
│    ▼                                                             │
│  ใช้ WINDOW MEMORY                                              │
│  ├─ Chatbots สนับสนุนลูกค้า                                      │
│  ├─ ระบบ Q&A รวดเร็ว                                           │
│  ├─ ผู้ช่วย E-commerce                                         │
│    │                                                             │
│    ▼                                                             │
│  กำหนดค่า: Redis สำหรับ production                               │
│  ขนาดหน้าต่าง: 8-12 ข้อความเป็นปกติ                            │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│              ตัวชี้วัดประสิทธิภาพ Memory                         │
│                    (n8n 2.0.47, มิถุนายน 2026)                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ความหน่วง (เปอร์เซ็นไทล์ที่ 95)                                 │
│  ┌────────────────────────────────────────────────────────┐   │
│  │ In-Memory    ████████████████████  12ms                  │   │
│  │ Redis        ████████████████████████████  45ms          │   │
│  │ PostgreSQL   ████████████████████████████████████  120ms│   │
│  └────────────────────────────────────────────────────────┘   │
│                                                                  │
│  ผลผลิต (คำขอต่อวินาทีต่อ core)                                │
│  ┌────────────────────────────────────────────────────────┐   │
│  │ In-Memory    ████████████████████████████████████  2500 │   │
│  │ Redis        ████████████████████████████  1800         │   │
│  │ PostgreSQL   ████████████████████  950                  │   │
│  └────────────────────────────────────────────────────────┘   │
│                                                                  │
│  การใช้งานหน่วยความจำ (ต่อ 1,000 เซสชันที่ใช้งานอยู่)          │
│  ┌────────────────────────────────────────────────────────┐   │
│  │ Window (Redis)     ████████  180MB                    │   │
│  │ Buffer (Redis)       ████████████████████  450MB     │   │
│  │ Session (Redis)      ████  120MB                       │   │
│  │ Window (Postgres)    ██  45MB (แค่แคช)                │   │
│  └────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

// ปรับให้เหมาะสมสำหรับประสิทธิภาพอินสแตนซ์เดียว
const config = {
  // เปิดใช้งาน worker threads สำหรับการดำเนินการ memory
  workerThreads: true,
  workerCount: 4,
  
  // Connection pooling
  redis: {
    poolSize: 20,
    maxRetries: 3
  },
  
  // การดำเนินการแบบ batch
  batchSize: 100,
  flushInterval: 1000  // ms
};

// Redis cluster ที่แชร์สำหรับการเก็บเซสชัน
const clusterConfig = {
  redis: {
    cluster: true,
    nodes: [
      { host: 'redis-1', port: 6379 },
      { host: 'redis-2', port: 6379 },
      { host: 'redis-3', port: 6379 }
    ],
    options: {
      maxRetriesPerRequest: 3,
      enableReadyCheck: true
    }
  }
};

// PostgreSQL read replicas
const postgresConfig = {
  primary: { host: 'postgres-primary', port: 5432 },
  replicas: [
    { host: 'postgres-replica-1', port: 5432 },
    { host: 'postgres-replica-2', port: 5432 }
  ],
  readPreference: 'nearest'
};

// คำนวณความต้องการโครงสร้างพื้นฐาน
const sessions = {
  expectedConcurrent: 10000,
  peakMultiplier: 2.5,
  
  // Memory ต่อประเภทเซสชัน
  windowMemory: 2 * 1024,      // 2KB ต่อเซสชัน
  bufferMemory: 8 * 1024,      // 8KB เฉลี่ย
  sessionMemory: 1.5 * 1024,   // 1.5KB เฉลี่ย
  
  // คำนวณทั้งหมด
  totalMemory() {
    return (this.expectedConcurrent * this.peakMultiplier) * 
           (this.windowMemory + this.sessionMemory);
  }
};

// ผลลัพธ์: ~87.5GB สำหรับ 10K พร้อมกันกับ buffer
// คำแนะนำ: Redis cluster ที่มี RAM 128GB

// การจัดสรรหน้าต่างบริบทโมเดล
const modelConfig = {
  model: 'gpt-4o',
  maxContext: 128000,
  
  // สำรองที่สำหรับ
  systemPrompt: 1500,
  safetyBuffer: 4000,
  responseSpace: 2000,
  
  // สำหรับ memory
  memoryBudget() {
    return this.maxContext - this.systemPrompt - 
           this.safetyBuffer - this.responseSpace;
  }
};

// 128K - 1.5K - 4K - 2K = 120.5K tokens สำหรับประวัติ
// ที่ 150 tokens/ข้อความ = ~800 ข้อความสูงสุด
// ขีดจำกัดจริง: 50 ข้อความสำหรับเวลาตอบสนอง <2 วินาที

// PostgreSQL พร้อมการเข้ารหัส
const securePostgres = {
  ssl: {
    rejectUnauthorized: true,
    ca: fs.readFileSync('/path/to/ca.crt'),
    key: fs.readFileSync('/path/to/client.key'),
    cert: fs.readFileSync('/path/to/client.crt')
  },
  // เปิดใช้งานการเข้ารหัสระดับคอลัมน์สำหรับฟิลด์ที่ละเอียดอ่อน
  encryption: {
    keyManagement: 'aws-kms',  // หรือ 'vault', 'azure-keyvault'
    keyId: 'alias/n8n-memory-encryption'
  }
};

// Redis กับ TLS
const secureRedis = {
  tls: {
    host: 'redis.internal',
    port: 6380,
    key: fs.readFileSync('/path/to/redis.key'),
    cert: fs.readFileSync('/path/to/redis.crt'),
    ca: fs.readFileSync('/path/to/redis-ca.crt')
  }
};

// การหลบเลี่ยง PII อัตโนมัติก่อนการจัดเก็บ
const maskPII = (data) => {
  const patterns = {
    email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
    phone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
    id: /\b\d{3}-\d{2}-\d{4}\b/g,
    creditCard: /\b(?:\d{4}[-\s]?){3}\d{4}\b/g
  };
  
  let masked = JSON.stringify(data);
  
  Object.entries(patterns).forEach(([type, pattern]) => {
    masked = masked.replace(pattern, `[${type.toUpperCase()}_MASKED]`);
  });
  
  return JSON.parse(masked);
};

// ใช้ก่อนจัดเก็บ
await redis.set(sessionKey, JSON.stringify(maskPII(conversation)));

// การลบเซสชันอย่างสมบูรณ์
const deleteUserData = async (userId) => {
  // หา session keys ทั้งหมดสำหรับผู้ใช้
  const pattern = `*_${userId}_*`;
  const keys = await redis.keys(pattern);
  
  // ลบจาก Redis
  if (keys.length > 0) {
    await redis.del(...keys);
  }
  
  // ลบจาก PostgreSQL
  await postgres.query(
    'DELETE FROM ai_memory.conversations WHERE session_key LIKE $1',
    [`%${userId}%`]
  );
  
  // บันทึกการลบสำหรับ audit
  await auditLog.record({
    action: 'data_deletion',
    userId,
    timestamp: new Date().toISOString(),
    keysDeleted: keys.length
  });
};

-- การล้างข้อมูลอัตโนมัติของเซสชันที่หมดอายุ
CREATE OR REPLACE FUNCTION cleanup_expired_sessions()
RETURNS void AS $$
BEGIN
  DELETE FROM ai_memory.conversations
  WHERE expires_at < NOW() - INTERVAL '7 days';
  
  DELETE FROM ai_memory.sessions
  WHERE last_activity < NOW() - INTERVAL '30 days';
END;
$$ LANGUAGE plpgsql;

-- กำหนดเวลากับ pg_cron
SELECT cron.schedule('cleanup-sessions', '0 2 * * *', 
  'SELECT cleanup_expired_sessions()');

// การกำหนดค่าเซสชันที่สอดคล้องกับ HIPAA
const hipaaConfig = {
  memory: {
    encryption: {
      atRest: true,
      inTransit: true,
      keyRotation: 90  // วัน
    },
    audit: {
      enabled: true,
      logAccess: true,
      logModifications: true
    },
    retention: {
      days: 2555,  // 7 ปี
      archiveAfter: 365
    }
  }
};

// การบันทึกการเข้าถึง
const logAccess = async (sessionKey, action, userId) => {
  await auditLog.insert({
    timestamp: new Date().toISOString(),
    sessionKey: hash(sessionKey),  // ไม่บันทึก keys จริง
    action,
    userId,
    ipAddress: $execution.metadata.clientIp,
    userAgent: $execution.metadata.userAgent
  });
};

// แย่: Session key คงที่
"sessionKey": "chat_session"

// แย่: ตัวระบุที่ไม่ไม่ซ้ำกัน
"sessionKey": "={{ $json.name }}"  // หลายคนชื่อสมชาย

// ดี: Composite unique key
"sessionKey": "={{ $json.userId }}_{{ $json.channel }}_{{ $json.timestamp }}"

// ดี: UUID สำหรับผู้ใช้ที่ไม่ระบุตัวตน
"sessionKey": "={{ $json.userId || $uuid }}"

// การตรวจสอบความถูกต้อง: ตรวจสอบความไม่ซ้ำกัน
const validateSessionKey = (key) => {
  if (!key || key.includes('undefined')) {
    throw new Error(`Session key ไม่ถูกต้อง: ${key}`);
  }
  return key;
};

// ตรวจสอบสุขภาพ memory
const checkMemoryHealth = async () => {
  const info = await redis.info('memory');
  const used = parseInt(info.match(/used_memory:(\d+)/)[1]);
  const peak = parseInt(info.match(/used_memory_peak:(\d+)/)[1]);
  
  return {
    currentMB: used / 1024 / 1024,
    peakMB: peak / 1024 / 1024,
    healthy: used < peak * 0.8
  };
};

// หมดอายุเซสชันเก่าโดยอัตโนมัติ
await redis.setex(sessionKey, 86400, data);  // 24 ชั่วโมง

const zlib = require('zlib');
const compressed = zlib.deflateSync(JSON.stringify(data)).toString('base64');
await redis.set(sessionKey, compressed);

// เริ่มสรุปที่ threshold token
if (tokenCount > 8000) {
  await summarizeAndCompress(sessionKey);
}

// ขนาด connection pool ที่เหมาะสม
const poolConfig = {
  redis: {
    poolSize: Math.max(10, Math.ceil(concurrentSessions / 100)),
    maxRetries: 3,
    retryDelay: 100,
    enableOfflineQueue: false  // ล้มเหลวอย่างรวดเร็ว
  },
  postgres: {
    min: 5,
    max: 20,
    idleTimeoutMillis: 30000,
    connectionTimeoutMillis: 5000
  }
};

// การตรวจสอบสุขภาพ connection
const healthCheck = setInterval(async () => {
  try {
    await redis.ping();
    await postgres.query('SELECT 1');
  } catch (error) {
    console.error('Memory backend ไม่สมบูรณ์:', error);
    // แจ้งเตือนหรือ failover
  }
}, 30000);

// การกู้คืนตาม checkpoint
const withRecovery = async (sessionKey, operation) => {
  // บันทึก checkpoint ก่อนการดำเนินการ
  const checkpoint = await redis.get(sessionKey);
  
  try {
    return await operation();
  } catch (error) {
    // กู้คืน checkpoint เมื่อล้มเหลว
    if (checkpoint) {
      await redis.set(sessionKey, checkpoint);
    }
    throw error;
  }
};

// การใช้งาน
await withRecovery(sessionKey, async () => {
  // การดำเนินการที่มีความเสี่ยงที่นี่
  await processMessage(message);
});

// การจัดการ token เชิงรุก
const manageTokens = (messages, maxTokens = 12000) => {
  const estimateTokens = (text) => Math.ceil(text.length / 4);
  
  let totalTokens = messages.reduce((sum, m) => 
    sum + estimateTokens(m.content), 0
  );
  
  while (totalTokens > maxTokens && messages.length > 2) {
    // ลบคู่ผู้ใช้-ผู้ช่วยที่เก่าที่สุด
    messages.splice(0, 2);
    totalTokens = messages.reduce((sum, m) => 
      sum + estimateTokens(m.content), 0
    );
  }
  
  return messages;
};

// Tiers การเก็บข้อมูล Hot → Warm → Cold
const tieredMemory = {
  // Hot: การสนทนาปัจจุบัน (Redis, <1 ชั่วโมง)
  async getHot(sessionKey) {
    return await redis.get(`hot:${sessionKey}`);
  },
  
  // Warm: การสนทนาล่าสุด (PostgreSQL, 1-30 วัน)
  async getWarm(sessionKey) {
    const result = await postgres.query(
      'SELECT * FROM conversations WHERE session_key = $1 AND updated_at > NOW() - INTERVAL \'30 days\'',
      [sessionKey]
    );
    return result.rows[0];
  },
  
  // Cold: การสนทนาที่เก็บถาวร (S3, >30 วัน)
  async getCold(sessionKey) {
    const s3Key = `conversations/${sessionKey}.json.gz`;
    const data = await s3.getObject({ Bucket: 'n8n-memory', Key: s3Key });
    return zlib.gunzipSync(data.Body);
  },
  
  // การ get ที่รวมกันพร้อมการส่งเสริมอัตโนมัติ
  async get(sessionKey) {
    // ลอง hot ก่อน
    let data = await this.getHot(sessionKey);
    if (data) return JSON.parse(data);
    
    // ลอง warm
    data = await this.getWarm(sessionKey);
    if (data) {
      // ส่งเสริมไปยัง hot
      await this.setHot(sessionKey, data);
      return data;
    }
    
    // ลอง cold
    data = await this.getCold(sessionKey);
    if (data) {
      // ส่งเสริมไปยัง warm และ hot
      await this.setWarm(sessionKey, data);
      await this.setHot(sessionKey, data);
      return data;
    }
    
    return null;
  }
};

// รวม buffer memory กับ RAG
const vectorMemory = {
  async addMessage(sessionKey, message) {
    // เก็บใน memory แบบดั้งเดิม
    await bufferMemory.add(sessionKey, message);
    
    // เก็บใน vector DB สำหรับการค้นหาเชิงความหมาย
    const embedding = await openai.embeddings.create({
      model: 'text-embedding-3-large',
      input: message.content
    });
    
    await pinecone.upsert({
      id: `${sessionKey}_${Date.now()}`,
      values: embedding.data[0].embedding,
      metadata: {
        sessionKey,
        content: message.content,
        timestamp: Date.now()
      }
    });
  },
  
  async retrieveRelevant(sessionKey, query, topK = 5) {
    // รับ matches เชิงความหมาย
    const embedding = await openai.embeddings.create({
      model: 'text-embedding-3-large',
      input: query
    });
    
    const matches = await pinecone.query({
      vector: embedding.data[0].embedding,
      topK,
      filter: { sessionKey }
    });
    
    // รวมกับ buffer memory ล่าสุด
    const recent = await bufferMemory.getRecent(sessionKey, 5);
    
    return {
      semantic: matches.matches.map(m => m.metadata),
      recent
    };
  }
};