สร้าง AI Chatbot สำหรับธุรกิจ: คู่มือฉบับสมบูรณ์

AI Chatbot กลายเป็นเครื่องมือสำคัญสำหรับธุรกิจยุคใหม่ ไม่ว่าจะใช้เพื่อ Customer Support, Sales, หรือ Internal Operations บทความนี้จะพาคุณไปเรียนรู้การสร้าง AI Chatbot ตั้งแต่เริ่มต้นจนพร้อมใช้งานจริง

ทำไมธุรกิจต้องมี AI Chatbot?

ประโยชน์ของ AI Chatbot

1. ให้บริการ 24/7: ไม่มีวันหยุด ไม่มีเวลาพัก
2. ลดภาระงาน Support Team: ตอบคำถามซ้ำๆ อัตโนมัติ
3. Scalability: รองรับลูกค้าพร้อมกันได้ไม่จำกัด
4. Consistency: ตอบคำถามสม่ำเสมอ ไม่มีอารมณ์
5. Data Collection: เก็บข้อมูล insight จากการสนทนา
6. Cost Reduction: ลดต้นทุนในระยะยาว

ROI ของ AI Chatbot

ตัวอย่างการคำนวณ ROI:

Before Chatbot:
- Support Agents: 5 คน x 30,000 บาท = 150,000 บาท/เดือน
- Tickets handled: 1,000 tickets/เดือน
- Cost per ticket: 150 บาท

After Chatbot:
- Chatbot handles: 70% of tickets (700)
- Agents handle: 30% (300) complex cases
- Need only: 2 Agents = 60,000 บาท/เดือน
- Chatbot cost: ~10,000 บาท/เดือน
- Total: 70,000 บาท/เดือน
- Savings: 80,000 บาท/เดือน (53% reduction)

ประเภทของ AI Chatbot

1. Rule-Based Chatbot

ทำงานตามกฎที่กำหนดไว้ล่วงหน้า

// Simple rule-based chatbot
const rules = {
  "สวัสดี": "สวัสดีครับ! ยินดีให้บริการครับ",
  "ราคา": "สินค้าของเรามีราคาเริ่มต้นที่ 999 บาท",
  "เปิดกี่โมง": "เราเปิดให้บริการ 9:00 - 18:00 น."
};

function respond(input) {
  for (const [keyword, response] of Object.entries(rules)) {
    if (input.includes(keyword)) {
      return response;
    }
  }
  return "ขออภัย ไม่เข้าใจคำถาม กรุณาติดต่อ support";
}

ข้อดี: ง่าย, เร็ว, ไม่มีค่าใช้จ่าย API ข้อเสีย: ไม่ flexible, ไม่เข้าใจบริบท

2. AI-Powered Chatbot (LLM-based)

ใช้ AI ในการเข้าใจและสร้างคำตอบ

# AI-powered chatbot with context
class AIBusinessChatbot:
    def __init__(self):
        self.client = OpenAI()
        self.conversation_history = []
        self.system_prompt = """คุณเป็น AI Customer Service ของบริษัท XYZ

ข้อมูลสำคัญ:
- เปิดให้บริการ 9:00-18:00 น. (จันทร์-ศุกร์)
- โทร: 02-xxx-xxxx
- Email: support@xyz.com

กฎ:
1. ตอบสุภาพ ใช้ครับ/ค่ะ
2. ถ้าไม่รู้คำตอบ ให้แนะนำติดต่อทีม support
3. ห้ามให้ข้อมูลเท็จ"""

    async def chat(self, user_message: str) -> str:
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })

        response = await self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": self.system_prompt},
                *self.conversation_history
            ],
            temperature=0.7
        )

        assistant_message = response.choices[0].message.content
        self.conversation_history.append({
            "role": "assistant",
            "content": assistant_message
        })

        return assistant_message

3. RAG-Enhanced Chatbot

ใช้ RAG เพื่อดึงข้อมูลจาก Knowledge Base

# RAG-enhanced business chatbot
class RAGBusinessChatbot:
    def __init__(self, knowledge_base_path: str):
        self.rag_pipeline = RAGPipeline()
        self.rag_pipeline.ingest([knowledge_base_path])
        self.client = OpenAI()

    async def chat(self, user_message: str) -> dict:
        # 1. Search relevant documents
        search_result = self.rag_pipeline.query(user_message, top_k=3)

        # 2. Generate response with context
        context = "\n".join([
            doc['content'] for doc in search_result['sources']
        ])

        response = await self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "system",
                    "content": f"""คุณเป็น AI Customer Service

ใช้ข้อมูลต่อไปนี้ในการตอบคำถาม:
{context}

ถ้าไม่มีข้อมูลเพียงพอ ให้บอกว่าจะส่งต่อให้ทีม support"""
                },
                {"role": "user", "content": user_message}
            ]
        )

        return {
            "answer": response.choices[0].message.content,
            "sources": search_result['sources']
        }

