<!-- ตัวอย่างการตอบสนอง TwiML -->
<Response>
  <Say>สวัสดี! ขอบคุณที่โทรมา ฉันกำลังเชื่อมต่อคุณกับผู้ช่วย AI ของเรา</Say>
  <Connect>
    <Stream url="wss://your-server.com/media-stream" />
  </Connect>
</Response>

┌─────────────────────────────────────────────────────────────────┐
│                         ผู้โทร                                 │
└─────────────────────┬───────────────────────────────────────────┘
                      │ การโทร
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│                        Twilio                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  หมายเลขโทรศัพท์ → Webhook TwiML → Media Stream (WebSocket) │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────┬───────────────────────────────────────────┘
                      │ WebSocket
                      ▼
┌─────────────────────────────────────────────────────────────────┐
│                     n8n Workflow                                │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────────┐  │
│  │  WebSocket   │───▶│  AI Agent    │───▶│  ElevenLabs TTS  │  │
│  │   Server     │◄───│  Processing  │◄───│   (Voice Out)    │  │
│  └──────────────┘    └──────────────┘    └──────────────────┘  │
│         │                   │                       │          │
│         ▼                   ▼                       ▼          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              การผสานรวมระบบธุรกิจ                      │   │
│  │  CRM | ปฏิทิน | ฐานข้อมูล | การชำระเงิน | การแจ้งเตือน │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

1. ผู้โทรกดหมายเลขโทรศัพท์
         ↓
2. Twilio รับสาย เรียก webhook ไปยัง n8n
         ↓
3. n8n workflow เริ่มต้นเซสชั่น AI agent
         ↓
4. ElevenLabs สร้างคำทักทาย ("สวัสดี ฉันช่วยอะไรคุณได้บ้าง?")
         ↓
5. Twilio สตรีมคำทักทายไปยังผู้โทร
         ↓
6. ผู้โทรพูด → เสียงถูกสตรีมผ่าน WebSocket ไปยัง n8n
         ↓
7. n8n ถอดเสียงเป็นข้อความ (Deepgram/Whisper)
         ↓
8. ข้อความถูกส่งไปยัง LLM (OpenAI/Claude/Ollama)
         ↓
9. LLM สร้างคำตอบ
         ↓
10. ElevenLabs สังเคราะห์เสียงตอบ
         ↓
11. เสียงถูกสตรีมกลับไปยังผู้โทร
         ↓
12. ทำซ้ำขั้นตอน 6-11 จนกว่าสายจะสิ้นสุดหรือต้องการโอนสาย
         ↓
13. n8n บันทึกการโทร อัปเดต CRM ส่งการแจ้งเตือน

┌─────────────────────────────────────────────────────────────────┐
│              ElevenLabs Conversational AI                       │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐      │
│  │   Speech     │───▶│   LLM with   │───▶│    Voice     │      │
│  │  Recognition │    │  Tool Calls  │    │  Synthesis   │      │
│  └──────────────┘    └──────┬───────┘    └──────────────┘      │
│                             │                                  │
│                             ▼                                  │
│                    ┌────────────────┐                          │
│                    │  n8n Webhook   │◄── Tool execution        │
│                    │  (Tool Calls)  │                          │
│                    └───────┬────────┘                          │
│                            │                                   │
└────────────────────────────┼───────────────────────────────────┘
                             │ API/WebSocket
                             ▼
                    ┌────────────────┐
                    │ Business Logic │
                    │  CRM/Calendar  │
                    └────────────────┘

# ใช้ Twilio CLI
twilio phone-numbers:buy:local --country-code TH

# หรือผ่าน Console: Phone Numbers → Manage → Buy a number

คุณคือ Sarah พนักงานต้อนรับที่เป็นมิตรสำหรับคลินิกทันตกรรมของเรา
คุณจัดการการนัดหมาย ตอบคำถามเกี่ยวกับบริการ และให้ข้อมูลทั่วไป
จงอบอุ่น เป็นมืออาชีพ และมีประสิทธิภาพ

ข้อมูลสำคัญ:
- เวลาทำการ: จันทร์-ศุกร์ 9:00-18:00 น.
- บริการ: ทันตกรรมทั่วไป จัดฟัน ฟอกสีฟัน
- การปรึกษาลูกค้าใหม่ไม่เสียค่าใช้จ่าย
- มีบริการฉุกเฉิน 24 ชั่วโมง

