StashDog MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting different resources (inventory, collections, tags, users, etc.), but 'manage_inventory_items' and 'smart_search' could overlap in search functionality, and 'manage_collections' and 'manage_groups' might be confused for similar organizational concepts. Descriptions help clarify, but some ambiguity remains.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern throughout, all using snake_case with clear action verbs like 'manage', 'get', 'import', and 'authenticate'. This predictability makes it easy for agents to understand and select tools.
Tool Count5/5
With 11 tools, the count is well-scoped for an inventory management server, covering authentication, core operations (inventory, collections, tags), and auxiliary features (users, notifications, subscriptions). Each tool appears to earn its place without bloat or thinness.
Completeness4/5
The toolset provides comprehensive CRUD/lifecycle coverage for inventory management, including import, search, and organization features. Minor gaps exist, such as no explicit tool for updating user details or handling subscription cancellations, but agents can likely work around these with the available 'manage' tools.
Average 2.9/5 across 11 of 11 tools scored.
See the Tool Scores section below for per-tool breakdowns.
This repository is archived. Archived repositories automatically receive an F maintenance tier.
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. It mentions 'fetching details' (read) and 'creating subscriptions' (write), implying both read and write operations, but doesn't specify permissions required, side effects, rate limits, or response formats. This is inadequate for a tool that performs mutations.
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 avoids redundancy. However, it could be more front-loaded with critical details (e.g., specifying the resource type) to improve clarity without sacrificing 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 of a tool that handles both read and write operations for subscriptions, with no annotations and no output schema, the description is incomplete. It fails to explain key behavioral aspects like authentication needs, error handling, or what 'fetching details' returns, leaving significant gaps for agent understanding.
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 ('countryCode' and 'currencyCode') clearly documented in the schema. The description adds no additional meaning beyond implying these are used for 'subscription pricing,' which is already covered by the schema descriptions. Baseline 3 is appropriate as 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 can 'fetch details and create subscriptions,' which provides a general purpose but lacks specificity about what resources are involved or how it differs from potential sibling tools like 'manage_users' or 'manage_notifications.' It's vague about the exact scope of 'subscriptions' (e.g., user subscriptions, product subscriptions).
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 prerequisites, context (e.g., after authentication), or exclusions, leaving the agent to infer usage based on the name alone among many sibling tools.
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. The description mentions 'managing users' which implies mutation capabilities, but only explicitly mentions 'fetching user details' which suggests read operations. It doesn't clarify what specific management actions are possible, what permissions are required, whether changes are reversible, or what the response format looks like. For a tool with 'manage' in its name and no annotation coverage, this is inadequate.
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. There's no wasted verbiage or unnecessary elaboration. However, the structure could be improved by front-loading the most critical information more clearly - the vague 'manage users' followed by the more specific 'fetching user details' creates some ambiguity about the tool's primary function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool named 'manage_users' with no annotations and no output schema, the description is incomplete. It hints at both management operations and fetching details without clarifying the scope. The description doesn't explain what 'managing' entails beyond fetching, what the tool returns, or how it differs from related sibling tools. Given the complexity implied by the name and the lack of structured documentation, more comprehensive description 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?
The schema description coverage is 100% with the single parameter 'userId' well-documented in the schema. The description doesn't add any meaningful parameter information beyond what's already in the schema. It doesn't provide context about valid user ID formats, where to find user IDs, or how this parameter relates to the tool's functionality. The baseline score of 3 is appropriate when the schema does all the parameter documentation work.
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 'Manage users including fetching user details' which provides a general purpose but is vague. It mentions 'fetching user details' as one aspect of management, but doesn't specify what other management actions might be possible. The description doesn't clearly distinguish this tool from potential sibling tools like 'manage_groups' or 'manage_collections' that might also involve user-related operations.
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, specific contexts where this tool is appropriate, or when other tools might be better suited. With sibling tools like 'authenticate', 'manage_groups', and 'manage_notifications' that could potentially overlap with user management, the lack of differentiation is a significant gap.
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 authenticates but doesn't describe what happens upon success (e.g., returns a token, sets a session), failure behavior, rate limits, security implications, or persistence of authentication. For a critical security tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose and parameters without any fluff. It's appropriately sized and front-loaded, with every word earning its place, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (authentication with security implications), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values, error handling, or behavioral traits needed for safe and effective use. The description should do more to compensate for these gaps, especially for a tool that likely enables other operations.
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 both parameters ('email' and 'password') well-documented in the schema. The description adds minimal value beyond the schema by mentioning these parameters generically, but doesn't provide additional context like format requirements or security notes. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Authenticate') and target ('with StashDog'), specifying the authentication method ('using email and password'). It distinguishes this as an authentication tool, which is different from all sibling tools that manage data or perform searches. However, it doesn't explicitly contrast with potential alternative authentication methods (e.g., OAuth), keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing authentication before other operations), exclusions, or how it relates to sibling tools like 'manage_users'. Usage is implied only by the tool's name, with no explicit context provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('import') but doesn't describe what happens during import (e.g., data extraction, validation, error handling), whether it requires specific permissions, or what the output looks like. This leaves critical behavioral traits undocumented for a tool that likely involves external data fetching and database writes.
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 front-loads the core action. It avoids unnecessary words and directly states the tool's function. However, it could be slightly more structured by separating usage context from the core purpose.
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 (importing from external URLs likely involves network calls, data parsing, and inventory updates), the description is incomplete. With no annotations and no output schema, it fails to cover behavioral aspects like error handling, response format, or side effects. The description alone is inadequate for safe and effective use 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 already documents the single 'url' parameter with its description. The tool description adds minimal value beyond the schema by repeating the example types ('product pages, images'), but doesn't provide additional syntax, format details, or constraints. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('import') and resource ('items'), and specifies the source ('from URLs'). It distinguishes this from sibling tools like 'manage_inventory_items' by focusing on external import rather than internal management. However, it doesn't explicitly differentiate from all siblings (e.g., 'smart_search' might also involve URLs).
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 (like authentication), when not to use it, or how it differs from sibling tools like 'manage_inventory_items' or 'smart_search'. The example URLs ('product pages, images') hint at context but lack explicit usage rules.
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 mentions operations (create, update, delete) but doesn't specify permissions needed, whether deletions are reversible, rate limits, or what the response looks like. This is inadequate for a mutation 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 a single, efficient sentence that front-loads key operations and uses natural language, with zero wasted words. It effectively communicates the core functionality without redundancy.
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 (handling multiple operations like create/update/delete), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like error handling, response format, or security requirements, leaving significant gaps for 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 already documents the single parameter 'instruction' with examples. The description adds no additional meaning beyond what the schema provides, such as syntax details or constraints, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('create, update, delete') and resources ('collections' and 'items within collections'), distinguishing it from siblings like manage_inventory_items or manage_tags. However, it doesn't explicitly differentiate from manage_groups, which might have overlapping functionality.
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 manage_groups or manage_tags, nor does it mention prerequisites (e.g., authentication) or exclusions. It only states what the tool does, not when it should be selected.
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 mentions the operations (create, search, rename, delete) but doesn't cover critical aspects like authentication needs, rate limits, error handling, or what happens on deletion (e.g., irreversible). This leaves significant gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the key operations without any wasted words. It's appropriately sized for the tool's complexity and gets straight to the point.
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 (handling multiple operations like create and delete), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values, error conditions, or behavioral nuances, which are essential for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the single parameter 'instruction' with examples. The description adds no additional meaning beyond what's in the schema, such as format constraints or edge cases, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs (create, search, rename, delete) and resource (tags), making it immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'manage_collections' or 'manage_groups' which might have similar patterns, 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 like 'manage_collections' or 'manage_groups', nor does it mention prerequisites or exclusions. It only states what the tool does, not when it's appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'intelligent searches' and 'natural language queries,' which imply some processing, but doesn't describe key behaviors: whether this is read-only or has side effects, how results are formatted, if there are rate limits, authentication needs, or error handling. For a search tool with zero annotation coverage, this leaves significant 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 front-loads the core purpose. There is no wasted text or redundancy, making it highly concise and well-structured for quick understanding.
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 (search tool with natural language processing), no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns, how results are structured, or any behavioral traits like performance or limitations. For a tool that likely processes queries intelligently, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters ('query' and 'limit') with examples and defaults. The description adds minimal value beyond the schema—it reiterates 'natural language queries' but doesn't provide additional syntax, constraints, or usage context. Baseline 3 is appropriate when the schema does the heavy lifting.
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: 'Perform intelligent searches across your inventory with natural language queries that can include multiple criteria.' It specifies the verb ('perform searches'), resource ('inventory'), and method ('natural language queries'). However, it doesn't explicitly distinguish this from potential sibling search tools (none are listed among siblings, but the description doesn't address this).
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 mentions 'natural language queries' but doesn't specify scenarios where this is preferred over structured search tools or other inventory access methods. No exclusions, prerequisites, or comparison to sibling tools (like 'get_inventory_stats') are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions operations like add, update, delete (implying mutations) and supports complex features, but fails to disclose critical traits such as authentication needs, rate limits, error handling, or whether changes are reversible. This is inadequate for a multi-operation 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences that efficiently cover purpose and features. It's front-loaded with core operations and avoids unnecessary details, though the second sentence could be slightly more streamlined.
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 (multiple operations like add/delete), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values, error conditions, or behavioral nuances needed for safe invocation, leaving significant gaps for 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?
The schema description coverage is 100%, so the input schema already documents the single parameter thoroughly with examples. The description adds no additional parameter semantics beyond what's in the schema, such as format constraints or edge cases, 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.
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 specific verbs (add, update, search, delete, manage) and resource (inventory items), distinguishing it from siblings like get_inventory_stats or manage_tags. However, it doesn't explicitly differentiate from manage_collections or manage_groups, which might handle similar resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through natural language instructions for inventory operations, but provides no explicit guidance on when to use this tool versus alternatives like smart_search or manage_tags. It mentions complex operations but 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. 'Fetch' implies a read-only operation, but it doesn't specify authentication requirements, rate limits, pagination behavior beyond the offset parameter, or what format the notifications are returned in. For a tool with 3 parameters and no output schema, 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 perfectly concise at just three words ('Fetch user notifications'). It's front-loaded with the core purpose and contains zero wasted words. Every element of the description earns its place.
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 (3 parameters, no output schema, no annotations), the description is minimally adequate but incomplete. It states what the tool does but lacks crucial context about authentication, return format, and usage guidelines. The absence of an output schema means the description should ideally explain what gets returned, but it doesn't.
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 clear descriptions for all three parameters (status, limit, offset). The description adds no additional parameter information beyond what's already in the schema. According to the scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no 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 'Fetch user notifications' clearly states the verb ('fetch') and resource ('user notifications'), making the tool's purpose immediately understandable. However, it doesn't distinguish this tool from potential sibling notification tools (none are listed, but the name 'manage_notifications' suggests broader functionality than just fetching).
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. While there are no obvious sibling notification tools in the list, the name 'manage_notifications' implies this might be part of a notification management suite, but the description doesn't clarify if this is the primary fetch tool or if other tools handle different notification operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what data is returned but doesn't describe how the statistics are computed (e.g., real-time vs. cached), any rate limits, error conditions, or authentication requirements. For a read-only tool with zero annotation coverage, this leaves significant gaps in understanding its operational 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, efficient sentence that front-loads the core purpose ('Get statistics about your inventory') and lists the specific counts returned. There is no wasted wording, repetition, or unnecessary detail, making it highly concise and well-structured for quick understanding.
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 is minimally adequate. It explains what statistics are returned but lacks details on output format, error handling, or dependencies. For a basic read operation, it meets the minimum viable threshold but doesn't provide a complete picture for reliable agent use.
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 adds value by implicitly confirming no parameters are needed, as it doesn't mention any filtering or options. This aligns with the schema, earning a baseline 4 for zero-parameter tools where the description doesn't contradict.
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 ('Get') and resource ('statistics about your inventory'), listing the specific metrics returned (item count, collection count, tag count). It distinguishes itself from sibling tools like 'manage_inventory_items' or 'smart_search' by focusing on aggregated statistics rather than item-level operations. However, it doesn't explicitly contrast with all siblings, keeping it at a 4 rather than a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage 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 (like whether authentication is required), when it's appropriate versus using other inventory-related tools, or any constraints on usage. With siblings like 'manage_inventory_items' for detailed operations, the lack of comparative context leaves 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 full burden for behavioral disclosure. 'Fetch' implies a read operation, but it doesn't specify whether this requires authentication, returns paginated results, includes metadata, or has any rate limits. For a tool with zero 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 with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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), the description is minimally adequate. However, with no annotations and no output schema, it doesn't address what the fetch returns (e.g., list format, fields) or behavioral aspects like authentication needs, leaving room for improvement despite the low complexity.
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 doesn't need to add parameter details, and 'Fetch user groups' appropriately implies no filtering or arguments are required, aligning with the empty schema.
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 'Fetch user groups' clearly states the verb ('fetch') and resource ('user groups'), making the tool's purpose immediately understandable. However, it doesn't differentiate this tool from potential siblings like 'manage_users' or 'manage_collections' that might also handle user-related data, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'manage_users' and 'smart_search' that might overlap with user data retrieval, there's no indication of whether this tool is for administrative group management, simple listing, or other specific contexts.
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:

[![stashdog-mcp-server MCP server](https://glama.ai/mcp/servers/dogfoodlab-io/stashdog-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/dogfoodlab-io/stashdog-mcp-server)

Score Badge

Copy to your README.md:

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

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