Painto
Server Details
Czech paint and coatings retailer. Search products by name, code, EAN or need; live stock levels and final prices incl. VAT; shipping and payment options; interactive catalogue where items are ticked in the page and sent as an order.
- Status
- Healthy
- Uptime
- 99.9% over 42 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-03-26
- URL
TDQS
Scored across 9 tools
There are two parallel tool families doing the same job: UCP tools (search_catalog, lookup_catalog, get_product) and Painto-native tools (painto_hledej, painto_dostupnost, painto_sortiment). search_catalog and painto_hledej are both catalog searches with nearly identical descriptions, and lookup_catalog overlaps with both get_product and painto_dostupnost on ID/EAN lookups. An agent has no clear rule for choosing between the protocols or between search/availability tools.
The set mixes two conventions: generic English snake_case (get_product, lookup_catalog, search_catalog) and Czech-prefixed snake_case (painto_hledej, painto_dostupnost, painto_kontakt, painto_sortiment, painto_doprava_platby). The language and prefixing are inconsistent across what is nominally one product surface. The painto_* family is at least internally consistent, which keeps this above a 1.
Nine tools is a reasonable scope for an e-shop catalog/assistance server. However the redundancy between the UCP trio and the Painto-native tools means several slots are effectively duplicates rather than earning distinct places. Slightly over-provisioned but within a normal range.
Browsing coverage is solid: search, product detail, stock, assortment overview, shipping/payment, contact, and an interactive catalog for multi-item orders. Notable gaps remain around order lifecycle — no cart, order submission/status, or order tracking tool, and no category/browse-by-taxonomy operation. Agents will hit dead ends once a user moves past product discovery.
Available Tools
9 toolsget_productBInspect
UCP Get Product — plný detail jednoho produktu se všemi variantami (rozměry), cenou a dostupností. Vyžaduje meta["ucp-agent"].profile.
| Name | Required | Description | Default |
|---|---|---|---|
| meta | Yes | {"ucp-agent":{"profile":"https://…"}} | |
| catalog | Yes | get_product_request: id, volitelně selected[{name,label}] |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the payload shape (variants/dimensions, price, availability) and a required auth-like meta profile, which is useful, but says nothing about errors, missing products, or limits for what is effectively a single-item retrieval.
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?
A single front-loaded sentence covering scope and prerequisite with no filler. The leading 'UCP Get Product' is mildly redundant with the tool name.
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?
Because there is no output schema, the description usefully describes the return contents (variants, price, availability) and the required meta profile. However, with zero annotations and no sibling routing, an agent still lacks the behavioral and selection context needed to call it confidently.
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 both params (meta, catalog) are already documented in the schema, including the 'id, volitelně selected[{name,label}]' shape. The description only restates the meta profile requirement already present in the schema, adding no new parameter meaning.
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+resource ('Get Product') and scope ('plný detail jednoho produktu se všemi variantami, cenou a dostupností'). Clear about what it returns, but it does not explicitly differentiate itself from siblings like search_catalog or lookup_catalog.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The only usage-adjacent statement is a prerequisite ('Vyžaduje meta["ucp-agent"].profile'), which is not when-to-use guidance. There is no indication of when to prefer this over search_catalog/lookup_catalog or any exclusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
lookup_catalogBInspect
UCP Catalog Lookup — produkty podle ID produktu (g…), ID varianty, katalogového čísla nebo EANu. Vyžaduje meta["ucp-agent"].profile.
| Name | Required | Description | Default |
|---|---|---|---|
| meta | Yes | {"ucp-agent":{"profile":"https://…"}} | |
| catalog | Yes | lookup_request: ids[] (max 50) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description bears the full burden, and it delivers very little: no statement that this is a read-only lookup, no pagination or batching behavior, no error semantics for unknown IDs. The only behavioral fact given (the required meta profile) largely restates the schema's required fields and the schema's own description of meta.
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, front-loaded with the operation and its accepted keys, with no filler. It loses a point for the garbled/truncated '(g…)' fragment that obscures an identifier form.
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, no annotations, and nested request objects, the description should say at least minimally what comes back (record shape, unmatched-ID handling). It covers inputs and auth but leaves the entire response contract unspecified, which is a meaningful gap for an agent planning a call.
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 the baseline would be 3, but the description adds real meaning by telling the agent what the opaque ids[] array actually accepts — product IDs, variant IDs, catalog numbers, or EANs. That is information the schema description ('lookup_request: ids[] (max 50)') does not convey.
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 and resource (catalog lookup of products) and enumerates the lookup keys (product ID, variant ID, catalog number, EAN), so an agent knows exactly what it retrieves. It does not, however, contrast itself with obvious siblings such as get_product or search_catalog, so 4 rather than 5.
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?
It discloses a prerequisite (meta["ucp-agent"].profile is required) and implies usage via listed identifier types, which is useful context. But it never says when to choose this over search_catalog or get_product, and gives no exclusions, so it stays at implied guidance rather than explicit routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
painto_doprava_platbyAInspect
Jak se zboží doveze a jak se dá zaplatit — dopravci, ceny dopravy, doprava zdarma od částky, platební metody.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
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 only restates content topics and does not mention whether the tool is read-only/static, where the information comes from, how current it is, or what format the answer takes. It is not misleading, but it is thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the core question and followed by concrete specifics. Every part is informative and there is no filler or redundancy.
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 informational tool with no output schema or annotations, the description covers the relevant subtopics adequately: carriers, prices, free shipping threshold, and payment methods. A small gap is that it does not explicitly state what the tool returns, but this is not critical for such a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so there are no parameter semantics for the description to clarify; the baseline for 0-parameter tools is 4. The description still adds value by enumerating the information domains the tool covers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's resource: delivery and payment information, and lists concrete subtopics (carriers, shipping prices, free-shipping threshold, payment methods). This differentiates it from siblings like painto_dostupnost, painto_kontakt, and painto_sortiment without needing to open the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool through its topic coverage, but it does not explicitly state when to use it versus alternatives or name any sibling tools. An agent can infer that delivery/payment questions belong here, but the guidance is not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
painto_dostupnostAInspect
Zjisti, kolik kusů konkrétního produktu je skladem. Hledá podle katalogového kódu nebo EANu.
| Name | Required | Description | Default |
|---|---|---|---|
| kod | Yes | Katalogový kód nebo EAN produktu. |
TDQS
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 core behavior—checking stock quantity by code or EAN—but does not explain edge cases, exact return format, or behavior when the code is not found. This is adequate but not richly transparent.
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 no filler or redundancy. Every word contributes meaning: the action, the resource, and the lookup key.
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 single-parameter lookup tool, the description tells the agent what to pass and what it returns (stock quantity). It could add detail about zero-stock or not-found behavior, but the core context needed for correct invocation is present.
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%, and the parameter description already states 'Katalogový kód nebo EAN produktu.' The tool description repeats the same information without adding new semantic detail, 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 uses a concrete action and resource: 'Zjisti, kolik kusů konkrétního produktu je skladem' (find how many pieces of a specific product are in stock). It clearly distinguishes this from siblings like painto_hledej (general search) and painto_sortiment by focusing on stock quantity lookup via catalog code or EAN.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool: when the agent has a catalog code or EAN and needs a stock count. It does not explicitly name alternatives or exclusion cases, so it stops short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
painto_hledejAInspect
Najdi nářadí nebo příslušenství podle názvu, kódu, EANu nebo potřeby (např. "váleček", "špachtle", "maskovací páska", "brusný papír"). Vrací název, cenu s DPH, skladovost a odkaz.
| Name | Required | Description | Default |
|---|---|---|---|
| dotaz | Yes | Co hledáš — název, kód, EAN nebo popis potřeby. | |
| limit | No | Kolik výsledků (1–30, výchozí 10). | |
| jen_skladem | No | true = vrátit jen to, co je fyzicky skladem. Výchozí false. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden and does a good job by stating what the tool returns: name, price incl. VAT, stock availability, and a link. It implicitly communicates a read-only search operation, though it does not cover edge cases such as no results or ordering behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: it states the action, gives representative examples, and then lists the return fields in one additional sentence. Every part earns its place.
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 relatively simple search tool, the description plus fully covered schema gives an agent enough to invoke it correctly. It states the return payload, parameter semantics are documented, and no output schema exists to explain further. A minor gap is the lack of explicit failure/no-result behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents all three parameters with 100% coverage, so the baseline is 3. The description adds value by giving real example values for 'dotaz' such as 'váleček', 'špachtle', and 'maskovací páska', which helps the agent form valid queries.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Najdi nářadí nebo příslušenství') and lists search keys (name, code, EAN, need) with concrete examples. It is easy to understand what the tool does, but it does not explicitly differentiate it from sibling catalog or assortment 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?
The intended use is implied clearly: search for products by various identifiers or needs. However, there is no explicit guidance about when to prefer this tool over painto_sortiment, painto_katalog_pdx, or painto_dostupnost, and no exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
painto_katalog_pdxAInspect
PDX — interaktivní katalog Painto. Zákazník si ve stránkách katalogu odfajfkuje zboží a pošle to jako objednávku nebo poptávku, i bez zakládání účtu. Použij, když se někdo ptá na katalog, ceník, nebo chce objednat víc položek najednou.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full transparency burden. It usefully discloses that the customer can act without creating an account and that the interaction results in an order or inquiry being sent. It does not describe what happens after submission or the exact return behavior, but the added behavioral context is meaningful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only two sentences. The first frames what the tool is and how it behaves, and the second gives the invocation triggers. Every clause adds value, with no filler or redundant schema repetition.
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 catalog tool, the description covers the purpose, user flow, account requirement, and when to use it. The only minor gap is that it does not explicitly state what the agent should return or display to the user, but that is not critical given the interactive nature of the catalog.
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 has zero parameters and the schema is already 100% covered by the empty properties object. The description appropriately adds no parameter details. Per the baseline for no-parameter tools, this is a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific resource (interactive Painto catalog) and explains the core action: customers check off goods and send them as an order or inquiry. It also distinguishes itself from siblings by calling out catalog, price list, and multi-item ordering use cases, which sets it apart from search, availability, and contact 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?
The description gives an explicit trigger condition: 'Use when someone asks for a catalog, price list, or wants to order multiple items at once.' This is clear context for when to invoke the tool. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
painto_kontaktAInspect
Kontakt na Painto.cz — e-shop, kamenná prodejna ve Znojmě, telefon, e-mail, fakturační údaje a podmínky pro velkoodběratele.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations at all, the description carries the full burden of behavioral disclosure. It discloses the data categories involved, but it does not explicitly state the operation (e.g., read-only lookup), the output form, or whether any side effects occur; these are only inferred from the informational nature of the content.
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?
A single compact sentence conveys all relevant categories without filler. It is front-loaded with the key term 'Kontakt' and organized with a dash and commas for readability.
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, no-output-schema informational tool, the description is sufficient: it tells the agent exactly what kind of information will be found. Sibling tool names further disambiguate the context, and no input/output documentation is required.
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 has zero parameters and the input schema is empty, so the baseline is 4. No parameter documentation is needed because there are no inputs to describe.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource as Painto.cz contact information and enumerates concrete contents: e-shop, physical store in Znojmo, phone, e-mail, invoicing data, and wholesale terms. It lacks an explicit action verb such as 'returns' or 'provides', so it stops short of the clearest possible definition, though the resource is clearly distinct from sibling tools like painto_doprava_platby or painto_sortiment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The listed data categories give an agent a clear context for when to select this tool: whenever contact, store, invoicing, or wholesale-condition information is requested. It does not explicitly name alternatives or state when not to use it, but the specificity of the content makes the usage scenario apparent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
painto_sortimentAInspect
Přehled sortimentu e-shopu Painto.cz (malířské a stavební nářadí) — kolik produktů je v nabídce a kolik z nich skladem. Začni tímhle, ať víš, co obchod nabízí.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral disclosure. It discloses that the tool reports counts of products and stock availability, which is useful. However, it does not explicitly state that the operation is read-only, nor describe response format, latency, or any side effects. For a simple overview tool this is adequate but not richly transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single well-structured sentence that front-loads the main purpose, includes the specific metrics, and ends with a clear usage recommendation. No filler or redundant content.
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 tool with no output schema, the description fully explains what the tool does, what information it provides, and when to use it. The sibling tools are not needed to disambiguate because this tool's role as an assortment overview is self-contained. Nothing essential is missing.
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 has zero parameters, so parameter-level documentation is unnecessary. The schema confirms an empty parameter object, and the description adds the relevant context of what the output will summarize. The baseline of 4 for zero-parameter tools 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 clearly states the tool provides an overview of the e-shop assortment with two specific metrics: total products and in-stock products. It names the resource (Painto.cz assortment) and the scope (painting and construction tools), making the purpose understandable. It does not explicitly contrast with siblings, but the purpose is specific enough to stand on its own.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes an explicit usage cue: 'Začni tímhle' (start with this) to learn what the shop offers. This gives clear context for when to call the tool. It does not mention when not to use it or name alternatives, but for a zero-parameter overview tool this is reasonably complete guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_catalogBInspect
UCP Catalog Search (Universal Commerce Protocol 2026-08-25). Hledání v sortimentu Painto.cz; ceny v haléřích (CZK minor units), živá dostupnost. Vyžaduje meta["ucp-agent"].profile.
| Name | Required | Description | Default |
|---|---|---|---|
| meta | Yes | {"ucp-agent":{"profile":"https://…"}} | |
| catalog | Yes | search_request: query, filters{categories[],price{min,max}}, pagination{limit,cursor} |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It does add useful context: prices are returned in haléře/CZK minor units and availability is live, and it discloses an authentication-like prerequisite (agent profile in meta). It still omits whether the call is read-only (implied by 'search'), how results are paginated, and what a failed profile check does.
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?
Very short and front-loaded, but the Czech-language sentence fragments and the parenthetical protocol identifier ('Universal Commerce Protocol 2026-08-25') add noise rather than usable guidance for a general agent. Every clause is terse, but the content-to-signal ratio is mediocre.
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 nested-object search tool with two required params and no output schema, the description is minimally adequate: it names the source, the price unit, and the auth prerequisite. It never explains pagination/cursor behavior or result shape, and the sibling landscape (multiple search-like tools) is left unresolved.
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 both meta and catalog are already documented in the schema, including the nested query/filters/pagination shape. The description adds the price-unit convention and restates the meta profile requirement, but adds no syntax or semantics beyond that. Baseline 3 is appropriate.
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 and resource ('UCP Catalog Search', search of Painto.cz assortment) plus the protocol version, so the agent knows it queries a product catalog. However it gives no differentiation from siblings such as painto_hledej, painto_sortiment, or lookup_catalog, which are not obviously distinguishable from this search 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?
The only usage constraint is a prerequisite ('Vyžaduje meta[ucp-agent].profile'), which tells the agent what must be supplied but not when to choose this tool over painto_hledej or lookup_catalog. No when-not-to-use or alternative routing is given.
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
- Added
get_product - Added
lookup_catalog - Added
search_catalog
6 tool updates
- First observed
painto_doprava_platby - First observed
painto_dostupnost - First observed
painto_hledej - First observed
painto_katalog_pdx - First observed
painto_kontakt - First observed
painto_sortiment
Related MCP Servers
- AlicenseNot gradedqualityBmaintenancePerplexity for social: ask what competitors are running across social and get answers grounded in real ad and creative data, not guesses.2Apache 2.0
- AlicenseCqualityBmaintenanceCompetitor Monitor AI - MCP server providing AI-powered tools and automation by MEOK AI Labs119 npm54 PyPIMIT
- AlicenseAqualityCmaintenanceEnables brand visibility monitoring across major AI platforms like ChatGPT, Claude, Gemini, and Perplexity. It allows users to track visibility scores, analyze competitor data, and receive actionable insights to improve AI-generated brand recommendations.1611 npm1MIT

industrylens-mcpofficial
AlicenseNot gradedqualityBmaintenanceBrowse IndustryLens's published competitive-intelligence reports and head-to-head competitor comparisons from any AI agent — real, source-backed data.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.