ยืนยันรายละเอียดการนัดหมอเสมอก่อนจบการโทร

# docker-compose.yml
version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your_secure_password
      - GENERIC_TIMEZONE=Asia/Bangkok
      - WEBHOOK_URL=https://your-domain.com/
    volumes:
      - ./n8n-data:/home/node/.n8n
    networks:
      - automation-network

  # Optional: Webhook tunnel สำหรับการพัฒนาในเครื่อง
  ngrok:
    image: ngrok/ngrok:latest
    command: http n8n:5678 --authtoken=${NGROK_AUTH_TOKEN}
    networks:
      - automation-network

networks:
  automation-network:
    driver: bridge

# สร้างไดเรกทอรี
mkdir -p n8n-data

# เริ่มบริการ
docker-compose up -d

# ตรวจสอบ logs
docker-compose logs -f n8n

// Node: สร้าง TwiML
const twiml = `<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Say>
    สวัสดี! ขอบคุณที่โทรมา Tropical Media
    ผู้ช่วย AI ของเรากำลังอยู่ในระหว่างการพัฒนา
    กรุณาฝากข้อความหลังเสียงสัญญาณ
  </Say>
  <Record maxLength="120" />
</Response>`;

return [{
  json: {
    headers: {
      'Content-Type': 'text/xml'
    },
    statusCode: 200,
    body: twiml
  }
}];

[Twilio Call] → [Webhook: การตั้งค่าเริ่มต้น] → [WebSocket Server]
                                              ↓
[ElevenLabs] ← [n8n AI Processing] ← [Speech-to-Text]
     ↓              ↓
[Voice Output] → [Caller]

คุณคือพนักงานต้อนรับ AI ที่เป็นประโยชน์สำหรับคลินิกทันตกรรม
ชื่อของคุณคือ Sarah

ความสามารถของคุณ:
- จัดตารางนัดหมอสำหรับผู้ป่วยเก่าและใหม่
- ตอบคำถามเกี่ยวกับบริการและราคา
- ให้ข้อมูลเวลาทำการและที่ตั้ง
- จัดการกรณีฉุกเฉินโดยการโอนสายไปยังทันตแพทย์เวร

เมื่อจัดตารางนัดหมาย:
1. รวบรวมชื่อเต็มของผู้ป่วย
2. ยืนยันหมายเลขโทรศัพท์
3. ถามวันที่และเวลาที่ต้องการ
4. ถามเหตุผลในการมา (ตรวจสุขภาพ, ทำความสะอาด, ฯลฯ)
5. ยืนยันรายละเอียดทั้งหมดก่อนจอง

จงอบอุ่น เป็นมืออาชีพ และอดทนเสมอ หากคุณไม่รู้สิ่งใด 
เสนอให้ตัวแทนของมนุษย์โทรกลับ

{
  "name": "check_availability",
  "description": "ตรวจสอบช่วงเวลานัดหมายที่ว่างสำหรับวันที่กำหนด",
  "parameters": {
    "type": "object",
    "properties": {
      "date": {
        "type": "string",
        "format": "date",
        "description": "วันที่ต้องการตรวจสอบ (YYYY-MM-DD)"
      },
      "appointment_type": {
        "type": "string",
        "enum": ["cleaning", "checkup", "consultation", "emergency"],
        "description": "ประเภทการนัดหมาย"
      }
    },
    "required": ["date", "appointment_type"]
  }
}

{
  "name": "book_appointment",
  "description": "จองนัดหมายสำหรับผู้ป่วย",
  "parameters": {
    "type": "object",
    "properties": {
      "patient_name": {
        "type": "string",
        "description": "ชื่อเต็มของผู้ป่วย"
      },
      "phone": {
        "type": "string",
        "description": "หมายเลขโทรศัพท์ของผู้ป่วย"
      },
      "date": {
        "type": "string",
        "format": "date"
      },
      "time": {
        "type": "string",
        "pattern": "^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$"
      },
      "appointment_type": {
        "type": "string"
      },
      "notes": {
        "type": "string"
      }
    },
    "required": ["patient_name", "phone", "date", "time", "appointment_type"]
  }
}

{
  "name": "send_summary",
  "description": "ส่งสรุปการโทรไปยังเจ้าหน้าที่ต้อนรับผ่าน Slack",
  "parameters": {
    "type": "object",
    "properties": {
      "summary": {
        "type": "string",
        "description": "สรุปการโทร"
      },
      "urgency": {
        "type": "string",
        "enum": ["low", "medium", "high"]
      }
    },
    "required": ["summary"]
  }
}

