┌─────────────────────────────────────────────────────────────────────────────────┐
│          Traditional n8n Development vs. n8n-mcp AI-Powered Development         │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Traditional Approach (Pre-MCP):                    AI-Powered Approach:       │
│   ┌─────────────────────────────────┐              ┌─────────────────────────┐ │
│   │  1. Open n8n editor             │              │  1. Open Claude/Cursor  │ │
│   │  2. Drag nodes from palette     │              │  2. Describe workflow:  │ │
│   │  3. Configure each node         │              │     "Build a workflow   │ │
│   │     individually                  │              │     that monitors       │ │
│   │  4. Connect nodes manually      │              │     database changes,   │ │
│   │  5. Write expressions             │              │     posts to Slack,     │ │
│   │  6. Test and debug                │              │     and handles errors" │ │
│   │  7. Export and deploy           │              │  3. AI generates        │ │
│   │                                   │              │     complete workflow   │ │
│   │  Time: 2-4 hours                  │              │  4. Review and refine   │ │
│   │  Skill: High (expressions,        │              │  5. Deploy              │ │
│   │         node configuration)       │              │                         │ │
│   │                                   │              │  Time: 10-20 minutes    │ │
│   └─────────────────────────────────┘              │  Skill: Conversational  │ │
│                                                    └─────────────────────────┘ │
│   Result: Technical bottleneck                    Result: Democratized        │
│           for non-experts                                    automation         │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    MCP Architecture Overview                                    │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   ┌──────────────────────┐                    ┌──────────────────────┐         │
│   │     MCP Host         │◄──────────────────►│    MCP Server        │         │
│   │  (AI Application)    │    stdio / HTTP    │   (Tool Provider)    │         │
│   │                      │    (bidirectional) │                      │         │
│   │  • Claude Desktop    │                    │  • n8n-mcp           │         │
│   │  • Claude Code       │                    │  • Database servers  │         │
│   │  • Cursor            │                    │  • GitHub MCP        │         │
│   │  • Windsurf          │                    │  • Slack MCP         │         │
│   └──────────────────────┘                    └──────────────────────┘         │
│                                                                                 │
│   Communication Flow:                                                           │
│   ┌────────────────────────────────────────────────────────────────────────┐ │
│   │  1. Host discovers available tools/resources from Server                │ │
│   │  2. Host sends tool invocation requests with parameters                 │ │
│   │  3. Server executes operation and returns results                       │ │
│   │  4. Host incorporates results into AI context                             │ │
│   └────────────────────────────────────────────────────────────────────────┘ │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    n8n-mcp System Architecture                                │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Layer 1: AI Coding Assistants (MCP Hosts)                                     │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
│   │ Claude Code  │  │   Cursor     │  │  Windsurf    │  │Claude Desktop│       │
│   │              │  │              │  │              │  │              │       │
│   │ • Terminal   │  │ • IDE Editor │  │ • AI Native  │  │ • Chat App   │       │
│   │ • File sys   │  │ • Code gen   │  │ • Code edit  │  │ • Desktop    │       │
│   └──────┬───────┘  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘       │
│          │                 │                 │                 │               │
│          └─────────────────┴─────────────────┴─────────────────┘               │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 2: Model Context Protocol (stdio/HTTP transport)                      │
│   ┌────────────────────────────────────────────────────────────────────────┐  │
│   │  • JSON-RPC 2.0 message format                                            │  │
│   │  • Tool/resource discovery                                              │  │
│   │  • Bidirectional streaming                                               │  │
│   │  • Authentication: API keys, OAuth, or bearer tokens                     │  │
│   └────────────────────────────────────────────────────────────────────────┘  │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 3: n8n-mcp Server                                                       │
│   ┌────────────────────────────────────────────────────────────────────────┐  │
│   │  Available Tools:                                                         │  │
│   │  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────────────┐   │  │
│   │  │ create_workflow │ │ update_workflow │ │ get_workflow            │   │  │
│   │  │                 │ │                 │ │                         │   │  │
│   │  │ list_workflows  │ │ delete_workflow │ │ duplicate_workflow      │   │  │
│   │  └─────────────────┘ └─────────────────┘ └─────────────────────────┘   │  │
│   │  ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────────────┐   │  │
│   │  │ execute_workflow│ │ activate_workflow│ │ deactivate_workflow    │   │  │
│   │  │                 │ │                 │ │                         │   │  │
│   │  │ get_execution   │ │ search_workflows│ │ export_workflow         │   │  │
│   │  └─────────────────┘ └─────────────────┘ └─────────────────────────┘   │  │
│   │                                                                         │  │
│   │  Available Resources:                                                   │  │
│   │  • workflow://{id} — Read workflow JSON                              │  │
│   │  • execution://{id} — Read execution results                           │  │
│   │  • node-types — List available n8n node types                          │  │
│   └────────────────────────────────────────────────────────────────────────┘  │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 4: n8n REST API Integration                                             │
│   ┌────────────────────────────────────────────────────────────────────────┐  │
│   │  • n8n instance URL configuration                                       │  │
│   │  • API key authentication                                               │  │
│   │  • Webhook trigger support                                              │  │
│   │  • Error handling and retry logic                                       │  │
│   └────────────────────────────────────────────────────────────────────────┘  │
│                                    │                                            │
│                                    ▼                                            │
│   Layer 5: Target n8n Instance                                                  │
│   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │
│   │   n8n        │  │   n8n        │  │   n8n        │  │   n8n        │       │
│   │  Cloud       │  │ Self-Hosted  │  │ Enterprise   │  │ Embedded     │       │
│   │              │  │              │  │              │  │              │       │
│   └──────────────┘  └──────────────┘  └──────────────┘  └──────────────┘       │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# ตั้งค่า environment variable สำหรับ API authentication
export N8N_API_KEY="your-secure-api-key-here"

# หรือตั้งค่าใน docker-compose.yml
environment:
  - N8N_API_KEY=${N8N_API_KEY}

# Global installation (แนะนำสำหรับ Claude Desktop)
npm install -g @n8n/mcp-server

# หรือใช้ npx (ไม่ต้องติดตั้ง)
npx -y @n8n/mcp-server

# Local installation (สำหรับโปรเจค Cursor/Windsurf)
cd your-project
npm install --save-dev @n8n/mcp-server

# สร้าง config directory ถ้ายังไม่มี
mkdir -p ~/.config/claude-code

# แก้ไข MCP settings file
nano ~/.config/claude-code/settings.json

# Config location
%APPDATA%\Claude\settings.json

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "http://localhost:5678",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

# เริ่ม Claude Code
claude

# ใน Claude Code session ตรวจสอบว่า MCP tools พร้อมใช้งาน
/mcp

# คุณควรเห็น n8n tools:
# - create_workflow
# - update_workflow
# - get_workflow
# - list_workflows
# - execute_workflow
# - etc.

User: สร้าง n8n workflow ที่ monitor webhook endpoint,
      validate payload และส่งการแจ้งเตือนไปยัง Slack
      ถ้าข้อมูลมี error flag

Claude: ฉันจะสร้าง webhook monitoring workflow นั้นให้คุณ
        พร้อม validation และ Slack notification ที่เหมาะสม

[Claude ใช้ n8n-mcp create_workflow tool]

Claude: ✅ สร้าง workflow "Webhook Monitor with Slack Alerts" สำเร็จ (ID: 1234)

   Workflow ประกอบด้วย:
   • Webhook trigger node รอที่ /webhook/monitor
   • IF node สำหรับตรวจสอบ payload structure
   • Slack message node สำหรับ error notifications
   • Error handling พร้อม automatic retries
   
   Webhook URL: https://your-instance.n8n.cloud/webhook/monitor
   
   คุณต้องการให้ฉัน:
   1. เปิดใช้งาน workflow ตอนนี้?
   2. เพิ่ม validation rules เพิ่มเติม?
   3. ตั้งค่า notification channels อื่น?

User: เปิดใช้งานและแสดงวิธีทดสอบ

Claude: [ใช้ activate_workflow และอธิบายกระบวนการทดสอบ]

# ให้ Claude วิเคราะห์ workflow ที่มีอยู่
claude

User: วิเคราะห์ workflow ID 5678 และแนะนำการปรับปรุง error handling

Claude: [ใช้ get_workflow เพื่ออ่าน JSON, วิเคราะห์, แนะนำการปรับปรุง]

