// การตัดสินใจกำหนดเส้นทางที่คุ้มค่า
const routingPrompt = `จำแนกคำขอขาเข้านี้เป็นหนึ่งในหมวดหมู่เหล่านี้:
- ง่าย: การแยกข้อมูลพื้นฐาน, การจัดรูปแบบ
- มาตรฐาน: การประมวลผลหลายขั้นตอน, การให้เหตุผลระดับปานกลาง
- ซับซ้อน: การวิเคราะห์เชิงลึก, การสร้างสรรค์, การเขียนโค้ด

คำขอ: {{$json.input}}

ตอบกลับด้วยเท่านั้น: ง่าย, มาตรฐาน หรือ ซับซ้อน`;

// ต้นทุน: ~$0.0001 ต่อการจำแนกประเภท
// ประหยัด: $0.01-$0.10 ต่อคำขอโดยการหลีกเลี่ยงการจัดสรรเกิน

{
  "name": "ตัวกำหนดเส้นทางโมเดล AI",
  "nodes": [
    {
      "parameters": {
        "model": "gpt-4o-mini",
        "options": {
          "temperature": 0.1,
          "maxTokens": 50
        },
        "prompt": "=จำแนกความซับซ้อนของคำขอ:\n{{$json.input}}\n\nตอบกลับ: ง่าย|มาตรฐาน|ซับซ้อน"
      },
      "type": "n8n-nodes-base.openAi",
      "typeVersion": 1.6
    },
    {
      "parameters": {
        "rules": {
          "rules": [
            {
              "value": "ง่าย",
              "output": 0
            },
            {
              "value": "มาตรฐาน",
              "output": 1
            },
            {
              "value": "ซับซ้อน",
              "output": 2
            }
          ]
        }
      },
      "type": "n8n-nodes-base.switch",
      "typeVersion": 1
    }
  ]
}

// ไม่มีประสิทธิภาพ: 1,000 การเรียก API แยกกัน
for (const item of items) {
  const result = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{ role: "user", content: item.prompt }]
  });
}

// มีประสิทธิภาพ: ประมวลผล 100 รายการต่อชุด
const batches = chunk(items, 100);
for (const batch of batches) {
  const combinedPrompt = batch.map((item, i) => 
    `[รายการ ${i + 1}] ${item.prompt}`
  ).join('\n\n---\n\n');
  
  const result = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [{ 
      role: "user", 
      content: `ประมวลผล ${batch.length} รายการนี้:\n\n${combinedPrompt}` 
    }]
  });
  
  // แยกวิเคราะห์และแจกจ่ายผลลัพธ์
  const responses = parseBatchResponse(result.choices[0].message.content);
}

{
  "name": "ตัวประมวลผล Batch",
  "nodes": [
    {
      "parameters": {
        "batchSize": 100,
        "options": {}
      },
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 3
    },
    {
      "parameters": {
        "jsCode": "// รวมรายการ Batch เข้าเป็น Prompt เดียว\nconst combined = items.map((item, i) => \n  `[${i + 1}] ${item.json.content}`\n).join('\\n\\n---\\n\\n');\n\nreturn [{\n  json: {\n    batchPrompt: combined,\n    itemCount: items.length,\n    originalItems: items\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2
    }
  ]
}

// ตรวจสอบแคชก่อนเรียก API
const similarRequests = await vectorDB.similaritySearch({
  query: currentRequest,
  threshold: 0.95, // เกณฑ์ความคล้ายคลึงสูง
  limit: 1
});

if (similarRequests.length > 0) {
  // Cache hit: ส่งคืนการตอบกลับที่แคชไว้
  return similarRequests[0].response;
}

// Cache miss: เรียก API และจัดเก็บผลลัพธ์
const response = await callLLM(currentRequest);
await vectorDB.store({
  request: currentRequest,
  response: response,
  embedding: await generateEmbedding(currentRequest)
});

{
  "name": "ชั้นแคชอัจฉริยะ",
  "nodes": [
    {
      "parameters": {
        "operation": "search",
        "indexName": "llm-request-cache",
        "options": {
          "k": 1,
          "minSimilarity": 0.95
        },
        "query": "={{ $json.input }}"
      },
      "type": "n8n-nodes-base.pinecone",
      "typeVersion": 1
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "={{ $json.results.length }}",
            "type": {
              "value": "gt",
              "version": 1
            },
            "rightValue": "0"
          }
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2
    }
  ]
}