อ่านเพิ่มเติมเกี่ยวกับ RAG ได้ที่ RAG คืออะไร? ทำไมถึงสำคัญสำหรับ AI

Architecture ของ AI Chatbot

Basic Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    AI Chatbot Architecture                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────┐     ┌─────────────────┐     ┌──────────────┐     │
│  │ Frontend │────▶│ Backend API     │────▶│ AI Service   │     │
│  │ (Chat UI)│◀────│ (Websocket/REST)│◀────│ (GPT/Claude) │     │
│  └──────────┘     └────────┬────────┘     └──────────────┘     │
│                            │                                    │
│                    ┌───────┴───────┐                           │
│                    │               │                           │
│                    ▼               ▼                           │
│            ┌─────────────┐ ┌─────────────┐                    │
│            │ Database    │ │ Knowledge   │                    │
│            │ (History)   │ │ Base (RAG)  │                    │
│            └─────────────┘ └─────────────┘                    │
└─────────────────────────────────────────────────────────────────┘

Production Architecture

┌─────────────────────────────────────────────────────────────────┐
│                Production Chatbot Architecture                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│     ┌──────────────────────────────────────────────────────┐   │
│     │                    Load Balancer                      │   │
│     └──────────────────────────┬───────────────────────────┘   │
│                                │                                │
│     ┌──────────────────────────┼───────────────────────────┐   │
│     │                          │                            │   │
│     ▼                          ▼                            ▼   │
│  ┌────────┐              ┌────────┐              ┌────────┐    │
│  │ API    │              │ API    │              │ API    │    │
│  │Server 1│              │Server 2│              │Server 3│    │
│  └───┬────┘              └───┬────┘              └───┬────┘    │
│      │                       │                       │         │
│      └───────────────────────┼───────────────────────┘         │
│                              │                                  │
│  ┌───────────────────────────┼───────────────────────────────┐ │
│  │                           ▼                               │ │
│  │  ┌────────────┐  ┌────────────┐  ┌────────────────────┐  │ │
│  │  │ Redis      │  │ PostgreSQL │  │ Vector DB          │  │ │
│  │  │ (Cache/    │  │ (History)  │  │ (Knowledge Base)   │  │ │
│  │  │  Sessions) │  │            │  │                    │  │ │
│  │  └────────────┘  └────────────┘  └────────────────────┘  │ │
│  └──────────────────────────────────────────────────────────┘ │
│                                                                 │
│  ┌──────────────────────────────────────────────────────────┐ │
│  │  External Services                                        │ │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐ │ │
│  │  │ OpenAI   │  │ Claude   │  │ CRM      │  │ Analytics│ │ │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘ │ │
│  └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘

สร้าง Chatbot Step-by-Step

Step 1: วางแผน Conversation Design

# conversation_design.yaml
intents:
  - name: greeting
    examples:
      - สวัสดี
      - หวัดดี
      - Hello
    response_type: greeting

  - name: product_inquiry
    examples:
      - สินค้าราคาเท่าไหร่
      - มีสินค้าอะไรบ้าง
      - อยากดูสินค้า
    response_type: rag_search
    search_topic: products

  - name: order_status
    examples:
      - สถานะคำสั่งซื้อ
      - ออเดอร์ถึงไหนแล้ว
      - ติดตามพัสดุ
    response_type: api_call
    api_endpoint: /orders/{order_id}

  - name: complaint
    examples:
      - ไม่พอใจบริการ
      - อยากร้องเรียน
      - สินค้ามีปัญหา
    response_type: escalate
    priority: high

Step 2: สร้าง Backend API

# chatbot_api.py
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.middleware.cors import CORSMiddleware
import json
import uuid

app = FastAPI()

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)