Claude: ฉันพบหลายจุดที่สามารถปรับปรุงได้:
   • ไม่มี error handling บน HTTP Request node (บรรทัด 45)
   • ขาด retry logic สำหรับ external API calls
   • ไม่มี notification เมื่อ workflow ล้มเหลว
   
   คุณต้องการให้ฉัน refactor workflow ด้วยการปรับปรุงเหล่านี้หรือไม่?

User: ใช่ ใช้การปรับปรุงทั้งหมด

Claude: [ใช้ update_workflow เพื่อใช้การเปลี่ยนแปลง]

# สร้างหลาย workflow ที่เกี่ยวข้อง
User: สร้างสาม workflow สำหรับ data pipeline:
   1. Extract data จาก PostgreSQL ทุกชั่วโมง
   2. Transform และ validate data
   3. Load เข้า data warehouse
   
   ควรเชื่อมต่อกันเพื่อให้ workflow 2 ทำงานหลังจาก 1 เสร็จ

Claude: [สร้างทั้งสาม workflow พร้อมการเชื่อมต่อและ error handling ที่เหมาะสม]

Cursor Menu → Preferences → Cursor Settings → MCP

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

{
  "servers": [
    {
      "name": "n8n",
      "command": "npx -y @n8n/mcp-server",
      "env": {
        "N8N_HOST": "${N8N_HOST}",
        "N8N_API_KEY": "${N8N_API_KEY}"
      }
    }
  ]
}

N8N_HOST=https://your-n8n-instance.n8n.cloud
N8N_API_KEY=n8n_api_your_api_key_here

You: @n8n สร้าง workflow ที่เชื่อมต่อกับ GitHub repository,
      เฝ้าดู issues ใหม่ และสร้าง task ใน Notion database
      พร้อมรายละเอียด issue

Cursor: ฉันจะสร้าง workflow สำหรับบูรณากร GitHub-to-Notion ให้คุณ

[Cursor เรียกใช้ n8n-mcp tools ผ่าน chat interface]

Cursor: ✅ สร้าง "GitHub Issues to Notion" workflow สำเร็จ

   Components:
   • GitHub Trigger: Poll หา issues ใหม่ทุก 5 นาที
   • Set Node: Format issue data สำหรับ Notion
   • Notion Node: สร้าง database entry
   • Error Handling: แจ้งเตือนเมื่อล้มเหลว
   
   Credentials ที่ต้องการ:
   • GitHub OAuth (ยังไม่ตั้งค่า)
   • Notion Integration Token (ยังไม่ตั้งค่า)
   
   ต้องการให้ฉันช่วยตั้งค่า credentials เหล่านี้หรือไม่?

You: @n8n สร้าง workflow ประมวลผลคำสั่งซื้อ e-commerce ที่ครบถ้วน:
   1. รับ webhook จาก Shopify เมื่อมีคำสั่งซื้อใหม่
   2. Validate inventory ใน PostgreSQL
   3. คำนวณค่าจัดส่งผ่าน ShipEngine API
   4. สร้าง invoice ใน QuickBooks
   5. ส่ง confirmation email ผ่าน SendGrid
   6. จัดการ errors ในแต่ละขั้นตอนด้วย Slack notifications

Cursor Agent: [ทำงานโดยอัตโนมัติเป็นเวลา 2-3 นาที]
   • สร้าง webhook endpoint
   • ตั้งค่า database query nodes
   • ตั้งค่า API integrations
   • เพิ่ม error handling branches
   • ทดสอบ connectivity

Cursor: ✅ สร้าง e-commerce workflow ที่สมบูรณ์พร้อม 12 nodes!
   
   📊 สรุป Workflow:
   • 1 Webhook trigger
   • 2 Database operations
   • 3 API integrations
   • 4 Email templates
   • 2 Error handling branches
   
   ทุก nodes ตั้งค่าด้วย credentials ที่เหมาะสม
   พร้อมเปิดใช้งานเมื่อคุณพร้อม

You: @n8n แสดง workflow ID 7890

Cursor: [แสดง workflow JSON inline]

   นี่คือ webhook monitoring workflow:
   
   ```json
   {
     "name": "Monitor Webhook",
     "nodes": [
       {
         "type": "n8n-nodes-base.webhook",
         "name": "Webhook",
         ...
       }
     ]
   }

**Context-Aware Workflow Generation:**

ถ้าคุณกำลังทำงานในโปรเจคที่มีโค้ดอยู่แล้ว Cursor สามารถสร้าง workflow ที่ตรงกับรูปแบบของคุณ:

---

## การบูรณากร Windsurf

Windsurf เป็น IDE ที่ขับเคลื่อนด้วย AI รุ่นใหม่ล่าสุดพร้อมความสามารถ agentic ที่ลึกซึ้ง ฟีเจอร์ Cascade ช่วยให้สร้าง workflow หลายขั้นตอนด้วย n8n-mcp

### การตั้งค่า

**ขั้นตอนที่ 1: เปิด Windsurf Settings**

**ขั้นตอนที่ 2: ตั้งค่า n8n-mcp**

เพิ่มใน Windsurf MCP configuration:

```json
{
  "mcpServers": {
    "n8n": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

You: @n8n สร้าง marketing automation workflow ที่ครอบคลุม:
   1. Monitor Google Sheets สำหรับ lead entries ใหม่
   2. Enrich leads ด้วย Clearbit data
   3. Score leads ตาม firmographic criteria
   4. Route hot leads ไป Salesforce
   5. เพิ่ม warm leads เข้า Mailchimp nurture sequence
   6. Log ทุกอย่างลง Airtable สำหรับ reporting

Windsurf Cascade: 
   🔄 Step 1/6: สร้าง Google Sheets trigger...
   ✅ Google Sheets trigger ตั้งค่าแล้ว
   
   🔄 Step 2/6: ตั้งค่า Clearbit enrichment...
   ✅ Clearbit API integration เพิ่มแล้ว
   
   🔄 Step 3/6: สร้าง lead scoring logic...
   ✅ IF nodes สำหรับ scoring criteria ตั้งค่าแล้ว
   
   🔄 Step 4/6: ตั้งค่า Salesforce routing...
   ✅ Salesforce node พร้อม field mapping
   
   🔄 Step 5/6: ตั้งค่า Mailchimp sequence...
   ✅ Mailchimp automation trigger ตั้งค่าแล้ว
   
   🔄 Step 6/6: เพิ่ม Airtable logging...
   ✅ Airtable logging พร้อม error handling
   
✅ สร้าง marketing automation workflow สมบูรณ์แล้ว!

   📈 Workflow Statistics:
   • 8 nodes รวม
   • 3 external APIs บูรณากร
   • 2 conditional branches
   • 100% error coverage
   
   ประมาณการประหยัดเวลา: 15 ชั่วโมง/สัปดาห์

You: @n8n นี่คือ spec สำหรับ data sync workflow:

   SPEC: Customer Data Synchronization
   
   Trigger: ทุกชั่วโมงผ่าน Cron
   Source: PostgreSQL customers table (last_modified > ${lastRun})
   Transform:
     - Normalize phone numbers
     - Validate email format
     - Split full_name เป็น first_name, last_name
   Destination: HubSpot Contacts API
   Error Handling: 
     - Retry 3 ครั้งด้วย exponential backoff
     - Alert Slack #data-ops เมื่อล้มเหลว
     - Log ทุก errors ไปยัง error tracking table
   
   สร้างให้ตรงกับ spec นี้พอดี

Windsurf: [ทำตาม spec อย่างแม่นยำ ถามคำถามเฉพาะที่จำเป็น
           implement complete workflow ตาม requirements]

You: @n8n อัปเดต workflow ที่เราสร้างเมื่อวานเพื่อเพิ่ม
      Zendesk integration สำหรับ support tickets

Windsurf: [จดจำ context ของ workflow ก่อนหน้า ดึงข้อมูล
           เพิ่ม Zendesk node พร้อม field mapping ที่เหมาะสม]

# แก้ไข Claude Desktop configuration
nano ~/Library/Application\ Support/Claude/config.json

# แก้ไข config ที่
%APPDATA%\Claude\config.json

{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "https://your-n8n-instance.n8n.cloud",
        "N8N_API_KEY": "n8n_api_your_api_key_here"
      }
    }
  }
}