{
  "name": "ตัวกรอง Trigger อัจฉริยะ",
  "nodes": [
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "={{ $json.payload.priority }}",
            "type": {
              "value": "in",
              "version": 1
            },
            "rightValue": "สูง,วิกฤติ"
          }
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2
    }
  ]
}

# MEMORY.md - โครงสร้างที่เพิ่มประสิทธิภาพ

## บริบติกำลัง (เก็บรักษาตลอดเวลา)
- การตั้งค่าและการกำหนดค่าหลักของผู้ใช้
- คำนิยามโครงการที่ใช้งานอยู่
- ข้อมูลรับรองความปลอดภัย (แฮชแล้ว)

## หน่วยความจำทำงาน (สรุปแล้ว)
- ประวัติการสนทนาล่าสุด (10 การแลกเปลี่ยนล่าสุด)
- บริบทงานปัจจุบัน
- รายการงานที่รอดำเนินการ

## หน่วยความจำที่เก็บถาวร (ที่เก็บเวกเตอร์)
- บันทึกการสนทนาย้อนหลัง (สรุปรายสัปดาห์)
- โครงการที่เสร็จสมบูรณ์ (ผลลัพธ์สำคัญเท่านั้น)
- รูปแบบและความชอบที่เรียนรู้

## นโยบายการหมดอายุ
- หน่วยความจำทำงาน: 30 วัน
- รายการที่เก็บถาวร: 90 วัน
- บันทึกระบบ: 7 วัน

// ประมวลผลบริบติก่อนเพื่อลดการใช้ Token
function optimizeContext(memory, maxTokens = 4000) {
  // การจัดอันดับความสำคัญสำหรับการเก็บรักษาบริบท
  const priority = [
    ...memory.critical,
    ...memory.working.slice(0, 5),
    ...summarizeOldMemory(memory.archived)
  ];
  
  // ตัดแต่ยังคงรักษาโครงสร้าง
  return truncateWithStructure(priority, maxTokens);
}

// การประหยัดที่เป็น typic: ลด Token บริบท 40-60%

# gateway.config.yaml
channels:
  # ต้นทุนสูง: ความสามารถ AI เต็มรูปแบบ
  email:
    model: gpt-4o
    memory: full
    reasoning: high
    
  # ต้นทุนปานกลาง: ความสามารถที่สมดุล
  slack:
    model: claude-3-5-sonnet
    memory: working
    reasoning: medium
    
  # ต้นทุนต่ำ: จำเป็นเท่านั้น
  telegram:
    model: gpt-4o-mini
    memory: minimal
    reasoning: low
    
  # ขับเคลื่อนด้วยเหตุการณ์: เฉพาะเชิงปฏิกิริยา
  webhook:
    model: none  # การตอบกลับที่กรองก่อน
    memory: none
    reasoning: none

// ใช้เป้าหมาย Session ที่เหมาะสมสำหรับประเภท Workload
// Session แยก: เหมาะสำหรับงานอิสระ ครั้งเดียว
openclaw agent --message "การวิเคราะห์อย่างรวดเร็ว" --session isolated

// Session ปัจจุบัน: แบ่งปันบริบทสำหรับงานที่เกี่ยวข้อง
openclaw agent --message "ดำเนินการงานก่อนหน้าต่อ" --session current

// Session ตั้งชื่อ: บริบทถาวรสำหรับโครงการที่กำลังดำเนินการ
openclaw agent --message "อัปเดตสถานะโครงการ" --session project:alpha

# เริ่มต้น Ollama ด้วยโมเดลที่เพิ่มประสิทธิภาพ
ollama pull llama3.1:8b
ollama pull mistral:7b-instruct

# กำหนดค่า OpenClaw ให้ใช้โมเดลภายใน
openclaw config set model.default.local llama3.1:8b
openclaw config set model.routing.threshold 0.85

