tg-mcp

by Abdk4Moura

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct action: listing chats, reading messages, searching, downloading media, sending text, sending files, and identifying the account. There is no overlap, and the boundaries between tools are clear.
Naming Consistency4/5
All tools share the 'tg_' prefix and most follow a verb_noun pattern (list_chats, read_chat, download_media, send_message, send_file). Two exceptions are 'search' (verb only) and 'whoami' (question format), which are minor deviations from the otherwise consistent pattern.
Tool Count5/5
Seven tools is well-scoped for a Telegram server, covering core operations without being either too sparse or overly heavy. Each tool has a clear purpose and earns its place in the set.
Completeness4/5
The set covers the primary Telegram workflows: discovering chats, reading and searching messages, downloading media, sending text and files, and checking account identity. Minor gaps like message editing/deletion or chat management exist, but they are not critical for the server's apparent purpose.
Average 4/5 across 7 of 7 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 3 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
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It reveals the ordering ('newest first') and id type ('numeric ids'), but leaves 'recent' undefined and does not state whether the operation has side effects. Adequate for a simple read-only list but not rich in detail.
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 a single sentence, front-loaded with the action, and contains no redundant words. Every phrase contributes meaning.
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?
The tool is simple and an output schema exists, so return values need not be described. The description covers purpose, ordering, and id format. Missing details like limit parameter explanation and usage guidance leave minor gaps, but overall it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter (limit) with 0% description coverage. The description does not mention the limit parameter at all, leaving its meaning to be inferred from the name and default. The parameter semantics are not enhanced.
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 uses a specific verb (List), names the resource (Telegram chats), and adds scope constraints (recent, numeric ids, newest first). This clearly distinguishes it from sibling tools like tg_read_chat or tg_send_message.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for obtaining chat IDs and recency order, but it does not explicitly state when to choose this tool over alternatives or mention exclusions. No sibling tools are referenced.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 of behavioral disclosure. It only states the purpose without mentioning whether the operation has side effects, requires authentication, or handles errors (e.g., no signed-in account). This minimal disclosure falls short of what is needed for a tool with zero annotations.
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 a single concise sentence that front-loads the core function. It avoids extraneous words or redundant phrasing, earning a perfect score for conciseness.
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 simplicity (no parameters, no output schema details needed since it exists), the description is largely complete. However, it could benefit from a hint about the return value (e.g., account info) even though the output schema exists, but for a whoami tool the purpose is clear enough.
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?
The tool has zero parameters, so the baseline for parameter semantics is 4. The description correctly omits parameter details, as there are none to explain, and the schema already confirms the empty parameter set.
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: identifying which Telegram account the server is signed in as. This specific verb+resource (identify current account) distinguishes it from sibling tools like tg_send_message or tg_list_chats, making its function unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use guidance is provided, but the tool's purpose is self-evident for checking the current account identity. There are no alternative tools that serve a similar purpose, so the usage context is implied rather than stated.
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?
With no annotations provided, the description carries the burden of disclosing behavior. It mentions that it returns a local path, which is a key behavior, and provides a dependency on other tools. However, it does not disclose edge cases like messages without media or potential errors, so it is only minimally adequate.
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 two sentences long, with no filler. It front-loads the action and result, then provides a useful dependency hint. Every word earns its place, making it highly concise and well-structured.
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 simplicity (2 parameters, output schema available), the description is mostly complete. It covers the main purpose, expected input source, and return type. The only gaps are edge cases (e.g., no media attached) and peer semantics, but the output schema likely fills in return structure details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning to message_id (where it comes from) but provides no explanation for the 'peer' parameter, which is still ambiguous. For a two-parameter tool, half the parameters lack semantic context, making this below average.
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 verb 'Download' and the resource 'media attached to one message', which is specific and distinct from sibling tools like tg_read_chat (reading messages) and tg_send_file (uploading). It also differentiates by noting the message_id source, making the tool's scope unambiguous.
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 provides clear context for when to use the tool by stating that message_id comes from tg_read_chat or tg_search, implying this tool is used after those operations. However, it does not explicitly name alternative tools or state when not to use it, but the context is sufficient for a simple download tool.
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?
With no annotations, the description carries the burden of behavioral disclosure. It discloses ordering and date-range types, but does not mention limit behavior, error cases, or permission requirements. This is a read tool, so safety is less critical, yet gaps remain.
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?
Two sentences, front-loaded with the primary action, and every sentence adds value. No redundant filler or repetition of schema information.
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?
For a simple read tool with an output schema, the description covers the essential behavioral aspects: ordering, peer formats, and date range. It lacks mention of limit and explicit guidance on when to use this vs tg_search, but these are minor gaps given the tool's low complexity.
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 coverage is 0%, so the description must compensate. It explains peer (numeric id, @username, 'me') and since/until (YYYY-MM-DD), but omits limit entirely. Three of four parameters receive partial or full semantic context, but limit's meaning is left to inference from its name.
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 function with a specific verb ('Read') and resource ('messages from a chat'), and adds ordering detail ('oldest first'). This distinguishes it from sibling tools like tg_send_message and tg_search.
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 provides useful context for usage: what 'peer' can be, and the date format for since/until. However, it does not explicitly contrast this with tg_search or state when to choose one over the other, so it lacks explicit exclusion criteria.
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. The term 'Search' implies a read-only operation, and the scope is mentioned. However, it does not disclose potential limitations (e.g., no media search, case sensitivity) or confirm non-destructiveness explicitly. It adds some context but remains minimal.
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 a single, front-loaded sentence with no redundant information. It earns its place by clearly stating the action and scope without any filler.
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 params, output schema present), the description is adequate. It explains the core behavior and scope, and the output schema covers return values. It lacks mention of pagination or ordering, but these are not critical for the description to be complete.
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 0%, so the description must compensate. It partially does by explaining 'query' (text to search) and 'peer' (scope: all chats or one peer). However, it does not mention 'limit' or other param-specific details. This adds some value but not comprehensive compensation.
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 function: searching messages by text. It distinguishes itself from sibling tools like tg_list_chats (listing chats) and tg_read_chat (reading messages) by specifying 'search messages by text' and the optional scope ('across all chats or within one peer'). This is a specific verb+resource+scope combination.
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 provides clear context on when to use this tool: when looking for messages containing specific text. It also clarifies scope options (all chats vs. one peer). However, it does not explicitly name alternatives or exclusions, but the context is strong enough to differentiate it from siblings.
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, the description carries the full burden of behavioral disclosure. It clearly states that delivery is immediate and irreversible by this server, which is critical for a send operation. Other traits like file size limits or path requirements are not mentioned, but the irreversibility is a strong and relevant disclosure.
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 compact and front-loaded with the key action, followed by essential behavioral and usage notes. Every sentence earns its place without redundancy, making it highly scannable for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no annotations and no schema descriptions, so the description must cover a lot. It covers the core purpose, a key behavior (irreversible), and a usage tip, but omits details like file path semantics, authentication requirements, or potential errors. The output schema exists, so return values are not needed, but the input context could be richer.
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 0%, so the description must compensate. It clarifies 'peer' with 'Use me for Saved Messages' and implies 'path' refers to the file to send, while 'caption' is optional. However, it does not explain the format or source of the path (e.g., local filesystem, URL), leaving some ambiguity.
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 'SEND a file to a Telegram chat' with a clear verb and resource, and highlights optional caption support. This distinguishes it from siblings like tg_send_message (text) and tg_download_media (download), making the purpose unambiguous.
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 provides useful context on when to use the tool: it sends files with immediate delivery and cannot be unsent, plus a specific tip for Saved Messages. However, it does not explicitly compare to alternatives like tg_send_message or mention when not to use it, but the context is sufficient for basic usage.
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 full burden. It discloses key behavioral traits: immediate delivery, irreversibility, and the 'me' alias for Saved Messages. This is significant for a send operation and helps the agent understand consequences, though it does not address potential errors or rate limits.
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 three concise sentences, each serving a distinct purpose: stating the action, noting the consequence, and giving a special usage tip. It is front-loaded with the main action and contains no superfluous words.
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?
For a simple text-send tool, the description covers the core purpose, immediate delivery, irreversibility, and the 'me' special value. An output schema exists, so return values need not be described. The only notable gap is the lack of detailed peer format guidance, but overall it is 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?
The input schema has zero coverage (no descriptions for peer or text). The description compensates partially by explaining the special 'me' value for peer, but it does not clarify acceptable formats for peer or any constraints on text. This leaves ambiguity in parameter usage.
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 sends a text message to a Telegram chat, using the explicit verb 'SEND' and identifying the resource. This distinguishes it from sibling tools like tg_send_file (file) and tg_read_chat (read), and the mention of 'real person' and 'Saved Messages' adds essential context.
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 gives clear context that this tool delivers immediately to a real person and cannot be unsent, implying suitable use cases. It also provides a usage tip for the 'me' peer value. However, it does not explicitly mention alternatives or when not to use this tool versus tg_send_file, so it falls short of a 5.
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:

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

Score Badge

Copy to your README.md:

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

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/Abdk4Moura/tg-mcp'

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