สร้าง support ticket automation workflow ที่:
1. รับ webhooks จาก Zendesk เมื่อมี tickets ใหม่
2. ใช้ AI classify urgency (Critical/High/Medium/Low)
3. ค้นหา customer plan ในฐานข้อมูล (Free/Pro/Enterprise)
4. Route Critical + Enterprise ไป senior support Slack
5. Route High + Pro/Enterprise ไป standard support
6. สร้าง Jira issue สำหรับ bugs, feature request ใน Productboard
7. ส่ง auto-response email ผ่าน SendGrid
8. Log ทุกอย่างพร้อม execution metadata

{
  "name": "Intelligent Support Ticket Routing",
  "nodes": [
    {
      "parameters": {
        "httpMethod": "POST",
        "path": "zendesk-ticket-webhook",
        "responseMode": "responseNode"
      },
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [250, 300],
      "webhookId": "zendesk-incoming",
      "name": "Zendesk Webhook"
    },
    {
      "parameters": {
        "jsCode": "// AI Classification Logic\nconst ticket = $json.body.ticket;\nconst subject = ticket.subject.toLowerCase();\nconst description = ticket.description.toLowerCase();\n\nlet urgency = 'Low';\nconst criticalKeywords = ['outage', 'down', 'crash', 'security', 'breach', 'urgent'];\nconst highKeywords = ['broken', 'error', 'not working', 'bug', 'issue'];\n\nif (criticalKeywords.some(k => subject.includes(k) || description.includes(k))) {\n  urgency = 'Critical';\n} else if (highKeywords.some(k => subject.includes(k) || description.includes(k))) {\n  urgency = 'High';\n} else if (ticket.priority === 'urgent') {\n  urgency = 'Critical';\n}\n\nreturn [{\n  json: {\n    ...$json,\n    urgency,\n    customer_id: ticket.requester.external_id,\n    ticket_id: ticket.id,\n    subject: ticket.subject\n  }\n}];"
      },
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [450, 300],
      "name": "AI Urgency Classifier"
    },
    {
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT plan_type, account_manager FROM customers WHERE id = $1",
        "parameters": ["={{ $json.customer_id }}"]
      },
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2,
      "position": [650, 300],
      "name": "Lookup Customer Plan",
      "credentials": {
        "postgres": {
          "id": "cred-postgres-prod",
          "name": "Production DB"
        }
      }
    },
    {
      "parameters": {
        "conditions": {
          "options": {
            "caseSensitive": true,
            "leftValue": "",
            "typeValidation": "strict"
          },
          "conditions": [
            {
              "id": "critical-enterprise",
              "leftValue": "={{ $json.urgency + '-' + $json.plan_type }}",
              "rightValue": "Critical-Enterprise",
              "operator": {
                "type": "string",
                "operation": "equals"
              }
            },
            {
              "id": "high-tier",
              "leftValue": "={{ $json.urgency }}",
              "rightValue": "High",
              "operator": {
                "type": "string",
                "operation": "equals"
              }
            },
            {
              "id": "enterprise-any",
              "leftValue": "={{ $json.plan_type }}",
              "rightValue": "Enterprise",
              "operator": {
                "type": "string",
                "operation": "equals"
              }
            }
          ],
          "combinator": "or"
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 2,
      "position": [850, 300],
      "name": "Priority Router"
    },
    {
      "parameters": {
        "channel": "#support-senior",
        "text": "🚨 *Critical Enterprise Ticket*\n*Customer:* {{ $json.customer_id }}\n*Plan:* {{ $json.plan_type }}\n*Urgency:* {{ $json.urgency }}\n*Subject:* {{ $json.subject }}\n*Ticket:* https://company.zendesk.com/agent/tickets/{{ $json.ticket_id }}",
        "blocks": [
          {
            "type": "section",
            "text": {
              "type": "mrkdwn",
              "text": "🚨 *Critical Enterprise Ticket Requires Immediate Attention*"
            }
          },
          {
            "type": "section",
            "fields": [
              {
                "type": "mrkdwn",
                "text": "*Customer:*\n{{ $json.customer_id }}"
              },
              {
                "type": "mrkdwn",
                "text": "*Plan:*\n{{ $json.plan_type }}"
              },
              {
                "type": "mrkdwn",
                "text": "*Urgency:*\n{{ $json.urgency }}"
              },
              {
                "type": "mrkdwn",
                "text": "*Account Manager:*\n{{ $json.account_manager }}"
              }
            ]
          },
          {
            "type": "actions",
            "elements": [
              {
                "type": "button",
                "text": {
                  "type": "plain_text",
                  "text": "View Ticket"
                },
                "url": "https://company.zendesk.com/agent/tickets/{{ $json.ticket_id }}"
              }
            ]
          }
        ]
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [1050, 200],
      "name": "Senior Support Alert"
    },
    {
      "parameters": {
        "channel": "#support-standard",
        "text": "📋 New {{ $json.urgency }} Priority Ticket\n*Subject:* {{ $json.subject }}\n*Plan:* {{ $json.plan_type }}"
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [1050, 350],
      "name": "Standard Support Alert"
    },
    {
      "parameters": {
        "resource": "issue",
        "operation": "create",
        "project": "SUP",
        "summary": "={{ $json.subject }}",
        "description": "={{ $json.body.ticket.description }}",
        "issuetype": "Bug",
        "fields": {
          "priority": "={{ $json.urgency === 'Critical' ? 'Highest' : $json.urgency === 'High' ? 'High' : 'Medium' }}",
          "labels": ["zendesk-auto", "{{ $json.plan_type }}"]
        }
      },
      "type": "n8n-nodes-base.jira",
      "typeVersion": 1,
      "position": [1250, 250],
      "name": "Create Jira Bug"
    },
    {
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.body.ticket.requester.email }}",
        "subject": "Re: {{ $json.subject }} - We've received your request",
        "text": "Hi there,\n\nThank you for contacting support. We've received your ticket and classified it as {{ $json.urgency }} priority.\n\nExpected response time: {{ $json.plan_type === 'Enterprise' ? '1 hour' : $json.plan_type === 'Pro' ? '4 hours' : '24 hours' }}\n\nTicket reference: #{{ $json.ticket_id }}\n\nBest regards,\nSupport Team",
        "options": {
          "categories": ["Support"]
        }
      },
      "type": "n8n-nodes-base.sendGrid",
      "typeVersion": 1,
      "position": [1450, 300],
      "name": "Auto-Response Email"
    },
    {
      "parameters": {
        "operation": "insert",
        "table": "support_automation_log",
        "columns": {
          "ticket_id": "={{ $json.ticket_id }}",
          "customer_id": "={{ $json.customer_id }}",
          "urgency": "={{ $json.urgency }}",
          "plan_type": "={{ $json.plan_type }}",
          "routed_to": "={{ $json.urgency === 'Critical' && $json.plan_type === 'Enterprise' ? 'senior' : 'standard' }}",
          "jira_issue": "={{ $('Create Jira Bug').item.json.key }}",
          "email_sent": "={{ $('Auto-Response Email').item.json.success }}",
          "created_at": "={{ $now }}"
        }
      },
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2,
      "position": [1650, 300],
      "name": "Log Execution"
    }
  ],
  "connections": {
    "Zendesk Webhook": {
      "main": [[{"node": "AI Urgency Classifier", "type": "main", "index": 0}]]
    },
    "AI Urgency Classifier": {
      "main": [[{"node": "Lookup Customer Plan", "type": "main", "index": 0}]]
    },
    "Lookup Customer Plan": {
      "main": [[{"node": "Priority Router", "type": "main", "index": 0}]]
    },
    "Priority Router": {
      "main": [
        [{"node": "Senior Support Alert", "type": "main", "index": 0}],
        [{"node": "Standard Support Alert", "type": "main", "index": 0}]
      ]
    },
    "Senior Support Alert": {
      "main": [[{"node": "Create Jira Bug", "type": "main", "index": 0}]]
    },
    "Standard Support Alert": {
      "main": [[{"node": "Create Jira Bug", "type": "main", "index": 0}]]
    },
    "Create Jira Bug": {
      "main": [[{"node": "Auto-Response Email", "type": "main", "index": 0}]]
    },
    "Auto-Response Email": {
      "main": [[{"node": "Log Execution", "type": "main", "index": 0}]]
    }
  },
  "settings": {
    "executionOrder": "v1",
    "errorWorkflow": "error-handler-workflow-id"
  }
}