async function routeToOptimalModel(request, complexity) {
  // กำหนดเส้นทางคำของ่ายไปยังโมเดลภายใน
  if (complexity === 'ง่าย') {
    return await ollama.generate({
      model: 'llama3.1:8b',
      prompt: request
    });
  }
  
  // กำหนดเส้นทางความซับซ้อนปานกลางพร้อม Fallback
  if (complexity === 'มาตรฐาน') {
    try {
      return await ollama.generate({
        model: 'mistral:7b-instruct',
        prompt: request
      });
    } catch {
      // Fallback ไปยัง API เมื่อโมเดลภายในขัดข้อง
      return await openai.chat.completions.create({
        model: 'gpt-4o-mini',
        messages: [{ role: 'user', content: request }]
      });
    }
  }
  
  // ความซับซ้อนสูง: ใช้โมเดล API ที่ดีที่สุดที่มี
  return await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: request }]
  });
}

version: '3.8'
services:
  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
      
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: n8n
      POSTGRES_USER: n8n
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data
      
  n8n-webhook:
    image: n8nio/n8n:latest
    environment:
      - N8N_MODE=webhook
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - QUEUE_BULL_REDIS_HOST=redis
    deploy:
      replicas: 2
      
  n8n-worker:
    image: n8nio/n8n:latest
    environment:
      - N8N_MODE=worker
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - QUEUE_BULL_REDIS_HOST=redis
    deploy:
      replicas: 5  # ขยายตาม Workload
      
  n8n-main:
    image: n8nio/n8n:latest
    environment:
      - N8N_MODE=main
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - QUEUE_BULL_REDIS_HOST=redis

// การขยายอัตโนมัติตามความลึกของคิว
const queueMetrics = await getQueueMetrics();

if (queueMetrics.waiting > 1000) {
  await scaleWorkers('+2');
} else if (queueMetrics.waiting < 100 && workers > 2) {
  await scaleWorkers('-1');
}

-- ปรับแต่งสำหรับรูปแบบการดำเนินการ Workflow
ALTER SYSTEM SET shared_buffers = '4GB';
ALTER SYSTEM SET effective_cache_size = '12GB';
ALTER SYSTEM SET maintenance_work_mem = '1GB';
ALTER SYSTEM SET work_mem = '256MB';

-- แบ่งส่วนตารางการดำเนินการสำหรับการใช้งานขนาดใหญ่
CREATE TABLE execution_entity_partitioned (
    id SERIAL,
    workflow_id VARCHAR(36),
    finished BOOLEAN,
    started_at TIMESTAMP,
    stopped_at TIMESTAMP,
    data JSONB
) PARTITION BY RANGE (started_at);

-- สร้างส่วนรายเดือน
CREATE TABLE execution_entity_2026_04 
    PARTITION OF execution_entity_partitioned
    FOR VALUES FROM ('2026-04-01') TO ('2026-05-01');

// ใช้ดัชนีสำหรับรูปแบบการสืบค้นทั่วไป
// ดัชนีบน workflow_id และ started_at สำหรับการสืบค้นการดำเนินการ
CREATE INDEX CONCURRENTLY idx_execution_workflow_time 
ON execution_entity(workflow_id, started_at DESC);

// ดัชนีบางส่วนสำหรับการดำเนินการที่ใช้งานอยู่
CREATE INDEX CONCURRENTLY idx_execution_active 
ON execution_entity(id) 
WHERE finished = false;

// อัลกอริทึมถังโทเค็นสำหรับการป้องกัน API
class RateLimiter {
  constructor(tokensPerSecond, bucketSize) {
    this.tokens = bucketSize;
    this.lastRefill = Date.now();
    this.tokensPerSecond = tokensPerSecond;
    this.bucketSize = bucketSize;
  }
  
  async acquire() {
    this.refill();
    if (this.tokens >= 1) {
      this.tokens--;
      return true;
    }
    
    // รอการมีโทเค็น
    const waitTime = Math.ceil((1 - this.tokens) * 1000 / this.tokensPerSecond);
    await sleep(waitTime);
    return this.acquire();
  }
  
  refill() {
    const now = Date.now();
    const elapsed = (now - this.lastRefill) / 1000;
    this.tokens = Math.min(
      this.bucketSize,
      this.tokens + elapsed * this.tokensPerSecond
    );
    this.lastRefill = now;
  }
}

// การใช้งาน
const openaiLimiter = new RateLimiter(100, 200); // 100 คำขอ/วินาที, burst ถึง 200