class ChatbotService:
    def __init__(self):
        self.sessions = {}
        self.rag = RAGBusinessChatbot("knowledge_base/")
        self.client = OpenAI()

    async def process_message(
        self,
        session_id: str,
        message: str
    ) -> dict:
        # Get or create session
        if session_id not in self.sessions:
            self.sessions[session_id] = {
                "history": [],
                "created_at": datetime.now(),
                "context": {}
            }

        session = self.sessions[session_id]

        # Classify intent
        intent = await self.classify_intent(message)

        # Process based on intent
        if intent == "greeting":
            response = await self.handle_greeting(session)
        elif intent == "product_inquiry":
            response = await self.handle_product_inquiry(message, session)
        elif intent == "order_status":
            response = await self.handle_order_status(message, session)
        elif intent == "complaint":
            response = await self.handle_complaint(message, session)
        else:
            response = await self.handle_general(message, session)

        # Store in history
        session["history"].append({
            "role": "user",
            "content": message,
            "timestamp": datetime.now().isoformat()
        })
        session["history"].append({
            "role": "assistant",
            "content": response["answer"],
            "timestamp": datetime.now().isoformat()
        })

        return response

    async def classify_intent(self, message: str) -> str:
        """Classify user intent using AI"""
        response = await self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "system",
                    "content": """Classify the intent:
                    - greeting: สวัสดี, หวัดดี
                    - product_inquiry: ถามเรื่องสินค้า
                    - order_status: ถามสถานะคำสั่งซื้อ
                    - complaint: ร้องเรียน, ไม่พอใจ
                    - general: อื่นๆ

                    Return only the intent name."""
                },
                {"role": "user", "content": message}
            ],
            temperature=0
        )
        return response.choices[0].message.content.strip().lower()

    async def handle_product_inquiry(
        self,
        message: str,
        session: dict
    ) -> dict:
        """Handle product questions with RAG"""
        result = await self.rag.chat(message)
        return {
            "answer": result["answer"],
            "sources": result.get("sources", []),
            "type": "product_inquiry"
        }

    async def handle_order_status(
        self,
        message: str,
        session: dict
    ) -> dict:
        """Handle order status inquiries"""
        # Extract order ID
        order_id = self.extract_order_id(message)

        if order_id:
            # Call order API
            order_info = await self.get_order_info(order_id)
            return {
                "answer": f"คำสั่งซื้อ {order_id}: {order_info['status']}",
                "type": "order_status",
                "data": order_info
            }
        else:
            return {
                "answer": "กรุณาระบุหมายเลขคำสั่งซื้อครับ",
                "type": "order_status",
                "need_info": "order_id"
            }

    async def handle_complaint(
        self,
        message: str,
        session: dict
    ) -> dict:
        """Handle complaints - escalate to human"""
        # Create ticket
        ticket_id = await self.create_support_ticket(
            message=message,
            session=session,
            priority="high"
        )

        return {
            "answer": f"""ขอบคุณที่แจ้งครับ เราเสียใจที่คุณพบปัญหา

ทีม support จะติดต่อกลับภายใน 24 ชั่วโมง
หมายเลข ticket: {ticket_id}

หากต้องการความช่วยเหลือเร่งด่วน โทร: 02-xxx-xxxx""",
            "type": "complaint",
            "ticket_id": ticket_id,
            "escalated": True
        }

chatbot = ChatbotService()

@app.websocket("/ws/chat/{session_id}")
async def websocket_chat(websocket: WebSocket, session_id: str):
    await websocket.accept()

    try:
        while True:
            data = await websocket.receive_text()
            message = json.loads(data)

            response = await chatbot.process_message(
                session_id,
                message["content"]
            )

            await websocket.send_text(json.dumps(response))

    except WebSocketDisconnect:
        print(f"Session {session_id} disconnected")

@app.post("/api/chat")
async def rest_chat(request: ChatRequest):
    """REST API endpoint for chat"""
    response = await chatbot.process_message(
        request.session_id,
        request.message
    )
    return response

Step 3: สร้าง Chat UI

// components/Chatbot.tsx
'use client';

import { useState, useEffect, useRef } from 'react';

interface Message {
  role: 'user' | 'assistant';
  content: string;
  timestamp: Date;
  sources?: any[];
}