สร้าง ELT pipeline workflow ที่:
1. รันทุกวันเวลา 2 AM UTC ผ่าน Cron
2. Extract transactions จาก PostgreSQL (24 ชั่วโมงล่าสุด)
3. Extract user events จาก MongoDB (24 ชั่วโมงล่าสุด)
4. Extract exchange rates จาก external API
5. Transform data: normalize currency, calculate fees, enrich ด้วย user data
6. Validate: ตรวจสอบ nulls, duplicates, outliers
7. Load เข้า Snowflake data warehouse
8. เมื่อ validation ล้มเหลว: quarantine bad records, alert data team
9. เมื่อสำเร็จ: แจ้งเตือน analytics Slack, อัปเดต Airflow DAG status
10. Keep full audit log ของทุก operations

{
  "name": "Daily ELT Data Pipeline",
  "trigger": {
    "type": "n8n-nodes-base.cron",
    "cronExpression": "0 2 * * *",
    "timezone": "UTC"
  },
  "nodes": [
    {
      "name": "Pipeline Orchestrator",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Calculate time window for extraction\nconst now = new Date();\nconst yesterday = new Date(now - 24 * 60 * 60 * 1000);\nconst timeWindow = {\n  start: yesterday.toISOString(),\n  end: now.toISOString(),\n  date_only: yesterday.toISOString().split('T')[0]\n};\n\nreturn [{\n  json: {\n    pipeline_id: $execution.id,\n    run_date: timeWindow.date_only,\n    extraction_window: timeWindow,\n    status: 'started',\n    started_at: now.toISOString()\n  }\n}];"
      }
    },
    {
      "name": "Extract Transactions",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT t.*, u.email, u.tier FROM transactions t JOIN users u ON t.user_id = u.id WHERE t.created_at >= $1 AND t.created_at < $2 AND t.status = 'completed'",
        "parameters": ["={{ $json.extraction_window.start }}", "={{ $json.extraction_window.end }}"]
      }
    },
    {
      "name": "Extract Events",
      "type": "n8n-nodes-base.mongoDb",
      "parameters": {
        "operation": "find",
        "collection": "user_events",
        "options": "{ \"timestamp\": { $gte: new Date('{{ $json.extraction_window.start }}'), $lt: new Date('{{ $json.extraction_window.end }}') } }"
      }
    },
    {
      "name": "Fetch Exchange Rates",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://api.exchangerate.host/latest",
        "query": {
          "base": "USD",
          "symbols": "EUR,GBP,JPY,CAD,AUD"
        },
        "options": {
          "timeout": 30000
        }
      }
    },
    {
      "name": "Transform & Enrich",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Data transformation logic\nconst transactions = $('Extract Transactions').all()[0].json;\nconst events = $('Extract Events').all()[0].json;\nconst rates = $('Fetch Exchange Rates').all()[0].json.rates;\n\nconst enriched = transactions.map(t => {\n  const rate = rates[t.currency] || 1;\n  const usdAmount = t.amount / rate;\n  const fee = calculateFee(usdAmount, t.tier);\n  \n  return {\n    ...t,\n    usd_amount: usdAmount,\n    exchange_rate: rate,\n    fee_usd: fee,\n    net_amount: usdAmount - fee,\n    event_count: events.filter(e => e.user_id === t.user_id).length,\n    _validation_status: 'pending'\n  };\n});\n\nfunction calculateFee(amount, tier) {\n  const rates = { free: 0.029, pro: 0.019, enterprise: 0.009 };\n  return amount * (rates[tier] || rates.free);\n}\n\nreturn enriched.map(e => ({ json: e }));"
      }
    },
    {
      "name": "Data Validator",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Validation rules\nconst records = $input.all();\nconst valid = [];\nconst invalid = [];\n\nfor (const record of records) {\n  const errors = [];\n  const r = record.json;\n  \n  // Rule 1: No null critical fields\n  if (!r.user_id || !r.amount || !r.currency) {\n    errors.push('MISSING_CRITICAL_FIELDS');\n  }\n  \n  // Rule 2: Amount range check\n  if (r.amount < 0 || r.amount > 1000000) {\n    errors.push('AMOUNT_OUT_OF_RANGE');\n  }\n  \n  // Rule 3: Duplicate check\n  const isDuplicate = valid.some(v => v.json.transaction_id === r.transaction_id);\n  if (isDuplicate) {\n    errors.push('DUPLICATE_TRANSACTION');\n  }\n  \n  // Rule 4: Outlier detection (amount > 5 std dev from mean)\n  const amounts = records.map(rec => rec.json.usd_amount);\n  const mean = amounts.reduce((a, b) => a + b, 0) / amounts.length;\n  const std = Math.sqrt(amounts.reduce((sq, n) => sq + Math.pow(n - mean, 2), 0) / amounts.length);\n  if (r.usd_amount > mean + 5 * std) {\n    errors.push('STATISTICAL_OUTLIER');\n  }\n  \n  if (errors.length > 0) {\n    invalid.push({\n      json: { ...r, _validation_errors: errors, _quarantine_reason: errors.join(', ') }\n    });\n  } else {\n    valid.push(record);\n  }\n}\n\nreturn [valid, invalid];",
        "mode": "runOnceForEachItem"
      }
    },
    {
      "name": "Load to Snowflake",
      "type": "n8n-nodes-base.snowflake",
      "parameters": {
        "operation": "insert",
        "table": "TRANSACTIONS_DAILY",
        "columns": "={{ Object.keys($json).join(', ') }}",
        "data": "={{ $json }}"
      }
    },
    {
      "name": "Quarantine Bad Records",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "data_quality_quarantine",
        "columns": {
          "pipeline_id": "={{ $json.pipeline_id }}",
          "record_data": "={{ JSON.stringify($json) }}",
          "validation_errors": "={{ $json._validation_errors.join(', ') }}",
          "quarantine_date": "={{ $now }}"
        }
      }
    },
    {
      "name": "Data Quality Alert",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#data-quality",
        "blocks": [
          {
            "type": "header",
            "text": {
              "type": "plain_text",
              "text": "⚠️ Data Quality Alert"
            }
          },
          {
            "type": "section",
            "text": {
              "type": "mrkdwn",
              "text": "Records failed validation and were quarantined."
            }
          }
        ]
      }
    },
    {
      "name": "Pipeline Complete",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// Final status and metrics\nconst validCount = $('Load to Snowflake').all().length;\nconst invalidCount = $('Quarantine Bad Records').all().length;\nconst total = validCount + invalidCount;\n\nreturn [{\n  json: {\n    pipeline_id: $json.pipeline_id,\n    status: 'completed',\n    run_date: $json.run_date,\n    metrics: {\n      total_records: total,\n      valid_records: validCount,\n      invalid_records: invalidCount,\n      success_rate: ((validCount / total) * 100).toFixed(2) + '%'\n    },\n    completed_at: new Date().toISOString()\n  }\n}];"
      }
    },
    {
      "name": "Notify Analytics Team",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#analytics",
        "text": "✅ Daily ELT Complete\nDate: {{ $json.run_date }}\nRecords: {{ $json.metrics.total_records }}\nSuccess Rate: {{ $json.metrics.success_rate }}"
      }
    },
    {
      "name": "Audit Log",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "pipeline_audit_log",
        "columns": {
          "pipeline_id": "={{ $json.pipeline_id }}",
          "run_date": "={{ $json.run_date }}",
          "status": "={{ $json.status }}",
          "metrics": "={{ JSON.stringify($json.metrics) }}",
          "created_at": "={{ $now }}"
        }
      }
    }
  ]
}

สร้าง marketing automation workflow ที่ซับซ้อน:
1. Trigger เมื่อลูกค้าทิ้งตะกร้า (ผ่าน Shopify webhook)
2. ตรวจสอบ customer lifetime value (CLV) และ engagement score
3. สำหรับลูกค้า high-value: ติดต่อส่วนตัวทันทีผ่าน SMS
4. สำหรับ medium-value: email sequence (ทันที + 24h + 72h)
5. สำหรับ low-value: single email พร้อม discount code
6. รวม product recommendations แบบ dynamic ตาม cart + purchase history
7. Track conversions และ attribute ไปยัง campaign ที่ถูกต้อง
8. หยุด sequence ถ้าลูกค้าซื้อสำเร็จ
9. A/B test subject lines สำหรับ email variants
10. รายงาน metrics รายวันไป marketing dashboard

