LINEにおけるAI統合：インテリジェントなLINEボット構築の完全ガイド

// 例：LINEボット応答用LLMの設定
interface AIConfig {
  model: string;
  systemPrompt: string;
  maxTokens: number;
  temperature: number;
}

const lineAIConfig: AIConfig = {
  model: 'gpt-4-turbo',
  systemPrompt: \`あなたはタイ料理レストランの親切なLINEアシスタントです。
    ユーザーメッセージと同じ言語で応答してください。
    LINEでの最適な表示のため、200文字未満で応答してください。
    メニュー：パッタイ（¥590）、グリーンカレー（¥690）、トムヤム（¥490）。
    営業時間：毎日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を使用）
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エラー:', err);
    res.status(500).end();
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(\`AI LINEボットがポート${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: \`ユーザーの意図を分類してください。JSONのみを返してください。
          可能な意図：greeting, product_inquiry, order, support, complaint, faq, other
          エンティティを抽出：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: '感情を分析してください。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}');
}

// ネガティブな感情を人間のエージェントにエスカレーション
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 || '';
}

// より速い体感応答時間のためにストリーミングを使用
async function streamAIResponse(event: WebhookEvent): Promise<void> {
  // 「入力中」インジケーターを即座に送信
  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;
}