export function Chatbot() {
  const [messages, setMessages] = useState<Message[]>([]);
  const [input, setInput] = useState('');
  const [isLoading, setIsLoading] = useState(false);
  const [sessionId] = useState(() => crypto.randomUUID());
  const messagesEndRef = useRef<HTMLDivElement>(null);
  const wsRef = useRef<WebSocket | null>(null);

  useEffect(() => {
    // Connect WebSocket
    wsRef.current = new WebSocket(
      `wss://api.example.com/ws/chat/${sessionId}`
    );

    wsRef.current.onmessage = (event) => {
      const response = JSON.parse(event.data);
      setMessages(prev => [...prev, {
        role: 'assistant',
        content: response.answer,
        timestamp: new Date(),
        sources: response.sources
      }]);
      setIsLoading(false);
    };

    return () => {
      wsRef.current?.close();
    };
  }, [sessionId]);

  useEffect(() => {
    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
  }, [messages]);

  const sendMessage = () => {
    if (!input.trim() || isLoading) return;

    // Add user message
    setMessages(prev => [...prev, {
      role: 'user',
      content: input,
      timestamp: new Date()
    }]);

    // Send to server
    wsRef.current?.send(JSON.stringify({ content: input }));
    setInput('');
    setIsLoading(true);
  };

  return (
    <div className="flex flex-col h-[600px] max-w-md mx-auto border rounded-lg">
      {/* Header */}
      <div className="bg-primary text-white p-4 rounded-t-lg">
        <h3 className="font-bold">AI Customer Support</h3>
        <p className="text-sm opacity-80">ออนไลน์ - ตอบทันที</p>
      </div>

      {/* Messages */}
      <div className="flex-1 overflow-y-auto p-4 space-y-4">
        {/* Welcome message */}
        {messages.length === 0 && (
          <div className="text-center text-gray-500 py-8">
            <p>สวัสดีครับ! มีอะไรให้ช่วยไหมครับ?</p>
          </div>
        )}

        {messages.map((msg, i) => (
          <div
            key={i}
            className={`flex ${msg.role === 'user' ? 'justify-end' : 'justify-start'}`}
          >
            <div
              className={`max-w-[80%] rounded-lg p-3 ${
                msg.role === 'user'
                  ? 'bg-primary text-white'
                  : 'bg-gray-100'
              }`}
            >
              <p>{msg.content}</p>
              {msg.sources && msg.sources.length > 0 && (
                <div className="mt-2 text-xs opacity-70">
                  <p>อ้างอิงจาก: {msg.sources.length} แหล่ง</p>
                </div>
              )}
            </div>
          </div>
        ))}

        {isLoading && (
          <div className="flex justify-start">
            <div className="bg-gray-100 rounded-lg p-3">
              <div className="flex space-x-2">
                <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce" />
                <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-100" />
                <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-200" />
              </div>
            </div>
          </div>
        )}

        <div ref={messagesEndRef} />
      </div>

      {/* Input */}
      <div className="p-4 border-t">
        <div className="flex space-x-2">
          <input
            type="text"
            value={input}
            onChange={(e) => setInput(e.target.value)}
            onKeyPress={(e) => e.key === 'Enter' && sendMessage()}
            placeholder="พิมพ์ข้อความ..."
            className="flex-1 border rounded-lg px-4 py-2 focus:outline-none focus:ring-2"
            disabled={isLoading}
          />
          <button
            onClick={sendMessage}
            disabled={isLoading || !input.trim()}
            className="bg-primary text-white px-4 py-2 rounded-lg disabled:opacity-50"
          >
            ส่ง
          </button>
        </div>
      </div>
    </div>
  );
}

Step 4: เพิ่ม Features เสริม

Quick Replies

// Quick reply buttons
const quickReplies = [
  { text: "ดูสินค้า", action: "product_inquiry" },
  { text: "ติดตามพัสดุ", action: "order_status" },
  { text: "ติดต่อ support", action: "contact_support" }
];

function QuickReplies({ onSelect }: { onSelect: (text: string) => void }) {
  return (
    <div className="flex flex-wrap gap-2 p-2">
      {quickReplies.map((reply, i) => (
        <button
          key={i}
          onClick={() => onSelect(reply.text)}
          className="px-3 py-1 border rounded-full text-sm hover:bg-gray-100"
        >
          {reply.text}
        </button>
      ))}
    </div>
  );
}

File Upload

# Handle file uploads in chat
@app.post("/api/chat/upload")
async def upload_file(
    file: UploadFile,
    session_id: str = Form(...)
):
    # Save file
    file_path = f"uploads/{session_id}/{file.filename}"
    await save_file(file, file_path)

    # Process with AI if it's an image
    if file.content_type.startswith("image/"):
        # Use vision model
        result = await analyze_image(file_path)
        return {"type": "image_analysis", "result": result}

    # Process documents
    elif file.content_type in ["application/pdf", "text/plain"]:
        content = await extract_text(file_path)
        return {"type": "document", "content_preview": content[:500]}

    return {"type": "file_received", "filename": file.filename}

Sentiment Tracking

