Email 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 targeting specific email operations like folder management, message retrieval, and flag handling. However, ClearMessageFlagsTool and setFlags could potentially cause confusion as they both deal with message flags, though their descriptions clarify one clears and the other sets flags.
Naming Consistency3/5
The naming is mixed with some tools using camelCase (ClearMessageFlagsTool) and others using snake_case (createFolder, getMessageList). While the verb_noun pattern is generally followed, the inconsistency in casing and the outlier 'search' (a single word) detract from a fully predictable pattern.
Tool Count5/5
With 10 tools, this server is well-scoped for an email management domain. It covers core operations like folder CRUD, message retrieval, deletion, moving, and searching, which is appropriate for handling email workflows without being overwhelming.
Completeness4/5
The toolset provides solid coverage for email management, including folder operations, message lifecycle (get, delete, move), and search capabilities. A minor gap is the lack of a tool for sending or composing emails, which might be expected in a full email server, but the existing tools support common agent tasks well.
Average 2.7/5 across 10 of 10 tools scored. Lowest: 1.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues 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

Behavior1/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 states the action ('sets flags') but does not explain what this entails—whether it modifies existing flags, adds new ones, overwrites them, or has side effects like notifications. It lacks details on permissions, error conditions, or what happens if flags are invalid. This leaves critical behavioral traits 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 a single sentence with no wasted words, making it highly concise. However, it is under-specified rather than efficiently informative—it lacks necessary details for a tool with three parameters and no annotations. While structurally simple, it does not earn its place by providing value beyond the name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a mutation tool with three parameters, no annotations, and no output schema), the description is severely incomplete. It does not explain the tool's behavior, parameter meanings, return values, or how it fits among siblings. For a tool that modifies message states, this level of documentation is inadequate and leaves the agent guessing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning none of the three parameters (folder, uid, flags) are documented in the schema. The description does not add any meaning beyond the schema—it does not explain what 'folder' refers to (e.g., mailbox folder), what 'uid' is (e.g., message identifier), or what 'flags' represent (e.g., read/unread, starred). This fails to compensate for the schema's lack of documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Sets flags on a message' restates the tool name 'setFlags' in a tautological manner without adding specificity. It mentions the resource ('message') and action ('sets flags'), but does not clarify what flags are, what they do, or how this differs from sibling tools like ClearMessageFlagsTool. This is a minimal restatement rather than a helpful explanation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a message in a folder), exclusions, or comparisons to sibling tools like ClearMessageFlagsTool (which likely removes flags) or other message-related tools. The agent must infer usage from the name alone, which is insufficient.
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 states the tool returns a list, implying a read-only operation, but does not cover aspects like pagination (hinted by 'start' and 'end' parameters), rate limits, authentication needs, or what happens if the folder is empty. This leaves significant gaps in understanding the tool's behavior 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 a single, straightforward sentence that efficiently conveys the core action. It is front-loaded with the main purpose and avoids unnecessary details. However, it could be more structured by including key usage notes, but as-is, it is appropriately sized with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a list operation with 3 parameters, no annotations, and no output schema, the description is incomplete. It does not explain the return format (e.g., structure of the message list), error handling, or how parameters interact (e.g., 'start' and 'end' for pagination). For a tool with such gaps in structured data, the description should provide more contextual detail to be fully helpful.
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 for undocumented parameters. It only mentions 'folder' in the context of the list operation, without explaining the semantics of 'start' (e.g., offset or page number) or 'end' (e.g., limit or end marker). This fails to add meaningful context beyond what the schema minimally provides, leaving parameters largely unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool 'Returns a list of messages in a given folder,' which clearly indicates its purpose as a read operation on messages. However, it does not differentiate from siblings like 'getMessage' (which fetches a single message) or 'search' (which might filter messages), making it somewhat vague in comparison. The verb 'Returns' and resource 'messages' are specific, but sibling distinction is lacking.
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 provides no guidance on when to use this tool versus alternatives. It does not mention scenarios like retrieving all messages in a folder versus using 'search' for filtered results or 'getMessage' for a single message. Without explicit when/when-not instructions or named alternatives, it offers minimal usage context.
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 full burden for behavioral disclosure. It states the action ('Clears flags') but lacks critical details: whether this is a mutation (implied by 'Clears'), what permissions are needed, if it's reversible, rate limits, or what happens on success/failure. For a tool with 3 required parameters and no annotation coverage, this is a significant 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, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place, though this conciseness comes at the cost of completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 required parameters, mutation implied, no annotations, no output schema), the description is incomplete. It doesn't cover parameter meanings, behavioral traits, usage context, or return values. For a tool that modifies message states, this leaves too many gaps for reliable agent operation.
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 but adds no parameter information. It doesn't explain what 'folder', 'uid', or 'flags' represent, their formats, or examples (e.g., flags as strings like '\Seen' or arrays). With 3 undocumented parameters, the description fails to provide meaningful semantics beyond the tool name.
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 action ('Clears') and resource ('flags on a message'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'setFlags' or 'deleteMessage', but it's specific enough to convey the core function without being tautological.
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 provides no guidance on when to use this tool versus alternatives like 'setFlags' (which might set or modify flags) or 'deleteMessage' (which removes messages entirely). There's no mention of prerequisites, context, or exclusions, leaving the agent to infer usage from tool names alone.
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 states the deletion action but lacks critical details: whether deletion is permanent or reversible, if it requires specific permissions, what happens on success/failure, or any rate limits. This is a significant gap for a destructive operation with zero 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It front-loads the core action ('Deletes') and directly states the parameters, making it easy to parse quickly. Every part of the sentence earns its place by conveying essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive deletion operation), lack of annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't address behavioral risks, return values, error conditions, or parameter details, leaving the agent with insufficient context to use the tool safely and effectively.
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 for undocumented parameters. It mentions 'UID' and 'folder' but adds minimal semantics beyond naming them—no explanation of what a UID is, valid folder formats, or constraints. This fails to adequately cover the two required parameters, leaving their meaning unclear.
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 action ('Deletes') and resource ('a message by UID from a given folder'), making the purpose specific and understandable. It distinguishes from siblings like 'deleteFolder' by specifying message deletion rather than folder deletion, though it doesn't explicitly contrast with other message-related tools like 'moveMessage' or 'setFlags'.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the message UID and folder name), when not to use it (e.g., for archiving vs. permanent deletion), or refer to sibling tools like 'moveMessage' for relocating messages instead of deleting them.
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 full burden for behavioral disclosure. It states the action ('Deletes') but lacks critical details: whether this is irreversible, if it requires specific permissions, what happens to contained messages, or error conditions. For a destructive operation with zero annotation coverage, this is a significant 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, efficient sentence with zero wasted words. It's appropriately sized and front-loaded, directly stating the tool's purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a destructive operation with no annotations, no output schema, and minimal parameter documentation, the description is incomplete. It should address behavioral risks, permissions, or error handling to adequately support an agent in invoking this tool correctly.
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 description doesn't add any parameter-specific information beyond the input schema. With 0% schema description coverage and 1 parameter, the baseline is 3 since the schema alone defines the parameter ('folderName') with type and constraints, but the description doesn't compensate by explaining format or semantics.
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 action ('Deletes') and resource ('a folder from the IMAP account'), providing specific verb+resource pairing. However, it doesn't differentiate from sibling tools like 'deleteMessage' or 'createFolder', which would require explicit comparison to achieve a perfect score.
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 provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., folder must exist), exclusions (e.g., cannot delete system folders), or comparisons to siblings like 'deleteMessage' or 'createFolder', leaving usage context unclear.
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 states the tool returns a message but doesn't specify what data is included (e.g., headers, body, attachments), error handling (e.g., for invalid UIDs or folders), or performance aspects (e.g., speed, rate limits). For a read operation with zero annotation coverage, this is a significant gap in transparency.
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, efficient sentence that front-loads the core functionality ('Returns a message') and includes essential details (UID, folder, IMAP account) without unnecessary words. Every part 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.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an IMAP message retrieval tool, no annotations, no output schema, and low schema description coverage, the description is incomplete. It lacks details on return values (e.g., message structure), error conditions, authentication needs, and how it differs from sibling tools. This leaves the agent with insufficient context for effective use.
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 description adds meaning beyond the input schema by explaining that 'folder' and 'uid' are used to retrieve a message from an IMAP account, which clarifies their purpose. However, with 0% schema description coverage, it doesn't detail parameter formats (e.g., folder naming conventions, UID constraints) or provide examples. This meets the baseline for minimal compensation but doesn't fully address the coverage gap.
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: 'Returns a message by UID from a given folder for a given IMAP account.' It specifies the verb ('Returns'), resource ('a message'), and key parameters (UID, folder, IMAP account). However, it doesn't explicitly differentiate from sibling tools like 'getMessageList' or 'search', which prevents a perfect score.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'getMessage' over 'getMessageList' (for listing messages) or 'search' (for finding messages by criteria), nor does it discuss prerequisites like authentication or folder existence. This leaves the agent without context for tool selection.
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 states the action ('Moves') but lacks details on permissions required, whether the move is reversible, error handling for invalid inputs, or side effects like updating folder counts. This is a significant 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, efficient sentence that directly states the tool's function without unnecessary words. It is front-loaded and wastes no space, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a mutation operation with 3 required parameters, no annotations, and no output schema, the description is inadequate. It fails to address critical aspects like behavioral traits, error scenarios, or return values, leaving significant gaps for an AI agent to use it correctly.
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 schema provides no parameter details. The description implies the parameters ('sourceFolder', 'destinationFolder', 'id') through context but doesn't explain their formats, constraints, or examples. It adds minimal value beyond what the parameter names suggest, meeting the baseline for low coverage.
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 action ('Moves') and the resource ('a message by ID from one folder to another'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'deleteMessage' or 'setFlags', but the verb 'Moves' is specific enough to imply a distinct operation.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing valid folder names or message IDs, nor does it contrast with related tools like 'deleteMessage' for removal or 'setFlags' for modifying message properties without moving.
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 full burden for behavioral disclosure. It mentions the tool returns a list of IDs for later use, which is helpful, but lacks critical details like whether this is a read-only operation, potential rate limits, authentication needs, error conditions, or pagination behavior for large result sets.
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 appropriately concise with two sentences that efficiently convey the core functionality and output usage. It's front-loaded with the main purpose, though the list of search options could be slightly more structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with 6 parameters, 0% schema coverage, no annotations, and no output schema, the description is insufficient. It doesn't explain parameter interactions, result format beyond 'list of ids', error handling, or limitations. The mismatch between described parameters and schema parameters further reduces completeness.
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 lists available search options (from, to, subject, since, before, unseen, flagged, answered, custom), which covers more parameters than the schema shows (6 vs 9 mentioned), but doesn't explain their semantics, formats, or how they combine. The mismatch between described and schema parameters creates confusion.
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 searches for messages in a specified folder using search parameters, which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like getMessageList, which might also retrieve messages but without search capabilities.
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 through the mention of 'searchOptions' and returning IDs for further message retrieval, suggesting this is for filtered searches rather than bulk listing. However, it doesn't explicitly state when to use this versus alternatives like getMessageList or getFolderList, nor does it mention prerequisites or exclusions.
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 states the tool creates a folder but doesn't cover critical aspects like required permissions, whether the operation is idempotent, error handling for duplicate names, or what happens on success/failure. This leaves significant gaps 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 wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a mutation operation with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits, error conditions, return values, and usage context, which are essential for safe and effective tool invocation by an AI agent.
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 input schema has 1 parameter with 0% description coverage, so the description must compensate. It doesn't explicitly mention the 'folderName' parameter or provide additional details like naming conventions or restrictions. However, with only one parameter, the tool's purpose inherently implies its use, justifying a baseline score above minimum.
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 action ('Creates') and the resource ('a new folder in the IMAP account'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'deleteFolder' or 'getFolderList' beyond the obvious action difference, which prevents a perfect score.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an active IMAP connection), exclusions, or comparisons to sibling tools like 'getFolderList' for listing folders. This lack of contextual direction limits its usefulness for an AI agent.
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 full burden for behavioral disclosure. It states the tool returns a list but doesn't specify format, pagination, ordering, error conditions, or whether it requires authentication. This leaves significant gaps in understanding how the tool behaves.
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, clear sentence that directly states the tool's function without unnecessary words. It's front-loaded with the core purpose and appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the returned list contains (e.g., folder names, IDs, properties), how results are structured, or any limitations. Given the lack of structured data, more context is needed.
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 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately doesn't mention parameters, which is correct for a parameterless tool, earning a baseline score of 4.
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 action ('Returns a list') and resource ('folders in the imap account'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'search' or 'getMessageList' that might also return lists, so it's not fully specific.
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 provides no guidance on when to use this tool versus alternatives like 'search' or 'getMessageList', nor does it mention prerequisites or context for folder listing. It simply states what it does without indicating appropriate usage scenarios.
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:

[![emailMCPServer MCP server](https://glama.ai/mcp/servers/ggiraudon/emailMCPServer/badges/card.svg)](https://glama.ai/mcp/servers/ggiraudon/emailMCPServer)

Score Badge

Copy to your README.md:

[![emailMCPServer MCP server](https://glama.ai/mcp/servers/ggiraudon/emailMCPServer/badges/score.svg)](https://glama.ai/mcp/servers/ggiraudon/emailMCPServer)

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/ggiraudon/emailMCPServer'

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