// Node: Parse Tool Request
const body = $input.first().json.body;

return [{
  json: {
    toolName: body.tool_name,
    parameters: body.parameters,
    callId: body.call_id,
    conversationId: body.conversation_id
  }
}];

// Node: ตรวจสอบปฏิทิน
const { date, appointment_type } = $input.first().json.parameters;

// สืบค้นระบบการจองของคุณ (ตัวอย่างด้วย Cal.com API)
const availability = await $httpRequest({
  method: 'GET',
  url: `https://api.cal.com/v1/availability`,
  qs: {
    apiKey: $env.CAL_API_KEY,
    dateFrom: date,
    dateTo: date,
    eventTypeId: getEventTypeId(appointment_type)
  }
});

// จัดรูปแบบช่วงเวลาที่ว่าง
const slots = availability.slots.map(slot => 
  new Date(slot.time).toLocaleTimeString('th-TH', { 
    hour: '2-digit', 
    minute: '2-digit',
    hour12: false 
  })
);

return [{
  json: {
    result: {
      available: slots.length > 0,
      slots: slots.slice(0, 5), // ส่งคืนช่วงเวลา 5 ช่วงแรก
      date: date
    }
  }
}];

function getEventTypeId(type) {
  const map = {
    'cleaning': 123,
    'checkup': 124,
    'consultation': 125,
    'emergency': 126
  };
  return map[type] || 124;
}

// Node: จองนัดหมาย
const params = $input.first().json.parameters;

// สร้างการจอง
const booking = await $httpRequest({
  method: 'POST',
  url: 'https://api.cal.com/v1/bookings',
  body: {
    apiKey: $env.CAL_API_KEY,
    eventTypeId: getEventTypeId(params.appointment_type),
    start: `${params.date}T${params.time}`,
    name: params.patient_name,
    email: `temp@${params.phone}.placeholder`, // Placeholder
    location: 'Phone consultation',
    metadata: {
      phone: params.phone,
      source: 'ai_voice_agent',
      notes: params.notes || ''
    }
  }
});

// เก็บใน CRM
await $httpRequest({
  method: 'POST',
  url: 'https://your-crm.com/api/appointments',
  body: {
    patient_name: params.patient_name,
    phone: params.phone,
    date: params.date,
    time: params.time,
    type: params.appointment_type,
    booking_id: booking.id,
    source: 'voice_agent'
  },
  headers: {
    'Authorization': `Bearer ${$env.CRM_API_KEY}`
  }
});

// ส่ง SMS ยืนยัน
await $httpRequest({
  method: 'POST',
  url: 'https://api.twilio.com/2010-04-01/Accounts/YOUR_SID/Messages.json',
  body: {
    To: params.phone,
    From: $env.TWILIO_PHONE_NUMBER,
    Body: `สวัสดี ${params.patient_name} นัดหมายของคุณวันที่ ${params.date} เวลา ${params.time} น. ได้รับการยืนยันแล้ว ตอบ CANCEL เพื่อเปลี่ยนกำหนดการ`
  },
  auth: {
    username: $env.TWILIO_ACCOUNT_SID,
    password: $env.TWILIO_AUTH_TOKEN
  }
});

return [{
  json: {
    result: {
      success: true,
      booking_id: booking.id,
      confirmation_sent: true
    }
  }
}];

// Node: ส่งไปยัง Slack
const { summary, urgency = 'low' } = $input.first().json.parameters;

const urgencyEmoji = {
  'high': '🔴',
  'medium': '🟡',
  'low': '🟢'
};

await $httpRequest({
  method: 'POST',
  url: $env.SLACK_WEBHOOK_URL,
  body: {
    text: `${urgencyEmoji[urgency]} *สรุป AI Voice Agent*`,
    blocks: [
      {
        type: 'header',
        text: {
          type: 'plain_text',
          text: 'สรุปการโทร AI Voice Agent'
        }
      },
      {
        type: 'section',
        fields: [
          {
            type: 'mrkdwn',
            text: `*ความเร่งด่วน:*\n${urgency}`
          },
          {
            type: 'mrkdwn',
            text: `*เวลา:*\n${new Date().toLocaleString('th-TH')}`
          }
        ]
      },
      {
        type: 'section',
        text: {
          type: 'mrkdwn',
          text: `*สรุป:*\n${summary}`
        }
      }
    ]
  }
});