{
  "name": "Abandoned Cart Recovery - Personalized",
  "nodes": [
    {
      "name": "Shopify Cart Abandoned",
      "type": "n8n-nodes-base.webhook",
      "parameters": {
        "httpMethod": "POST",
        "path": "cart-abandoned",
        "responseMode": "responseNode"
      }
    },
    {
      "name": "Enrich Customer Data",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT c.*, COUNT(o.id) as total_orders, COALESCE(SUM(o.total), 0) as lifetime_value, MAX(o.created_at) as last_order_date FROM customers c LEFT JOIN orders o ON o.customer_id = c.id WHERE c.id = $1 GROUP BY c.id",
        "parameters": ["={{ $json.customer_id }}"]
      }
    },
    {
      "name": "Calculate Engagement Score",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const customer = $json;\nconst daysSinceLastOrder = Math.floor((new Date() - new Date(customer.last_order_date)) / (1000 * 60 * 60 * 24));\nconst orderFrequency = customer.total_orders / Math.max(1, Math.floor(daysSinceLastOrder / 30));\n\nlet engagementScore = 0;\nengagementScore += Math.min(customer.lifetime_value / 100, 50); // Max 50 points\nengagementScore += Math.min(customer.total_orders * 5, 30); // Max 30 points\nengagementScore += orderFrequency > 1 ? 20 : orderFrequency * 10; // Max 20 points\n\nlet segment = 'low';\nif (engagementScore >= 70) segment = 'high';\nelse if (engagementScore >= 40) segment = 'medium';\n\nreturn [{\n  json: {\n    ...customer,\n    engagement_score: Math.round(engagementScore),\n    segment,\n    days_since_order: daysSinceLastOrder\n  }\n}];"
      }
    },
    {
      "name": "Segment Router",
      "type": "n8n-nodes-base.switch",
      "parameters": {
        "rules": {
          "rules": [
            { "value": "high", "output": 0 },
            { "value": "medium", "output": 1 },
            { "value": "low", "output": 2 }
          ]
        }
      }
    },
    {
      "name": "High-Value: Send SMS",
      "type": "n8n-nodes-base.twilio",
      "parameters": {
        "operation": "send",
        "to": "={{ $json.phone }}",
        "from": "+1234567890",
        "body": "Hi {{ $json.first_name }}, you left items in your cart! Complete your order now: https://shop.com/cart/{{ $json.cart_id }}?discount=VIP10"
      }
    },
    {
      "name": "High-Value: Mark VIP",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "update",
        "table": "customers",
        "columns": {
          "priority": "vip_abandoned_cart",
          "last_touch": "={{ $now }}"
        },
        "where": "id = {{ $json.id }}"
      }
    },
    {
      "name": "Medium-Value: A/B Test",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "// 50/50 A/B test\nconst variant = Math.random() < 0.5 ? 'A' : 'B';\nconst subjects = {\n  A: \"Don't miss out on your cart, {{ $json.first_name }}!\",\n  B: \"Your items are waiting (and selling fast)\"\n};\n\nreturn [{\n  json: {\n    ...$json,\n    ab_variant: variant,\n    subject_line: subjects[variant]\n  }\n}];"
      }
    },
    {
      "name": "Medium: Send Email 1",
      "type": "n8n-nodes-base.sendGrid",
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.email }}",
        "subject": "={{ $json.subject_line }}",
        "html": "<html><body><h1>Hi {{ $json.first_name }}</h1><p>You left items in your cart. <a href='https://shop.com/cart/{{ $json.cart_id }}'>Complete your order</a></p></body></html>"
      }
    },
    {
      "name": "Medium: Wait 24h",
      "type": "n8n-nodes-base.wait",
      "parameters": {
        "amount": 24,
        "unit": "hours"
      }
    },
    {
      "name": "Check Purchase Status",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT COUNT(*) as purchased FROM orders WHERE customer_id = $1 AND created_at > $2",
        "parameters": ["={{ $json.id }}", "={{ $json.last_touch }}"]
      }
    },
    {
      "name": "Still Abandoned?",
      "type": "n8n-nodes-base.if",
      "parameters": {
        "conditions": {
          "number": [
            { "value1": "={{ $json.purchased }}", "value2": 0 }
          ]
        }
      }
    },
    {
      "name": "Medium: Send Email 2",
      "type": "n8n-nodes-base.sendGrid",
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.email }}",
        "subject": "Still thinking it over? Here's 10% off",
        "html": "<html><body><h1>Your cart misses you</h1><p>Use code COMEBACK10 for 10% off your order: <a href='https://shop.com/cart/{{ $json.cart_id }}?discount=COMEBACK10'>Complete Purchase</a></p></body></html>"
      }
    },
    {
      "name": "Low-Value: Discount Email",
      "type": "n8n-nodes-base.sendGrid",
      "parameters": {
        "from": "[email protected]",
        "to": "={{ $json.email }}",
        "subject": "Complete your order with 15% off",
        "html": "<html><body><h1>Special offer for you</h1><p>Use code SAVE15 for 15% off: <a href='https://shop.com/cart/{{ $json.cart_id }}?discount=SAVE15'>Shop Now</a></p></body></html>"
      }
    },
    {
      "name": "Track Campaign Touch",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "marketing_touches",
        "columns": {
          "customer_id": "={{ $json.id }}",
          "campaign": "abandoned_cart_recovery",
          "segment": "={{ $json.segment }}",
          "channel": "email",
          "sent_at": "={{ $now }}"
        }
      }
    },
    {
      "name": "Daily Report",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#marketing-metrics",
        "text": "📊 Daily Cart Recovery Summary\nHigh-value SMS sent: X\nMedium-value emails: Y\nLow-value emails: Z\nConversions attributed: W"
      }
    }
  ]
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    n8n-mcp Security Architecture                                │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Layer 1: AI Tool Authentication                                             │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • ใช้ API keys แยกสำหรับแต่ละ AI tool instance                          │  │
│   │  • Rotate keys ทุก 90 วัน                                            │  │
│   │  • เก็บ keys ใน environment variables, ไม่ใช่ใน config files          │  │
│   │  • ใช้ n8n instances แยกสำหรับ dev/staging/production                │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Layer 2: MCP Server Security                                                │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • รัน n8n-mcp ใน isolated container                                    │  │
│   │  • จำกัด network access เฉพาะ n8n instance                           │  │
│   │  • Enable request logging และ monitoring                                │  │
│   │  • Implement rate limiting (แนะนำ 100 req/min)                       │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Layer 3: n8n API Security                                                     │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • ใช้ API keys ด้วยสิทธิ์ขั้นต่ำ (read-only เมื่อเป็นไปได้)    │  │
│   │  • Enable IP allowlisting                                               │  │
│   │  • Implement workflow-level access controls                             │  │
│   │  • Audit ทุก API calls                                                  │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Layer 4: Workflow Security                                                    │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  • ตรวจสอบ AI-generated workflows ก่อน activation                      │  │
│   │  • Implement credential vaulting (ไม่ hardcode secrets)               │  │
│   │  • เพิ่ม error handling เพื่อป้องกัน data leakage                           │  │
│   │  • ใช้ credentials แยกสำหรับ dev/production                        │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# ใช้ environment variables สำหรับ credentials
export N8N_API_KEY="n8n_api_$(cat /secure/path/to/key)"
export N8N_HOST="https://your-instance.n8n.cloud"

# เริ่ม Claude Code ด้วยสิทธิ์ที่จำกัด
claude --allow-read ./project --allow-write ./project

# ตรวจสอบ MCP tool calls ทั้งหมดก่อน execution
# Claude Code จะขอ confirmation สำหรับ operations ที่มีความเสี่ยง

// .cursor/settings.json
{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "${N8N_HOST}",
        "N8N_API_KEY": "${N8N_API_KEY}"
      }
    }
  },
  // Enable confirmation prompts
  "mcp.confirmDestructiveOperations": true,
  "mcp.showToolCallsInChat": true
}

// .windsurf/settings.json
{
  "mcpServers": {
    "n8n": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "env": {
        "N8N_HOST": "${N8N_HOST}",
        "N8N_API_KEY": "${N8N_API_KEY}"
      }
    }
  },
  // Security settings
  "mcp.requireConfirmation": true,
  "mcp.auditLogPath": "./logs/mcp-audit.json"
}

☐ ไม่มี hardcoded credentials ใน workflow JSON
☐ ไม่มี PII ใน test data หรือ expressions
☐ Error handling ป้องกัน data leakage
☐ API keys ใช้ least-privilege access
☐ Webhook endpoints ใช้ authentication
☐ Workflow ตรวจสอบโดย human ก่อน activation
☐ มีแผน rollback ที่ document
☐ Monitoring และ alerting ตั้งค่าแล้ว

