Register UZ MCP Server

Server Quality Checklist

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

Latest release: v0.1.1
Disambiguation4/5
Most tools have distinct purposes, clearly targeting specific resources like financial reports, accounting units, or reference data. However, there is some overlap between get_uctovny_vykaz and get_uctovny_vykaz_with_labeled_tables, as both retrieve financial reports but with different formatting, which could cause confusion if an agent needs to choose between them. Other tools are well-separated by resource type and action.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern using snake_case, starting with 'get_' for retrieval operations. The naming is predictable and uniform across all 25 tools, making it easy for agents to understand the pattern and infer tool purposes from their names.
Tool Count3/5
With 25 tools, the count is borderline high for a server focused on Slovak financial and business registry data. While it covers many aspects like reference data, financial reports, and pagination helpers, it may feel heavy and potentially overwhelming for agents, especially with multiple similar pagination tools. A more streamlined set could improve usability without losing functionality.
Completeness5/5
The tool set provides comprehensive coverage for the domain of accessing Slovak business and financial registry data. It includes retrieval of detailed entities (e.g., accounting units, financial reports), reference data (e.g., regions, legal forms), and pagination support for discovering changes. There are no obvious gaps; agents can perform all necessary operations from listing to detailed queries, ensuring no dead ends in workflows.
Average 3.6/5 across 25 of 25 tools scored. Lowest: 2.9/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 is passing
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the return content but does not disclose behavioral traits such as error handling (e.g., invalid ID), authentication needs, rate limits, or whether it's a read-only operation. The description adds minimal context 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, stating the purpose and return details in two sentences without unnecessary details. It efficiently communicates core information, though it could be slightly more structured by explicitly separating usage context.
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 one parameter with full schema coverage and an output schema (implied by 'Has output schema: true'), the description is minimally complete. It covers basic purpose and return content but lacks usage guidelines and behavioral details, which are important for a tool in a context with many siblings and no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'id' documented as 'Annual report ID'. The description does not add meaning beyond this, as it only implies an ID is needed without specifying format or source. Baseline 3 is appropriate since the schema adequately covers the single parameter.
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 verb 'Get' and resource 'detailed information about an annual report', specifying what it returns (report details including type, periods, attachments, and references). It distinguishes from some siblings like 'get_vyrocne_spravy' (likely listing multiple reports) by focusing on a single report's details, though not explicitly contrasting all alternatives.
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 does not mention prerequisites (e.g., needing an ID from another call) or compare with siblings like 'get_vyrocne_spravy' for listing reports or 'get_financial_report_pdf_url' for PDF access, 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool searches and returns matching values, which implies read-only behavior, but doesn't mention error conditions, rate limits, authentication requirements, or what happens when no matches are found. The description is minimal and lacks important operational context.
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 concise with three sentences. The first sentence states the core functionality, the second describes the return behavior, and the third provides concrete examples. No wasted words, though it could be slightly more structured with clearer separation of concepts.
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 5 parameters with 0% schema coverage and no annotations, the description is incomplete. While an output schema exists (which helps with return values), the description doesn't adequately explain parameter usage or behavioral constraints. For a search tool with multiple filtering parameters, more guidance is needed about how parameters interact and what constitutes a valid search.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. The description mentions row/column labels and provides examples, but doesn't explain the purpose of 'id', 'row_code', or 'table_name' parameters. It only partially addresses 2 of the 5 parameters, leaving significant gaps in parameter understanding.
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 searches for specific values in a financial report by matching row/column labels and returns matching values. It provides specific examples like 'Výsledok hospodárenia' and 'SPOLU MAJETOK' to illustrate usage. However, it doesn't explicitly differentiate from sibling tools like 'get_uctovny_vykaz' or 'get_uctovny_vykaz_with_labeled_tables'.
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 context ('useful for extracting specific metrics') and provides examples, but doesn't explicitly state when to use this tool versus alternatives like 'get_uctovny_vykaz' (which might return full reports) or 'get_uctovny_vykaz_with_labeled_tables' (which might return structured tables). No explicit when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool returns detailed information but does not cover aspects like authentication needs, rate limits, error handling, or whether it's a read-only operation (implied by 'Get' but not explicit). This leaves significant gaps for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the purpose and return details without unnecessary words. It is front-loaded with the main action and includes specific examples of returned data, making it easy to parse.
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 complexity (simple read operation with one parameter), 100% schema coverage, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers what the tool does and what it returns, though it could benefit from more behavioral context due to the lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with the parameter 'id' documented as 'Accounting unit ID'. The description does not add any additional meaning beyond this, such as format examples or constraints. Since the schema fully covers the parameter, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get detailed information') and resource ('accounting unit'), specifying it returns company details like name, IČO, DIČ, address, legal form, and references to financial documents. However, it does not explicitly differentiate from sibling tools (e.g., get_uctovne_jednotky might be similar), which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as sibling tools like get_uctovne_jednotky or get_uctovna_zavierka. It lacks context on prerequisites, exclusions, or specific scenarios, leaving the agent to infer usage from the purpose alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool returns 'closure details including periods, dates, type, and references to financial reports,' which adds some context about output. However, it lacks critical behavioral details such as whether this is a read-only operation, error handling (e.g., for invalid IDs), authentication requirements, or rate limits. For a tool with no annotations, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences that are front-loaded: the first states the purpose, and the second details the return information. There is no wasted text, and it efficiently conveys core information. A minor deduction for not structuring usage hints more explicitly.
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 required parameter), 100% schema coverage, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose and output details adequately. However, it could improve by adding behavioral context (e.g., read-only nature) to compensate for the lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'id' parameter documented as 'Accounting closure ID.' The description does not add any meaning beyond this, as it doesn't explain parameter usage, constraints, or examples. With high schema coverage, the baseline score is 3, reflecting adequate but no extra value from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get detailed information about an accounting closure (financial statement).' It specifies the verb ('Get') and resource ('accounting closure'), and distinguishes it from siblings like 'get_uctovne_zavierky' (plural) by focusing on a single closure. However, it doesn't explicitly differentiate from other financial tools like 'get_uctovny_vykaz' (accounting statement), making it slightly less specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a closure ID), exclusions, or compare it to sibling tools like 'get_uctovne_zavierky' (which might list closures) or 'get_financial_report_pdf_url' (which might retrieve reports). Usage is implied from the description but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states it 'gets' data, implying a read operation, but doesn't disclose behavioral traits like authentication needs, rate limits, or response format. The description adds minimal value beyond the basic 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it highly concise.
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 has 0 parameters, 100% schema coverage, and an output schema exists, the description is adequate for a simple read operation. However, it lacks context on usage or behavioral details, which could be helpful despite the structured data.
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, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, earning a baseline score for tools with no parameters.
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 verb ('Get list') and resource ('ownership types with their codes'), making the purpose explicit. It distinguishes from siblings by specifying 'ownership types' rather than other entities like regions or legal forms, though it doesn't explicitly contrast with similar tools like get_pravne_formy.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage based on 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool returns a full URL for downloading a PDF, which implies a read-only operation, but doesn't cover aspects like authentication requirements, rate limits, error handling, or whether the URL is ephemeral. This leaves significant gaps in understanding the tool's 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 front-loaded and concise, consisting of two sentences that directly state the tool's purpose and output without any wasted words. Every sentence earns its place by providing essential information efficiently.
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) and the presence of an output schema (which likely covers return values), the description is reasonably complete. It specifies the resource and output type, though it lacks usage guidelines and behavioral details, which are minor gaps in this context.
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 'id' parameter clearly documented as 'Financial report ID'. The description adds no additional semantic details beyond this, such as format examples or constraints, so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'URL for PDF version of a financial report', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_attachment_url' or 'get_vyrocna_sprava', which might also involve financial reports or URLs, leaving some ambiguity in sibling context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing a valid financial report ID, or compare it to siblings like 'get_attachment_url' for other file types, leaving the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's a read operation ('Get list'), but lacks details on permissions, rate limits, pagination, or error handling. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get list of all legal forms') and adds specific details (codes and names). There is no wasted verbiage or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, output schema exists), the description is adequate but minimal. It covers the purpose and data returned, but lacks behavioral context that annotations would normally provide. The presence of an output schema means return values don't need explanation, keeping it complete enough for basic use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a high baseline score for not adding unnecessary information.
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 verb ('Get list') and resource ('all legal forms (právne formy)'), specifying what data is retrieved (codes and names). It distinguishes itself from siblings by focusing on legal forms, but doesn't explicitly contrast with similar list tools like get_kraje or get_okresy beyond the subject matter.
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. While the description implies it's for retrieving legal forms, it doesn't mention prerequisites, timing, or comparisons to other tools like get_druhy_vlastnictva or get_velkosti_organizacie that might serve related purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes what data is returned (settlements with codes and parent district references) but doesn't mention critical behaviors like whether this is a read-only operation, if it requires authentication, rate limits, pagination, or error handling. For a data retrieval tool with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the core functionality without unnecessary words. It's front-loaded with the main purpose and includes essential details about the data structure. Every part of the sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool has no parameters, an output schema exists, and annotations are absent, the description is moderately complete. It explains what data is returned but lacks behavioral context (e.g., read-only nature, authentication needs). The output schema likely covers return values, so the description doesn't need to detail them, but it should address other operational aspects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, and it adds value by explaining what data will be returned (settlements with codes and parent district references), which complements the output schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get list of Slovak settlements (sídla) with their codes.' It specifies the verb ('Get'), resource ('Slovak settlements'), and key attributes ('codes' and 'reference to parent district'). However, it doesn't explicitly differentiate from sibling tools like 'get_kraje' or 'get_okresy' which likely return different geographic entities.
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 sibling tools like 'get_kraje' (regions) or 'get_okresy' (districts), nor does it explain the relationship between settlements and these other geographic entities. Usage is implied but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states it 'gets' data, implying a read operation, but doesn't disclose behavioral traits like rate limits, authentication needs, response format, or whether it returns all codes or supports filtering. For a tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with zero waste. The first sentence directly states the tool's purpose, and the second provides essential context about SK NACE. It's appropriately sized and front-loaded.
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 has 0 parameters, 100% schema coverage, and an output schema exists, the description is moderately complete. It explains what SK NACE is, which helps interpret results. However, with no annotations and a read operation, it should ideally mention response characteristics or usage constraints, but the output schema mitigates this gap.
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, and schema description coverage is 100%. With no parameters to document, the description doesn't need to add parameter semantics. It appropriately explains what SK NACE is, which provides context for the tool's output. Baseline for 0 parameters is 4.
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: 'Get SK NACE classification codes' with the verb 'Get' and resource 'SK NACE classification codes'. It distinguishes the tool by specifying it's for Slovak economic activity classification, which differentiates it from siblings like get_kraje or get_okresy. However, it doesn't explicitly contrast with other classification tools (none in siblings), so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for usage, or comparisons to other tools. While siblings include various get_* tools for different data types, there's no explicit when/when-not advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves a list with codes, implying a read-only operation, but does not mention any behavioral traits such as authentication requirements, rate limits, error handling, or the format/structure of the output. This leaves significant gaps for an agent to understand how to interact with it effectively.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's purpose without any unnecessary words. It is front-loaded and efficiently conveys the essential information, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, output schema exists), the description is minimally complete. It states what the tool does but lacks details on usage context and behavioral aspects. The existence of an output schema means the description doesn't need to explain return values, but without annotations, it should provide more guidance on when and how to use the tool relative to siblings.
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 does not add any parameter information, which is appropriate here. A baseline of 4 is applied as it adequately handles the lack of parameters without introducing confusion.
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 verb 'Get' and the resource 'list of organization sizes (veľkosti organizácie) with their codes', making the purpose specific and understandable. However, it does not explicitly distinguish this tool from its many sibling 'get_' tools, which all appear to retrieve different types of data from the same system, so it misses full 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 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. Given the many sibling tools (e.g., get_kraje, get_okresy, get_pravne_formy), there is no indication of context, prerequisites, or exclusions for selecting this specific tool over others in the same domain.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the tool 'gets' information, implying a read operation, but doesn't disclose behavioral traits like authentication needs, rate limits, error conditions, or what 'detailed information' includes beyond structure. This is inadequate 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the purpose and followed by a usage hint. It avoids redundancy and is efficiently structured, though the second sentence could be slightly more specific to enhance clarity without adding bulk.
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 has an output schema (which likely defines return values), a single parameter with full schema coverage, and no annotations, the description is reasonably complete. It covers the purpose and basic usage, but could improve by addressing behavioral aspects like permissions or data format, given the lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'id' documented as 'Template ID'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate since the schema fully covers the parameter.
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 verb 'Get' and resource 'detailed information about a financial report template', explaining that templates define report structure. It distinguishes from siblings like 'get_sablony' (likely listing templates) by focusing on detailed info for a specific template, though not explicitly naming alternatives.
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 stating 'Use this to interpret the data in financial reports', suggesting it's for understanding report structure. However, it doesn't explicitly say when to use this vs. other template-related tools (e.g., 'get_sablony' for listing templates) or provide exclusions, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns a download URL but does not cover critical aspects like authentication requirements, rate limits, error conditions, or whether the URL is temporary or permanent. This leaves significant gaps for a tool that likely involves file access.
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 in the first sentence and adds useful return value information in the second. Both sentences earn their place by clarifying the action and output, with zero wasted words.
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 (single parameter, no nested objects) and the presence of an output schema (which likely covers the return URL), the description is reasonably complete. However, it lacks behavioral details like authentication or error handling, which are important for a download operation, preventing a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already fully documents the 'id' parameter. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain where to find the 'prilohy array' or provide examples). Baseline 3 is appropriate as the schema handles 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 ('Get the download URL') and resource ('for a financial report attachment'), distinguishing it from sibling tools like get_financial_report_pdf_url (which likely returns a PDF URL rather than a general attachment URL). It avoids tautology by not just restating the tool name.
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, such as get_financial_report_pdf_url or other attachment-related tools. It mentions the resource but does not specify prerequisites, exclusions, or contextual usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the tool is 'useful for estimating pagination progress,' which hints at a read-only, non-destructive behavior, but doesn't explicitly state this. It lacks details on permissions, rate limits, error conditions, or what the output contains (though an output schema exists). For a tool with no annotations, this is insufficient behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded: two sentences that directly state the purpose and usage. Every word earns its place, with no redundant or vague language. It's appropriately sized for a simple counting 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 moderate complexity (5 parameters, 1 required), 100% schema coverage, and the presence of an output schema, the description is reasonably complete. It covers the core purpose and a key usage scenario. However, it could be more complete by addressing behavioral aspects (since annotations are absent) or clarifying sibling tool relationships, which slightly limits its effectiveness.
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 all parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain how 'pokracovat_za_id' relates to 'remaining IDs' or provide examples). With high schema coverage, the baseline is 3, and the description doesn't compensate with extra insights.
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: 'Get count of remaining accounting unit IDs after a given ID.' It specifies the verb ('Get count') and resource ('remaining accounting unit IDs'), and the sibling tool list shows similar 'get_zostavajuce_id_' tools for different entities, but the description doesn't explicitly differentiate this from those siblings (e.g., 'uctovne_jednotky' vs 'uctovne_vykazy'), which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage context: 'Useful for estimating pagination progress.' This suggests when to use the tool (for pagination estimation) but doesn't explicitly state when not to use it or name alternatives. For example, it doesn't clarify if this should be used instead of or alongside the sibling 'get_uctovne_jednotky' tool for listing actual units.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool returns detailed information including specific components (title page, tables, attachments), which adds behavioral context beyond a simple 'get' operation. However, it doesn't cover aspects like error handling, authentication needs, rate limits, or whether it's read-only (implied but not stated).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences: the first states the purpose and return content, and the second provides a usage tip. It's front-loaded with key information and avoids unnecessary details, though the second sentence could be more integrated for better flow.
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 has an output schema (which handles return values), no annotations, and high schema coverage, the description is reasonably complete. It covers the purpose, return content, and a usage guideline, addressing core needs. However, for a tool with no annotations, it could benefit from more behavioral details like read-only confirmation or error scenarios.
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 parameter 'id' documented as 'Financial report ID.' The description adds minimal value beyond this, only referencing 'idSablony' in a usage note, which isn't a parameter. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't significantly enhance parameter understanding.
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 verb ('Get detailed information') and resource ('about a financial report'), specifying it returns report content including title page data, tables, and attachment information. It distinguishes from siblings like 'get_financial_report_pdf_url' by focusing on detailed structured data rather than PDF output, though it doesn't explicitly name alternatives.
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 mentioning 'Use idSablony to get the template for interpreting tables,' which suggests a prerequisite or related tool, but doesn't explicitly state when to use this tool versus alternatives like 'get_uctovny_vykaz_with_labeled_tables' or 'get_uctovne_vykazy' (which likely lists reports). No clear exclusions or when-not scenarios are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the tool's process ('Fetches both the report and its template, then combines them') and output benefit ('labeled data'), but lacks critical details like whether this is a read-only operation, potential performance impacts (e.g., slower due to combining data), error handling, or authentication needs. For a tool with no annotation coverage, this leaves significant gaps in understanding its 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 efficiently structured in two sentences: the first states the purpose and process, and the second explains the benefit. Every sentence adds value without redundancy, making it front-loaded and easy to parse quickly.
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 moderate complexity (involving fetching and combining data), no annotations, and an output schema (which handles return values), the description is reasonably complete. It explains the core functionality and output format well, but could improve by addressing behavioral aspects like performance or errors, and clarifying the parameter. The presence of an output schema reduces the need to detail return values.
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 1 parameter ('id') with 0% description coverage, meaning the schema provides no semantic context. The description does not mention the 'id' parameter at all, failing to compensate for the coverage gap. However, with only one parameter, the baseline is slightly higher than minimal, but the description adds no value beyond what's inferred from the tool name (e.g., 'id' likely refers to a report ID).
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 ('Get financial report with labeled tables'), the resource ('financial report'), and the key differentiator ('labeled tables' with row/column labels). It explicitly distinguishes this from manual cross-referencing, making its purpose distinct from siblings like 'get_uctovny_vykaz' (which likely lacks labeling).
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 mentioning it 'makes it easy to understand what each value represents without manually cross-referencing the template,' suggesting it's preferable for human-readable output. However, it doesn't explicitly state when to use this tool versus alternatives (e.g., 'get_uctovny_vykaz' for raw data or 'get_uctovny_vykaz_table_value_by_labels' for specific values), nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool is 'useful for estimating pagination progress,' which implies read-only behavior and a counting function, but doesn't detail aspects like rate limits, authentication needs, error handling, or what the output looks like. For a tool with no annotations, this leaves significant gaps in understanding its operational behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by a usage note. Every word earns its place, with no redundancy or fluff. It's efficiently structured for quick comprehension.
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 moderate complexity (2 parameters, 1 required), 100% schema coverage, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose and usage context adequately. However, without annotations, it could benefit from more behavioral details (e.g., performance or limits), but the output schema reduces the need for extensive description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already documents both parameters (zmenene_od and pokracovat_za_id) with descriptions. The description adds value by explaining the overall purpose ('count of remaining annual report IDs after a given ID'), which provides context for parameter usage, but doesn't add specific semantics beyond what the schema provides. Baseline 3 is appropriate when schema coverage is high.
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: 'Get count of remaining annual report IDs after a given ID.' It specifies the verb ('Get count'), resource ('remaining annual report IDs'), and scope ('after a given ID'), which distinguishes it from siblings like get_vyrocne_spravy (likely fetching reports). However, it doesn't explicitly differentiate from similar tools like get_zostavajuce_id_uctovne_jednotky, which suggests a pattern but not a direct comparison.
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: 'Useful for estimating pagination progress.' This implies when to use the tool—for pagination tracking—and hints at its role in workflows involving sequential ID retrieval. It doesn't explicitly state when not to use it or name alternatives, but the context is sufficient for typical usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool retrieves a list with codes, but does not disclose behavioral traits such as whether it's read-only, requires authentication, has rate limits, or how data is formatted. This leaves significant gaps 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose without unnecessary words. Every part of the sentence earns its place by specifying what is retrieved and the data included, making it highly concise and well-structured.
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, output schema exists), the description is reasonably complete for its purpose. However, with no annotations and an output schema, it could benefit from more behavioral context (e.g., data format or usage notes) to fully compensate for the lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description adds no parameter information, which is acceptable as there are no parameters to explain, aligning with the baseline for zero parameters.
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 ('Get list') and resource ('Slovak regions (kraje)'), specifying both the action and the data returned. It distinguishes from siblings like 'get_okresy' (districts) by focusing specifically on regions, providing clear 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 implies usage when Slovak region data is needed, but does not explicitly state when to use this tool versus alternatives (e.g., 'get_okresy' for districts). No exclusions or prerequisites are mentioned, leaving usage context partially inferred rather than explicitly guided.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: the tool returns IDs (not full records), has pagination support, and includes default/max limits ('Returns up to max_zaznamov IDs (default 1000, max 10000)'). It also hints at a response structure with 'existujeDalsieId' for pagination control. However, it doesn't mention error conditions, rate limits, or authentication requirements.
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 concise and well-structured in three sentences: purpose, limits, and pagination guidance. Each sentence earns its place by providing essential information without redundancy. It's front-loaded with the core purpose and efficiently covers key operational details.
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 complexity (6 parameters, pagination, filtering) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose, limits, and pagination mechanics. However, it could better address sibling tool differentiation and provide more explicit usage scenarios. With no annotations, it does a solid job but has minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema: it mentions 'max_zaznamov' defaults and limits, and explains 'pokracovat_za_id' for pagination. However, it doesn't provide additional context for parameters like 'zmenene_od' or filtering parameters (ico, dic, pravna_forma). 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.
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: 'Get list of accounting unit IDs changed since a given date. Use this to discover entities that have been modified.' This specifies the verb ('get list'), resource ('accounting unit IDs'), and scope ('changed since a given date'). However, it doesn't explicitly differentiate from sibling tools like 'get_uctovna_jednotka' (singular vs. plural), which might cause confusion about when to use each.
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 some usage context: 'Use this to discover entities that have been modified' and mentions pagination with 'pokracovat_za_id' when 'existujeDalsieId is true.' However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., 'get_uctovna_jednotka' for a single unit or other filtering tools). The guidance is implied rather than clearly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the tool's behavioral trait of being useful for pagination progress, which is helpful. However, it lacks details on permissions, rate limits, or error handling, leaving gaps for a tool that likely involves data queries.
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 highly concise and front-loaded with two sentences that directly convey purpose and usage. Every sentence earns its place without redundancy, making it efficient and easy to parse.
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 moderate complexity (2 parameters, 1 required), 100% schema coverage, and presence of an output schema, the description is complete enough. It covers purpose and usage context, and the output schema likely handles return values, so no major gaps exist.
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 fully documents both parameters. The description adds no additional parameter semantics beyond what's in the schema, such as explaining 'zmenene_od' or 'pokracovat_za_id' further. Baseline 3 is appropriate as the schema handles the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Get count of remaining accounting closure IDs after a given ID,' which is a specific verb+resource combination. It distinguishes itself from siblings like 'get_uctovne_zavierky' (likely listing closures) by focusing on count/remaining IDs, though it doesn't explicitly name alternatives.
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 usage with 'Useful for estimating pagination progress,' indicating when to use this tool. However, it doesn't explicitly state when not to use it or name specific alternatives among siblings, such as 'get_uctovne_zavierky' for full listings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It describes a read-only list operation, but lacks details on behavioral traits such as pagination, rate limits, authentication needs, or error handling. It adds basic context about data structure but is minimal for a tool with output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose and key details (list, Slovak districts, codes, parent region reference). There is no wasted text, making it highly concise and well-structured for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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, output schema exists), the description is reasonably complete. It specifies the data type and structure, and with an output schema, return values need not be explained. However, it could benefit from more behavioral context, such as data freshness or usage examples.
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, and schema description coverage is 100%, so no parameter documentation is needed. The description does not add param info, which is appropriate, earning a baseline score of 4 for zero-param tools where schema fully covers inputs.
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 ('Get list') and resource ('Slovak districts (okresy)'), specifying the data includes codes and parent region references. It distinguishes from siblings like 'get_kraje' (regions) by focusing on districts, providing specific scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving district-level data, but offers no explicit guidance on when to use this versus alternatives like 'get_kraje' for regions or other data tools. No exclusions or prerequisites are mentioned, leaving usage context inferred rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool returns a list with basic information (id, name, regulation, validity period), which is useful behavioral context. However, it does not mention potential limitations like pagination, rate limits, or authentication needs, leaving gaps for a read 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 a single, well-structured sentence that efficiently conveys purpose and return value. It is front-loaded with the main action and includes no unnecessary details, making it highly concise and effective.
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 (0 parameters, read-only operation), the description is mostly complete. It specifies what is returned, and an output schema exists, so return values need not be detailed. However, without annotations, it could benefit from mentioning any behavioral constraints like data freshness or access requirements.
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, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately does not discuss parameters, earning a high baseline score as it avoids redundancy with the schema.
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 ('Get list of all available financial report templates') and the resource ('financial report templates'), distinguishing it from siblings like 'get_sablona' (singular) or other financial tools. It provides precise scope without ambiguity.
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 implies usage for retrieving all templates with basic info, but does not explicitly state when to use this tool versus alternatives like 'get_sablona' (singular) or other financial report tools. It provides clear context but lacks explicit exclusions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the tool's behavioral trait of being a read-only operation for counting IDs, which is useful. However, it lacks details on permissions, rate limits, error handling, or the exact output format, leaving gaps in behavioral context.
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 in the first sentence and adds a usage note in the second, with zero wasted words. Every sentence earns its place by providing essential information efficiently.
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 moderate complexity (2 parameters, 1 required), 100% schema coverage, and the presence of an output schema (which handles return values), the description is largely complete. It covers purpose and usage well but could benefit from more behavioral details like error cases or performance notes, though the output schema mitigates this gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, such as explaining the relationship between 'zmenene_od' and 'pokracovat_za_id' or providing examples. 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 ('Get count of remaining financial report IDs') and resource ('financial report IDs'), distinguishing it from siblings like 'get_uctovne_vykazy' (which likely lists reports) by focusing on pagination progress estimation. It avoids tautology by explaining functionality beyond the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to use this tool ('Useful for estimating pagination progress'), providing clear context for its application. While it doesn't name specific alternatives, the purpose inherently distinguishes it from sibling tools that retrieve actual data rather than counts.
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?
With no annotations provided, the description carries the full burden and adds valuable behavioral context: it discloses the return limit ('Returns up to max_zaznamov IDs (default 1000, max 10000)'), pagination mechanism, and the condition for pagination ('when existujeDalsieId is true'). It does not cover aspects like error handling or authentication needs, but provides key operational details.
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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by concise details on limits and pagination. Every sentence earns its place with no wasted words, making it efficient and easy to parse.
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 complexity (list retrieval with pagination), no annotations, and the presence of an output schema (which handles return values), the description is complete enough. It covers purpose, usage guidelines, key behavioral traits (limits, pagination), and references the output schema condition ('existujeDalsieId'), providing all necessary context for an agent to use the tool effectively.
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 all parameters fully. The description mentions 'max_zaznamov' and 'pokracovat_za_id' in context, but adds no new semantic details beyond what the schema provides (e.g., default values and constraints are already in 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.
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: 'Get list of annual report IDs changed since a given date.' It specifies the verb ('Get'), resource ('annual report IDs'), and scope ('changed since a given date'), distinguishing it from siblings like 'get_vyrocna_sprava' (singular) or other unrelated 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 usage: it explains when to use pagination ('Use pokracovat_za_id for pagination when existujeDalsieId is true'). However, it does not explicitly state when not to use this tool or name alternatives among siblings, such as 'get_vyrocna_sprava' for detailed reports.
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?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: default and maximum return limits (1000/10000), pagination mechanism, and the conditional nature of pagination. It doesn't mention rate limits, authentication needs, or error conditions, but covers the essential operational behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly front-loaded with the core purpose, followed by essential behavioral details. Every sentence earns its place: first states purpose, second covers limits, third explains pagination. No wasted words or redundant information.
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 this is a read-only list operation with full schema coverage and an output schema (implied by context signals), the description provides complete context. It covers purpose, usage, key behavioral constraints, and pagination - everything needed to understand when and how to use this tool effectively.
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 all three parameters. The description adds minimal value beyond the schema - it mentions max_zaznamov defaults and limits, but doesn't provide additional context about parameter interactions or usage patterns. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('Get list of financial report IDs') and resource ('financial report IDs'), and distinguishes this tool from siblings by specifying it returns IDs changed since a date rather than full reports or other data. It provides precise scope that differentiates it from tools like get_uctovny_vykaz or get_uctovne_jednotky.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides when-to-use guidance: 'changed since a given date' establishes the primary use case, and it specifies pagination conditions ('when existujeDalsieId is true'). It also distinguishes from siblings by focusing on ID retrieval rather than full content, though it doesn't name specific alternatives.
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?
With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it specifies pagination logic, default and maximum return limits (1000 default, 10000 max), and the condition for using pagination (when existujeDalsieId is true). It could improve by mentioning rate limits or authentication needs, but covers core operational behavior effectively.
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 essential operational details in two concise sentences. Every sentence adds value: the first defines the tool, the second covers pagination and limits without any wasted words.
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 moderate complexity, 100% schema coverage, and the presence of an output schema (which handles return values), the description is complete. It covers purpose, usage, pagination, and limits, leaving no gaps for the agent to understand how to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds some context by linking pokracovat_za_id to pagination and explaining max_zaznamov defaults, but doesn't provide significant additional meaning beyond the schema. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('Get list'), resource ('accounting closure IDs'), and scope ('changed since a given date'). It distinguishes itself from sibling tools like 'get_uctovna_zavierka' (singular) by specifying it returns a list of IDs rather than a single closure.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: it specifies when to use pagination ('Use pokracovat_za_id for pagination when existujeDalsieId is true'), includes default and maximum values for max_zaznamov, and implies this is for retrieving changed IDs rather than all IDs or other data types, differentiating it from siblings like get_uctovne_jednotky.
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:

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

Score Badge

Copy to your README.md:

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

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/freevisionsk/registeruz-mcp'

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