AI Integration ใน LINE: คู่มือฉบับสมบูรณ์สำหรับสร้างบอท LINE อัจฉริยะ

// ตัวอย่าง: กำหนดค่า LLM สำหรับการตอบกลับของ LINE bot
interface AIConfig {
  model: string;
  systemPrompt: string;
  maxTokens: number;
  temperature: number;
}

const lineAIConfig: AIConfig = {
  model: 'gpt-4-turbo',
  systemPrompt: \`คุณคือผู้ช่วย LINE ที่เป็นมิตรสำหรับร้านอาหารไทย
    ตอบในภาษาเดียวกับข้อความของผู้ใช้
    ตอบกระชับ (ต่ำกว่า 200 ตัวอักษร) สำหรับการแสดงผลที่ดีบน LINE
    เมนู: ผัดไทย (฿159), แกงเขียวหวาน (฿189), ต้มยำ (฿149)
    เวลาเปิด: 10:00-22:00 ทุกวัน\`,
  maxTokens: 200,
  temperature: 0.7,
};

// ประมวลผลข้อความเสียงจาก LINE
async function handleAudioMessage(event: LineMessageEvent) {
  const audioContent = await lineClient.getMessageContent(event.message.id);
  const transcript = await speechToText(audioContent);
  const aiResponse = await generateResponse(transcript);

  return lineClient.replyMessage(event.replyToken, {
    type: 'text',
    text: aiResponse,
  });
}

mkdir line-ai-bot && cd line-ai-bot
npm init -y
npm install @line/bot-sdk express openai dotenv
npm install -D typescript @types/express @types/node ts-node
npx tsc --init

LINE_CHANNEL_SECRET=your_channel_secret
LINE_CHANNEL_ACCESS_TOKEN=your_channel_access_token
OPENAI_API_KEY=your_openai_api_key
PORT=3000

// src/index.ts
import express from 'express';
import { Client, middleware, WebhookEvent, TextMessage } from '@line/bot-sdk';
import OpenAI from 'openai';
import dotenv from 'dotenv';

dotenv.config();

const lineConfig = {
  channelSecret: process.env.LINE_CHANNEL_SECRET!,
  channelAccessToken: process.env.LINE_CHANNEL_ACCESS_TOKEN!,
};

const lineClient = new Client(lineConfig);
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// ที่เก็บประวัติการสนทนา (ใช้ Redis ใน production)
const conversationHistory = new Map<string, Array<{role: string; content: string}>>();

async function getAIResponse(userId: string, userMessage: string): Promise<string> {
  const history = conversationHistory.get(userId) || [];
  history.push({ role: 'user', content: userMessage });
  const recentHistory = history.slice(-10);

  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: \`คุณคือผู้ช่วย LINE อัจฉริยะ
          ตอบกลับในภาษาเดียวกับผู้ใช้
          ตอบกระชับ (ต่ำกว่า 500 ตัวอักษร)
          หากถูกถามเกี่ยวกับสินค้าหรือบริการ ให้คำแนะนำที่เป็นประโยชน์
          เป็นมิตรและมืออาชีพ\`,
      },
      ...recentHistory.map(msg => ({
        role: msg.role as 'user' | 'assistant',
        content: msg.content,
      })),
    ],
    max_tokens: 300,
    temperature: 0.7,
  });

  const aiResponse = completion.choices[0].message.content || 'ขออภัย ไม่สามารถประมวลผลคำขอของคุณได้';
  history.push({ role: 'assistant', content: aiResponse });
  conversationHistory.set(userId, history);

  return aiResponse;
}

async function handleEvent(event: WebhookEvent): Promise<void> {
  if (event.type !== 'message' || event.message.type !== 'text') return;

  const userId = event.source.userId || 'unknown';
  const aiResponse = await getAIResponse(userId, event.message.text);

  await lineClient.replyMessage(event.replyToken, {
    type: 'text',
    text: aiResponse,
  } as TextMessage);
}

const app = express();
app.post('/webhook', middleware(lineConfig), async (req, res) => {
  try {
    await Promise.all(req.body.events.map(handleEvent));
    res.status(200).json({ status: 'ok' });
  } catch (err) {
    console.error('Webhook error:', err);
    res.status(500).end();
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(\`AI LINE Bot ทำงานบนพอร์ต ${PORT}\`);
});

// src/intent-classifier.ts
interface IntentResult {
  intent: string;
  confidence: number;
  entities: Record<string, string>;
}

async function classifyIntent(message: string): Promise<IntentResult> {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: \`จำแนก intent ของผู้ใช้ ส่ง JSON เท่านั้น
          Intent ที่เป็นไปได้: greeting, product_inquiry, order, support, complaint, faq, other
          ดึง entities: product_name, quantity, date, language\`,
      },
      { role: 'user', content: message },
    ],
    response_format: { type: 'json_object' },
    max_tokens: 100,
  });

  return JSON.parse(completion.choices[0].message.content || '{}');
}

// src/sentiment.ts
async function analyzeSentiment(message: string): Promise<{
  sentiment: 'positive' | 'neutral' | 'negative';
  score: number;
}> {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: 'วิเคราะห์ sentiment ส่ง JSON: {"sentiment": "positive|neutral|negative", "score": 0.0-1.0}',
      },
      { role: 'user', content: message },
    ],
    response_format: { type: 'json_object' },
    max_tokens: 50,
  });

  return JSON.parse(completion.choices[0].message.content || '{"sentiment":"neutral","score":0.5}');
}

// ส่งต่อ sentiment เชิงลบไปยังเจ้าหน้าที่มนุษย์
async function handleWithSentiment(event: WebhookEvent) {
  const sentiment = await analyzeSentiment(event.message.text);

  if (sentiment.sentiment === 'negative' && sentiment.score > 0.8) {
    await notifyHumanAgent(event.source.userId, event.message.text);
    return replyWithEscalationMessage(event.replyToken);
  }

  return handleWithAI(event);
}

async function detectLanguageAndRespond(message: string): Promise<string> {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: \`ตรวจจับภาษาและตอบในภาษาเดียวกัน
          รองรับ: ไทย, อังกฤษ, ญี่ปุ่น, จีน
          ถ้าไม่แน่ใจ ให้ตอบเป็นภาษาอังกฤษ\`,
      },
      { role: 'user', content: message },
    ],
    max_tokens: 300,
  });

  return completion.choices[0].message.content || '';
}

// ใช้ streaming สำหรับเวลาตอบกลับที่รู้สึกเร็วขึ้น
async function streamAIResponse(event: WebhookEvent): Promise<void> {
  // ส่ง "typing" indicator ทันที
  await lineClient.pushMessage(event.source.userId!, {
    type: 'text',
    text: '...',
  });

  // สร้างคำตอบ AI
  const response = await getAIResponse(event.source.userId!, event.message.text);

  // ส่งคำตอบจริง
  await lineClient.pushMessage(event.source.userId!, {
    type: 'text',
    text: response,
  });
}

// ตัวกรองความปลอดภัยของเนื้อหา
async function filterResponse(response: string): Promise<string> {
  const moderation = await openai.moderations.create({
    input: response,
  });

  if (moderation.results[0].flagged) {
    return 'ขออภัย ไม่สามารถให้ข้อมูลนั้นได้ กรุณาติดต่อทีมซัพพอร์ตของเรา';
  }

  return response;
}