EpicMe MCP

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation2/5
Multiple tools have overlapping or unclear purposes. For example, 'annotatedMessage', 'structuredContent', and 'getResourceLinks' all seem to demonstrate metadata or structured data features, making it difficult for an agent to choose between them. Similarly, 'echo' and 'printEnv' both serve debugging purposes, while 'add' and 'zip' are isolated utilities with no clear connection to the others.
Naming Consistency2/5
The naming conventions are inconsistent and chaotic. There is a mix of styles: some tools use camelCase (e.g., 'annotatedMessage', 'getResourceLinks'), others use snake_case (e.g., 'longRunningOperation', 'printEnv'), and some are single words (e.g., 'add', 'echo', 'zip'). There is no discernible pattern, which makes the set harder to navigate and predict.
Tool Count3/5
With 11 tools, the count is reasonable for a server, but it feels borderline due to the lack of a clear domain. The tools appear to be a miscellaneous collection of demonstrations and utilities rather than a cohesive set for a specific purpose, making the number seem slightly high for the apparent scope.
Completeness2/5
The server lacks a clear domain, making it difficult to assess completeness. However, based on the tool descriptions, it seems to be a demonstration server for MCP features. There are significant gaps: for example, if it's meant to showcase MCP capabilities, it might miss tools for other core features like streaming or error handling. The tools are fragmented and don't form a complete workflow or coverage of a specific area.
Average 2.9/5 across 11 of 11 tools scored.
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 is passing
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

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 but offers minimal information. It states the tool 'returns' something, implying a read-only operation, but doesn't specify whether it's a simple fetch, has side effects, requires authentication, involves rate limits, or what format the return value takes. The description lacks details on what 'MCP_TINY_IMAGE' represents or how it behaves, leaving significant gaps in understanding.
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 extremely concise with a single, straightforward sentence: 'Returns the MCP_TINY_IMAGE'. It's front-loaded and wastes no words, making it easy to parse quickly. Every word earns its place by conveying the core action, though it lacks depth.
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 simplicity (0 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain what 'MCP_TINY_IMAGE' is, what 'returns' entails (e.g., data format, potential errors), or how it fits into broader workflows. While minimal context might suffice for a trivial tool, this leaves too many unanswered questions about usage and output.
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 the input schema has 100% description coverage (though empty). The description doesn't need to add parameter semantics since there are none to explain. This meets the baseline of 4 for tools with no parameters, as there's no gap to compensate for.
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 'Returns the MCP_TINY_IMAGE' is a tautology that essentially restates the tool name 'getTinyImage' with slightly different wording. It doesn't specify what the MCP_TINY_IMAGE actually is (e.g., an image resource, metadata, URL) or what 'returns' means in practical terms. While it indicates a retrieval action, the purpose remains vague and indistinguishable from other retrieval tools like 'getResourceLinks' or 'getResourceReference'.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any specific context, prerequisites, or exclusions, nor does it differentiate it from sibling tools like 'getResourceLinks' or 'getResourceReference' that might also retrieve resources. There's no indication of when this tool is appropriate or what problems it solves.
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 full burden. It mentions demonstrating annotation patterns but doesn't disclose behavioral traits such as whether it's read-only, if it modifies state, what the output looks like, or any side effects. This is inadequate for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point without waste. It's appropriately sized for a simple tool, though it could be more front-loaded with operational details.
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 no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, how annotations are demonstrated, or the complexity involved. For a tool with 2 parameters and full schema coverage, more context on behavior and output is needed.
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 parameters fully. The description adds no meaning beyond the schema, such as explaining why to choose specific message types or image inclusion. Baseline 3 is appropriate when schema does the heavy lifting.
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 demonstrates annotation usage for content metadata, which is a clear purpose, but it's vague about what the tool actually does operationally. It doesn't specify a concrete action like 'generate' or 'display' annotated messages, nor does it distinguish from siblings like 'structuredContent' or 'echo' that might handle similar content.
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 alternatives. Given siblings like 'structuredContent' and 'echo' that might handle content, the description lacks explicit when/when-not instructions or prerequisites, leaving usage context implied at best.
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 resource links but doesn't describe what these links contain, how they're formatted, whether the operation is idempotent, or any performance characteristics like rate limits. The description is minimal and fails to provide essential behavioral context for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function. It's appropriately sized for a simple tool and front-loaded with the core action. However, it could be slightly more informative without losing conciseness, such as by hinting at the link types or usage context.
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 moderate complexity (returns multiple links of different types), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the resource links are, their format, or what 'different types of resources' means. For a tool that presumably returns structured data, this leaves significant gaps in understanding how to interpret results.
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 no parameter semantics beyond what the input schema provides. With 100% schema description coverage and only one parameter ('count') fully documented in the schema, the baseline score is 3. The description doesn't explain why 'count' matters or how it affects the returned links, so it doesn't compensate but doesn't detract either.
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 multiple resource links that reference different types of resources', which provides a vague purpose. It specifies the verb 'returns' and resource 'resource links', but doesn't clarify what these links are used for or how they differ from similar tools like 'getResourceReference' or 'getTinyImage'. The purpose is understandable but lacks specificity and sibling 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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any context for usage, prerequisites, or exclusions. Given sibling tools like 'getResourceReference' and 'getTinyImage' that might handle related resources, the lack of comparative guidance leaves the agent without clear direction on 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns something but doesn't describe what a 'resource reference' is, any side effects, error conditions, or performance aspects. This leaves significant gaps in understanding the tool's behavior beyond the basic action.
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 with no wasted words. It's appropriately sized for a simple tool, but it could be more front-loaded with key details. However, it's efficient and clear in its brevity.
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 (a read operation with one parameter) and lack of annotations or output schema, the description is incomplete. It doesn't explain what a 'resource reference' is, how it's used, or what the return value looks like. This leaves the agent with insufficient context to use the tool effectively beyond the basic schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'resourceId' fully documented in the schema. The description adds no additional meaning beyond what the schema provides, such as examples or context for the resource ID. Since the schema does the heavy lifting, 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.
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 resource reference that can be used by MCP clients,' which provides a basic purpose but lacks specificity about what type of resource or what 'resource reference' entails. It distinguishes from some siblings like 'echo' or 'printEnv' but not clearly from 'getResourceLinks' which might be related. The purpose is vague rather than 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?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention any context, prerequisites, or exclusions. For example, it doesn't clarify if this is for internal MCP client use only or how it differs from 'getResourceLinks.' The description offers no usage instructions.
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. It mentions 'sampling' but does not disclose behavioral traits such as whether this is a read-only or mutative operation, potential rate limits, authentication needs, or what the output format looks like. The description is minimal and lacks critical operational context.
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, efficient sentence with no wasted words. It is appropriately sized for the tool's complexity, though it could be more front-loaded with key details to improve clarity.
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 lack of annotations and output schema, the description is incomplete. It does not explain what 'sampling' returns, how results are formatted, or any error conditions, leaving significant gaps for an LLM interaction tool with two parameters.
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 fully documents the two parameters ('prompt' and 'maxTokens'). The description adds no additional meaning beyond what the schema provides, such as examples or constraints, meeting the baseline for high schema coverage.
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 action ('Samples from an LLM') but is vague about the specific mechanism ('using MCP's sampling feature') without explaining what sampling entails. It distinguishes from siblings like 'echo' or 'printEnv' by involving LLM interaction, but lacks specificity about the resource or output type.
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 provided on when to use this tool versus alternatives. The description does not mention prerequisites, context, or exclusions, leaving the agent to infer usage based on the tool name alone among siblings like 'annotatedMessage' or 'structuredContent'.
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 full burden. It mentions 'long running operation with progress updates', which implies asynchronous behavior and potential delays, but doesn't specify timeout handling, cancellation options, or what 'progress updates' entail. For a tool with no annotation coverage, this leaves significant behavioral 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, efficient sentence that directly states the tool's function. It's appropriately sized and front-loaded with no wasted words, making it easy for an agent 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 (long-running operation with progress updates), no annotations, and no output schema, the description is insufficient. It doesn't explain what the operation demonstrates, what progress updates look like, or what the expected outcome is. For a tool with behavioral implications, more context is needed.
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 fully documents both parameters (duration and steps). The description adds no additional meaning about parameters beyond what the schema provides. According to guidelines, baseline is 3 when schema coverage is high (>80%) and no param info is in description.
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 'demonstrates a long running operation with progress updates', which provides a vague purpose. It specifies the verb 'demonstrates' and resource 'operation', but lacks specificity about what the operation actually does or its domain context. It doesn't distinguish from sibling tools like 'add', 'echo', or 'sampleLLM' which have different functions.
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 any specific scenarios, prerequisites, or exclusions. Given the sibling tools include various utilities, there's no indication whether this is for testing, simulation, or actual processing, leaving the agent with no 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 the full burden of behavioral disclosure. It states the tool returns content but doesn't describe any behavioral traits such as rate limits, authentication requirements, error conditions, or what happens when invalid input is provided. The mention of 'output schema for client data validation' suggests some validation behavior, but this is not elaborated.
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, efficient sentence that gets straight to the point. It's appropriately sized for a simple tool with one parameter. However, it could be slightly more front-loaded by specifying what type of structured content is returned earlier in the description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which handles return value documentation), a simple input schema with 100% coverage, and no complex annotations, the description is reasonably complete. It covers the basic purpose and hints at validation use. The main gap is lack of specificity about what structured content is actually returned.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the single parameter 'location' clearly documented as 'City name or zip code.' The description adds no additional meaning beyond what the schema provides - it doesn't explain how the location parameter affects the returned content or provide examples. Baseline score of 3 is appropriate since the schema does the heavy lifting.
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 structured content' which indicates a read operation, but it's vague about what specific content is returned. It mentions 'client data validation' but doesn't specify what kind of structured content (e.g., weather data, business listings, etc.). The purpose is clear enough to understand it's a retrieval tool but lacks specificity about the resource being accessed.
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 any sibling tools or specific contexts where this tool is preferred. The phrase 'for client data validation' hints at validation use cases, but this is too general to serve as practical guidance 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 basic action but doesn't cover important aspects like error handling (e.g., overflow), performance, or output format, which are critical for a tool with no output schema.
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 extremely concise and front-loaded with a single, clear sentence that directly states the tool's function. There is no wasted verbiage, making it efficient and easy to parse.
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 simplicity and lack of annotations or output schema, the description is incomplete. It doesn't explain the return value (e.g., sum as a number) or potential behavioral traits, leaving gaps that could hinder correct invocation by an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with both parameters clearly documented in the schema. The description adds no additional meaning beyond what the schema provides, so it meets the baseline score for high schema coverage without compensating with extra insights.
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 with a specific verb ('Adds') and resource ('two numbers'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'echo' or 'sampleLLM' that might also perform mathematical operations, so it doesn't reach the highest 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 any prerequisites, constraints, or suggest other tools for related tasks, leaving the agent with no context for 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Echoes back the input' implies a read-only, non-destructive operation, but it lacks details on output format, error handling, or any constraints like rate limits. This is a significant gap for a tool 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 extremely concise with just three words, front-loaded and zero waste. Every word earns its place by directly conveying the core function without unnecessary elaboration, making it highly efficient.
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 simplicity (1 parameter, no output schema), the description is incomplete. It doesn't explain the return value (e.g., what 'echoes back' means in practice) or provide context for use among siblings. Without annotations or output schema, more detail is needed to fully inform an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'message' parameter fully documented. The description adds no additional meaning beyond what the schema provides, such as examples or usage context. According to the rules, with high schema coverage (>80%), the baseline is 3 even without param info in the description.
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 'Echoes back the input' clearly states the tool's function with a specific verb ('echoes') and resource ('input'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'printEnv' or 'sampleLLM' that might also output data, so it doesn't reach the highest 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. With siblings like 'printEnv' (prints environment variables) and 'sampleLLM' (likely generates text), there's no indication of when 'echo' is appropriate, such as for testing or simple output, leaving usage 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. It mentions the tool compresses files and returns a data URI, but lacks details on behavioral traits such as error handling (e.g., invalid URIs), performance (e.g., size limits), or side effects (e.g., network requests for URIs). This is inadequate for a tool that processes external resources.
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 that efficiently conveys the tool's purpose, input, and output without unnecessary details. It is front-loaded with the core action and avoids redundancy, 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 complexity (processing multiple external files) and lack of annotations or output schema, the description is insufficient. It doesn't explain return values (e.g., structure of the data URI), error conditions, or limitations, leaving gaps 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.
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 fully documents the 'files' parameter as a mapping of file names to URLs. The description adds marginal value by specifying that URIs can be data URIs and clarifying the mapping purpose, but doesn't provide additional syntax or format details beyond what the schema already covers.
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 ('compresses'), the resource ('provided resource files'), and the output ('to a zip file, which it returns as a data URI resource link'). It distinguishes itself from sibling tools like 'getResourceLinks' or 'getTinyImage' by focusing on compression rather than retrieval or image processing.
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., file availability), exclusions (e.g., unsupported file types), or compare it to sibling tools like 'add' or 'structuredContent' for handling multiple files. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'prints' (implying read-only output) and mentions its debugging purpose, which is helpful context. However, it doesn't describe the output format, whether sensitive data might be exposed, or any rate limits - leaving some behavioral aspects unclear.
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 perfectly concise - a single sentence that front-loads the core functionality ('Prints all environment variables') followed by the specific use case. Every word earns its place with no redundancy or unnecessary elaboration.
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 tool's simplicity (0 parameters, no output schema, no annotations), the description provides adequate but minimal information. It explains what the tool does and its primary use case, but doesn't describe the output format or any behavioral constraints. For such a simple tool, this is acceptable but not comprehensive.
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 already fully documents the parameter situation. The description appropriately doesn't discuss parameters, maintaining focus on the tool's purpose. A baseline of 4 is appropriate for zero-parameter tools when the description doesn't attempt to discuss non-existent parameters.
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 ('Prints all environment variables') and the resource being acted upon ('environment variables'). It also distinguishes this tool's purpose from sibling tools by specifying its debugging use case for MCP server configuration, which is unique among the listed siblings.
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 explicitly states when to use this tool ('helpful for debugging MCP server configuration'), providing clear context for its application. However, it doesn't specify when NOT to use it or name alternative tools for similar purposes, which prevents a perfect score.
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:

[![epic-me-mcp MCP server](https://glama.ai/mcp/servers/epicweb-dev/epic-me-mcp/badges/card.svg)](https://glama.ai/mcp/servers/epicweb-dev/epic-me-mcp)

Score Badge

Copy to your README.md:

[![epic-me-mcp MCP server](https://glama.ai/mcp/servers/epicweb-dev/epic-me-mcp/badges/score.svg)](https://glama.ai/mcp/servers/epicweb-dev/epic-me-mcp)

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/epicweb-dev/epic-me-mcp'

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