เป้าหมาย:
• ทดสอบ n8n-mcp กับ power users 2-3 คน
• สร้าง sample workflows 5-10 ตัว
• จด best practices ภายใน
• ระบุ security requirements

Deliverables:
• รายงาน pilot พร้อม metrics
• การตรวจสอบ security เสร็จสมบูรณ์
• เอกสาร training เริ่มต้น
• ตัดสินใจ go/no-go สำหรับ Phase 2

เป้าหมาย:
• ขยายไปยัง automation team เต็มรูปแบบ
• สร้าง workflow library (20+ templates)
• Implement governance framework
• ฝึกอบรม team leads

Deliverables:
• Workflow catalog พร้อม documentation
• Governance policy document
• Training เสร็จสมบูรณ์สำหรับผู้ใช้ 20+ คน
• กระบวนการ support ที่จัดตั้งขึ้น

เป้าหมาย:
• การ deploy หลาย department
• 100+ AI-assisted workflows
• Automated testing และ deployment
• Monitoring และ observability เต็มรูปแบบ

Deliverables:
• Enterprise workflow standards
• Automated CI/CD สำหรับ workflows
• Analytics dashboard
• ROI measurement

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    AI-Generated Workflow Governance                            │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Developer สร้าง workflow ผ่าน AI                                            │
│          │                                                                      │
│          ▼                                                                      │
│   ┌─────────────────────┐                                                    │
│   │ Automated Scanning  │                                                    │
│   │ • Security check    │                                                    │
│   │ • Credential scan   │                                                    │
│   │ • Policy compliance │                                                    │
│   └──────────┬──────────┘                                                    │
│              │                                                                  │
│     ┌────────┴────────┐                                                       │
│     ▼                 ▼                                                       │
│  Pass            Fail                                                         │
│     │                 │                                                       │
│     ▼                 ▼                                                       │
│ Review            Return with                                                 │
│ Queue             fixes required                                              │
│     │                                                                       │
│     ▼                                                                       │
│ Technical                                                                     │
│ Review                                                                        │
│ (Senior Dev)                                                                  │
│     │                                                                       │
│     ▼                                                                       │
│   ┌─────────────────────┐                                                    │
│   │ Production Deploy   │                                                    │
│   │ • Version control   │                                                    │
│   │ • Monitoring        │                                                    │
│   │ • Rollback plan     │                                                    │
│   └─────────────────────┘                                                    │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    Multi-Agent Workflow Development                            │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Architect Agent (Claude Code)                                               │
│   • ออกแบบโครงสร้าง workflow                                                │
│   • กำหนด node requirements                                                 │
│   • สร้าง documentation                                                     │
│          │                                                                      │
│          ▼                                                                      │
│   Implementation Agent (Cursor)                                                 │
│   • สร้าง workflow JSON                                                   │
│   • ตั้งค่า nodes และ expressions                                          │
│   • เพิ่ม error handling                                                     │
│          │                                                                      │
│          ▼                                                                      │
│   Review Agent (Windsurf)                                                     │
│   • ตรวจสอบตาม best practices                                            │
│   • แนะนำ optimizations                                                   │
│   • ตรวจสอบ security compliance                                           │
│          │                                                                      │
│          ▼                                                                      │
│   Testing Agent (Claude Code)                                                 │
│   • สร้าง test scenarios                                                    │
│   • รัน validation                                                         │
│   • รายงาน issues                                                           │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

# โครงสร้าง workflow repository
n8n-workflows/
├── workflows/
│   ├── support-automation.json
│   ├── data-pipeline.json
│   └── marketing-campaigns/
│       ├── abandoned-cart.json
│       └── welcome-series.json
├── docs/
│   ├── support-automation.md  # AI-generated documentation
│   └── data-pipeline.md
├── tests/
│   └── workflow-validator.js
└── .cursor/
    └── mcp.json

# Workflow: Support Ticket Automation

## Overview
Route support tickets โดยอัตโนมัติตาม urgency และ customer tier

## Trigger
- Webhook: `/webhook/support-incoming`
- Source: Zendesk

## Flow
1. รับ ticket webhook
2. Classify urgency ผ่าน AI analysis
3. ค้นหา customer plan
4. Route ไปยังทีมที่เหมาะสม
5. สร้าง Jira issue
6. ส่ง confirmation email

## Nodes
| Node | Type | Purpose |
|------|------|---------|
| Webhook | Webhook | Entry point |
| AI Classifier | Code | Urgency detection |
| Customer Lookup | Postgres | Plan retrieval |
| Router | IF | Priority routing |

## Error Handling
- Retry: 3 attempts
- Fallback: Slack notification
- Logging: PostgreSQL

## Maintenance
- Last updated: 2026-05-19
- Owner: [email protected]

// AI-generated test suite สำหรับ n8n workflow

describe('Support Ticket Automation', () => {
  test('Critical + Enterprise routes to senior support', async () => {
    const result = await executeWorkflow({
      ticket: {
        subject: 'URGENT: System outage',
        priority: 'urgent',
        requester: { external_id: 'ENT-123' }
      }
    });
    
    expect(result.routing).toBe('senior');
    expect(result.slack_channel).toBe('#support-senior');
  });
  
  test('Low priority + Free tier routes to standard', async () => {
    const result = await executeWorkflow({
      ticket: {
        subject: 'Feature question',
        priority: 'low',
        requester: { external_id: 'FREE-456' }
      }
    });
    
    expect(result.routing).toBe('standard');
  });
  
  test('Missing customer ID handles gracefully', async () => {
    const result = await executeWorkflow({
      ticket: {
        subject: 'Help needed',
        requester: { external_id: null }
      }
    });
    
    expect(result.error).toBeDefined();
    expect(result.error_handled).toBe(true);
  });
  
});

# 1. ตรวจสอบว่า n8n-mcp ติดตั้งแล้ว
npm list -g @n8n/mcp-server

# 2. ทดสอบ MCP server ด้วยตนเอง
npx @n8n/mcp-server

# 3. ตรวจสอบ environment variables
echo $N8N_HOST
echo $N8N_API_KEY

# 4. ตรวจสอบว่า n8n API เข้าถึงได้
curl -H "X-N8N-API-KEY: $N8N_API_KEY" \
     "$N8N_HOST/api/v1/workflows"

# 5. ตรวจสอบ logs ของ AI tool สำหรับ errors
# Claude Code: ~/.claude/logs/
# Cursor: View → Output → MCP

// สาเหตุทั่วไปและการแก้ไข:

// 1. Invalid node type
// Fix: ใช้ node type ที่ถูกต้องจาก n8n documentation
"type": "n8n-nodes-base.httpRequest" // ถูกต้อง
"type": "http-request" // ไม่ถูกต้อง

// 2. Missing required parameters
// Fix: ตรวจสอบ node schema สำหรับ required fields
{
  "parameters": {
    "url": "={{ $json.endpoint }}", // Required
    "method": "POST", // Required
    // "headers" is optional
  }
}

// 3. Invalid JSON ใน expressions
// Fix: ใช้ JSON syntax ที่ถูกต้อง
"query": "={{ JSON.stringify($json.params) }}"

// 4. Credential reference errors
// Fix: ตรวจสอบว่า credential ID มีอยู่
"credentials": {
  "slackApi": {
    "id": "valid-credential-id-here"
  }
}

# 1. ตรวจสอบว่า credentials มีอยู่ใน n8n
n8n credential:list

# 2. ตรวจสอบ credential permissions
# ตรวจสอบว่า API keys มี scopes ที่ต้องการ

# 3. ทดสอบ credential ใน n8n UI ก่อน
# Manual test ก่อน AI-generated workflow

# 4. อัปเดต credential reference ใน workflow
# AI อาจต้องการ explicit credential ID

User: "เพิ่ม delay ระหว่าง email และ SMS nodes,
        และเปลี่ยน delay จาก 1 ชั่วโมงเป็น 30 นาที"

AI: [ค้นหา workflow, ระบุ nodes, อัปเดต delay configuration,
     รักษา settings อื่นๆ, commit change]

AI: "ฉันสังเกตเห็นว่า HTTP node นี้ไม่มี error handling
     ตาม API documentation มีอัตราความล้มเหลว 2%
     ต้องการให้ฉันเพิ่ม automatic retry logic หรือไม่?"

