chess
Server Details
Chess.com MCP — wraps the Chess.com public API (free, no auth)
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
- Repository
- pipeworx-io/mcp-chess
- GitHub Stars
- 0
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 3.7/5 across 8 of 8 tools scored. Lowest: 2.9/5.
Most tools have distinct purposes (e.g., get_games, get_leaderboards, get_player, get_stats for Chess.com data; discover_tools, remember, recall, forget for memory management), but there is a clear overlap between the memory tools (remember/recall/forget) and discover_tools, which serves as a meta-tool for finding other tools, creating some ambiguity in the overall set. The descriptions help differentiate them, but the dual domains (chess data and memory/tool discovery) cause potential confusion.
The naming is mostly consistent with a verb_noun pattern (e.g., get_games, get_leaderboards, get_player, get_stats, discover_tools, forget, recall, remember), but there are minor deviations such as 'discover_tools' using 'discover' instead of 'get' and the memory tools using single verbs (forget, recall, remember) without nouns. Overall, the pattern is readable and predictable with only slight inconsistencies.
With 8 tools, the count is reasonable for a server named 'chess' that combines chess data retrieval and memory management. It is slightly over-scoped due to the inclusion of memory tools and a meta-tool (discover_tools) that might be better suited for a separate utility server, but it remains manageable and well within typical bounds (3-15 tools).
For the chess data domain, the tools cover key retrieval operations (games, leaderboards, player profiles, stats), but there are notable gaps such as lack of CRUD operations for game actions (e.g., play, analyze, or update games) and no coverage for tournaments or real-time data. The memory tools add functionality but do not fill these chess-specific gaps, making the surface incomplete for advanced chess workflows.
Available Tools
9 toolsask_pipeworxAInspect
Ask a question in plain English and get an answer from the best available data source. Pipeworx picks the right tool, fills the arguments, and returns the result. No need to browse tools or learn schemas — just describe what you need. Examples: "What is the US trade deficit with China?", "Look up adverse events for ozempic", "Get Apple's latest 10-K filing".
| Name | Required | Description | Default |
|---|---|---|---|
| question | Yes | Your question or request in natural language |
Tool Definition Quality
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 explains the tool's core behavior (natural language processing, automated tool selection, argument filling) and provides examples, but doesn't address important aspects like rate limits, authentication requirements, error handling, or what happens when no suitable data source is found.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a clear purpose statement, key behavioral explanation, and illustrative examples. Every sentence adds value, and the information is front-loaded with the most important details first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description provides good coverage of the tool's purpose and usage but lacks details about behavioral constraints, error conditions, and response format. The examples help but don't fully compensate for the missing structural information about what the tool returns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage for the single parameter, the schema already documents the 'question' parameter adequately. The description adds value by providing concrete examples of appropriate question formats and emphasizing natural language input, though it doesn't add significant semantic detail beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('Ask a question', 'get an answer') and resources ('from the best available data source'). It distinguishes itself from sibling tools by emphasizing natural language processing and automated tool selection, unlike the more specific data retrieval tools in the sibling list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 ('No need to browse tools or learn schemas — just describe what you need') and includes concrete examples that illustrate appropriate use cases. It implicitly suggests alternatives by contrasting with manual tool selection approaches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
discover_toolsAInspect
Search the Pipeworx tool catalog by describing what you need. Returns the most relevant tools with names and descriptions. Call this FIRST when you have 500+ tools available and need to find the right ones for your task.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of tools to return (default 20, max 50) | |
| query | Yes | Natural language description of what you want to do (e.g., "analyze housing market trends", "look up FDA drug approvals", "find trade data between countries") |
Tool Definition Quality
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 describes the search functionality and return format ('most relevant tools with names and descriptions'), but lacks details on error handling, performance expectations, or authentication requirements, leaving some behavioral aspects unclear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by usage guidance, all in two efficient sentences with zero wasted words. Each sentence adds clear value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (search function with 2 parameters) and lack of annotations/output schema, the description provides good context on purpose and usage but could better cover behavioral aspects like result ordering or limitations, leaving minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 no additional parameter semantics beyond what the schema provides, such as examples or usage nuances, 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.
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 ('Search the Pipeworx tool catalog') and resource ('tool catalog'), and distinguishes it from siblings by emphasizing its discovery function rather than direct data retrieval like the sibling tools (get_games, get_leaderboards, etc.).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is provided on when to use this tool ('Call this FIRST when you have 500+ tools available and need to find the right ones for your task'), including a specific threshold (500+ tools) and context (finding tools for a task), with no misleading or contradictory advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
forgetCInspect
Delete a stored memory by key.
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Memory key to delete |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. While 'Delete' implies a destructive operation, the description doesn't disclose whether deletion is permanent, reversible, requires specific permissions, or has side effects. It also doesn't mention what happens if the key doesn't exist or any rate limits. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a destructive operation with no annotations and no output schema, the description is insufficient. It doesn't explain what constitutes a 'stored memory', what format the key uses, what happens on success/failure, or any behavioral traits. For a mutation tool with zero structured coverage, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'key' fully documented in the schema. The description adds no additional meaning beyond what the schema provides ('Memory key to delete'), so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and resource ('a stored memory by key'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'recall' (which likely retrieves memories) or 'remember' (which likely stores memories), 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.
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 deletion is appropriate, what happens after deletion, or how it differs from sibling tools like 'recall' or 'remember'. This leaves the agent with minimal context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_gamesBInspect
Retrieve a player's completed games for a specific month (format: YYYY/MM, e.g., '2024/01'). Returns game URLs, time controls, results, and ratings.
| Name | Required | Description | Default |
|---|---|---|---|
| year | Yes | Year (e.g., 2024) | |
| month | Yes | Month as a number (1-12) | |
| username | Yes | Chess.com username |
Tool Definition Quality
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 states the tool returns game data (URLs, time controls, results, ratings) but doesn't disclose behavioral traits like whether it's read-only (implied by 'Get'), rate limits, authentication needs, error conditions, pagination, or data freshness. For a 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by return details. Every word earns its place with zero waste, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 required parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the purpose and return data but lacks behavioral context (e.g., rate limits, errors) and usage guidelines. Without annotations or output schema, more detail would be helpful for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 three parameters (username, year, month) with clear descriptions. The description adds no additional parameter semantics beyond implying the temporal filtering context, which is already covered by the schema. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get'), resource ('player's completed games'), and scope ('for a specific month'), distinguishing it from siblings like get_leaderboards (leaderboard data), get_player (player profile), and get_stats (statistics). It provides a complete picture of what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'for a specific month' which implies temporal context, but provides no explicit guidance on when to use this tool versus alternatives like get_stats (which might include game data) or get_player (which might include game history). There's no mention of prerequisites, limitations, or comparative use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_leaderboardsBInspect
Check top-ranked Chess.com players by format (daily, rapid, blitz, bullet). Returns rankings with ratings and win percentages.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Tool Definition Quality
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 describes a read operation ('Get'), implying it's non-destructive, but doesn't mention any behavioral traits such as rate limits, authentication needs, pagination, or what happens if no data is available. For a 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the tool's purpose clearly without unnecessary details. It's front-loaded with the core action and resource, and every word earns its place by specifying the scope (game formats). There's no waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple read operation with no parameters) and lack of annotations/output schema, the description is minimally adequate. It explains what the tool does but lacks details on behavioral aspects and usage context. Without an output schema, it doesn't describe return values, which could be a gap, but the simplicity of the tool makes this less critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100% (since there are no parameters to describe). The description adds no parameter information, which is appropriate here. Baseline for 0 parameters is 4, as there's nothing to compensate for, and the description doesn't need to cover parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get the top-ranked Chess.com players across game formats including daily, rapid, blitz, and bullet.' It specifies the verb ('Get') and resource ('top-ranked Chess.com players'), and mentions the scope of game formats. However, it doesn't explicitly differentiate from sibling tools like get_stats (which might provide statistical data rather than rankings).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 get_player or get_stats. It mentions the types of rankings (daily, rapid, etc.) but doesn't specify use cases, prerequisites, or exclusions. Without this context, an agent might struggle to choose between this and sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_playerAInspect
Get a Chess.com player's profile by username (e.g., 'hikaru'). Returns title, country, followers, join date, and last online time.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | Chess.com username (case-insensitive, e.g., "hikaru", "magnuscarlsen") |
Tool Definition Quality
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 indicates this is a read operation for public data, which implies no destructive actions or authentication needs, but does not mention rate limits, error conditions, or response format details. It adds basic context about what data is returned, 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.
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 key data points without unnecessary words. It is front-loaded with the main action and resource, making it easy to parse and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema, no annotations), the description is adequate but has gaps. It specifies what data is returned, which helps compensate for the lack of output schema, but does not cover behavioral aspects like error handling or performance constraints, 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.
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 'username' fully documented in the schema. The description does not add extra parameter details beyond what the schema provides, but since there is only one parameter and the schema covers it well, a baseline of 4 is appropriate as the description doesn't need to compensate for gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get') and resource ('Chess.com player's public profile') with explicit details about what information is retrieved ('name, title, followers, country, join date, and last online time'). It distinguishes itself from sibling tools like 'get_games', 'get_leaderboards', and 'get_stats' by focusing on profile data rather than game history, rankings, or statistics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving public profile data, but does not explicitly state when to use this tool versus alternatives like 'get_stats' for performance metrics or 'get_games' for match history. No exclusions or prerequisites are mentioned, leaving some ambiguity about context-specific selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_statsBInspect
Get a player's ratings and game records across daily, rapid, blitz, and bullet formats. Returns current/best ratings and win/loss/draw counts.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | Chess.com username |
Tool Definition Quality
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 describes what data is returned but doesn't mention error handling (e.g., for invalid usernames), rate limits, authentication requirements, or whether the data is cached or real-time. This leaves significant gaps in understanding the tool's 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.
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 scope without unnecessary words. It front-loads the key action and resource, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (retrieving multi-format statistics) and lack of annotations or output schema, the description adequately covers what data is returned but falls short on behavioral aspects like error handling and performance. It's complete enough for basic use but lacks depth for robust agent interaction.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 'username' clearly documented as 'Chess.com username'. The description adds no additional semantic context beyond this, such as format constraints or examples. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get') and resource ('a player's game statistics'), listing the exact data points returned (rating, best rating, win/loss/draw record) and the formats covered (daily, rapid, blitz, bullet). It distinguishes from sibling tools like 'get_games' (which likely returns game details) and 'get_player' (which likely returns profile information).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 'get_player' or 'get_games'. It doesn't mention prerequisites, such as whether the username must exist or be valid, nor does it specify any context for when this tool is appropriate versus other statistical tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recallAInspect
Retrieve a previously stored memory by key, or list all stored memories (omit key). Use this to retrieve context you saved earlier in the session or in previous sessions.
| Name | Required | Description | Default |
|---|---|---|---|
| key | No | Memory key to retrieve (omit to list all keys) |
Tool Definition Quality
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 that memories can be retrieved from 'earlier in the session or in previous sessions' which adds useful context about persistence. However, it doesn't mention error handling, performance characteristics, or what happens when a non-existent key is provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences that are perfectly front-loaded: the first sentence explains the core functionality, the second provides usage context. Every word earns its place with zero waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with 1 optional parameter and no output schema, the description is quite complete. It explains what the tool does, when to use it, and the parameter semantics. The main gap is lack of information about return format or error conditions, which would be helpful given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage, so the baseline is 3. The description adds value by explaining the semantic meaning of omitting the key parameter: 'omit to list all keys' and connecting it to the tool's dual functionality. This goes beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('retrieve', 'list') and resources ('previously stored memory', 'all stored memories'). It distinguishes this tool from siblings like 'remember' (which stores) and 'forget' (which removes).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('to retrieve context you saved earlier') and provides clear usage guidance: 'Retrieve a previously stored memory by key, or list all stored memories (omit key).' It also distinguishes between the two modes of operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
rememberAInspect
Store a key-value pair in your session memory. Use this to save intermediate findings, user preferences, or context across tool calls. Authenticated users get persistent memory; anonymous sessions last 24 hours.
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Memory key (e.g., "subject_property", "target_ticker", "user_preference") | |
| value | Yes | Value to store (any text — findings, addresses, preferences, notes) |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it explains persistence differences ('Authenticated users get persistent memory; anonymous sessions last 24 hours'), which is crucial context beyond basic storage functionality. However, it doesn't mention rate limits, size constraints, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste - the first states the core functionality with examples, the second adds crucial behavioral context about persistence. Every sentence earns its place and the description is appropriately sized for a simple storage tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with no annotations and no output schema, the description provides good context about persistence behavior and usage scenarios. However, it doesn't explain what happens on duplicate keys, return values, or error conditions, leaving some gaps for a mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema descriptions, but doesn't need to compensate for gaps. 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.
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 verb ('store') and resource ('key-value pair in your session memory'), and distinguishes it from sibling 'recall' by focusing on storage rather than retrieval. It provides concrete examples of what to store ('intermediate findings, user preferences, or context across tool calls').
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('save intermediate findings, user preferences, or context across tool calls'), but doesn't explicitly state when not to use it or name alternatives. It implies usage for memory persistence but doesn't contrast with other storage mechanisms or sibling tools like 'forget'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!