Telegram MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes: get_context_info for session info, notify for structured notifications, send for free messages, send_code for code snippets, send_file for files, send_image for images, unattended_mode for task loops, and wait_reply for blocking replies. However, send and notify could be confused as both send messages, though descriptions clarify notify is preferred for structured content.
Naming Consistency5/5
All tools follow a consistent 'telegram_' prefix with snake_case naming (e.g., telegram_get_context_info, telegram_notify). The verb-noun pattern is clear and uniform across all eight tools, making them easily identifiable and predictable.
Tool Count5/5
With 8 tools, the set is well-scoped for a Telegram integration server. It covers core functionalities like sending messages, files, images, and code, plus advanced features like context retrieval and unattended modes, without being overwhelming or lacking essential operations.
Completeness4/5
The toolset provides comprehensive coverage for Telegram communication, including sending various content types, receiving replies, and managing sessions. A minor gap is the lack of tools for managing Telegram-specific entities like chats or users, but the focus on agent notification workflows is well-covered.
Average 4.4/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: automatic truncation for messages over 300 characters and a prompt to use 'telegram_notify' for structured messages. However, it doesn't cover other potential behaviors like error handling, rate limits, or authentication needs, leaving some gaps for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured into three brief points: purpose, automatic handling, and recommendation. Each sentence adds value without redundancy. However, the formatting includes extra whitespace and quotes, slightly detracting from cleanliness, but the content itself is efficiently presented.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is fairly complete. It covers purpose, usage guidelines, and key behaviors like truncation. However, it lacks details on return values or error cases, which could be useful despite no output schema. For a simple tool, this is adequate but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'message' parameter documented as '消息内容' (message content). The description doesn't add any parameter-specific semantics beyond what the schema provides, such as format constraints or examples. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to heavily.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '发送自由格式消息到 Telegram' (send free-form messages to Telegram). It specifies the verb ('发送' - send) and resource ('Telegram'), and distinguishes it from the sibling 'telegram_notify' by mentioning it's for free-form messages. However, it doesn't fully differentiate from other siblings like 'telegram_send_code', 'telegram_send_file', or 'telegram_send_image', which also send content to Telegram.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines: it states '不推荐，请优先使用 telegram_notify' (not recommended, please prioritize using telegram_notify) and explains that 'telegram_notify' is for structured messages, while this tool is for free-form messages. This clearly defines when to use this tool versus alternatives, including exclusions and recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the tool sends images to Telegram but doesn't disclose behavioral traits like authentication requirements, rate limits, error handling, or what happens if the image path is invalid. The warning symbol (⚠️) introduces usage scenarios rather than behavioral risks. Some context is provided about file path handling ('相对于项目目录或绝对路径'), but key behavioral aspects remain undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage scenarios, parameters, example) and uses bullet points effectively. It's appropriately sized for a 2-parameter tool. Minor improvements could include tighter phrasing (e.g., the usage scenarios could be more concise), but overall it's efficient with zero wasted sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is reasonably complete. It covers purpose, usage guidelines, parameters, and provides an example. The main gap is the lack of behavioral transparency (no info on authentication, errors, etc.), but for a sending tool with good parameter coverage and clear usage context, it's mostly adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters clearly documented in the schema. The description adds minimal value beyond the schema: it restates that 'image_path' is a file path and 'caption' is optional text, and provides an example showing usage. However, it doesn't add significant semantic context like path format details or caption length limits beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as '发送图片到 Telegram' (send image to Telegram), which is a specific verb+resource combination. It distinguishes itself from siblings like telegram_send (general sending), telegram_send_file (file sending), and telegram_send_code (code sending) by focusing specifically on images. The Chinese title reinforces this specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage scenarios in a dedicated '使用场景' section, listing four specific cases when to use this tool (e.g., '生成了图表、可视化结果', '创建了截图、示意图'). It also specifies supported image formats (PNG, JPG, GIF, WebP), giving clear context for when this tool is appropriate versus alternatives like telegram_send_file for non-image files.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It effectively discloses key behavioral traits: it's a read-only operation (获取并发送 implies retrieval and transmission, not mutation), requires specific data inputs (token usage from system budget), and specifies the output format and content. However, it doesn't mention potential side effects like rate limits or authentication needs, though these might be less critical for this tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but not optimally structured. It front-loads the purpose clearly, but the detailed instructions and example output format (while helpful) make it somewhat verbose. Every sentence earns its place by providing necessary guidance, but it could be more streamlined for quick scanning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (2 parameters, no output schema, no annotations), the description is quite complete. It covers purpose, usage steps, output content, and example format. The main gap is the lack of an output schema, but the description compensates by detailing the return information and providing an example. For a context-reporting tool, this is sufficient though not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds significant value beyond the schema: it explains that token_total and token_used should be derived from system budget information (<budget:token_budget>), provides context for why these parameters are needed (to include token usage in the output), and shows how they're used in the example output format. This compensates well for the schema-only documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '获取并发送当前会话的上下文信息到 Telegram' (get and send current session context information to Telegram). It specifies the exact action (get and send), resource (context information), and destination (Telegram), distinguishing it from sibling tools like telegram_send or telegram_notify which appear to send generic messages or notifications.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines: it instructs when to use this tool (to send context information including token usage), specifies prerequisites (checking system token usage via <budget:token_budget>), and outlines required steps (include token usage, send complete context). It implicitly distinguishes from siblings by focusing on context info rather than general messaging or file sending.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: it's a file-sending operation (implies mutation/action), supports various file types (text, code, images, PDFs, documents), handles large files automatically, and includes a caption parameter. However, it doesn't mention potential limitations like file size caps, authentication needs, or error conditions, leaving some gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage scenarios, exclusions, priority, parameters, support, example), making it easy to scan. It's appropriately sized for the complexity, though some redundancy exists (e.g., repeating parameter info). Every sentence contributes to understanding, but it could be slightly more streamlined.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is highly complete. It covers purpose, detailed usage guidelines, behavioral aspects (file types, large file handling), parameter basics, and includes an example. This provides sufficient context for an agent to use the tool effectively, compensating for the lack of annotations and output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with both parameters (file_path, caption) documented in the schema. The description adds minimal value beyond the schema: it reiterates that file_path is relative or absolute and caption is optional, but doesn't provide additional context like format examples or constraints. This meets the baseline of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool's purpose as '发送文件到 Telegram' (send file to Telegram), which is a specific verb+resource combination. It clearly distinguishes this tool from siblings like telegram_notify (for summaries), telegram_send_code (for code snippets), and telegram_send_image (for images only), making its role unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides extensive usage guidance, including explicit '使用场景' (usage scenarios) with four bullet points of when to use it, '不要使用的场景' (scenarios not to use) with three bullet points, and a '优先级' (priority) section that names alternatives (telegram_notify, telegram_send_code) and specifies when to choose this tool over them. This covers when, when-not, and alternatives comprehensively.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and excels at disclosing behavioral traits: it explains the multi-step workflow, polling strategy (timing intervals), exit conditions (via '退出' or Ctrl+C), silent mode behavior, and that the tool itself doesn't send messages (only waits). This provides comprehensive operational context beyond basic functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections (工作流程, ⚠️ 重要, 📋 通知内容最佳实践, etc.) but is overly verbose at approximately 500+ characters. While informative, it includes extensive examples and implementation details that could be condensed, reducing front-loaded clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (automated loop with multiple behaviors), no annotations, and no output schema, the description is remarkably complete. It covers purpose, workflow, behavioral details, parameter usage, return values (next_instruction, should_exit, interrupted), exit strategies, and integration with sibling tools, leaving minimal gaps for agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds significant value by explaining parameter semantics beyond the schema: it clarifies that current_status should be '1-2句话' (1-2 sentences), provides context for max_wait default (7 days), and introduces a silent parameter not in the schema with detailed usage guidance (首次进入时使用 false, 后续循环使用 true). This compensates for schema limitations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as '进入无人值守模式 - 智能远程任务循环' (enter unattended mode - intelligent remote task loop), which is specific about enabling an automated task execution cycle. However, it doesn't explicitly differentiate from sibling tools like telegram_wait_reply, which also involves waiting for user input.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides excellent usage guidance with explicit when-to-use scenarios (e.g., '进入无人值守模式' for automated task loops), when-not-to-use alternatives (e.g., using telegram_notify for summaries instead of this tool for messaging), and references to sibling tools (telegram_notify, telegram_send_code, telegram_send_file) for specific notification types.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and excels by detailing behavioral traits: polling intervals (30s/60s/120s based on time), user interruptibility (Ctrl+C), timeout behavior (returns timeout: true), and return structure (reply, timeout, interrupted). This provides comprehensive operational context beyond basic functionality.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (参数, 行为, 返回) and front-loaded purpose. It's appropriately sized, but minor redundancy exists (e.g., parameter details partially overlap with schema). Every sentence adds value, though it could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (blocking polling with intervals and interrupts), no annotations, and no output schema, the description is complete. It covers purpose, parameters, detailed behavior, and return values, providing all necessary context for an agent to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'max_wait' fully documented in the schema. The description repeats the parameter name and default value but adds minimal extra context (e.g., '最长等待时间（秒）' is already in schema). Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as '等待用户回复（阻塞式轮询）' (wait for user reply with blocking polling), which is a specific verb+resource combination. It distinguishes itself from sibling tools like telegram_send (which sends messages) by focusing on receiving replies through a polling mechanism.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through its behavioral details (blocking polling with timeout), suggesting it should be used when waiting for user responses. However, it doesn't explicitly state when to use this tool versus alternatives like telegram_notify or how it relates to other tools in the workflow, missing explicit alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses behavioral traits such as the tool's function (sending notifications), parameter constraints (e.g., summary length limit), and best practices for content. However, it lacks details on potential side effects (e.g., rate limits, authentication needs), which would be helpful for a notification tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, parameters, best practices, examples), front-loaded with the core purpose. Every sentence adds value, such as clarifying parameter roles and providing actionable guidance, with no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is mostly complete. It covers purpose, parameters, usage guidelines, and examples. However, it lacks details on behavioral aspects like error handling or response format, which would enhance completeness for a notification tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining parameter semantics in Chinese, providing best practices for 'summary' and 'details', and including examples that illustrate usage. This compensates for the schema's basic descriptions, though it doesn't add deep technical details beyond what's implied.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '发送结构化通知到 Telegram' (send structured notifications to Telegram). It specifies the verb '发送' (send) and the resource 'Telegram', and distinguishes it from sibling tools like telegram_send, telegram_send_code, etc., by emphasizing structured notifications with specific event types rather than general messaging.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines in the '最佳实践' (Best Practices) section, including when to use (e.g., for concise summaries without code snippets) and when not to use (e.g., avoid including thought processes). It also implicitly distinguishes from siblings by focusing on structured notifications, though it doesn't name alternatives directly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It adds valuable behavioral context: the tool sends code with syntax highlighting, includes a recommendation to keep code under 50 lines, and suggests adding a caption. However, it doesn't mention potential limitations like rate limits, authentication needs, or error handling, which would be helpful for a mutation tool (sending implies a write operation).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, usage scenarios, parameters, example), uses bullet points for readability, and every sentence adds value. It's appropriately sized—not overly verbose—and front-loaded with the core purpose, making it efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description does a good job covering the tool's purpose, usage, and parameters. It includes an example invocation, which aids understanding. However, as a mutation tool (sending code), it could benefit from more details on behavioral aspects like error responses or confirmation of success, though the example partially compensates.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds meaningful semantics: it explains that 'code' should be kept under 50 lines, 'language' includes examples like python/javascript, and 'caption' is optional but recommended to explain why the code is sent. This provides practical guidance beyond the schema's basic descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '发送代码段到 Telegram（带语法高亮）' which translates to 'Send code snippets to Telegram (with syntax highlighting)'. It specifies the verb (send), resource (code snippets), and key feature (syntax highlighting), distinguishing it from siblings like telegram_send_file or telegram_notify.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines with '⚠️ 使用场景（仅在必要时使用）' (scenarios to use) and '❌ 不要使用的场景' (scenarios not to use), including clear alternatives like telegram_notify and telegram_send_file. It specifies when to use (e.g., for key errors, bug fixes) and when not to use (e.g., for general task completion), helping the agent choose correctly among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![telegram-mcp-server MCP server](https://glama.ai/mcp/servers/archetyx/telegram-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/archetyx/telegram-mcp-server)

Score Badge

Copy to your README.md:

[![telegram-mcp-server MCP server](https://glama.ai/mcp/servers/archetyx/telegram-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/archetyx/telegram-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/archetyx/telegram-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server