AI: "ฉันได้วิเคราะห์ workflows 47 ตัวของคุณ พบว่า 12 ตัว query
     database table เดียวกัน ฉันสามารถรวมเหล่านี้เป็น
     single optimized data pipeline ที่ลด API calls 65%
     ได้ ต้องการดู proposal หรือไม่?"

User: [Voice] "สร้าง workflow ที่ monitor API health
               ทุก 5 นาที และ page ทีมถ้า
               response time เกิน 2 วินาที"

AI: [Transcribe, ตีความ, สร้าง complete workflow]

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    MCP Protocol Message Flow                                   │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   Phase 1: Server Discovery และ Initialization                                  │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                                                                         │  │
│   │  Host ────────────► Server                                               │  │
│   │        initialize                                                       │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "method": "initialize",                                        │  │
│   │          "params": {                                                    │  │
│   │            "protocolVersion": "2025-11-25",                             │  │
│   │            "capabilities": {                                            │  │
│   │              "tools": { "listChanged": true },                          │  │
│   │              "resources": { "subscribe": true }                         │  │
│   │            }                                                            │  │
│   │          }                                                              │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   │  Host ◄─────────── Server                                               │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "result": {                                                    │  │
│   │            "protocolVersion": "2025-11-25",                             │  │
│   │            "serverInfo": {                                              │  │
│   │              "name": "n8n-mcp",                                         │  │
│   │              "version": "1.0.0"                                         │  │
│   │            },                                                           │  │
│   │            "capabilities": {                                            │  │
│   │              "tools": {                                                   │  │
│   │                "create_workflow": { ... },                            │  │
│   │                "execute_workflow": { ... }                              │  │
│   │              },                                                           │  │
│   │              "resources": {                                             │  │
│   │                "workflow://{id}": { ... }                             │  │
│   │              }                                                          │  │
│   │            }                                                            │  │
│   │          }                                                              │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Phase 2: Tool Invocation                                                      │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                                                                         │  │
│   │  Host ────────────► Server                                               │  │
│   │        tools/call                                                         │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "method": "tools/call",                                        │  │
│   │          "params": {                                                    │  │
│   │            "name": "create_workflow",                                   │  │
│   │            "arguments": {                                               │  │
│   │              "name": "Webhook Monitor",                                 │  │
│   │              "nodes": [...],                                              │  │
│   │              "connections": {...}                                       │  │
│   │            }                                                            │  │
│   │          },                                                             │  │
│   │          "id": 1                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   │  Host ◄─────────── Server                                               │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "result": {                                                    │  │
│   │            "content": [                                                   │  │
│   │              {                                                          │  │
│   │                "type": "text",                                          │  │
│   │                "text": "Workflow created successfully. ID: 12345"       │  │
│   │              }                                                          │  │
│   │            ],                                                           │  │
│   │            "isError": false                                             │  │
│   │          },                                                             │  │
│   │          "id": 1                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   Phase 3: Resource Access                                                        │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │                                                                         │  │
│   │  Host ────────────► Server                                               │  │
│   │        resources/read                                                     │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "method": "resources/read",                                    │  │
│   │          "params": {                                                    │  │
│   │            "uri": "workflow://12345"                                    │  │
│   │          },                                                             │  │
│   │          "id": 2                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   │  Host ◄─────────── Server                                               │  │
│   │        {                                                                │  │
│   │          "jsonrpc": "2.0",                                              │  │
│   │          "result": {                                                    │  │
│   │            "contents": [{                                                │  │
│   │              "uri": "workflow://12345",                                 │  │
│   │              "mimeType": "application/json",                            │  │
│   │              "text": "{...full workflow JSON...}"                     │  │
│   │            }]                                                           │  │
│   │          },                                                             │  │
│   │          "id": 2                                                        │  │
│   │        }                                                                │  │
│   │                                                                         │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

// stdio transport characteristics:
// - Latency ต่ำสุด
// - Process isolation
// - Automatic cleanup เมื่อ parent exit
// - ไม่มี network exposure

// ตัวอย่าง stdio configuration:
{
  "mcpServers": {
    "n8n": {
      "command": "npx",
      "args": ["-y", "@n8n/mcp-server"],
      "transport": "stdio"  // Explicit, แม้จะเป็น default
    }
  }
}

// SSE transport characteristics:
// - Network-accessible
// • รองรับหลาย clients พร้อมกัน
// • ต้องการ authentication
// • Enable centralized logging

// ตัวอย่าง SSE configuration:
{
  "mcpServers": {
    "n8n-enterprise": {
      "url": "https://mcp-gateway.company.com/n8n",
      "transport": "sse",
      "headers": {
        "Authorization": "Bearer ${MCP_TOKEN}"
      }
    }
  }
}

// Error handling wrapper สำหรับ n8n-mcp calls
async function callN8nMcpWithRetry(toolName, args, maxRetries = 3) {
  const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
  
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const result = await callMcpTool('n8n', toolName, args);
      
      // ตรวจสอบ MCP-level errors
      if (result.isError) {
        throw new MCPError(result.content[0].text, result.errorCode);
      }
      
      return result;
      
    } catch (error) {
      const isRetryable = [
        '-32603',  // Internal error (อาจเป็น transient)
        '1003',    // Rate limited
        'ECONNRESET',
        'ETIMEDOUT'
      ].includes(error.code);
      
      if (!isRetryable || attempt === maxRetries) {
        throw error;
      }
      
      // Exponential backoff
      const waitTime = Math.pow(2, attempt) * 1000;
      console.log(`Attempt ${attempt} failed, retrying in ${waitTime}ms...`);
      await delay(waitTime);
    }
  }
}

// แทนที่จะสร้างจากศูนย์ ใช้ pre-validated templates
const workflowTemplates = {
  'webhook-processing': {
    nodes: ['webhook', 'code', 'if', 'slack'],
    defaultConfig: { ... }
  },
  'scheduled-etl': {
    nodes: ['cron', 'postgres', 'transform', 'snowflake'],
    defaultConfig: { ... }
  }
};

// AI กรอกรายละเอียดเฉพาะ ขณะที่รักษาโครงสร้างที่พิสูจน์แล้ว
function generateFromTemplate(templateName, customizations) {
  const base = workflowTemplates[templateName];
  return merge(base, customizations);
}

แทนที่จะ: "สร้าง workflow 50 nodes"

ใช้: "สร้าง trigger node"
     → "เพิ่ม data extraction nodes"
     → "เพิ่ม transformation logic"
     → "เพิ่ม output nodes"
     → "เชื่อมทุกอย่างเข้าด้วยกัน"

ผล: สร้างเร็วขึ้น, debug ง่ายขึ้น

// สร้าง branches ที่เป็นอิสระกันพร้อมกัน
const [branchA, branchB, branchC] = await Promise.all([
  generateBranch('validation'),
  generateBranch('processing'),
  generateBranch('notification')
]);

// Merge เข้า workflow เดียว
return mergeWorkflows([branchA, branchB, branchC]);

// ก่อน: Sequential execution
const results = [];
for (const item of items) {
  const result = await processItem(item);
  results.push(result);
}

// หลัง: Batch processing
const batches = chunk(items, 100);
const results = await Promise.all(
  batches.map(batch => processBatch(batch))
);

// ก่อน: N+1 queries
const users = await getAllUsers();
for (const user of users) {
  const orders = await getUserOrders(user.id);  // N queries
}

// หลัง: Single JOIN query
const usersWithOrders = await query(`
  SELECT u.*, json_agg(o.*) as orders
  FROM users u
  LEFT JOIN orders o ON o.user_id = u.id
  WHERE u.id IN (${userIds.join(',')})
  GROUP BY u.id
`);

