LINE MCP Server: Connect AI Agents to LINE with Model Context Protocol

AI Agent (Claude, Gemini, GPT, etc.)
       |
       v
  MCP Client (built into AI agent)
       |
       v
  MCP Protocol (standardized JSON-RPC)
       |
       v
  MCP Server (LINE Bot MCP Server)
       |
       v
  LINE Messaging API
       |
       v
  LINE Official Account --> Users

// Traditional approach: Custom webhook + API code
// You need to write and maintain all of this:

import { Client } from "@line/bot-sdk";

const client = new Client({
  channelAccessToken: process.env.LINE_CHANNEL_ACCESS_TOKEN!,
});

// Handle incoming webhook
app.post("/webhook", async (req, res) => {
  const events = req.body.events;
  for (const event of events) {
    if (event.type === "message" && event.message.type === "text") {
      // Parse intent, generate response, format message...
      await client.replyMessage(event.replyToken, {
        type: "text",
        text: "Hello!",
      });
    }
  }
  res.sendStatus(200);
});

// MCP approach: AI agent controls LINE directly
// Just tell Claude in natural language:

"Send a welcome message to user U1234567890 on LINE
saying 'Welcome to our store! Check out our new spring
collection with 20% off this week.'"

// The AI agent calls push_text_message via MCP automatically

# No installation required -- runs directly
npx @line/line-bot-mcp-server

# Pull the official image
docker pull ghcr.io/line/line-bot-mcp-server:latest

# Run with environment variables
docker run -it --rm \
  -e CHANNEL_ACCESS_TOKEN=your_channel_access_token \
  -e DESTINATION=your_user_id \
  ghcr.io/line/line-bot-mcp-server:latest

// macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
// Windows: %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "line-bot": {
      "command": "npx",
      "args": ["-y", "@line/line-bot-mcp-server"],
      "env": {
        "CHANNEL_ACCESS_TOKEN": "your_channel_access_token_here",
        "DESTINATION": "your_default_user_id_here"
      }
    }
  }
}

{
  "mcpServers": {
    "line-bot": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "CHANNEL_ACCESS_TOKEN",
        "-e", "DESTINATION",
        "ghcr.io/line/line-bot-mcp-server:latest"
      ],
      "env": {
        "CHANNEL_ACCESS_TOKEN": "your_channel_access_token_here",
        "DESTINATION": "your_default_user_id_here"
      }
    }
  }
}

You: "Send a test message to LINE saying Hello from AI"

Claude: I'll send that message to your LINE account now.
[Calls push_text_message with message "Hello from AI"]
Message sent successfully!

Prompt: "Send a message to user U1234567890 saying:
Thank you for your order! Your tracking number is TH20260402001.
Expected delivery: April 5, 2026."

// AI agent automatically calls:
// push_text_message({ user_id: "U1234567890", message: "..." })

Prompt: "Create a Flex Message for our spring sale with:
- A hero image banner
- Title: Spring Collection 2026
- 20% discount badge
- A 'Shop Now' button linking to https://shop.example.com
Send it to user U1234567890"

// AI agent generates the Flex Message JSON and calls:
// push_flex_message({
//   user_id: "U1234567890",
//   alt_text: "Spring Collection 2026 - 20% Off",
//   flex_content: { type: "bubble", hero: {...}, body: {...}, footer: {...} }
// })

Prompt: "Get the LINE profile for user U1234567890"

// Returns: { displayName, userId, pictureUrl, statusMessage, language }

Prompt: "Broadcast a message to all followers:
Happy Songkran! Enjoy 30% off all items this week.
Use code SONGKRAN2026 at checkout."

// AI agent calls broadcast_text_message for all followers

// app/api/webhooks/line/route.ts
// This handles INCOMING messages from LINE users
import { NextRequest, NextResponse } from "next/server";
import crypto from "crypto";

const CHANNEL_SECRET = process.env.LINE_CHANNEL_SECRET!;

function verifySignature(body: string, signature: string): boolean {
  const hash = crypto
    .createHmac("SHA256", CHANNEL_SECRET)
    .update(body)
    .digest("base64");
  return hash === signature;
}

export async function POST(req: NextRequest) {
  const body = await req.text();
  const signature = req.headers.get("x-line-signature") || "";

  if (!verifySignature(body, signature)) {
    return NextResponse.json({ error: "Invalid signature" }, { status: 401 });
  }

  const { events } = JSON.parse(body);

  for (const event of events) {
    if (event.type === "message" && event.message.type === "text") {
      // Forward to AI agent for processing via MCP
      await forwardToAIAgent(event);
    }
  }

  return NextResponse.json({ status: "ok" });
}

async function forwardToAIAgent(event: LineEvent) {
  // AI agent processes the message and responds via MCP
  // push_text_message or push_flex_message back to the user
  const aiResponse = await processWithAI(event.message.text, event.source.userId);
  // Response is sent back through MCP server automatically
}

Customer sends message on LINE
       |
       v
  Webhook Handler (inbound)
       |
       v
  AI Router Agent
       |
       +---> Sales Agent (product inquiries)
       |        |---> MCP: push_flex_message (product cards)
       |
       +---> Support Agent (issue resolution)
       |        |---> MCP: push_text_message (status updates)
       |
       +---> Marketing Agent (campaign management)
                |---> MCP: broadcast_flex_message (promotions)

// custom-line-mcp-tools.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

const server = new McpServer({
  name: "custom-line-tools",
  version: "1.0.0",
});

// Custom tool: Send order status with tracking
server.tool(
  "send_order_status",
  "Send order status update with tracking info to a LINE user",
  {
    user_id: z.string().describe("LINE user ID"),
    order_id: z.string().describe("Order ID"),
    status: z.enum(["confirmed", "shipped", "delivered"]),
    tracking_number: z.string().optional(),
  },
  async ({ user_id, order_id, status, tracking_number }) => {
    const flexMessage = buildOrderStatusFlex(order_id, status, tracking_number);
    await lineClient.pushMessage(user_id, flexMessage);
    return { content: [{ type: "text", text: `Order status sent to ${user_id}` }] };
  }
);

// Custom tool: Send product recommendation carousel
server.tool(
  "send_recommendations",
  "Send personalized product recommendations as a carousel",
  {
    user_id: z.string().describe("LINE user ID"),
    category: z.string().describe("Product category"),
    limit: z.number().default(5),
  },
  async ({ user_id, category, limit }) => {
    const products = await getRecommendations(user_id, category, limit);
    const carousel = buildProductCarousel(products);
    await lineClient.pushMessage(user_id, carousel);
    return { content: [{ type: "text", text: `Sent ${products.length} recommendations` }] };
  }
);

// Secure token management for production
// Use a secrets manager instead of plain environment variables

import { SecretManagerServiceClient } from "@google-cloud/secret-manager";

const client = new SecretManagerServiceClient();

async function getLineToken(): Promise<string> {
  const [version] = await client.accessSecretVersion({
    name: "projects/my-project/secrets/line-channel-token/versions/latest",
  });
  return version.payload?.data?.toString() || "";
}

// Rotate tokens periodically
async function rotateToken(): Promise<void> {
  const newToken = await requestNewChannelToken();
  await client.addSecretVersion({
    parent: "projects/my-project/secrets/line-channel-token",
    payload: { data: Buffer.from(newToken) },
  });
}