LINE

What is py-mcp-line?

py-mcp-line is a Python-based Model Context Protocol (MCP) server designed to integrate with LINE Bot. It allows Language Models (LMs) to access and analyze LINE conversations by providing a standardized interface to LINE messages. This project aims to bridge the gap between LINE communication and AI-driven language processing.

How to use py-mcp-line?

To use py-mcp-line, you need to first clone the repository and install the required dependencies:

git clone https://github.com/amornpan/py-mcp-line.git
cd py-mcp-line
pip install -r requirements.txt

Next, configure your environment by creating a .env file with your LINE Channel Secret, Access Token, server port, and messages file path:

LINE_CHANNEL_SECRET=your_channel_secret
LINE_ACCESS_TOKEN=your_access_token
SERVER_PORT=8000
MESSAGES_FILE=data/messages.json

Finally, you can integrate it with applications like Claude Desktop by adding the server configuration to your Claude Desktop configuration file, allowing Claude to interact with your LINE messages.

Key Features of py-mcp-line

• Asynchronous Operation: Utilizes Python's asyncio for efficient handling of concurrent operations.
• Environment-based Configuration: Easy configuration management using python-dotenv.
• Comprehensive Logging: Robust logging system for monitoring and debugging.
• LINE Bot Webhook Event Handling: Processes various LINE Bot events.
• Message Storage: Stores LINE messages in JSON format.
• FastAPI Integration: Provides API endpoints for seamless integration.
• Pydantic Models: Ensures data validation for incoming and outgoing data.
• Support for Multiple Message Types: Handles text, sticker, and image messages.
• Resource Listing and Reading: API endpoints to list available message types and read messages with filtering capabilities.
• Error Handling: Comprehensive error handling for webhook validation, message storage, resource access, and LINE API responses.
• Security Features: Includes LINE message signature validation, environment variable-based configuration, and input validation.

Use Cases of py-mcp-line

• Language Model Integration: Enables Language Models to analyze and understand LINE conversations for various AI applications.
• Chatbot Development: Provides a backend for advanced LINE chatbots that require deep conversation analysis.
• Data Analysis: Facilitates the collection and analysis of LINE message data for insights.
• Customer Support Automation: Can be used to build systems that automatically process and respond to customer inquiries on LINE.
• Research and Development: Offers a platform for researchers to experiment with AI models on real-world LINE conversation data.

FAQ from py-mcp-line

Q: What is the Model Context Protocol (MCP)? A: The Model Context Protocol is a standardized interface that allows Language Models to interact with and analyze various forms of contextual data, in this case, LINE conversations.

Q: What Python versions are supported? A: py-mcp-line requires Python 3.8 or higher.

Q: How do I configure the LINE API credentials? A: You need to create a .env file in the project root and provide your LINE_CHANNEL_SECRET and LINE_ACCESS_TOKEN obtained from the LINE Developers console.

Q: Can I filter messages when reading resources? A: Yes, the read_resource API supports filtering by date, user, or content.

Q: What kind of messages does it support? A: It supports text, sticker, and image messages from LINE.

Python LINE MCP Server

A Model Context Protocol server implementation in Python that provides access to LINE Bot messages. This server enables Language Models to read and analyze LINE conversations through a standardized interface.

Features

Core Functionality

• Asynchronous operation using Python's asyncio
• Environment-based configuration using python-dotenv
• Comprehensive logging system
• LINE Bot webhook event handling
• Message storage in JSON format
• FastAPI integration for API endpoints
• Pydantic models for data validation
• Support for text, sticker, and image messages

Prerequisites

• Python 3.8+
• Required Python packages:
  • fastapi
  • pydantic
  • python-dotenv
  • mcp-server
  • line-bot-sdk
  • uvicorn

Installation

git clone https://github.com/amornpan/py-mcp-line.git
cd py-mcp-line
pip install -r requirements.txt

Project Structure

PY-MCP-LINE/
├── src/
│   └── line/
│       ├── __init__.py
│       └── server.py
├── data/
│   └── messages.json
├── tests/
│   ├── __init__.py
│   └── test_line.py
├── .env
├── .env.example
├── .gitignore
├── README.md
├── Dockerfile
└── requirements.txt

Directory Structure Explanation

• src/line/ - Main source code directory
  • __init__.py - Package initialization
  • server.py - Main server implementation
• data/ - Data storage directory
  • messages.json - Stored LINE messages
• tests/ - Test files directory
  • __init__.py - Test package initialization
  • test_line.py - LINE functionality tests
• .env - Environment configuration file (not in git)
• .env.example - Example environment configuration
• .gitignore - Git ignore rules
• README.md - Project documentation
• Dockerfile - Docker configuration
• requirements.txt - Project dependencies

Configuration

Create a .env file in the project root:

LINE_CHANNEL_SECRET=your_channel_secret
LINE_ACCESS_TOKEN=your_access_token
SERVER_PORT=8000
MESSAGES_FILE=data/messages.json

API Implementation Details

Resource Listing

@app.list_resources()
async def list_resources() -> list[Resource]

• Lists available message types from the LINE Bot
• Returns resources with URIs in the format line://<message_type>/data
• Includes resource descriptions and MIME types

Resource Reading

@app.read_resource()
async def read_resource(uri: AnyUrl) -> str

• Reads messages of the specified type
• Accepts URIs in the format line://<message_type>/data
• Returns messages in JSON format
• Supports filtering by date, user, or content

Usage with Claude Desktop

Add to your Claude Desktop configuration:

On MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json On Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "line": {
      "command": "python",
      "args": [
        "server.py"
      ],
      "env": {
        "LINE_CHANNEL_SECRET": "your_channel_secret",
        "LINE_ACCESS_TOKEN": "your_access_token",
        "SERVER_PORT": "8000",
        "MESSAGES_FILE": "data/messages.json"
      }
    }
  }
}

Error Handling

The server implements comprehensive error handling for:

• Webhook validation failures
• Message storage errors
• Resource access errors
• URI validation
• LINE API response errors

All errors are logged and returned with appropriate error messages.

Security Features

• Environment variable based configuration
• LINE message signature validation
• Proper error handling
• Input validation through Pydantic

Contact Information

Amornpan Phornchaicharoen

Feel free to reach out to me if you have any questions about this project or would like to collaborate!

---

Made with ❤️ by Amornpan Phornchaicharoen

Author

Amornpan Phornchaicharoen

Requirements

Create a requirements.txt file with:

fastapi>=0.104.1
pydantic>=2.10.6
uvicorn>=0.34.0 
python-dotenv>=1.0.1
line-bot-sdk>=3.5.0
anyio>=4.5.0
mcp==1.2.0

These versions have been tested and verified to work together. The key components are:

• fastapi and uvicorn for the API server
• pydantic for data validation
• line-bot-sdk for LINE Bot integration
• mcp for Model Context Protocol implementation
• python-dotenv for environment configuration
• anyio for asynchronous I/O support

Acknowledgments

• LINE Developers for the LINE Messaging API
• Model Context Protocol community
• Python FastAPI community
• Contributors to the python-dotenv project