// Hook การดำเนินการ n8n สำหรับการติดตามต้นทุน
const costTracker = {
  async beforeExecute(workflowId, executionId) {
    await trackMetric('execution.start', {
      workflowId,
      executionId,
      timestamp: Date.now()
    });
  },
  
  async afterExecute(workflowId, executionId, result, costs) {
    await trackMetric('execution.complete', {
      workflowId,
      executionId,
      duration: Date.now() - result.startTime,
      costs: {
        aiTokens: costs.tokens || 0,
        aiCost: costs.estimatedCost || 0,
        computeTime: costs.computeMs || 0
      }
    });
  }
};

// รวมต้นทุนรายวัน
async function getDailyCostReport(date) {
  return await db.query(`
    SELECT 
      workflow_id,
      SUM(ai_cost) as total_cost,
      SUM(ai_tokens) as total_tokens,
      COUNT(*) as execution_count,
      AVG(duration) as avg_duration
    FROM execution_metrics
    WHERE DATE(timestamp) = $1
    GROUP BY workflow_id
    ORDER BY total_cost DESC
  `, [date]);
}

# จุดสิ้นสุดเมตริกที่กำหนดเอง
- name: n8n_cost_total
  help: ต้นทุน AI API ทั้งหมดต่อ Workflow
  type: counter
  labels: [workflow_id, model]

- name: n8n_execution_duration
  help: ระยะเวลาการดำเนินการ Workflow
  type: histogram
  labels: [workflow_id]
  buckets: [0.1, 0.5, 1, 2, 5, 10, 30, 60]

- name: n8n_cache_hit_ratio
  help: อัตราการ Cache Hit สำหรับคำขอ LLM
  type: gauge
  labels: [cache_type]

// เมตริกที่สำคัญสำหรับการตัดสินใจเพิ่มประสิทธิภาพ
const dashboardMetrics = {
  // ประสิทธิภาพต้นทุน
  costPerExecution: totalCost / totalExecutions,
  costPerTask: totalCost / totalTasksCompleted,
  modelCostDistribution: breakdownByModel,
  
  // ประสิทธิภาพ
  avgExecutionTime: totalDuration / totalExecutions,
  p95ExecutionTime: percentile(executionTimes, 95),
  errorRate: failedExecutions / totalExecutions,
  
  // การใช้งานทรัพยากร
  queueDepth: currentQueueSize,
  workerUtilization: activeWorkers / totalWorkers,
  apiQuotaUsage: usedQuota / totalQuota
};

# การตรวจจับความผิดปกติด้านต้นทุน
- alert: HighCostAnomaly
  expr: |
    (
      sum(rate(n8n_cost_total[1h])) 
      / 
      sum(rate(n8n_cost_total[1h] offset 1d))
    ) > 2
  for: 15m
  labels:
    severity: warning
  annotations:
    summary: "ต้นทุน AI API เพิ่มขึ้นเป็นสองเท่าเมื่อเทียบกับเมื่อวาน"

- alert: ExecutionFailureRate
  expr: |
    (
      sum(rate(n8n_execution_failed_total[5m]))
      /
      sum(rate(n8n_execution_total[5m]))
    ) > 0.1
  for: 5m
  labels:
    severity: critical
  annotations:
    summary: "อัตราความล้มเหลวในการดำเนินการสูงกว่า 10%"

// แทนการตอบกลับแบบอิสระที่ต้องการการแยกวิเคราะห์
const unstructuredPrompt = `แยกรายละเอียดการประชุมจากข้อความนี้: ${text}`;
// การตอบกลับ: "การประชุมกำหนดไว้ในวันพรุ่งนี้เวลา 14:00 น. ที่ห้องประชุม A"
// ต้องการ: ขั้นตอนการแยกวิเคราะห์เพิ่มเติม

// ใช้ผลลัพธ์โครงสร้าง
const structuredPrompt = `แยกรายละเอียดการประชุมจากข้อความนี้: ${text}

ตอบกลับในรูปแบบ JSON นี้เท่านั้น:
{
  "date": "YYYY-MM-DD",
  "time": "HH:MM",
  "location": "string",
  "attendees": ["string"]
}`;
// การตอบกลับ: {"date": "2026-04-22", "time": "14:00", ...}
// ประหยัด: ขั้นตอนการแยกวิเคราะห์, ลดการจัดการข้อผิดพลาด, รูปแบบสม่ำเสมอ

