LINE中的AI集成：构建智能LINE机器人的完整指南

// 示例：为LINE机器人响应配置LLM
interface AIConfig {
  model: string;
  systemPrompt: string;
  maxTokens: number;
  temperature: number;
}

const lineAIConfig: AIConfig = {
  model: 'gpt-4-turbo',
  systemPrompt: \`你是一家泰国餐厅的友好LINE助手。
    使用与用户消息相同的语言回复。
    保持回复简洁（200字以内），以便在LINE中最佳显示。
    菜单：泰式炒河粉（¥59）、绿咖喱（¥69）、冬阴功（¥49）。
    营业时间：每天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 generateProductRecommendation(userId: string): Promise<FlexMessage> {
  const userProfile = await getUserProfile(userId);
  const recommendations = await getAIRecommendations(userProfile);

  return {
    type: 'flex',
    altText: '个性化推荐',
    contents: {
      type: 'carousel',
      contents: recommendations.map(product => ({
        type: 'bubble',
        hero: {
          type: 'image',
          url: product.imageUrl,
          size: 'full',
          aspectRatio: '20:13',
        },
        body: {
          type: 'box',
          layout: 'vertical',
          contents: [
            { type: 'text', text: product.name, weight: 'bold', size: 'lg' },
            { type: 'text', text: product.price, color: '#06C755' },
            { type: 'text', text: product.aiReason, size: 'sm', color: '#888888', wrap: true },
          ],
        },
        footer: {
          type: 'box',
          layout: 'vertical',
          contents: [
            {
              type: 'button',
              action: { type: 'message', label: '立即购买', text: \`购买 ${product.name}\` },
              style: 'primary',
              color: '#06C755',
            },
          ],
        },
      })),
    },
  };
}

// 使用流式传输获得更快的感知响应时间
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;
}