aum-mcp-server

by aumsuthar

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Tools are cleanly divided into two distinct domains: notes (set/get/list/delete) and Office documents (Word read/create, PowerPoint read/create). Within each domain, actions are clearly differentiated, with no overlapping purposes.
Naming Consistency5/5
All tools follow a consistent pattern: resource prefix (note_, word_, ppt_) followed by a verb in snake_case. This makes the tool set predictable and easy to navigate for both humans and agents.
Tool Count5/5
With 8 tools spanning two focused areas, the count is well-scoped. Each tool serves a clear, necessary function without redundancy, and the server avoids being overly large or sparse.
Completeness4/5
Notes have full CRUD coverage. For Word and PowerPoint, read and create are covered, but there are no tools for updating existing documents or deleting them. This is a minor gap, but the core workflows (viewing and creating documents) are supported.
Average 3.3/5 across 8 of 8 tools scored. Lowest: 2.4/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
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only says 'Retrieve a note by key' which implies a read operation, but it does not mention if the tool is idempotent, what happens if the key is missing (error vs null), whether it's safe to invoke repeatedly, or any side effects. There is no contradiction with annotations as none exist.
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 extremely short at four words, one sentence. It is front-loaded with the verb and resource. While this is concise, it may be too terse for a tool with no annotations, but for a simple single-parameter retrieval tool, it is adequately concise.
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 (one required parameter, no nested objects, no output schema), the description provides the bare minimum. It does not specify the return format, success/error behavior, or whether partial keys are accepted. For a retrieval tool without an output schema, more context about what is returned would help the agent use the tool correctly.
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 100%, so the schema already documents the 'key' parameter as 'Note key to retrieve'. The description adds no additional meaning beyond the schema, merely restating the parameter's role. However, the description and schema together are minimal and leave ambiguity about the key's format (e.g., is it a UUID, path, or something else). The agent gains no semantic clarity beyond what's in the schema.
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 'Retrieve a note by key' which clearly identifies the verb (Retrieve) and resource (note) and the method (by key). It is distinct from siblings like note_set or note_list, but does not elaborate on what retrieval means or whether it's a full or partial read. It's not a tautology, but it's minimal.
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 note_list or word_read. It does not state any preconditions (e.g., key must exist), nor scenarios where it should or should not be used. The context signals show several sibling tools, but no differentiation is offered.
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 exist, so the description must carry the full burden of behavioral disclosure. It only repeats the verb 'delete,' which implies destruction, but lacks details about side effects (e.g., irreversibility, impact on related data), required permissions, or error conditions. For a mutation tool, this is insufficient.
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. It is appropriately sized for a simple one-parameter tool, though it could benefit from modest expansion on behavioral context without becoming verbose.
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 is a deletion operation with no output schema or annotations, the description is incomplete. It omits crucial context such as permanent nature of deletion, return values, error scenarios, and any constraints. A more complete description would note irreversibility and common failure modes.
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% (the key parameter is described as 'Note key to delete'). The description adds 'by key,' which does not enrich beyond the schema. Baseline 3 applies, as the description offers no additional meaning.
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 'Delete a note by key' clearly states the action (delete) and the resource (note) with an identifier (key). This distinguishes it from sibling tools like note_get (retrieve), note_set (create/update), and note_list (list), though it does not explicitly call out the 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?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, when deletion is appropriate, or any warnings about irreversibility. An agent is left without context to decide between this and note_set for removal.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. However, it does not mention whether the tool overwrites existing files, requires specific permissions, or has size/length limits. The description is minimal, leaving the agent uncertain about side effects like file replacement or editing behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that directly conveys the tool's purpose and output format. There is no redundant information, no filler, and it front-loads the essential action (create a .docx file). It is appropriately sized for a straightforward tool.
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 low complexity (two parameters, no output schema, no annotations), the description is mostly adequate but lacks clarity on overwrite behavior and return value (e.g., success/failure indication). Without an output schema, some return information would be helpful. It covers the basics but leaves 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 coverage is 100%, so the schema already documents both parameters. The description adds no additional meaning beyond what the schema provides—it simply restates that items contain structured content with headings, paragraphs, and bullets, which is already clear from the enum values in the schema. 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 that the tool creates a .docx file from structured content and lists the supported elements (headings, paragraphs, bullets). The purpose is explicit and different from sibling tools like word_read, ppt_create, or note_set, but does not differentiate itself from other creation tools like ppt_create.
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 generating Word documents from structured data, but provides no guidance on when to use this tool versus alternatives such as ppt_create or note_set, nor does it mention prerequisites (e.g., file path validity) or situations where this tool would be inappropriate.
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 discloses the overwrite behavior, but lacks details on return value, error conditions, authorization needs, or side effects. For a write operation, this is insufficient.
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 (two sentences, 11 words) and front-loaded with the key action. No redundant or unnecessary information is present.
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 simplicity (2 params, no output schema, no nested objects), the description lacks key context such as what the tool returns (acknowledgment, created note, etc.) and any constraints or error states. It is incomplete for a tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already documents both parameters. The description adds no additional meaning to the parameters beyond what is in the schema, warranting the baseline score of 3.
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 'Save a note with a key' with a specific verb and resource. It explicitly mentions overwriting behavior, distinguishing it from sibling tools like note_get (read), note_list (list), and note_delete (delete).
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 creating or updating notes by key ('overwrites existing notes'), but does not provide explicit guidance on when to use this tool versus alternatives (e.g., note_get for reading, note_delete for removal). The coverage is adequate but not prescriptive.
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 behavioral disclosure burden. It only states it creates a file but omits key traits such as whether existing files are overwritten, required permissions, file size limits, or error handling. For a mutation tool, this is insufficient.
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 front-loads the core purpose. Every word earns its place with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple file-creation tool with 2 parameters and no output schema, the description covers the basic input structure. However, it lacks details on overwrite behavior, return values, or potential errors, leaving gaps for an agent that needs to invoke 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 coverage is 100% and the description adds 'each with a title and optional bullet points', which echoes the schema but does not add new meaning beyond what the property descriptions already provide. Baseline 3 is appropriate; no extra constraints or format details are given.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a .pptx file from a list of slides, each with a title and optional bullet points. The verb 'create' and resource 'PowerPoint file' are specific, and it distinguishes itself from siblings like word_create (Word files) and note_set (notes).
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 creating PowerPoint files but offers no explicit guidance on when to choose it over alternatives like word_create or note_set. Sibling tools exist, so additional context about when to use each would be beneficial but is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must handle behavioral disclosure. It states the action (list all keys), but does not mention if this is a read-only operation, if it returns data in any particular format, or if there are any side effects. With no annotations, it carries full burden but is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with verb and resource. No wasted words. Perfectly concise for a trivial tool.
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?
Tool is simple (0 params, no output schema), so description is arguably complete. However, no mention of expected output format or behavior when no notes exist. Could clarify that it returns a list of strings. Given simplicity, a 3 is reasonable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has zero parameters and 100% coverage (no need for additional param info). The description does not add any parameter meaning, but since schema is empty, baseline is 4. It correctly provides context about what is listed (keys), which is useful.
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?
Description clearly states the tool lists all saved note keys. It is specific about the resource (note keys) and the action (list). Sibling tools include note_set, note_get, note_delete, so it is distinct from others.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance. The description implies it is for listing all keys, but does not clarify that this returns only keys, not values, or that it is a simple enumeration. No alternative tool suggested (e.g., note_get for retrieving a value).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior. It states the core action (extract text) and implies a read-only operation, but lacks details on error handling (e.g., missing file, non-pptx format), performance characteristics, or whether the tool modifies the file. The description is functional but not fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-formed sentence that conveys all essential information without any extraneous words. Every element earns its place: the verb, resource type, file format, and the 'slide by slide' detail. It is optimally concise.
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 (one parameter, no output schema), the description is nearly complete. It explains what the tool does and hints at the output structure ('slide by slide'). However, it could more explicitly state the return format (e.g., an array of strings per slide) and error behaviors, which would make it fully self-contained.
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 already provides a clear description for the only parameter ('Absolute path to the .pptx file') with 100% coverage. The tool description does not add any additional meaning or context beyond what the schema provides, so the parameter semantics are adequate but not enhanced.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Extract', the resource 'all text content from a Microsoft PowerPoint (.pptx) file', and the manner 'slide by slide'. It distinctly differentiates from sibling tools like ppt_create (creation) and word_read (Word files), making the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage 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 (e.g., word_read for Word files, note_read for notes). An agent reading the description alone cannot determine under what circumstances this tool is appropriate or when to choose a sibling tool, leaving a significant gap in decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden of behavioral disclosure. It states the core action ('Extract all text content') which implies a non-destructive read, but does not mention output format, error handling, or whether .doc is supported. This is adequate but leaves 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, clear sentence with no redundant words. It is front-loaded and immediately conveys what the tool does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one parameter and no output schema. The description conveys the purpose and the resource, and it implicitly indicates the return value (the extracted text). Minor gaps include lack of explicit return value description and edge cases, but for such a straightforward tool, the description is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the only parameter (path). The description adds no additional meaning beyond the schema, which already documents the path as an absolute path to the .docx file. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool extracts text content from a .docx file, using a specific verb ('Extract') and resource ('Microsoft Word (.docx) file'). This distinguishes it from sibling tools like word_create (which creates) and ppt_read (which reads PPT files).
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 implicitly communicates when to use this tool: for reading text from Word .docx files. It does not explicitly mention alternatives or exclusions, but the clarity of the resource and the presence of siblings like ppt_read make it obvious. Minor gap: no explicit 'when not to use' guidance.
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:

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

Score Badge

Copy to your README.md:

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

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/aumsuthar/aum-mcp-server'

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