return [{
  json: {
    result: {
      sent: true,
      channel: 'reception-team'
    }
  }
}];

// Node: ส่งคืนไปยัง ElevenLabs
const toolResult = $input.first().json.result;

return [{
  json: {
    statusCode: 200,
    body: {
      result: toolResult
    }
  }
}];

// Node: Proxy ไปยัง ElevenLabs
const callSid = $input.first().json.body.CallSid;
const from = $input.first().json.body.From;

// ตรรกะที่กำหนดเอง: ตรวจสอบว่าผู้โทรถูกบล็อกหรือไม่
const isBlocked = await checkBlockedList(from);

if (isBlocked) {
  return [{
    json: {
      headers: { 'Content-Type': 'text/xml' },
      body: `<?xml version="1.0"?>
<Response>
  <Say>หมายเลขนี้ถูกบล็อก</Say>
  <Hangup/>
</Response>`
    }
  }];
}

// ส่งต่อไปยัง ElevenLabs
return [{
  json: {
    headers: { 'Content-Type': 'text/xml' },
    body: `<?xml version="1.0"?>
<Response>
  <Connect>
    <Stream url="wss://api.elevenlabs.io/v1/convai/twilio/connect/${AGENT_ID}" />
  </Connect>
</Response>`
  }
}];

// Node: โอนสาย
const { callSid, transferTo } = $input.first().json.parameters;

// การโอนสาย Twilio โดยใช้ Dial
const twiml = `<?xml version="1.0"?>
<Response>
  <Say>ฉันกำลังโอนสายไปยังสมาชิกในทีม กรุณารอสักครู่</Say>
  <Dial>
    <Number>${transferTo}</Number>
  </Dial>
</Response>`;

// อัปเดตการโทรผ่าน Twilio API
await $httpRequest({
  method: 'POST',
  url: `https://api.twilio.com/2010-04-01/Accounts/${TWILIO_SID}/Calls/${callSid}`,
  body: {
    Twiml: twiml
  },
  auth: {
    username: $env.TWILIO_ACCOUNT_SID,
    password: $env.TWILIO_AUTH_TOKEN
  }
});

return [{
  json: {
    result: {
      transferred: true,
      to: transferTo
    }
  }
}];

{
  "name": "transfer_to_human",
  "description": "โอนสายไปยังตัวแทนของมนุษย์",
  "parameters": {
    "type": "object",
    "properties": {
      "department": {
        "type": "string",
        "enum": ["sales", "support", "billing", "emergency"]
      },
      "reason": {
        "type": "string",
        "description": "เหตุผลในการโอนสาย"
      }
    },
    "required": ["department"]
  }
}

// Node: การตรวจจับภาษา
const message = $input.first().json.body.message;

// ใช้ OpenAI เพื่อตรวจจับภาษา
const detection = await $httpRequest({
  method: 'POST',
  url: 'https://api.openai.com/v1/chat/completions',
  body: {
    model: 'gpt-4o-mini',
    messages: [
      {
        role: 'system',
        content: 'ตรวจจับภาษาของข้อความป้อนข้อมูล คืนค่าเฉพาะรหัส ISO 639-1 (เช่น "th", "en", "zh", "ja")'
      },
      {
        role: 'user',
        content: message
      }
    ]
  },
  headers: {
    'Authorization': `Bearer ${$env.OPENAI_API_KEY}`
  }
});

const language = detection.choices[0].message.content.trim();

// แมปไปยังเสียง ElevenLabs
const voiceMap = {
  'th': 'custom-thai-voice-id',    // ไทย
  'en': 'TX3AEvVoIzMeN6jBfAjZ',    // อังกฤษ
  'zh': 'Hh1cR3w8I9fHNkEn11VW',    // จีน
  'ja': 'custom-japanese-voice-id' // ญี่ปุ่น
};

return [{
  json: {
    language: language,
    voice_id: voiceMap[language] || voiceMap['th'],
    system_prompt: getLocalizedPrompt(language)
  }
}];

function getLocalizedPrompt(lang) {
  const prompts = {
    'th': 'คุณเป็นผู้ช่วยที่เป็นประโยชน์...',
    'en': 'You are a helpful assistant...',
    'zh': '你是一个乐于助人的助手...',
    'ja': 'あなたは役立つアシスタントです...'
  };
  return prompts[lang] || prompts['th'];
}