// แทนการเรียกเพียงครั้งเดียวที่มีราคาแพง
const complexPrompt = `วิเคราะห์รายงานทางการเงินนี้และให้:
1. แนวโน้มรายได้
2. รายละเอียดค่าใช้จ่าย
3. การวิเคราะห์กระแสเงินสด
4. การประเมินความเสี่ยง
5. คำแนะนำ

รายงาน: ${report}`;
// ต้นทุน: ~$0.10-$0.20, คุณภาพ: แปรผัน

// แยกเป็นขั้นตอนโครงสร้าง
const steps = [
  { prompt: `แยกข้อมูลรายได้: ${report}`, cost: 0.02 },
  { prompt: `แยกข้อมูลค่าใช้จ่าย: ${report}`, cost: 0.02 },
  { prompt: `คำนวณกระแสเงินสดจาก: ${revenue} ${expenses}`, cost: 0.01 },
  { prompt: `ระบุความเสี่ยงใน: ${extractedData}`, cost: 0.03 },
  { prompt: `สร้างคำแนะนำจาก: ${analysis}`, cost: 0.04 }
];
// ต้นทุนรวม: ~$0.12, คุณภาพ: สูงกว่า (แต่ละขั้นตอนเฉพาะทาง)

// ลบช่องว่างส่วนเกินและการจัดรูปแบบ
function compressText(text) {
  return text
    .replace(/\s+/g, ' ')           // ยุบช่องว่าง
    .replace(/\n{3,}/g, '\n\n')      // จำกัดบรรทัดใหม่
    .replace(/\[\s+/g, '[')          // ปรับวงเล็บให้เป็นปกติ
    .replace(/\s+\]/g, ']')
    .trim();
}

// ย่อรูปแบบทั่วไป
const abbreviations = {
  'artificial intelligence': 'AI',
  'machine learning': 'ML',
  'natural language processing': 'NLP',
  'customer relationship management': 'CRM'
};

function abbreviateText(text) {
  let result = text;
  for (const [full, abbr] of Object.entries(abbreviations)) {
    result = result.replace(new RegExp(full, 'gi'), abbr);
  }
  return result;
}

// การประหยัด typic: ลด Token 20-40%

// แทนการรวมเอกสารทั้งหมด
function extractRelevantContext(fullDocument, query) {
  // ใช้ความคล้ายคลึงของ embedding เพื่อหาส่วนที่เกี่ยวข้อง
  const sections = chunkDocument(fullDocument);
  const queryEmbedding = embed(query);
  
  const relevantSections = sections
    .map(section => ({
      ...section,
      similarity: cosineSimilarity(queryEmbedding, section.embedding)
    }))
    .filter(s => s.similarity > 0.7)
    .sort((a, b) => b.similarity - a.similarity)
    .slice(0, 3); // 3 อันดับแรกที่เกี่ยวข้องมากที่สุด
  
  return relevantSections.map(s => s.content).join('\n\n');
}

// ตรวจสอบกฎก่อนเรียก AI ที่มีราคาแพง
function preFilterRequest(request) {
  // Pattern matching ง่ายสำหรับการตอบกลับทั่วไป
  const rules = [
    {
      pattern: /^(hi|hello|hey)\b/i,
      response: "สวัสดี! ฉันจะช่วยอะไรคุณได้บ้างวันนี้?"
    },
    {
      pattern: /^(thank|thanks)\b/i,
      response: "ยินดีค่ะ! มีอะไรอีกที่ฉันช่วยได้ไหม?"
    },
    {
      pattern: /(business hours|open hours)/i,
      response: "เวลาทำการของเราคือ จันทร์-ศุกร์, 9:00-18:00 น."
    }
  ];
  
  for (const rule of rules) {
    if (rule.pattern.test(request)) {
      return { matched: true, response: rule.response };
    }
  }
  
  return { matched: false };
}

// การใช้งาน
const filter = preFilterRequest(userMessage);
if (filter.matched) {
  return filter.response; // ต้นทุน: $0
}
// ดำเนินการต่อไปยังโมเดล AI... // ต้นทุน: $0.01-$0.10