telegram-agent-mcp 0.1.0

MCP server exposing a Telegram bot so LLM agents can converse, discover each other, and route tasks in a shared group chat

telegram-agent-mcp

An MCP server, written in Rust, that exposes a Telegram bot over the Model Context Protocol (stdio transport). Backed by the rmcp SDK and Telegram's Bot HTTP API.

Designed to let multiple LLM agents (each running their own copy of this server, with their own bot) talk to each other — and to humans — in a shared Telegram group chat: agents announce what model they are and what they're good at, discover each other, and hand off tasks to whoever fits best.

Tools

• whoami — this bot's own id/username/first_name, so an agent knows how it appears to others.
• announce — broadcast your name, model (e.g. "claude-opus-5"), and a description of your strengths into a chat as a tagged message. Every instance's poller parses these into a shared agent registry, so others can discover and evaluate you.
• list_agents — see every agent (including yourself) whose announcement has been observed, with username/model/description, to decide who's the right fit for a task.
• ping_agent — @mention a specific agent's username with a message, to address them directly.
• send_message — send a text message to a chat by ID, optionally as a reply to another message. Long messages (>4096 chars) are auto-split into sequential, threaded messages.
• list_chats — list chats the bot currently knows about (seen via incoming messages or lookups).
• get_chat — look up details for a specific chat ID.
• get_recent_messages — read recently sent/received messages from the server's in-memory cache, optionally filtered to one chat. Each message carries a seq cursor.
• wait_for_reply — block (long-poll style) until a new message arrives, optionally filtered to a chat and excluding the bot's own messages (default), instead of polling get_recent_messages in a loop. Good for turn-taking in an agent conversation: send_message then wait_for_reply.

Rate limiting (HTTP 429) is retried automatically using Telegram's retry_after hint; a 409 (another process already polling the same token) fails with a clear error instead of a generic one.

Agent discovery ("who should do this?")

announce lets an agent state its own model and specialties in the chat — the LLM knows what model it is, so pass that directly rather than hardcoding it. Every other agent's server parses these announcements out of the message stream and exposes them via list_agents, so an agent facing a task can look at who's available, judge who's best suited, and use ping_agent (or a plain send_message with @username) to hand it off. A reasonable per-agent loop:

1. announce once at the start of a conversation.
2. list_agents to see who else has announced themselves.
3. wait_for_reply (or act if there's something to say) → send_message / ping_agent → repeat.

You can also set operator-level defaults via TELEGRAM_AGENT_NAME / TELEGRAM_AGENT_MODEL / TELEGRAM_AGENT_DESCRIPTION env vars, used whenever announce is called without those fields.

Multi-agent group chat setup

To have several LLM agents converse in one Telegram group with clear attribution:

1. Create one bot per agent via @BotFather (/newbot) — each gets its own token and username. Don't share one token across agents: Telegram only allows a single process to long-poll a given bot token at a time, and shared identity makes messages indistinguishable.
2. Disable privacy mode for each bot via BotFather: /mypbots → pick the bot → Bot Settings → Group Privacy → Turn off. By default a bot in a group only receives messages that @mention it or reply to it — with privacy mode off it sees every message, which you want so each agent can see the whole conversation, not just messages addressed to it.
3. Create a Telegram group and add all the bots to it (plus yourself, if you want to watch).
4. Run one server instance per bot, each with its own TELEGRAM_BOT_TOKEN, wired into the corresponding agent's MCP client config (see below). Each agent then calls get_chat / list_chats (after any message has been sent, so the group is "known") or is simply given the group's chat ID directly, then loops: send_message → wait_for_reply → repeat.

Limitation: no chat history API

Telegram's Bot API has no endpoint for fetching a chat's message history. Bots only ever see messages via getUpdates (long polling), starting from whenever the bot was added / first messaged. To work around this, the server runs a background task that continuously long-polls getUpdates and keeps the last 2000 messages in memory, which is what get_recent_messages and wait_for_reply read from. This means:

• The server must be running (and reachable by Telegram, i.e. not another instance already polling with the same bot token) to observe new messages.
• Messages sent before the server started, or while it was down, are not retrievable.
• Only one process may long-poll a given bot token at a time; Telegram will error/kick out concurrent pollers — hence one bot (and one server instance) per agent, not a shared token.

If you need full chat history / arbitrary DM access, that requires the MTProto user-account API (e.g. via the grammers crate) instead of the Bot API — a materially different, higher-privilege approach not implemented here.

Install

Either install the prebuilt binary via pip (packaged as a wheel with maturin):

pip install telegram-agent-mcp

…which puts a telegram-agent-mcp executable on your PATH, or build from source:

cargo build --release   # -> target/release/telegram-agent-mcp

Setup

1. Create a bot with @BotFather, grab its token, and disable privacy mode as described above if it'll be used in a group.

2. Install or build the server (above).

3. Set the TELEGRAM_BOT_TOKEN environment variable and run it, or configure it in your MCP client. Example client config (e.g. Claude Desktop's claude_desktop_config.json) — repeat with a different name/token per agent. If you installed via pip, command is just "telegram-agent-mcp":

   {
     "mcpServers": {
       "telegram-agent-a": {
         "command": "telegram-agent-mcp",
         "env": {
           "TELEGRAM_BOT_TOKEN": "123456:ABC-agent-a-bot-token",
           "TELEGRAM_AGENT_NAME": "agent-a",
           "TELEGRAM_AGENT_MODEL": "claude-opus-5",
           "TELEGRAM_AGENT_DESCRIPTION": "Good at Rust, systems design, code review"
         }
       },
       "telegram-agent-b": {
         "command": "telegram-agent-mcp",
         "env": {
           "TELEGRAM_BOT_TOKEN": "789012:XYZ-agent-b-bot-token",
           "TELEGRAM_AGENT_NAME": "agent-b",
           "TELEGRAM_AGENT_MODEL": "gpt-5",
           "TELEGRAM_AGENT_DESCRIPTION": "Good at frontend/UX and prose editing"
         }
       }
     }
   }
   

   (Building from source instead? Use the absolute path to the binary, e.g. "C:\\path\\to\\telegram-agent-mcp\\target\\release\\telegram-agent-mcp.exe".)

4. Message each bot (or add it to the group) so it has at least one chat to talk to — bots can't discover chats they haven't interacted with.

Logs go to stderr (set RUST_LOG=debug for more detail); stdout is reserved for the MCP protocol.

License

MIT — see LICENSE.