// Node: ตรวจสอบลายเซ็น Twilio
const crypto = require('crypto');

const authToken = $env.TWILIO_AUTH_TOKEN;
const twilioSignature = $input.first().json.headers['x-twilio-signature'];
const url = $input.first().json.originalUrl;
const params = $input.first().json.body;

// สร้างสตริงสำหรับการลงนาม
let data = url;
Object.keys(params).sort().forEach(key => {
  data += key + params[key];
});

// คำนวณลายเซ็นที่คาดหวัง
const expectedSignature = crypto
  .createHmac('sha1', authToken)
  .update(Buffer.from(data, 'utf8'))
  .digest('base64');

// ตรวจสอบ
if (twilioSignature !== expectedSignature) {
  return [{
    json: {
      statusCode: 403,
      body: { error: 'ลายเซ็นไม่ถูกต้อง' }
    }
  }];
}

// ดำเนินการต่อ
return $input.all();

// Node: ตรวจสอบขีดจำกัดอัตรา
const caller = $input.first().json.body.From;
const cacheKey = `rate_limit:${caller}`;

// ตรวจสอบ Redis หรือแคชที่คล้ายกัน
const callCount = await cache.get(cacheKey) || 0;

if (callCount > 10) { // สูงสุด 10 สายต่อชั่วโมง
  return [{
    json: {
      statusCode: 429,
      body: { error: 'เกินขีดจำกัดอัตรา' }
    }
  }];
}

// เพิ่มตัวนับ
await cache.set(cacheKey, callCount + 1, 'EX', 3600); // 1 ชั่วโมง TTL

return $input.all();

// Node: บันทึกการโทร
const callData = $input.first().json;

await $httpRequest({
  method: 'POST',
  url: 'https://your-logging-service.com/api/logs',
  body: {
    timestamp: new Date().toISOString(),
    level: 'info',
    service: 'voice-agent',
    call_sid: callData.CallSid,
    from: callData.From,
    to: callData.To,
    duration: callData.CallDuration,
    status: callData.CallStatus,
    // อย่าบันทึกสำเนาการสนทนาเต็มไปยัง logs สาธารณะ
    transcript_hash: hashTranscript(callData.Transcript)
  }
});

// Workflow: การตรวจสอบสุขภาพ (ทำซ้ำทุก 5 นาที)
// Trigger: Cron - */5 * * * *

const checks = [
  checkTwilioConnectivity(),
  checkElevenLabsAPI(),
  checkDatabaseConnection(),
  checkCRMConnection()
];

const results = await Promise.all(checks);

const allHealthy = results.every(r => r.healthy);

if (!allHealthy) {
  await $httpRequest({
    method: 'POST',
    url: $env.PAGERDUTY_WEBHOOK,
    body: {
      severity: 'warning',
      summary: 'ระบบ Voice Agent ลดลง',
      details: results.filter(r => !r.healthy)
    }
  });
}

return [{
  json: {
    healthy: allHealthy,
    checks: results,
    timestamp: new Date().toISOString()
  }
}];

Twilio: 100 สาย × 5 นาที × $0.0085 = $4.25
หมายเลขโทรศัพท์: $1.15
ElevenLabs: 500 นาที × $0.05 = $25.00
OpenAI: ~$5.00
Deepgram: 500 นาที × $0.0043 = $2.15
----------------------------------------
รวม: ~$37.55/เดือน

เทียบกับพนักงานต้อนรับ: $2,500+/เดือน

# docker-compose.prod.yml
version: '3.8'

services:
  n8n:
    image: n8nio/n8n:latest
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '2'
          memory: 4G
    environment:
      - N8N_REDIS_HOST=redis
      - EXECUTIONS_MODE=queue
    networks:
      - voice-agent-network

  redis:
    image: redis:alpine
    networks:
      - voice-agent-network

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - voice-agent-network

networks:
  voice-agent-network:

curl -X POST https://your-webhook-url.com/webhook/twilio-voice \
  -d "CallSid=test" \
  -d "From=+1234567890"

curl -X POST https://your-n8n-instance.com/webhook/elevenlabs-tools \
  -H "Content-Type: application/json" \
  -d '{
    "tool_name": "check_availability",
    "parameters": {"date": "2026-04-10", "appointment_type": "cleaning"}
  }'