LINE AI Chatbot: Build Intelligent Bots with GPT & NLP

// Example: Configuring an LLM for LINE bot responses
interface AIConfig {
  model: string;
  systemPrompt: string;
  maxTokens: number;
  temperature: number;
}

const lineAIConfig: AIConfig = {
  model: 'gpt-4-turbo',
  systemPrompt: \`You are a helpful LINE assistant for a Thai restaurant.
    Respond in the same language as the user message.
    Keep responses under 200 characters for optimal LINE display.
    Available menu items: Pad Thai (฿159), Green Curry (฿189), Tom Yum (฿149).
    Business hours: 10:00-22:00 daily.\`,
  maxTokens: 200,
  temperature: 0.7,
};

// Processing voice messages from 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 });

// Conversation history store (use Redis in production)
const conversationHistory = new Map<string, Array<{role: string; content: string}>>();

async function getAIResponse(userId: string, userMessage: string): Promise<string> {
  // Get or initialize conversation history
  const history = conversationHistory.get(userId) || [];

  // Add user message to history
  history.push({ role: 'user', content: userMessage });

  // Keep only last 10 messages for context window
  const recentHistory = history.slice(-10);

  const completion = await openai.chat.completions.create({
    model: 'gpt-4-turbo',
    messages: [
      {
        role: 'system',
        content: \`You are an intelligent LINE assistant.
          Respond naturally in the same language as the user.
          Keep responses concise (under 500 characters).
          If asked about products or services, provide helpful recommendations.
          Be friendly and professional.\`,
      },
      ...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 || 'Sorry, I could not process your request.';

  // Store AI response in history
  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 userMessage = event.message.text;

  const aiResponse = await getAIResponse(userId, userMessage);

  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 running on port ${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: \`Classify the user intent. Return JSON only.
          Possible intents: greeting, product_inquiry, order, support, complaint, faq, other.
          Extract entities: product_name, quantity, date, language.
          Example: {"intent": "order", "confidence": 0.95, "entities": {"product_name": "Pad Thai", "quantity": "2"}}\`,
      },
      { role: 'user', content: message },
    ],
    response_format: { type: 'json_object' },
    max_tokens: 100,
  });

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

# Using Vercel
npm install -g vercel
vercel --prod

# Or using Docker
docker build -t line-ai-bot .
docker run -p 3000:3000 line-ai-bot

// 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: 'Analyze sentiment. Return 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}');
}

// Route negative sentiment to human agents
async function handleWithSentiment(event: WebhookEvent) {
  const sentiment = await analyzeSentiment(event.message.text);

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

  // Continue with AI response
  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: \`Detect the language and respond in that same language.
          Supported: Thai, English, Japanese, Chinese.
          If unsure, respond in English.\`,
      },
      { 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: 'Personalized Recommendations',
    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: 'Order Now', text: \`Order ${product.name}\` },
              style: 'primary',
              color: '#06C755',
            },
          ],
        },
      })),
    },
  };
}

// Use streaming for faster perceived response time
async function streamAIResponse(event: WebhookEvent): Promise<void> {
  // Send a "typing" indicator immediately
  await lineClient.pushMessage(event.source.userId!, {
    type: 'text',
    text: '...',
  });

  // Generate AI response
  const response = await getAIResponse(event.source.userId!, event.message.text);

  // Send the actual response
  await lineClient.pushMessage(event.source.userId!, {
    type: 'text',
    text: response,
  });
}

// Content safety filter
async function filterResponse(response: string): Promise<string> {
  const moderation = await openai.moderations.create({
    input: response,
  });

  if (moderation.results[0].flagged) {
    return 'I apologize, but I cannot provide that information. Please contact our support team.';
  }

  return response;
}