Skip to main content
Glama
line-desktop-mcp

line-desktop-mcp

by onlygummy

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault

No arguments

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Reads your own LINE chats. Call login first: it returns at once when the saved session still works, and only opens a QR window when it does not. Then use list_chats to find the chat and get_messages to read it, or search_messages to look for text across what has already been read. For what needs attention, call unread once instead of reading every chat. Every message read is stored in a local SQLite archive and every image is saved as a backup; nothing is sent to LINE and nothing is marked as read. logout ends the session and deletes the saved login, not the archive.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}
logging
{}
prompts
{
  "listChanged": true
}
resources
{
  "subscribe": false,
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
loginA

Log in by scanning a QR code in a window on this machine.

Call this first. It returns at once when the saved session still works, so it is safe to call on every start. Otherwise it opens the 'Line Desktop MCP' window, shows the QR, and waits up to timeout_sec for the scan plus any PIN LINE asks for. Closing that window stops the wait, in which case nothing is saved.

The window appears on this machine, so the login cannot be completed from a different host. Keep the session file private: it holds the access token and the Letter Sealing keys.

logoutA

Log this device out of LINE and delete the saved session.

LINE is asked to invalidate the session first. If that request fails, the local file is deleted anyway, because the stored token is what matters. Your phone stays logged in: only this server's device is signed out, and the next login scans a fresh QR code.

The archive and the image backups are kept, so nothing that was already read is lost. Every tool still needs a login before it can reach LINE again, because the session file is what they run on.

list_chatsA

List your LINE chats with name, kind, unread count and last preview.

Call this before get_messages to find the chat you want. A direct chat is named after the other person; a group keeps its LINE name. Nothing is marked as read. The listing is cached for a few minutes and archived locally, so it still answers when LINE cannot be reached (stale: true says the data came from the archive). total counts the chats after filtering and before the limit; truncated is true when more chats exist than limit returned.

get_messagesA

Read the newest messages of one LINE chat, oldest first.

Pass after and before to read a time window instead of the newest slice: a bare date means local midnight, and before includes the whole day. The archive answers first, so a window that was read before is cheap and works offline; LINE is only paged back when the archive cannot fill limit.

Pass around to read the messages around one id, which is how a search hit turns into its conversation. That answer comes from the archive only, so the id must have been read before; context sets how many messages appear on each side and limit is ignored. around cannot be combined with after or before.

Returns a JSON result plus the images those messages contain. Messages are decrypted when the saved session holds the Letter Sealing keys; a sealed message that cannot be opened has sealed: true and no text. Every message read is stored in a local SQLite archive, and every image is saved under the media directory before it is attached, so the next call is cheaper and still works when LINE is unreachable.

Pass include_images=false to keep the image message rows but attach no image blocks. max_images defaults to 20 and caps the attachments; max_image_bytes adds an optional byte cap. The ids that were not attached appear in images_skipped. Pass max_images=null to remove the count cap for one call.

Check partial: true means the page budget ran out before limit, so older messages were not reached. Check stale: true means LINE could not be reached and the result came from the local archive.

search_messagesA

Search archived messages for text, or for a message kind.

Pass query to match text, kinds to match what a message is, or both. kinds=["image"] with no query is how you find photos and files, which have no text to match.

Searches the local archive, which holds only the messages this server has read. Read coverage before concluding that something does not exist: a small messages_scanned means most history was never read.

Narrow the search with chats, after/before, from_sender, and since_days. A bare date means local midnight, and before includes the whole day. When both after and since_days are given, after wins. order="oldest" answers "where did this start", and offset pages through more hits; truncated: true means more hits exist after this page.

from_sender accepts a mid or part of a name, matched only against senders already archived. Pass chats to narrow the search, and sync=true to read the newest page of those chats and page older messages from LINE first (at most three older pages per chat).

Text search only sees messages that have text: images, stickers, and sealed messages that could not be decrypted never match a query. Each hit carries a snippet around the match when query was given.

match="words" needs every space-separated term of the query, in any order, so "invoice today" also finds "today's invoice". It helps Latin scripts only: Thai has no word separators, which makes the query one term either way.

unreadA

List chats with unread messages and the newest messages in each.

One call instead of one get_messages per chat. Chats are ordered by their latest activity, and chats_skipped says how many unread chats did not fit in chats_limit. Every message read is archived, and nothing is marked as read on LINE: the counts stay until the chat is opened on the phone.

It costs one LINE request per chat, so the caps are low on purpose. Images are downloaded only with include_images=true, because a digest of ten chats can hold dozens. When LINE cannot be reached the archive answers instead, and stale says so.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.4/5.0

Scored across 6 tools

Disambiguation4/5

login/logout, list_chats, get_messages and search_messages each target a distinct action, but `unread` overlaps with `list_chats` (chat listing) and `get_messages` (newest messages per chat). The descriptions do a good job distinguishing the digest use case from full reads, so misselection is unlikely but possible.

Naming Consistency3/5

The core read tools follow a clean verb_noun pattern (list_chats, get_messages, search_messages), but `login`, `logout` and especially `unread` break it — `unread` is an adjective with no verb and gives no hint of the action performed. Mixed conventions, though still readable.

Tool Count5/5

Six tools is well-scoped for a LINE client: session handling, chat listing, message reading, search and an unread digest. Each tool earns its place with no redundancy padding the surface.

Completeness3/5

The surface is deliberately read-only: there is no send_message, no reply/react, no mark-as-read, and no way to act on what is read. Coverage of the reading/archiving lifecycle is excellent, but for a messaging domain the write side is a notable gap that will dead-end agents asked to respond.

Maintenance

ActivityNo data
ResponsivenessOutdated data