Colombia 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 specific Colombian data categories like airports, cities, departments, regions, natural areas, indigenous reservations, radios, presidents, tourist attractions, and maps. However, there is some overlap between get_department and search_colombia, as both can retrieve department information, which might cause minor confusion. The descriptions help clarify, but the boundaries are not perfectly sharp.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern in snake_case, such as get_airports, get_cities, get_department, get_departments_by_region, get_indigenous_reservations, get_natural_areas, get_president, get_presidents, get_radios, get_regions, get_tourist_attractions, and search_colombia. This uniformity makes the tool set predictable and easy to understand, with no deviations in naming conventions.
Tool Count5/5
With 15 tools, the server is well-scoped for providing comprehensive information about Colombia, covering geography, culture, history, and tourism. Each tool serves a specific and relevant function, such as retrieving airports, cities, departments, regions, natural areas, indigenous reservations, radios, presidents, tourist attractions, maps, and a general search. The count is appropriate for the domain, avoiding both thinness and bloat.
Completeness4/5
The tool set offers broad coverage of Colombian data, including CRUD-like retrieval for various entities like departments, cities, regions, airports, natural areas, indigenous reservations, radios, presidents, and tourist attractions. Minor gaps exist, such as no update or delete operations (which may be intentional for a read-only informational server) and limited filtering options in some tools, but agents can work around these with the available search and filtering capabilities. The surface is largely complete for querying Colombian information.
Average 3.9/5 across 15 of 15 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide strong behavioral hints (readOnlyHint: true, openWorldHint: true, idempotentHint: true, destructiveHint: false). The description adds minimal behavioral context beyond this - it clarifies that this retrieves 'detailed information' about a specific president, which provides some additional semantic context. However, it doesn't describe what constitutes 'detailed information' or any other behavioral traits not covered by annotations.
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 reasonably concise and well-structured. It starts with the core purpose, then provides Args and Returns sections, followed by an example. The Spanish language structure is clear. While efficient, the example could be more integrated with the main description rather than appearing as a separate section.
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 simple nature of this tool (single parameter, read-only operation with good annotation coverage), the description is mostly adequate. However, without an output schema, the description should ideally provide more detail about what 'información detallada' includes. The annotations cover safety aspects well, but the description could better explain the relationship with the sibling 'get_presidents' tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'id' clearly documented as 'ID del presidente' with type integer and minimum value 1. The description adds no additional parameter semantics beyond what's already in the schema. With high schema coverage, the baseline score of 3 is appropriate since the schema does the heavy lifting for parameter documentation.
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: 'Obtiene información detallada de un presidente específico' (Gets detailed information of a specific president). It uses a specific verb ('obtiene') and resource ('presidente específico'), but doesn't explicitly differentiate from its sibling 'get_presidents' (plural). The description is clear but lacks sibling differentiation, which would be helpful since both tools deal with presidents.
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 the sibling tool 'get_presidents' (which presumably lists multiple presidents) or other related tools. The example usage shows how to invoke it but doesn't provide contextual guidance about appropriate use cases or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations cover key behavioral traits (read-only, open-world, idempotent, non-destructive), so the description adds minimal value. It mentions the tool 'attempts to find information,' which hints at potential incompleteness but doesn't elaborate on limitations like accuracy or coverage. No contradictions with annotations exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with a clear purpose statement. However, it includes an 'Ejemplo de uso' section that, while helpful, slightly reduces conciseness. Overall, it's efficient with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema) and rich annotations, the description is adequate but incomplete. It lacks details on output format (e.g., structure of search results) and doesn't address how it differs from sibling tools, which is crucial given the context of many specific retrieval alternatives.
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 the parameter 'query' well-defined in the schema. The description adds examples (e.g., 'Busca Medellín') that illustrate usage but doesn't provide additional semantic details beyond what the schema already specifies, 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 as a general search tool for Colombian departments, cities, or tourist places. It uses specific verbs ('find information about') and resources, though it doesn't explicitly differentiate from its many siblings like get_cities or get_tourist_attractions, which appear to be more specific retrieval tools.
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. With many sibling tools (e.g., get_cities, get_tourist_attractions) that seem to fetch specific data, the description lacks any indication of when this general search is preferred over those targeted tools, leaving usage context unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide comprehensive behavioral hints (readOnlyHint: true, openWorldHint: true, idempotentHint: true, destructiveHint: false), so the description's burden is reduced. It adds some context about what information is returned ('nombre, capital, bandera, moneda, etc.'), but doesn't provide additional behavioral details like response format, data freshness, or limitations.
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 well-structured with a clear purpose statement, return information, and usage examples. It's appropriately sized for a simple lookup tool. The Spanish/English mix is slightly inconsistent but doesn't significantly impact clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only country information tool with comprehensive annotations but no output schema, the description provides adequate coverage. It explains what information is returned and gives usage examples, though it could be more specific about the exact data structure returned or limitations of the information.
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 (empty schema). The description appropriately doesn't discuss parameters since none exist, which is correct for this case. No additional parameter information is needed or provided.
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: 'Obtiene información general sobre Colombia como país' (Gets general information about Colombia as a country). It specifies the verb ('obtiene') and resource ('información general sobre Colombia'), but doesn't explicitly differentiate from sibling tools like 'get_president' or 'get_departments' which provide more specific information subsets.
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 provides usage examples that imply when to use this tool ('¿Cuál es la capital de Colombia?' and 'Dame información general de Colombia'), suggesting it's for general country overview questions. However, it doesn't explicitly state when NOT to use it or mention alternatives among the many sibling tools for more specific queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide key behavioral hints (readOnlyHint: true, destructiveHint: false, etc.), so the bar is lower. The description adds useful context by specifying that it returns detailed information (población, superficie, capital, descripción), which is not covered by annotations. However, it does not disclose additional traits like rate limits, error handling, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. The 'Args' and 'Returns' sections are structured but slightly redundant with the schema. The example usage is helpful but adds length. Overall, it's efficient with minimal waste, though the schema overlap reduces conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (read-only, idempotent, with annotations covering safety), no output schema, and rich annotations, the description is mostly complete. It specifies the resource, parameters, return details, and usage examples. However, it could improve by clarifying output format or error cases, but annotations reduce the need for extensive behavioral disclosure.
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 (id and name) with descriptions and constraints. The description adds minimal value by restating the parameters in the 'Args' section and providing examples (e.g., 'Antioquia', 'Cundinamarca'), but does not explain semantics beyond what the schema provides, such as interaction between parameters or default behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Obtiene información detallada') and resource ('departamento específico'), and distinguishes it from sibling tools like 'get_departments' (plural) by specifying it retrieves information for a single department. The title 'Obtener Departamento Específico' reinforces this distinction.
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 by providing example queries ('Dame información sobre Antioquia'), but does not explicitly state when to use this tool versus alternatives like 'get_departments' (which likely lists multiple departments) or 'get_departments_by_region'. No explicit exclusions or prerequisites are mentioned, leaving usage context somewhat inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds useful context by specifying it returns 'URLs de mapas' (map URLs), which clarifies the output format beyond what annotations provide. 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with purpose statement, args, returns, and usage examples in separate sections. It's appropriately sized, though the example section could be slightly more concise. Most sentences earn their place by clarifying functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with good annotations and no output schema, the description is reasonably complete. It covers purpose, parameter usage, return format (URLs), and examples. The main gap is lack of explicit guidance on when to use versus sibling tools, but overall it provides sufficient context for agent 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%, with the parameter department_id fully documented in the schema. The description adds minimal value beyond the schema by mentioning it's optional and for obtaining a specific department's map, but doesn't provide additional details like ID ranges or examples. Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('obtiene' - gets) and resource ('mapas de Colombia o de un departamento específico'), distinguishing it from sibling tools like get_department or get_departments which return data rather than maps. It explicitly mentions both country-level and department-level map retrieval.
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 provides implied usage through example queries ('Dame el mapa de Antioquia', 'Quiero ver mapas de Colombia'), showing when to use the tool for map requests. However, it doesn't explicitly state when to use this versus alternatives like get_department (which returns department data) or search_colombia (which might include maps in broader searches).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide strong behavioral hints (readOnlyHint: true, destructiveHint: false, openWorldHint: true, idempotentHint: true), covering safety and idempotency. The description adds value by specifying the return format ('Lista de presidentes con nombre, período, partido político y ciudad de nacimiento'), which is not covered by annotations. It does not contradict annotations and provides useful context about output structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by return details and usage examples. Every sentence adds value: the first states what it does, the second specifies the return format, and the examples illustrate typical queries. It is appropriately sized with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema) and rich annotations, the description is mostly complete. It covers purpose, return format, and usage examples. However, it could improve by explicitly differentiating from sibling tools like 'get_president'. With annotations handling behavioral aspects, the description provides adequate context for a list-retrieval tool.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description correctly does not discuss parameters, focusing instead on the tool's function and output. This aligns with the baseline of 4 for tools with 0 parameters, as it avoids unnecessary details.
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: 'Obtiene la lista de presidentes de Colombia' (Gets the list of presidents of Colombia). It specifies the verb ('obtiene') and resource ('presidentes de Colombia'), but does not explicitly differentiate it from its sibling 'get_president' (singular), which likely returns details for a specific president. The purpose is clear but lacks sibling differentiation.
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 includes example usage phrases ('¿Quiénes han sido los presidentes de Colombia?', 'Lista de presidentes colombianos'), which imply when to use this tool for general list queries. However, it does not explicitly state when to use this versus alternatives like 'get_president' (for a specific president) or 'search_colombia' (for broader searches). Guidelines are implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover key behavioral traits (read-only, open-world, idempotent, non-destructive), so the bar is lower. The description adds useful context about the return format (list with name, population, postal code) and example queries, but does not disclose additional traits like rate limits, authentication needs, or error handling. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by Args, Returns, and usage examples. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, read-only operation), rich annotations, and no output schema, the description is largely complete. It covers purpose, parameter context, return format, and usage examples. A minor gap is the lack of explicit error handling or edge-case guidance, but overall it provides sufficient context for 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%, providing a clear description of the single parameter (department_id as an integer ID). The description adds minimal value beyond the schema by mentioning the parameter in context but does not elaborate on semantics (e.g., valid ID ranges beyond the schema's minimum). Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Obtiene todas las ciudades/municipios') and resource ('de un departamento específico'), distinguishing it from sibling tools like get_department or get_departments. It precisely communicates the tool's function without being vague or tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 (to get cities/municipalities for a specific department), as reinforced by the example usage statements. However, it does not explicitly state when not to use it or name alternatives (e.g., using get_departments first to find department IDs), which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide comprehensive behavioral hints (readOnly, openWorld, idempotent, non-destructive). The description adds useful context about filtering capability and return format (name, community, department), which helps the agent understand what data to expect. However, it doesn't disclose additional behavioral traits like rate limits, authentication needs, or pagination behavior that might be relevant for a list operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It starts with the core purpose, explains the optional filtering, specifies return format, and provides concrete usage examples. Every sentence adds value without redundancy. The bilingual presentation (Spanish description with Spanish examples) is consistent and efficient for its intended context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list tool with comprehensive annotations and a well-documented single parameter, the description provides adequate context. It covers purpose, filtering capability, and return format. The main gap is the lack of output schema, but the description compensates by specifying what fields to expect. Given the tool's low complexity, this is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the schema already fully documents the single optional parameter. The description adds marginal value by mentioning the filtering capability in natural language and providing example usage, but doesn't add semantic details beyond what's in the schema. The baseline of 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.
Purpose5/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: 'Obtiene la lista de resguardos indígenas de Colombia' (Gets the list of indigenous reservations in Colombia). It specifies the exact resource (indigenous reservations) and verb (obtains/list), and distinguishes it from siblings like get_departments or get_natural_areas by focusing on this specific cultural/geographic dataset.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: when needing indigenous reservation data for Colombia, optionally filtered by department. It includes example queries that demonstrate usage scenarios. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings, though the sibling list suggests related geographic tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering the safety and idempotency profile. The description adds useful context about filtering capability and the return format (name, frequency, city, streaming URL), which isn't covered by annotations. However, it doesn't mention potential rate limits, authentication needs, or pagination 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 well-structured and appropriately sized. It starts with the core purpose, explains the optional parameter, details the return format, and provides relevant usage examples. Every sentence adds value without redundancy, and the information is front-loaded effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 optional parameter), rich annotations covering safety and idempotency, and no output schema, the description provides sufficient context. It explains what the tool does, how to use it, and what it returns. The main gap is the lack of an output schema, but the description compensates by detailing the return format. For a simple read operation, this is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter city_id clearly documented in the schema. The description mentions filtering by city and provides usage examples that imply the parameter's purpose, but doesn't add significant semantic value beyond what the schema already states. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/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 ('obtiene') and resource ('lista de emisoras de radio de Colombia'), and distinguishes it from siblings by specifying it's for radio stations rather than airports, cities, or other Colombian data. The description explicitly mentions Colombia, which differentiates it from generic radio station tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (to get radio stations in Colombia, optionally filtered by city), and the examples reinforce this usage. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, though the sibling list shows related tools like get_cities that might be used in conjunction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds useful context about what the tool returns (list with name, description, location, images) and provides concrete search examples, which goes beyond the annotations. 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (purpose, args, returns, examples) and uses bullet points for readability. It's appropriately sized for a tool with 2 parameters, though the example queries could be slightly more concise. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with good annotations and 100% schema coverage, the description provides sufficient context: clear purpose, parameter guidance, return format, and usage examples. The main gap is the lack of an output schema, but the description compensates by describing the return format. It could benefit from more explicit sibling tool differentiation.
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 fully documents both parameters (city_id and search). The description repeats this information in the 'Args' section and provides example keywords ('playa', 'museo', 'parque'), but doesn't add significant semantic value beyond what's in the schema. This meets the baseline of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Obtiene' - gets) and resource ('atracciones turísticas de Colombia'), and distinguishes it from siblings like get_cities or search_colombia by focusing specifically on tourist attractions. The description explicitly mentions filtering by city or keyword, which adds specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (searching for tourist attractions by city or keyword) and includes example queries. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools (like when to use search_colombia instead).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds value by specifying the return format (list with id, nombre, capital, población, superficie, región) and clarifying that Bogotá D.C. is included. However, it doesn't mention potential limitations like rate limits or authentication needs beyond what annotations provide.
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 efficiently structured: first sentence states the core purpose, second specifies the return format, and third provides usage examples. Every sentence adds value without redundancy. It's appropriately sized for a simple data retrieval tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, rich annotations), the description is nearly complete. It covers purpose, return format, and usage examples. The only minor gap is lack of explicit guidance on when to use alternative tools like get_departments_by_region for filtered results.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics, detailing the structure of returned data. This exceeds the baseline expectation for a zero-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Obtiene los 32 departamentos de Colombia más Bogotá D.C.' This specifies the exact resource (Colombian departments plus Bogotá D.C.) and action (obtains/gets). It distinguishes from siblings like get_department (singular) and get_departments_by_region (filtered).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool through example queries: '¿Cuáles son los departamentos de Colombia?' and 'Lista todos los departamentos.' This indicates it's for comprehensive listing without filtering. However, it doesn't explicitly state when NOT to use it (e.g., for filtered results use get_departments_by_region).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds useful context about filtering capability and the return format (name, category, department), which goes beyond what annotations provide. No contradictions with annotations exist.
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 efficiently structured with a clear purpose statement, parameter explanation, return value description, and usage examples. Every sentence serves a distinct purpose without redundancy, and the information is front-loaded with the core functionality stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with good annotations and a simple parameter, the description is reasonably complete. It explains what the tool does, the optional filtering parameter, and the return format. However, without an output schema, it could benefit from more detail on the structure of returned areas (e.g., fields beyond name, category, department).
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 the parameter 'department_id' well-documented in the schema as an optional integer for filtering. The description adds minimal value beyond the schema, only repeating that it filters by department without providing additional context like valid department IDs or filtering behavior specifics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('obtiene' - gets/obtains) and resource ('lista de áreas naturales protegidas de Colombia'), specifying it retrieves protected natural areas in Colombia. It distinguishes from siblings by focusing on this specific resource type, unlike other tools that handle airports, cities, departments, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool - to get protected natural areas in Colombia, optionally filtered by department. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools for related queries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, open-world, idempotent, and non-destructive traits. The description adds valuable context beyond annotations by specifying the return format (list with name, city, type, IATA/OACI codes) and providing usage examples, which helps the agent understand output structure and practical application.
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 well-structured and appropriately sized, with a clear purpose statement, parameter explanation, return details, and usage examples. Every sentence adds value without redundancy, and it is front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 optional parameter), rich annotations covering safety and behavior, and no output schema, the description is complete enough. It explains what the tool does, how to use it, what it returns, and provides examples, compensating adequately for the lack of output schema.
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 fully documents the optional department_id parameter. The description adds no additional parameter semantics beyond what the schema provides, such as format details or examples of department IDs. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Obtiene la lista de aeropuertos de Colombia') and distinguishes it from siblings by focusing on airports rather than cities, departments, or other Colombian entities. It specifies the resource (airports) and scope (Colombia) explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use it ('Puede filtrar por departamento'), but does not explicitly state when not to use it or name alternatives among siblings. It implies usage for airport queries in Colombia, which is helpful but lacks explicit exclusions or comparisons to tools like get_cities or search_colombia.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide comprehensive behavioral information (readOnlyHint: true, openWorldHint: true, idempotentHint: true, destructiveHint: false). The description adds useful context about what the tool returns ('Lista de departamentos de esa región') and provides concrete usage examples that help the agent understand typical queries. This goes beyond what annotations provide, though it doesn't mention potential limitations like rate limits or authentication needs.
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 structured and concise. It starts with the core purpose, then provides parameter details with valuable mappings, return information, and practical usage examples. Every sentence serves a clear purpose with zero wasted words. 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.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only lookup tool with comprehensive annotations and a single well-documented parameter, this description is complete. It explains what the tool does, documents the parameter semantics thoroughly, shows what it returns, and provides usage examples. The lack of an output schema is compensated by the clear return description. No additional context is needed for this type of tool.
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?
With 100% schema description coverage, the schema already fully documents the single parameter. However, the description adds significant value by providing a complete mapping of region_id values to region names (1=Caribe, 2=Pacífico, etc.), which is crucial semantic information that helps the agent understand what each numeric ID represents. This goes well beyond the baseline expectation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verb ('Obtiene' - gets) and resource ('departamentos que pertenecen a una región específica' - departments belonging to a specific region). It distinguishes from siblings like 'get_departments' (which presumably gets all departments) by specifying the regional filtering aspect.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: when you need departments filtered by region. The usage examples reinforce this context. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools (like when to use 'get_departments' instead).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world data. The description adds valuable context beyond annotations by specifying the exact number of regions (6), naming them explicitly, and describing the return format ('Lista de regiones con id, nombre y descripción'). This provides concrete behavioral details about what data to expect, which annotations alone don't cover.
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 structured and concise. It leads with the core purpose, immediately lists the specific regions, describes the return format, and provides two relevant usage examples. Every sentence earns its place with no redundant information. The bilingual presentation (Spanish description with Spanish examples) is consistent and appropriate for the tool's context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple, parameterless read-only tool with comprehensive annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description provides complete context. It explains what data is returned, gives concrete examples of the regions, and includes usage examples. Since there's no output schema, the description appropriately covers the return format. This is fully adequate for the tool's complexity level.
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 input schema has 0 parameters with 100% coverage, so the schema fully documents the absence of parameters. The description appropriately doesn't discuss parameters, which is correct for a parameterless tool. It instead focuses on what the tool returns, which adds semantic value beyond the empty schema. A baseline of 4 is appropriate for 0-parameter tools when the description adds meaningful context about outputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool's purpose: 'Obtiene las 6 regiones naturales de Colombia' (Gets the 6 natural regions of Colombia). It names all six specific regions (Caribe, Pacífico, Orinoquía, Amazonía, Andina e Insular), clearly distinguishing this from sibling tools like get_departments or get_natural_areas. The verb+resource combination is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context through two example queries ('¿Cuáles son las regiones de Colombia?' and 'Dame información sobre las regiones naturales'), which effectively illustrate when to use this tool. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools, such as get_departments_by_region for a different granularity of information.
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:

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

Score Badge

Copy to your README.md:

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

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