UK Data: Catalogue
Server Details
Search 16,000+ API operations and 95 built tools by need, then call any of them 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 largely distinct roles: call_tool invokes, list_apis inventories imported APIs, and tool_search finds tools semantically. There is minor overlap between list_apis and tool_search for discovering what is available, but the descriptions make the intended distinction clear.
call_tool and list_apis follow a verb_noun pattern, while tool_search reverses it to noun_verb. The names are still readable and understandable, but the set does not follow a single predictable convention.
Three tools is compact but appropriate for a meta-layer server: one for discovery, one for inventory, and one for invocation. It is on the thin side for a catalogue server, but each tool has a clear purpose.
The surface covers the basic search-then-call workflow and can leverage imported APIs for actual data operations. However, it lacks native catalogue-specific operations such as browsing datasets or retrieving dataset details, and completeness depends entirely on what imported APIs exist.
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.
1 tool update
- Changed
call_tool1 field changed- added
Input schema / properties / authAdded value: +{ + "description": "string: optional, your own key or token for the service being called (imported APIs that need one); used for this request only, never stored", + "type": "string" +}
3 tool updates
- First observed
call_tool - First observed
list_apis - First observed
tool_search
Related MCP Connectors
Turn any task into the right API calls: discover, evaluate, and integrate public APIs.
Free search across ~35,000 agent tools (x402 bazaar + MCP registry) by plain-language need.
Build and run agents and automations across hundreds of apps using natural language.
Search and run data, text, code, PDF and web APIs. Requests not stored. Network tools need a key.
Related MCP Servers
- 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 gradedqualityDmaintenanceA universal AI API orchestrator that connects to 17+ services (Stripe, Slack, GitHub, etc.) and enables natural language task execution, multi-step automation, and complex orchestration across them without coding.1,535 npm1MIT
- 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 gradedqualityNot gradedmaintenanceUniversal AI API Orchestrator. 850 tools across 53 services under a single MCP interface. Connect Claude, GPT, or Gemini to Stripe, Slack, GitHub, LinkedIn, Cloudflare, Shopify, Twilio, and 46 more via natural language. $0.10/execution, no subscription. Patent Pending.1,535 npm5-
Glama MCP Gateway
Add one secure layer between your agents and this server.