mdma

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool has a distinct, non-overlapping purpose: build-system-prompt creates prompts, get-doc fetches documentation, get-prompt retrieves named prompts, get-spec provides the full specification, list-docs catalogs available docs, list-packages lists npm packages, and validate-prompt validates custom prompts. The descriptions clearly differentiate their functions, eliminating ambiguity.
Naming Consistency5/5
All tools follow a consistent verb_noun naming pattern (e.g., build-system-prompt, get-doc, list-docs, validate-prompt). The naming is uniform across all seven tools, with no mixing of conventions like camelCase or snake_case, making it highly predictable and readable.
Tool Count5/5
With 7 tools, the count is well-scoped for the MDMA domain, covering key operations like prompt generation, documentation retrieval, specification access, and validation. Each tool serves a clear purpose without redundancy, and the set feels complete yet not overwhelming for the server's scope.
Completeness4/5
The tool set provides comprehensive coverage for MDMA-related tasks, including prompt building, documentation access, specification retrieval, and validation. Minor gaps exist, such as no tools for updating or deleting prompts or docs, but agents can work around this using the available tools for core workflows like authoring and reviewing.
Average 3.7/5 across 7 of 7 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 156 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
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.
This repository includes a glama.json configuration file.
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.
View related servers

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. It only states what the tool returns, without mentioning any behavioral traits such as whether it's read-only, has rate limits, requires authentication, returns structured data, or handles errors. For a retrieval tool with zero annotation coverage, this leaves significant gaps in understanding how it 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 extremely concise and front-loaded in a single sentence that directly states the tool's core function. Every word earns its place without any redundancy or unnecessary elaboration, making it efficient for quick comprehension.
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 for a retrieval tool. It doesn't explain what the return value looks like (e.g., prompt text, metadata, or structure), error conditions, or any behavioral context. The agent is left guessing about the output format and operational characteristics.
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 parameter 'name' fully documented in the schema as accepting one of three specific prompt names. The description adds no additional parameter semantics beyond what's already in the schema, such as format details or usage examples. With high schema coverage, 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.
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 ('Returns') and resource ('named MDMA prompt'), and identifies the three possible prompt names. However, it doesn't explicitly differentiate this tool from sibling tools like 'get-doc' or 'validate-prompt' that might also retrieve content, leaving some ambiguity about when to use this specific prompt-retrieval tool.
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 sibling tools like 'get-doc' or 'validate-prompt', nor does it specify any prerequisites, contexts, or exclusions for usage. The agent receives no help in choosing between retrieval options.
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 'Generates a custom MDMA prompt' and 'Returns only the custom prompt part', which covers basic output behavior. However, it doesn't address important aspects like whether this is a read-only operation, potential side effects, error conditions, or performance characteristics. The description provides minimal behavioral context beyond the core 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 appropriately concise with two sentences that each serve distinct purposes: the first states what the tool does, the second explains output usage. It's front-loaded with the core functionality. While efficient, it could be slightly more structured by separating behavioral details from integration instructions.
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 5 parameters with 100% schema coverage but no annotations or output schema, the description provides adequate but minimal context. It covers the basic purpose and output format, but doesn't address the complexity of generating MDMA prompts from multiple structured inputs. For a tool with no output schema, it should ideally describe the return format more thoroughly beyond 'only the custom prompt part'.
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 5 parameters thoroughly. The description mentions the parameters generically ('structured input (domain, components, fields, steps)') but doesn't add meaningful semantic context beyond what the schema provides. The baseline of 3 is appropriate when the schema does the heavy lifting, though the description could have explained relationships between parameters.
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: 'Generates a custom MDMA prompt from structured input' with specific components listed (domain, components, fields, steps). It distinguishes from siblings by focusing on building system prompts rather than retrieving or validating them. However, it doesn't explicitly contrast with all sibling tools like 'get-prompt' or 'validate-prompt'.
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 context through the example of building MDMA prompts and mentions how to integrate the output ('use buildSystemPrompt({ customPrompt }) in code'). However, it lacks explicit guidance on when to choose this tool over alternatives like 'get-prompt' or 'validate-prompt', and doesn't specify 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?
With no annotations provided, the description carries full burden for behavioral disclosure. While it states what data is returned, it doesn't describe important behavioral aspects like whether results are paginated, sorted, filtered, or cached. It also doesn't mention performance characteristics, error conditions, or authentication requirements.
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 communicates the core functionality without any wasted words. It's appropriately sized for a zero-parameter tool and front-loads the essential information about what the tool returns.
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 operation with no output schema, the description adequately covers what data is returned. However, it lacks important contextual information about the return format (array structure, field types), potential limitations (number of packages, sorting), and how this tool relates to sibling tools in the MDMA ecosystem.
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 with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't waste space discussing non-existent parameters, though it could theoretically mention that no filtering options are available.
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 ('Returns') and resource ('all MDMA npm packages'), including the exact data fields returned (purpose, install command, usage example, category). It distinguishes itself from siblings like 'list-docs' by focusing specifically on npm packages rather than documentation.
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 this tool is appropriate versus using 'get-doc' or 'list-docs', nor does it specify any prerequisites or contextual constraints for its use.
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 validates and returns warnings/suggestions, which clarifies it's a read-only analysis tool (not destructive). However, it omits details like error handling, performance characteristics, or authentication requirements, leaving gaps in behavioral context.
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 and output. Every word earns its place, with no redundancy or unnecessary elaboration, making it highly concise and front-loaded with essential information.
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 moderate complexity (validation with conventions), lack of annotations, and no output schema, the description is minimally adequate. It covers the core purpose but lacks details on output format (e.g., structure of warnings/suggestions), error cases, or MDMA convention specifics, leaving room for improvement in completeness.
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 the single parameter 'prompt' as 'The custom prompt text to validate'. The description adds no additional meaning beyond this, such as format examples or constraints. Baseline 3 is appropriate when the schema handles parameter documentation adequately.
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 ('validates'), resource ('a custom prompt'), and purpose ('against MDMA conventions'), distinguishing it from siblings like 'get-prompt' or 'list-docs' which retrieve rather than validate. It precisely defines the tool's function without being vague or tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for validating custom prompts against MDMA conventions, but provides no explicit guidance on when to use this tool versus alternatives like 'get-prompt' or 'build-system-prompt'. It lacks any mention of prerequisites, exclusions, or comparative scenarios with sibling tools.
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 adds useful context like the source URL, allowed paths, and default branch, but lacks details on error handling, rate limits, or authentication needs. It adequately describes the operation but misses some behavioral traits.
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 front-loaded with the core purpose in the first sentence, followed by essential details in subsequent clauses. Every sentence adds value—specifying allowed paths and defaults—with zero waste, making it efficiently structured and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (fetching files from a repo), no annotations, and no output schema, the description is fairly complete. It covers purpose, source, allowed paths, and defaults, but could improve by mentioning the return format (text contents) or potential errors. It's adequate but has minor gaps.
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 thoroughly. The description adds marginal value by mentioning the default branch for 'ref' and examples for 'path', but does not provide additional semantic meaning beyond what the schema specifies. Baseline 3 is appropriate here.
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 ('Fetches the latest version'), resource ('MDMA documentation file'), and source ('public GitHub repo'), distinguishing it from siblings like 'list-docs' (which lists files) or 'get-prompt' (which fetches prompts). It precisely defines what the tool does without ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use this tool by specifying allowed paths ('any entry from list-docs, plus any *.md file under "docs/" or "blueprints/"'), which implicitly guides usage. However, it does not explicitly state when not to use it or name alternatives among siblings, such as 'get-prompt' for prompt files.
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. It discloses the tool's behavior as a read-only operation that returns comprehensive specification data, but does not mention potential limitations like rate limits, authentication needs, or response format details. It adds basic context but lacks depth on operational traits.
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 purpose ('Returns the full MDMA specification') and lists key components without redundancy. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is complete enough for a read-only specification retrieval tool. It clearly states what is returned, though it could benefit from mentioning the return format or any behavioral constraints to fully cover context without annotations.
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 lack of inputs. The description does not need to add parameter semantics, but it implicitly confirms no parameters are required by not mentioning any. This meets the baseline for zero-parameter tools.
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 ('Returns') and resource ('full MDMA specification'), listing exactly what it includes: component types, schemas, binding syntax, and authoring rules. It distinguishes itself from siblings like get-doc or get-prompt by specifying it returns the specification itself rather than documentation or prompts.
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 when the full specification is needed, but does not explicitly state when to use this tool versus alternatives like get-doc for documentation or validate-prompt for validation. No exclusions or prerequisites are mentioned, leaving usage context somewhat open-ended.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It effectively describes the tool's behavior: it returns a catalog with specific fields (path, title, description) from a public GitHub repository. However, it doesn't mention potential limitations like rate limits, authentication requirements, or pagination behavior, which would be valuable for a read 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 perfectly concise with two sentences that each serve distinct purposes: the first explains what the tool does and what it returns, the second explains when to use it. There is zero wasted language or redundancy.
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 zero-parameter read operation with no annotations and no output schema, the description provides good context about what the tool returns (catalog with path, title, description) and its relationship to other tools. However, without an output schema, additional details about the return format structure would be helpful for completeness.
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 baseline would be 4. The description appropriately doesn't waste space discussing parameters that don't exist, maintaining focus on the tool's purpose and usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Returns the catalog'), resource ('MDMA documentation files'), and scope ('available for fetching from the public GitHub repo'). It explicitly distinguishes from its sibling 'get-doc' by explaining this tool is for discovery while 'get-doc' is for fetching specific documents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Use this to discover what docs you can pass to get-doc') and names the alternative tool ('get-doc') for the subsequent action. This clearly establishes the workflow relationship between these two tools.
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:

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

Score Badge

Copy to your README.md:

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

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/MobileReality/mdma'

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