{
  "name": "SOX Compliance Data Change Tracking",
  "trigger": {
    "type": "n8n-nodes-base.postgresTrigger",
    "event": [
      "INSERT",
      "UPDATE",
      "DELETE"
    ],
    "schema": "public",
    "table": "financial_records"
  },
  "nodes": [
    {
      "name": "Capture Change",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const change = $json;\nconst changeType = change.__operation === 'INSERT' ? 'CREATE' : change.__operation === 'UPDATE' ? 'MODIFY' : 'DELETE';\n\nreturn [{\n  json: {\n    change_id: generateUUID(),\n    table: change.__table,\n    record_id: change.id,\n    change_type: changeType,\n    old_values: changeType === 'CREATE' ? null : change.__old,\n    new_values: changeType === 'DELETE' ? null : change.__new,\n    changed_by: change.__user,\n    changed_at: change.__timestamp,\n    requires_approval: changeType === 'DELETE' || (changeType === 'MODIFY' && change.amount !== change.__old.amount)\n  }\n}];"
      }
    },
    {
      "name": "Risk Assessment",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const change = $json;\nlet riskLevel = 'LOW';\n\n// High-risk indicators\nif (change.change_type === 'DELETE') riskLevel = 'CRITICAL';\nelse if (Math.abs(change.new_values.amount - (change.old_values?.amount || 0)) > 10000) riskLevel = 'HIGH';\nelse if (change.changed_at.getHours() < 6 || change.changed_at.getHours() > 22) riskLevel = 'MEDIUM';\n\nreturn [{\n  json: {\n    ...change,\n    risk_level: riskLevel,\n    auto_approved: riskLevel === 'LOW' && change.change_type !== 'DELETE'\n  }\n}];"
      }
    },
    {
      "name": "Route by Risk",
      "type": "n8n-nodes-base.switch",
      "parameters": {
        "rules": {
          "rules": [
            { "value": "CRITICAL", "output": 0 },
            { "value": "HIGH", "output": 1 },
            { "value": "MEDIUM", "output": 2 },
            { "value": "LOW", "output": 3 }
          ]
        }
      }
    },
    {
      "name": "Critical Alert",
      "type": "n8n-nodes-base.pagerduty",
      "parameters": {
        "operation": "create",
        "incident": {
          "title": "CRITICAL: Financial Record Deleted",
          "service": "compliance",
          "urgency": "high"
        }
      }
    },
    {
      "name": "Require Approval",
      "type": "n8n-nodes-base.slack",
      "parameters": {
        "channel": "#compliance-approvals",
        "blocks": [
          {
            "type": "section",
            "text": { "type": "mrkdwn", "text": "Approval Required" }
          }
        ]
      }
    },
    {
      "name": "Auto-Log",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "insert",
        "table": "sox_audit_log",
        "columns": { /* ... */ }
      }
    }
  ]
}

{
  "name": "IoT Predictive Maintenance",
  "trigger": {
    "type": "n8n-nodes-base.mqtt",
    "topics": ["sensors/+/telemetry"],
    "qos": 1
  },
  "nodes": [
    {
      "name": "Parse Telemetry",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const payload = JSON.parse($json.payload);\nconst sensorId = $json.topic.split('/')[1];\n\nreturn [{\n  json: {\n    sensor_id: sensorId,\n    temperature: payload.temp,\n    vibration: payload.vib,\n    pressure: payload.pressure,\n    timestamp: payload.ts,\n    facility: payload.facility_id,\n    equipment_type: payload.equipment_type\n  }\n}];"
      }
    },
    {
      "name": "Anomaly Detection",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://ml-api.company.com/predict",
        "method": "POST",
        "body": {
          "sensor_data": "={{ $json }}"
        }
      }
    },
    {
      "name": "Check Thresholds",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "jsCode": "const reading = $json;\nconst thresholds = {\n  temperature: { warn: 80, critical: 95 },\n  vibration: { warn: 5, critical: 10 },\n  pressure: { warn: 150, critical: 200 }\n};\n\nconst alerts = [];\nfor (const [metric, value] of Object.entries(reading)) {\n  if (thresholds[metric]) {\n    if (value >= thresholds[metric].critical) {\n      alerts.push({ metric, level: 'CRITICAL', value });\n    } else if (value >= thresholds[metric].warn) {\n      alerts.push({ metric, level: 'WARNING', value });\n    }\n  }\n}\n\nreturn [{\n  json: {\n    ...reading,\n    alerts,\n    requires_action: alerts.some(a => a.level === 'CRITICAL')\n  }\n}];"
      }
    },
    {
      "name": "Maintenance Prediction",
      "type": "n8n-nodes-base.postgres",
      "parameters": {
        "operation": "executeQuery",
        "query": "SELECT AVG(days_to_failure) as avg_days FROM maintenance_history WHERE equipment_type = $1 AND sensor_readings <@ $2::jsonb",
        "parameters": ["={{ $json.equipment_type }}", "={{ JSON.stringify({temp: $json.temperature, vib: $json.vibration}) }}"]
      }
    },
    {
      "name": "Create Work Order",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://cmms.company.com/api/workorders",
        "method": "POST",
        "body": {
          "equipment_id": "={{ $json.sensor_id }}",
          "priority": "={{ $json.alerts[0].level }}",
          "predicted_failure": "={{ $json.avg_days }} days",
          "description": "AI-predicted maintenance required"
        }
      }
    }
  ]
}

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    Workflow Migration Assessment                                │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│   ขั้นตอนที่ 1: Inventory                                                      │
│   • Export workflows ที่มีอยู่ทั้งหมด                                            │
│   • Document trigger types และ frequencies                                   │
│   • Catalog integrations และ credentials ทั้งหมด                             │
│   • ระบุ error rates และ reliability issues                                   │
│                                                                                 │
│   ขั้นตอนที่ 2: Prioritization                                                  │
│   ┌─────────────────────────────────────────────────────────────────────────┐  │
│   │  ให้คะแนนแต่ละ workflow บน:                                              │  │
│   │  • Complexity (1-10) — สูง = เหมาะสำหรับ AI                             │  │
│   │  • Business impact (1-10) — เริ่มต้นด้วย high impact                    │  │
│   │  • Change frequency (1-10) — การเปลี่ยนแปลงบ่อย benefit มากที่สุด    │  │
│   │  • Error rate (1-10) — Workflows ที่เสียต้องดูก่อน                    │  │
│   │                                                                          │  │
│   │  Priority Score = Complexity × 0.3 + Impact × 0.4 +                    │  │
│   │                   ChangeFreq × 0.2 + ErrorRate × 0.1                    │  │
│   └─────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
│   ขั้นตอนที่ 3: Migration Waves                                               │
│   • Wave 1: ง่าย, low-risk (1-2 สัปดาห์)                                        │
│   • Wave 2: ความซับซ้อนปานกลาง (3-4 สัปดาห์)                                   │
│   • Wave 3: ซับซ้อน, critical (6-8 สัปดาห์)                                   │
│                                                                                 │
│   ขั้นตอนที่ 4: Validation                                                      │
│   • Parallel running (เก่า + ใหม่)                                              │
│   • Output comparison                                                           │
│   • Stakeholder sign-off                                                        │
│   • Gradual traffic shifting                                                    │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

{
  "name": "Customer Onboarding (Legacy)",
  "nodes": [
    { "type": "webhook", "name": "Webhook" },
    { "type": "postgres", "name": "CreateUser" },
    { "type": "httpRequest", "name": "SendWelcomeEmail" },
    { "type": "slack", "name": "NotifySales" },
    // ... 8 nodes อื่นๆ
  ]
}

User: "วิเคราะห์ customer onboarding workflow นี้และแนะนำการปรับปรุง
      สำหรับ error handling ที่ดีขึ้น, เพิ่ม retry logic, implement idempotency
      checks, และ optimize database queries"

Claude Code: [วิเคราะห์ workflow โดยใช้ n8n-mcp]

Claude: วิเคราะห์เสร็จสมบูรณ์ ฉันพบหลายโอกาสในการปรับปรุง:

ปัญหาที่พบ:
• ไม่มี idempotency check — duplicate webhooks สร้าง duplicate users
• ไม่มี retry logic บน HTTP nodes
• Sequential database queries สามารถ batch ได้
• ไม่มี error notifications
• ไม่มี circuit breaker สำหรับ external services

การเปลี่ยนแปลงที่แนะนำ:
1. เพิ่ม idempotency check โดยใช้ webhook signature
2. Implement retry ด้วย exponential backoff
3. Batch database operations
4. เพิ่ม error handling ครอบคลุม
5. เพิ่ม circuit breaker สำหรับ SendGrid API

ต้องการให้ฉัน implement การปรับปรุงเหล่านี้หรือไม่?

User: ใช่ ใช้การปรับปรุงทั้งหมด

Claude: [ใช้ update_workflow เพื่อใช้การเปลี่ยนแปลง]

✅ Workflow อัปเดตด้วย 15 การปรับปรุง:
   • เพิ่ม Idempotency middleware
   • Retry logic: 3 attempts, exponential backoff
   • Database queries batched (เร็วขึ้น 40%)
   • Error handling บนทุก external calls
   • Circuit breaker สำหรับ SendGrid API
   • Comprehensive audit logging