UK Data: Tool catalogue
Server Details
Find the right tool for any need across every family and imported API, then call it by name
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 3 tools
The three tools have mostly distinct roles: discovery via tool_search, API inventory via list_apis, and execution via call_tool. There is minor overlap between list_apis and tool_search as discovery surfaces, but the descriptions make their boundaries reasonably clear.
All tools follow a consistent snake_case verb_noun pattern: call_tool, list_apis, tool_search. The convention is predictable and easy to parse.
Three tools is a well-scoped surface for a tool catalogue/gateway: one for discovery, one for API inventory, and one for execution. Each tool has a clear purpose and earns its place.
The set covers the core catalogue lifecycle: find tools, inspect imported APIs, and invoke them. A minor gap is the lack of a direct list-all native tools operation, but tool_search largely mitigates this.
Available Tools
3 toolscall_toolCIdempotentInspect
Call any tool by name with an arguments object, including imported API operations (api__operation). Costs what the tool costs. (cost: 1 credit)
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | object | |
| auth | No | string: optional, your own key or token for the service being called (imported APIs that need one); used for this request only, never stored | |
| name | No | string, required |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds genuinely useful context beyond annotations by disclosing a credit cost and warning that cost depends on the invoked tool. However, it says nothing about side effects of the dispatched call, error/failure behavior, or whether the optional auth token is forwarded to the target service, which matters for a dispatcher whose annotations claim idempotentHint=true and destructiveHint=false despite arbitrary targets.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is short and front-loaded, which is good, but the cost clause is muddled: 'Costs what the tool costs. (cost: 1 credit)' leaves it ambiguous whether the charge is flat or passthrough. Two sentences cover three separate facts, and the redundancy costs clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a universal dispatcher that can reach every tool and external API, the description omits the essentials an agent needs to call it correctly: how args must be serialized (the schema says string, the description says object), what happens on target failure, and whether the call is gated by the target's own permissions. Annotations cover the safety profile only loosely, and there is no output schema to lean on.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all three parameters carry descriptions; the description's 'arguments object' corroborates the args parameter but does not resolve the schema oddity that args is typed as string while documented as 'object'. No added detail on name formatting or auth scope beyond what the schema already says, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb+resource: invoke any tool by name with an arguments object, and explicitly notes it covers imported API operations (api__operation). That distinguishes it from concrete siblings like weather or company_search, and implicitly from tool_search/list_apis, which discover rather than execute. It stops short of naming those siblings for contrast.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance at all: nothing says when to route through call_tool instead of invoking a concrete sibling directly, or when to use tool_search/list_apis first. The only hint is the parenthetical about imported APIs, which implies but never states the selection rule.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_apisBRead-onlyIdempotentInspect
List imported APIs with operation counts. Free. (cost: 0 credit)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds one genuinely new behavioral fact not in annotations: the call costs 0 credits. It says nothing about pagination, result limits, or what happens when no APIs have been imported.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, front-loaded sentences with the purpose first and the cost second. The cost is stated twice ("Free." and "(cost: 0 credit)"), which is mild redundancy but does not obscure the meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read tool with full annotation coverage, most of what an agent needs is present. With no output schema, though, the description should say more about the returned shape — for example whether each API entry includes id, base URL and per-operation counts — and about behavior when the list is empty.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description correctly implies a no-argument, unfiltered full listing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ("List") and resource ("imported APIs") plus a return-content hint ("with operation counts"). However, "imported" is undefined and an agent could read this as listing available/third-party APIs rather than user-imported ones, and nothing distinguishes it from the ~90 sibling data-source tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives. The only implicit usage signal is the cost note, which tells an agent this call is economically safe but not when it is the right choice over something like tool_search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tool_searchBRead-onlyIdempotentInspect
Describe what you need in plain words and get the best matching tools (native and imported APIs) with their parameters and how to call them. Free. (cost: 0 credit)
| Name | Required | Description | Default |
|---|---|---|---|
| need | No | string, required | |
| limit | No | number 1-15 | |
| sector | No | optional: government, finance-banking, retail-ecommerce, education-reference, science-space, health, transport-travel, geo-weather, media-entertainment, developer-tools, other |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered structurally. The description adds meaningful non-annotation context: that results are tool definitions with call parameters, and that the call is free (0 credits) — the latter being real value in a credit-based catalog. It says nothing about ranking, relevance, or empty-result behavior, so it adds value but not rich 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with the outcome front-loaded and no filler. The trailing 'Free. (cost: 0 credit)' restates the same fact twice, a minor redundancy that keeps it off a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description does the right thing by sketching the return shape (matching tools, their parameters, how to call them). For a three-parameter discovery tool it is largely adequate, but the absence of any guidance on default result count, result ordering, or the relationship to sibling discovery/list tools leaves gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description clarifies that the `need` parameter should be natural language ('plain words'), which is a small semantic addition, but it says nothing about `limit` behavior (default value, effect on response size) or what `sector` actually constrains.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('describe what you need' → 'get the best matching tools') and names the resource domain (native and imported APIs) plus the return content (parameters and how to call them). It does not, however, distinguish itself from the sibling list_apis, which an agent could plausibly confuse with this tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: describing a need in plain words suggests the tool is for discovery when the right endpoint is unknown, but it never says when to prefer this over list_apis or any specific sibling search tool. There are no exclusions or prerequisite conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
call_tool - First observed
list_apis - First observed
tool_search
Related MCP Connectors
Discover, inspect and run 63,000+ agent tools from one balance. Pay per call, no subscriptions.
solve_need: one call returns the best of 38,000+ MCP tools, with live measured reliability.
Free search across ~35,000 agent tools (x402 bazaar + MCP registry) by plain-language need.
Search, inspect and invoke every public tool on Invokera through one MCP connection.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to find the right tool from a vague, misspelled, or rambling description by searching a library of tools and returning ranked matches with fit grades, links, and evidence.1MIT
- FlicenseNot gradedqualityCmaintenanceEnables agents to securely discover and invoke a centrally governed catalog of tools from distributed internal and external providers, with policy enforcement, quotas, inspection, and audit controls.-
- FlicenseAqualityDmaintenanceEnables autonomous task execution by dynamically searching APIs, generating Python tools, and running them on-demand, with built-in web search, scraping, and file operations.3-
- AlicenseNot gradedqualityBmaintenanceEnables agents to search across the pooled tools of many connected MCP servers and invoke them through a single endpoint, returning only the handful of tools relevant to each request. Filters by the caller's permissions before ranking, so agents never see or plan around tools their user is not allowed to use.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.