class SentimentTracker:
    def __init__(self):
        self.client = OpenAI()

    async def analyze_sentiment(self, message: str) -> dict:
        response = await self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {
                    "role": "system",
                    "content": """Analyze sentiment and return JSON:
                    {
                        "sentiment": "positive|neutral|negative",
                        "score": 0.0-1.0,
                        "emotions": ["happy", "frustrated", etc.]
                    }"""
                },
                {"role": "user", "content": message}
            ]
        )
        return json.loads(response.choices[0].message.content)

    async def should_escalate(self, session_history: list) -> bool:
        """Check if conversation should be escalated to human"""
        recent_sentiments = []
        for msg in session_history[-5:]:
            if msg["role"] == "user":
                sentiment = await self.analyze_sentiment(msg["content"])
                recent_sentiments.append(sentiment)

        # Escalate if multiple negative sentiments
        negative_count = sum(
            1 for s in recent_sentiments if s["sentiment"] == "negative"
        )
        return negative_count >= 2

Integrations

LINE Integration

# LINE Chatbot Integration
from linebot import LineBotApi, WebhookHandler
from linebot.models import MessageEvent, TextMessage, TextSendMessage

line_bot_api = LineBotApi('YOUR_CHANNEL_ACCESS_TOKEN')
handler = WebhookHandler('YOUR_CHANNEL_SECRET')

@app.post("/webhook/line")
async def line_webhook(request: Request):
    signature = request.headers['X-Line-Signature']
    body = await request.body()

    try:
        handler.handle(body.decode(), signature)
    except InvalidSignatureError:
        raise HTTPException(status_code=400)

    return 'OK'

@handler.add(MessageEvent, message=TextMessage)
def handle_message(event):
    user_id = event.source.user_id

    # Process with chatbot
    response = chatbot.process_message(user_id, event.message.text)

    line_bot_api.reply_message(
        event.reply_token,
        TextSendMessage(text=response["answer"])
    )

Facebook Messenger Integration

# Facebook Messenger Integration
@app.post("/webhook/facebook")
async def facebook_webhook(request: Request):
    data = await request.json()

    for entry in data.get("entry", []):
        for messaging_event in entry.get("messaging", []):
            sender_id = messaging_event["sender"]["id"]

            if "message" in messaging_event:
                message_text = messaging_event["message"].get("text", "")

                # Process with chatbot
                response = await chatbot.process_message(sender_id, message_text)

                # Send response
                await send_facebook_message(sender_id, response["answer"])

    return {"status": "ok"}

async def send_facebook_message(recipient_id: str, message: str):
    await httpx.post(
        "https://graph.facebook.com/v18.0/me/messages",
        params={"access_token": FB_ACCESS_TOKEN},
        json={
            "recipient": {"id": recipient_id},
            "message": {"text": message}
        }
    )

Monitoring & Analytics

Metrics to Track

# Chatbot analytics
class ChatbotAnalytics:
    def __init__(self):
        self.metrics = {
            "total_conversations": 0,
            "messages_processed": 0,
            "avg_response_time": 0,
            "escalation_rate": 0,
            "satisfaction_score": 0,
            "intent_distribution": {}
        }

    def log_conversation(self, session: dict, response: dict):
        """Log conversation for analytics"""
        self.metrics["messages_processed"] += 1

        # Log intent
        intent = response.get("type", "general")
        self.metrics["intent_distribution"][intent] = \
            self.metrics["intent_distribution"].get(intent, 0) + 1

        # Log to analytics service
        analytics.track({
            "event": "chatbot_message",
            "properties": {
                "session_id": session["id"],
                "intent": intent,
                "response_time_ms": response.get("latency_ms"),
                "escalated": response.get("escalated", False),
                "sources_count": len(response.get("sources", []))
            }
        })

    def get_dashboard_data(self) -> dict:
        """Get data for analytics dashboard"""
        return {
            **self.metrics,
            "top_intents": sorted(
                self.metrics["intent_distribution"].items(),
                key=lambda x: x[1],
                reverse=True
            )[:5]
        }

สรุป

การสร้าง AI Chatbot สำหรับธุรกิจต้องพิจารณาหลายปัจจัย ตั้งแต่การออกแบบ conversation flow, เลือก architecture ที่เหมาะสม, ไปจนถึงการ monitor และปรับปรุงอย่างต่อเนื่อง

---

อ่านบทความที่เกี่ยวข้อง

• RAG คืออะไร? ทำไมถึงสำคัญสำหรับ AI - เรียนรู้ RAG สำหรับ Chatbot
• คู่มือเชื่อมต่อ AI API - วิธีเชื่อมต่อ OpenAI, Claude
• AI Agents: ระบบ AI ที่ทำงานได้อัตโนมัติ - พัฒนา Chatbot เป็น Agent

---

พร้อมสร้าง AI Chatbot สำหรับธุรกิจแล้วหรือยัง?

ติดต่อทีม AI Unlocked เราพร้อมให้คำปรึกษาและพัฒนา AI Chatbot ที่ตอบโจทย์ธุรกิจของคุณ