countries
Server Details
Countries MCP — world country data from REST Countries API v3.1
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
- Repository
- pipeworx-io/mcp-countries
- 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.8/5 across 10 of 10 tools scored. Lowest: 2.9/5.
The tool set has clear overlap between several country-related tools (e.g., countries_by_currency, countries_by_language, countries_by_region, get_country_by_code, search_countries) that all retrieve country information but with different filters or scopes, which could cause confusion. However, the descriptions help differentiate them, and the memory tools (remember, recall, forget) are distinct from the country tools, though ask_pipeworx and discover_tools introduce ambiguity by overlapping with the purpose of finding or using other tools.
Naming conventions are inconsistent across the tool set: some use snake_case with descriptive prefixes (e.g., countries_by_currency, get_country_by_code), while others use single words or different patterns (e.g., ask_pipeworx, discover_tools, forget, recall, remember, search_countries). There is no uniform verb_noun pattern, and the mix of styles (e.g., 'ask' vs. 'discover' vs. 'search') reduces predictability and readability.
With 10 tools, the count is reasonable for a server named 'countries', which suggests a focus on country data. However, the inclusion of general-purpose tools like ask_pipeworx, discover_tools, and memory management tools (remember, recall, forget) expands the scope beyond just country information, making the set slightly over-scoped but still manageable and not excessive.
For the domain of country data, the tools provide good coverage for querying and retrieving information (e.g., by currency, language, region, code, or name), but there are notable gaps such as lack of update, create, or delete operations for country data, which might be expected in a full CRUD lifecycle. The memory tools add utility but do not fill these domain-specific gaps, and the general tools (ask_pipeworx, discover_tools) do not compensate for missing core operations.
Available Tools
10 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 full burden and does well by explaining key behaviors: Pipeworx 'picks the right tool, fills the arguments, and returns the result.' It implies automation and abstraction but lacks details on rate limits, error handling, or data source limitations. No contradiction with annotations exists.
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 operational details and examples. Every sentence adds value: the first defines the tool, the second explains how it works, and the third provides concrete examples. No wasted words, efficiently structured.
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 (natural language processing to select and invoke tools) and lack of annotations or output schema, the description is mostly complete. It covers purpose, usage, and behavior well but could mention limitations or response formats. It adequately compensates for missing structured data.
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 the single 'question' parameter. The description adds minimal value beyond the schema by emphasizing 'plain English' and 'natural language,' but doesn't provide additional syntax or format details. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Ask a question in plain English and get an answer from the best available data source.' It specifies the verb ('ask'), resource ('data source'), and distinguishes from siblings by emphasizing natural language input versus structured parameter-based tools like 'countries_by_currency' or 'search_countries'.
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: 'No need to browse tools or learn schemas — just describe what you need.' It contrasts with sibling tools that require specific parameters or structured queries, providing clear alternatives and exclusions for natural language versus structured interactions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
countries_by_currencyAInspect
Find countries using a currency (e.g., "EUR" for Euro, "USD" for US Dollar). Returns name, capital, region, and currency details.
| Name | Required | Description | Default |
|---|---|---|---|
| currency | Yes | Currency code or name (e.g. "eur", "usd", "dollar") |
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 the return format ('name, capital, and region'), which is helpful, but lacks details on error handling, rate limits, or authentication needs. No contradiction with annotations exists.
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 appropriately sized with two sentences: one stating the purpose and one specifying the return format. It is front-loaded and wastes no words, making it highly efficient.
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 (1 parameter, no output schema, no annotations), the description is mostly complete. It covers purpose and return values, but could improve by addressing behavioral aspects like error cases or usage context.
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 the 'currency' parameter. The description does not add meaning beyond what the schema provides, such as examples 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.
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 ('Find') and resource ('all countries that use a given currency'), and distinguishes it from siblings by focusing on currency-based lookup rather than language, region, code, or general search.
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 when currency-based country lookup is needed, but does not explicitly state when to use this tool versus alternatives like 'countries_by_language' or 'search_countries'. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
countries_by_languageAInspect
Find countries where a language is spoken (e.g., "Spanish", "Mandarin"). Returns name, capital, region, population, and official language status.
| Name | Required | Description | Default |
|---|---|---|---|
| language | Yes | Language name (e.g. "spanish", "french", "arabic") |
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 the tool returns specific fields, implying a read-only operation, but does not mention potential limitations like partial matches, case sensitivity, or error handling. It adds some context (return fields) but lacks details on performance, rate limits, or data freshness.
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 front-loads the core purpose and follows with return details. Every word earns its place, with no redundancy or unnecessary elaboration, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 explains what the tool does and what it returns, but lacks usage guidelines and behavioral details like error cases or data scope. It meets minimum viability but could be more complete for optimal agent 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?
The input schema has 100% description coverage, so the parameter 'language' is well-documented in the schema. The description adds no additional parameter details beyond implying the tool uses this input, but with only one parameter and high schema coverage, the baseline is 3. The description's clarity on output compensates slightly, raising it to 4.
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 ('Find all countries where a given language is spoken') and the resource ('countries'), distinguishing it from siblings like countries_by_currency or countries_by_region. It also specifies the exact return fields (name, capital, region, population), making the purpose unambiguous.
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 such as search_countries or get_country_by_code. It mentions the parameter 'language' but does not specify use cases, exclusions, or comparisons to sibling tools, leaving the agent to infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
countries_by_regionAInspect
List all countries in a region (e.g., "Africa", "Europe", "Asia"). Returns name, capital, population, area, and flag emoji.
| Name | Required | Description | Default |
|---|---|---|---|
| region | Yes | Region name — one of: africa, americas, asia, europe, oceania |
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 for behavioral disclosure. It states it's a list operation but doesn't mention whether it's read-only, if there are rate limits, authentication needs, pagination behavior, or error handling. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves beyond basic functionality.
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 communicates the tool's purpose, scope, and output. Every word earns its place with no redundancy or unnecessary information, making it appropriately sized and front-loaded.
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 simple single parameter with full schema coverage and no output schema, the description adequately covers the basic functionality. However, it lacks details about behavioral aspects (rate limits, errors, etc.) and doesn't explain the return format beyond listing fields, leaving some gaps in completeness for practical 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%, with the region parameter fully documented in the schema (including allowed values). The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline score 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 specific action ('List all countries'), target resource ('in a geographic region'), and output fields ('with name, capital, population, and flag'). It distinguishes from siblings like 'countries_by_currency' or 'search_countries' by specifying region-based filtering rather than currency, language, code, or general search.
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 countries by region, but provides no explicit guidance on when to use this tool versus alternatives like 'countries_by_currency' or 'search_countries'. It mentions the region parameter but doesn't clarify scenarios where region-based listing is preferred over other filtering methods.
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?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it's a search operation that returns the most relevant tools, and it should be called first in specific scenarios. However, it doesn't mention rate limits, authentication needs, or error conditions, leaving some behavioral aspects unspecified.
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 appropriately sized with two sentences that each serve distinct purposes: the first explains what the tool does, the second provides usage guidance. There is no wasted language, and the most critical information (purpose and when to use) is front-loaded.
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 functionality with 2 parameters) and no annotations or output schema, the description does well by explaining purpose and usage guidelines. However, it lacks details about return format (though it mentions tools with names and descriptions) and doesn't address potential limitations or error cases, leaving some 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 fully documents both parameters. The description adds minimal value beyond the schema by mentioning 'search by describing what you need' which aligns with the query parameter, but doesn't provide additional semantic context about how parameters interact or affect results.
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', 'returns') and resource ('Pipeworx tool catalog'), distinguishing it from sibling tools which focus on country data rather than tool discovery. It explicitly mentions searching by describing needs and returning relevant tools with names and descriptions.
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: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This gives clear context about usage scenarios and distinguishes it from alternatives (sibling tools handle country data, not tool discovery).
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes a memory, implying a destructive mutation, but doesn't clarify if deletion is permanent, reversible, requires specific permissions, or has side effects. 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 that directly states the tool's action without unnecessary words. It is front-loaded and wastes no space, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature (deletion), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral risks, return values, or error conditions, which are critical for safe and effective tool invocation in this context.
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 'key' fully documented in the schema as 'Memory key to delete'. The description adds no additional meaning beyond this, such as key format or examples, but the schema provides sufficient baseline information, warranting a score of 3.
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 a specific verb ('Delete') and resource ('stored memory by key'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'recall' (which likely retrieves memories) or 'remember' (which likely stores them), missing an opportunity for full sibling distinction.
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 prerequisites (e.g., needing an existing memory key), exclusions, or how it relates to sibling tools like 'recall' or 'remember', leaving the agent to infer usage context independently.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_country_by_codeAInspect
Get country details by ISO code (e.g., "US" for United States or "FRA" for France). Returns capital, population, languages, currencies, area, and region.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | ISO 3166-1 alpha-2 or alpha-3 country code |
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 describes the lookup behavior but lacks details on error handling (e.g., invalid codes), rate limits, authentication needs, or what 'full country information' includes. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It is front-loaded with the core purpose and includes necessary examples, making it appropriately sized and well-structured.
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 (1 parameter, no nested objects) and high schema coverage, the description is adequate but incomplete. It lacks output details (no output schema) and behavioral context, which is needed for full understanding, especially with no annotations.
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 the parameter. The description adds minimal value by reiterating the code format (ISO 3166-1 alpha-2/alpha-3) and providing examples ('US', 'USA'), but no additional semantics 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 a specific verb ('Get') and resource ('full country information'), and it distinguishes from siblings by specifying the lookup method (by ISO code) rather than by currency, language, region, or search.
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 context by specifying the input format (ISO codes), but it does not explicitly state when to use this tool versus alternatives like 'search_countries' or other sibling tools. No exclusions or prerequisites are mentioned.
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?
No annotations are provided, so the description carries the full burden. It discloses that memories can be retrieved from 'earlier in the session or in previous sessions,' implying persistence across sessions, which is useful behavioral context. However, it doesn't cover error handling (e.g., what happens if the key doesn't exist), performance aspects, or format of returned data, leaving gaps for a tool with no annotations.
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 functionality in the first sentence, followed by usage guidance. Both sentences earn their place by providing essential information without redundancy. It's appropriately sized for a simple tool with one optional parameter.
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 (1 optional parameter, no output schema, no annotations), the description is mostly complete. It covers purpose, usage, and parameter semantics effectively. However, it lacks details on return values (e.g., format of retrieved memories or list output), which is a minor gap since there's no output schema to compensate.
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 input schema has 100% description coverage, with the parameter 'key' documented as 'Memory key to retrieve (omit to list all keys).' The description adds semantic context by explaining that omitting the key lists 'all stored memories,' reinforcing the schema's guidance. Since schema coverage is high, the baseline is 3, but the description provides additional clarity on the omit behavior, warranting a higher score.
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: 'Retrieve a previously stored memory by key, or list all stored memories (omit key).' It specifies the verb ('retrieve'/'list') and resource ('memory'), distinguishing it from sibling tools like 'remember' (store) and 'forget' (delete). However, it doesn't explicitly differentiate from 'discover_tools' or other siblings beyond the memory context.
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 usage guidance: 'Use this to retrieve context you saved earlier in the session or in previous sessions.' It also specifies when to omit the key ('omit key to list all keys'), offering clear context for when to use each mode. This directly addresses alternatives by tying usage to saved memories.
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 the full burden of behavioral disclosure. It effectively describes key behavioral traits: it's a storage operation (implied mutation), specifies persistence differences between authenticated users (persistent) and anonymous sessions (24-hour lifespan), and clarifies the cross-tool context utility. It doesn't mention rate limits or error conditions, but covers the essential behavior well.
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 perfectly concise and front-loaded: the first sentence states the core purpose, and the second sentence adds crucial usage context and behavioral details. Every sentence earns its place with no wasted words.
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 excellent context about what the tool does, when to use it, and key behavioral aspects (persistence differences). It doesn't describe the return value or error cases, but given the tool's relative simplicity and the clarity provided, it's nearly complete.
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 (key and value). The description doesn't add any parameter-specific information beyond what's in the schema descriptions. This meets the baseline expectation when schema coverage is complete.
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 a specific verb ('Store') and resource ('key-value pair in your session memory'), and distinguishes it from sibling tools like 'forget' (which presumably removes) and 'recall' (which presumably retrieves). It explicitly mentions what gets stored and where.
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: 'to save intermediate findings, user preferences, or context across tool calls.' It also distinguishes usage contexts by mentioning authenticated vs. anonymous sessions, helping the agent choose appropriately based on session type.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_countriesBInspect
Search for countries by name. Returns official name, capital, region, population, area, languages, currencies, and flag emoji.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Country name to search for (partial matches are supported) |
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 adds value by specifying the return fields (common name, official name, capital, etc.) and flag emoji, which helps understand output format. However, it doesn't mention behavioral traits like rate limits, error handling, or whether the search is case-sensitive, leaving gaps 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences: one stating the purpose and parameter, and another detailing the return values. It's front-loaded with the core functionality, and every sentence adds value without waste. However, it could be slightly more structured by separating usage guidance from output details.
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 (1 parameter, no annotations, no output schema), the description is somewhat complete but has gaps. It covers the purpose and output fields, which is helpful, but lacks details on behavioral aspects like performance or limitations. Without annotations or output schema, more context on usage and results would improve 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?
Schema description coverage is 100%, so the schema already documents the 'query' parameter with its type and description. The description adds minimal semantics beyond the schema by implying the search is by name, but it doesn't provide additional details like search algorithm or match specificity beyond what's in the schema. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for countries by name' specifies the verb (search) and resource (countries). It distinguishes from siblings by focusing on name search rather than currency, language, region, or code-based lookup. However, it doesn't explicitly mention how it differs from siblings beyond the search parameter.
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 context through 'Search for countries by name,' suggesting this tool is for name-based queries. However, it doesn't provide explicit guidance on when to use this vs. alternatives like 'countries_by_currency' or 'get_country_by_code,' nor does it mention any exclusions or prerequisites for usage.
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!