Discord MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Each tool targets a distinct resource-action pair: guild, channel, message, reaction, pin, or thread. Even similar tools like list_messages and get_message are clearly differentiated by scope, so an agent should not confuse them.
Naming Consistency5/5
All tools follow a consistent snake_case verb_noun pattern, such as get_, list_, send_, edit_, delete_, add_, pin_, and create_. The naming is uniform and predictable across the entire set.
Tool Count4/5
At 17 tools, the server is slightly above the ideal 3-15 tool range but each tool maps to a concrete Discord API operation and earns its place. The count is heavy but still navigable and well-scoped for a Discord bot.
Completeness4/5
The set covers core Discord workflows well: guild/channel reads, full message CRUD, reactions, pins, and thread creation. Obvious gaps like channel creation/deletion, member management, and thread editing/deleting are notable but not critical for the primary message-interaction use case.
Average 3.5/5 across 17 of 17 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description alone must disclose behavioral traits. It only states the basic action and omits side effects (the message remains in the channel), permission requirements, idempotency, and behavior when the message is not currently pinned.
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 with no filler, and the action is front-loaded. It communicates the essential purpose without wasting tokens.
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?
For a simple two-parameter mutation tool, the description is minimally adequate, and the schema covers parameter intent. However, with no annotations and no output schema, the description leaves behavioral context and error/precondition details unaddressed, so it is not fully 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 100%, so the schema already documents both channel_id and message_id fully. The description adds no parameter-level meaning beyond that, which is acceptable per the baseline.
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 uses a specific verb ('Unpins') and identifies the resource ('a message in a Discord channel'), making the core action immediately clear. It does not explicitly call out sibling tools or scope differences, so it stops just short of full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to choose this tool over alternatives like pin_message or delete_message. The description implies use when a message should be unpinned, but it doesn't mention preconditions such as the message already being pinned.
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 present, so the description carries the full burden of behavioral disclosure. It only says 'fetches' which suggests a read operation, but it does not clarify ordering, pagination behavior, permissions needed, or whether the operation has any side effects. This is minimal coverage 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It conveys the core action and target resource efficiently.
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?
Given the simple nature of the tool and full parameter documentation, the description is adequate for basic invocation. However, there is no output schema and the description does not mention return format, message ordering, or the relationship between 'recent' and the before/after/around parameters, leaving some ambiguity for an agent choosing and calling the 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 coverage is 100%, so the schema already documents all five parameters. The description adds meaningful value by specifying 'channel or thread,' which expands the semantic scope of channel_id beyond the schema's 'The ID of the channel.' It also implies that limit and before/after/around control the 'recent' result set.
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 a specific verb and resource: it fetches recent messages from a Discord channel or thread. It is distinguishable from sibling get_message because it describes plural recent messages rather than a single message, though it does not explicitly name the alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus siblings like get_message, send_message, or get_pinned_messages. The word 'recent' implies a use case but no explicit context, exclusions, or alternative routing is provided.
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 must carry the behavioral burden. It only restates the destructive action and does not disclose irreversibility, required permissions, limitations (e.g., age of message), or error behavior. This is a meaningful gap for a delete 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?
A single clear sentence with no filler or redundant explanation. The core action and target are front-loaded, and every word contributes to comprehension.
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?
For a simple two-parameter tool with full schema coverage, the description is mostly adequate. However, because it is a destructive operation with no annotations and no usage guidance, the overall context is incomplete even if the basic call is clear.
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% and the two parameters are self-explanatory. The description adds no additional parameter meaning, so the baseline score of 3 is appropriate.
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 states a specific verb ('Deletes') and a clear resource ('a message in a Discord channel'). It is unambiguous and naturally distinguishes the tool from siblings like send_message, edit_message, and delete_reaction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites like permissions or whether the message must be authored by the calling user. There are no exclusions or alternative tool references.
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?
With no annotations, the description carries the full burden of behavioral disclosure. It states the core action but does not mention idempotency, what happens if the bot has no such reaction, permission requirements, rate limits, or whether the action is reversible. These are relevant operational details for an agent invoking a destructive Discord API call.
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?
A single sentence with no redundant words. The verb, object, and scope are front-loaded and immediately actionable.
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?
For a simple 3-parameter tool with full schema coverage, the description is minimally sufficient. However, no annotations and no output schema mean key behavioral context—such as no-op behavior or result semantics—is missing, so the agent must infer expected API behavior.
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%, so the baseline is 3. The description adds no extra meaning beyond the schema; it essentially restates that the emoji is the reaction to remove. It does not clarify emoji format (e.g., unicode vs. custom emoji ID) or constraints.
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 states a specific verb ('deletes'), a precise resource ('the bot's reaction on a message'), and the context ('in a Discord channel'). It clearly differentiates from sibling tools like delete_message and add_reaction by scoping to the bot's own reaction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives, such as add_reaction for adding reactions or delete_message for removing the message itself. The wording implies the bot can only remove its own reaction, but no explicit selection criteria or exclusions are provided.
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 disclosing behavior. It only says 'Edits', which signals mutation, but omits important behavioral details such as whether existing fields are replaced, what happens if only content or only embeds is provided, and what failure modes exist (e.g., attempting to edit a non-bot or deleted message). This is a significant gap for a mutation 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 a single sentence that leads with the verb 'Edits' and packs the resource scope into a compact phrase. There is no filler, redundant wording, or repetition of schema details.
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 is simple and the schema fully documents its parameters, but with no output schema and no annotations, an agent still lacks information about return values, failure conditions, and how content and embeds interact when only one is supplied. The description is sufficient to attempt a call, but it is not fully self-sufficient for confident invocation.
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%, as all four parameters (channel_id, message_id, content, embeds) are already documented in the input schema. The description adds no extra parameter semantics, so the baseline of 3 is appropriate.
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 states a clear verb ('Edits') and a specific resource ('previously sent message by the bot in a Discord channel'), so the core action is unambiguous. It implicitly differentiates this from send_message and delete_message through the phrase 'previously sent', but it does not explicitly name sibling alternatives, so it falls just short of a 5.
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?
'Previously sent message by the bot' gives useful context and implies that the bot can only edit its own prior messages, which is a relevant constraint. However, the description does not explicitly state when to choose this over send_message or delete_message, nor does it mention that content and embeds are optional replacements. The usage guidance is mostly implied rather than prescribed.
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 that the tool lists members; it does not discuss pagination behavior, response format, sorting, rate limits, or whether the operation is read-only in any explicit way. 'Lists' implies a read operation, but beyond that, behavior is opaque.
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 that immediately states the action and target. There is no fluff, redundant phrasing, or unnecessary preamble. It is as concise as possible while still conveying the core purpose.
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 description is minimally viable for a simple list operation: the agent knows what the tool does and which parameters to provide. However, with no annotations and no output schema, the description leaves pagination behavior and return details under-specified. It is adequate for selecting the tool, but not fully complete for using it without additional inference.
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%, so every parameter (guild_id, after, limit) is already documented. The description adds no extra parameter semantics, but the baseline of 3 applies because the schema does the heavy lifting for parameter understanding.
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 is specific and unambiguous: it states the verb 'lists', the resource 'members', and the scope 'Discord guild/server'. This clearly distinguishes it from sibling tools like list_guilds, list_channels, and list_messages, which operate on different resource types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage context is provided. The description does not mention when to prefer this tool over alternatives, nor does it describe any prerequissites or exclusions. While the purpose is clear, there is no guidance on when this is the right choice relative to get_guild or other list operations.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic effect and does not mention permission requirements, rate limits, idempotency, custom emoji constraints, or what happens on failure. This is a meaningful gap for a mutation 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 a single, direct sentence with no filler or repetition. It front-loads the action and resource, making it immediately scannable and efficient.
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?
For a simple three-parameter write operation, the description and schema together provide enough to invoke the tool, but the lack of annotations and behavioral nuance leaves gaps around permissions, error handling, and when to prefer alternatives. It is minimally viable but not fully 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 100%, so the input schema already documents all three parameters clearly, including an example for emoji. The description adds no additional meaning beyond what the schema provides, so a baseline score of 3 is appropriate.
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 identifies the specific operation (adding a reaction emoji), the target resource (a message in a Discord channel), and is distinct from sibling tools like delete_reaction or send_message. It leaves no ambiguity about what the tool does.
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 operation itself implies when to use the tool: when a reaction should be added to a message. However, there is no explicit guidance about alternatives or exclusions, such as noting that delete_reaction removes reactions or that send_message handles message creation. The usage context is understandable but not elaborated.
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?
There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals that the thread is public and that creation can occur from a channel or a message, but it does not mention permissions, side effects, response format, or failure conditions. This is a meaningful gap for a mutation 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 a single front-loaded sentence with no filler or redundant information. It efficiently states the action, resource, and the two creation contexts in the fewest possible words.
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 schema fully covers inputs, and the description clarifies the dual modes of thread creation, which is helpful. However, the absence of an output schema and annotations means the description should probably disclose what the tool returns and any authorization requirements. For a simple create operation, it is minimally sufficient but not 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 100%, so the schema already documents all four parameters. The description adds no additional parameter-level detail beyond the schema; the mention of 'or from a message' lightly reinforces the optional message_id parameter but does not enrich it.
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 ('Creates') and resource ('new public thread'), and further specifies the context: 'in a Discord channel or from a message.' This clearly distinguishes it from siblings like send_message or get_message, even without naming an alternative.
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 when to use the tool: when a new public thread needs to be created. However, it provides no explicit guidance about when not to use it, prerequisites, or alternatives. There is no direct mention of scenarios where another tool would be more appropriate.
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?
There are no annotations, so the description carries the full burden. It only restates the action of retrieving details and adds no information about return shape, error behavior, permissions, or potential side effects. The mention of threads is mildly useful but does not qualify as substantive behavioral 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 a single, efficiently worded sentence that communicates the action, target, and input criterion without any redundant or filler content.
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?
For a simple single-parameter get operation, the description is sufficient for basic invocation. However, with no output schema and no annotations, the word 'details' gives no indication of what fields are returned or what happens for invalid/private channels, leaving some contextual ambiguity.
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% and the channel_id parameter is already documented as 'The ID of the channel.' The description's 'by its ID' phrase adds little beyond the schema, so the baseline of 3 is appropriate.
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 states a specific verb ('Gets details'), a specific resource ('specific Discord channel or thread'), and the lookup method ('by its ID'). This clearly distinguishes it from listing tools like list_channels and other get tools like get_guild.
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 intended use is implied: call this when you already have a channel or thread ID and need its details. However, it gives no explicit guidance about when to prefer list_channels or get_guild, nor when not to use this tool.
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?
With no annotations, the description carries the full burden of behavioral disclosure. It states the mutation effect ('pins a message') but does not mention permission requirements, idempotency, or failure cases such as the channel pin limit. This is a significant gap for a tool that changes server state.
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 zero wasted words. It conveys the core operation immediately and is easy to parse.
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?
For a simple two-parameter mutation, the description is adequately clear about the operation, and the schema documents all parameters. However, the lack of any permission or prerequisite guidance, combined with no annotations or output schema, leaves room for avoidable failed calls.
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 for both channel_id and message_id, so the baseline is 3. The description adds no additional parameter meaning 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 specific action ('Pins') and the resource ('a message in a Discord channel'). It is immediately distinguishable from the sibling unpin_message and get_pinned_messages, so an agent can identify what this tool does without opening the schema.
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: it is for pinning messages in Discord. However, it does not explicitly state when to use it versus unpin_message, nor does it mention any prerequisites such as required permissions or the message needing to already exist.
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?
There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the core action and target, but does not mention required permissions, rate limits, public visibility of the message, or what happens on failure. For a mutating tool with zero annotation coverage, this is a notable gap.
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 with no filler. It front-loads the main action and target, making it immediately scannable for an 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?
With 5 parameters, no annotations, and no output schema, the description provides a minimal but functional summary. The schema robustly documents the parameters, but the description omits operational context like return value, permission requirements, and potential errors, so the agent is left to infer these important details.
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 100%, so the baseline is 3. The description adds a small clarification that channel_id refers to text channels or threads, but it does not otherwise elaborate on tts, embeds, content, or reply_to_message_id 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 uses a specific verb ('Sends') and identifies both the action and the resource ('a message to a specified Discord text channel or thread'). This clearly differentiates it from sibling tools like edit_message, delete_message, or create_thread.
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 the tool should be used whenever you need to send a message to a Discord text channel or thread, but it does not explicitly state when not to use it or name alternatives. No exclusions or comparative guidance is provided.
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. 'Retrieves' conveys read-only behavior, but the description does not disclose error handling, auth requirements, or whether the returned message is a full object or a summary. For a simple get-by-ID operation this is adequate but 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 concise, front-loaded sentence with no filler. It states exactly what the tool does and the two required identifiers, earning every word.
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 low in complexity, has only two required parameters, and those parameters are fully documented in the schema. The description makes the purpose unambiguous. The only minor gaps are the lack of return-value and error-behavior details, which are not critical for a simple retrieval action.
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%, since both channel_id and message_id have descriptions in the schema. The tool description merely restates that these IDs are used and adds no new semantic detail beyond the schema, so baseline 3 applies.
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 ('Retrieves'), specifies the exact resource ('a specific message'), and names the two identifying inputs (channel ID and message ID). This clearly distinguishes it from the sibling list_messages tool and from message mutations like send_message, edit_message, and delete_message.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to choose this tool over alternatives. The sibling list_messages is the obvious alternative for getting multiple messages, but the description does not mention this relationship or any prerequisites such as having valid IDs beforehand.
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 full burden of disclosing behavior. 'Gets all' signals a read-only operation and a list-style result, but ordering, pagination, errors, and permissions are not mentioned.
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?
A single sentence states the action, target, and scope with no filler. The key information is front-loaded and every word contributes.
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 one-parameter, read-only tool, the description plus schema provide enough to invoke it correctly. The lack of output-format details and alternative routing is minor given the tool's simplicity.
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 already describes channel_id at 100% coverage as 'The ID of the channel.' The description adds no parameter-level meaning beyond the schema.
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 and resource: 'Gets all pinned messages in a Discord channel.' The 'pinned' qualifier makes it clearly distinct from list_messages and get_message.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to choose this tool over list_messages or get_message. An agent must infer the intended use from the tool name and the 'pinned' qualifier.
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 transparency burden. It usefully clarifies that only guilds the bot is a member of are returned and that this is a listing operation. However, it does not disclose pagination behavior, default ordering, or response shape.
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, compact sentence that front-loads the verb and resource, adds a helpful parenthetical clarification, and contains no filler or redundant schema content.
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-only listing tool, the description plus the fully documented schema is largely sufficient. The main gap is the lack of an explicit response format or pagination explanation, but the optional after/before/limit parameters already imply pagination exists.
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% coverage for all three parameters, so the description does not need to repeat their meaning. The description adds no additional parameter-level nuance beyond the schema, so the baseline score of 3 applies.
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 states a specific verb ('Lists'), a clear resource ('all Discord guilds (servers)'), and a precise scope ('the bot is currently a member of'). This clearly distinguishes it from sibling tools like get_guild and list_channels.
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 this tool is for enumerating the guilds the bot can access, but it does not explicitly state when to prefer it over alternatives such as get_guild. No exclusion criteria or alternative tool guidance is provided.
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 behavioral disclosure. 'Gets information' clearly signals a read-only operation, but the description does not mention authentication failure behavior, rate limits, or what fields are returned. It is adequate but not deeply transparent.
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, concise sentence with no filler. It directly states the action and the target resource, and every word contributes meaning.
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?
For a zero-parameter read-only tool, the description names the target resource and implies safe reading. However, with no output schema and no annotations, the word 'information' is vague: an agent cannot anticipate the exact response shape or whether specific fields like bot user ID, username, or avatar will be present.
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 and 100% schema description coverage, so there are no parameter semantics for the description to add. The description nevertheless clarifies that the call is scoped to the authenticated bot user, which is the only context an agent needs for a no-argument call.
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 ('Gets information') and identifies the exact resource ('current authenticated Discord bot user'), which clearly distinguishes it from sibling tools that operate on guilds, channels, messages, and reactions. No ambiguity remains about what the tool does.
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 the tool is for retrieving data about the bot's own identity; no sibling tool targets the bot user itself, so the intended use is fairly evident. However, it does not explicitly state when to prefer this over alternatives or provide exclusions, so guidance is implied rather than fully 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, the description carries the burden of behavioral disclosure. It correctly implies a read-only detail fetch and lists what kinds of data are included, but it does not mention errors for invalid IDs, permissions requirements, rate limits, or how with_counts changes the response. It provides some behavioral context but leaves notable gaps.
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 well-structured sentence with no filler. It front-loads the primary action and resource, then gives concrete examples of what the details include. Every phrase adds value.
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 relatively simple getter with fully documented parameters, the description provides enough to understand the tool's role and expected output shape. Since there is no output schema, the enumerated response contents (roles, emojis, member count) help compensate for that absence, though error and edge-case behavior is not addressed.
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%, so both parameters are already documented. The description reinforces that guild_id identifies the target server but adds no new meaning for with_counts. Baseline 3 is appropriate because the schema already does the work.
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 names a specific verb ('gets'), a specific resource ('details of a specific Discord guild/server by its ID'), and concrete detail categories (roles, emojis, member count). This clearly distinguishes it from list_guilds, which would be about multiple guilds rather than one targeted by ID.
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 establishes clear context: use this when you have a specific guild ID and need its details, rather than listing guilds. It does not explicitly name the sibling list_guilds as the alternative or state when not to use it, but the 'by its ID' phrasing makes the intended scope obvious.
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 must carry the full burden. It conveys a read-only listing operation and clarifies the required scope. It does not address pagination, permissions, or error behavior, but for a straightforward list tool these omissions are moderate.
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?
One sentence with no filler. The core action and scope are front-loaded, making it easy to parse at a glance.
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?
This is a simple list tool with one required parameter fully documented. The description explains what it returns (all channels) and the required scope. It does not detail channel types or return object shape, but with no output schema and low complexity, the definition is largely 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 coverage is 100% — the only parameter guild_id is already described. The description reinforces that the guild is a Discord server but adds no additional format or semantics beyond the schema.
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?
Description states a specific verb ('Lists'), resource ('channels'), and scope ('in a specific Discord guild/server'). This clearly distinguishes it from siblings like list_guilds and get_channel, which operate on different resources or granularity.
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 clearly implies the appropriate use case: when you need all channels for a given guild. However, it does not explicitly mention alternatives like get_channel for a single channel, so no exclusions are stated.
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:

[![discord-mcp-server MCP server](https://glama.ai/mcp/servers/swaritsoni6-lgtm/discord-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/swaritsoni6-lgtm/discord-mcp-server)

Score Badge

Copy to your README.md:

[![discord-mcp-server MCP server](https://glama.ai/mcp/servers/swaritsoni6-lgtm/discord-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/swaritsoni6-lgtm/discord-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/swaritsoni6-lgtm/discord-mcp-server'

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