Kaupia
Server Details
An Amazon for AI agents: search, compare and buy real products from real stores.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 5 tools
Each tool targets a distinct action in the shopping lifecycle: search_products (discovery), get_product (single product inspection), create_checkout (purchase start), report_outcome (feedback), and shop_scorecard (shop trust metrics). The only near-pair is search_products vs get_product, but the descriptions clearly delimit them—search returns ranked candidates, get_product must be called per product_id before quoting a variant.
Four of five tools follow a clean verb_noun snake_case pattern (create_checkout, get_product, report_outcome, search_products). shop_scorecard breaks the pattern by being noun-only, a minor but noticeable deviation in an otherwise consistent set.
Five tools is well-scoped for a product-search-and-checkout domain—discover, inspect, purchase, report, and assess trust. Each tool has a clear, non-redundant role, with no filler.
The surface covers a full discover → inspect → checkout → report → trust loop. The main gap is no way to retrieve an existing checkout's state (e.g. get_checkout or list_checkouts), forcing the agent to hold checkout_id externally and relying solely on report_outcome for status.
Available Tools
5 toolscreate_checkoutAInspect
Start a purchase. v0 returns the merchant's checkout link for the chosen variant plus a Kaupia checkout_id. Keep the checkout_id and call report_outcome later so the order is covered and ranked.
| Name | Required | Description | Default |
|---|---|---|---|
| agent | No | unknown | |
| quantity | No | ||
| product_id | Yes | ||
| variant_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden and does disclose key return behavior: a merchant checkout link plus checkout_id, and the required follow-up call to report_outcome. However, it does not mention side effects, permissions, idempotency, or error behavior for a purchase-creating operation.
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 two tight sentences with the primary action and return information front-loaded. Every sentence contributes useful context about the returned checkout_id and the required report_outcome follow-up.
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?
The description covers the core workflow and output identifiers, and an output schema exists, so return values need not be fully restated. Still, for a four-parameter, zero-coverage schema with no annotations, it leaves important parameter and safety details unexplained.
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 0%, so the description must compensate for undocumented parameters. It references a chosen variant, but does not explain product_id, variant_id, quantity, or agent semantics, leaving most parameters without added 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?
The description clearly states that this tool starts a purchase and creates a checkout, returning a merchant checkout link and Kaupia checkout_id. It distinguishes the later reporting step via report_outcome, though it does not explicitly contrast with search_products or get_product.
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 gives clear usage context: start a purchase, keep the checkout_id, and call report_outcome afterward so the order is covered and ranked. It names the follow-up tool explicitly, but does not provide exclusions or guidance against alternative tools for related tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_productCInspect
Live details for one product: variants, price, stock status, checkout links.
| Name | Required | Description | Default |
|---|---|---|---|
| agent | No | unknown | |
| country | No | US | |
| product_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden. It says 'Live details' and lists returned data categories, but does not state read-only/non-destructive behavior, auth requirements, rate limits, or freshness guarantees.
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?
Single sentence, front-loaded with purpose and return categories, with no filler. Every phrase contributes to the description.
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?
Output schema exists, so return values needn't be explained. But with no annotations and 0% parameter description coverage, the definition leaves calling semantics such as product_id format and country/agent effects unaddressed, which is not complete enough for reliable invocation.
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 0%, and the description does not mention product_id, country, or agent. It adds no meaning for any of the three parameters.
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 and makes the single-product scope explicit, so it is clearly distinguishable from search_products. It does not name the sibling it contrasts with, but the scope is clear.
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?
No when-to-use, when-not-to-use, prerequisite, or alternative guidance is provided. The only usage signal is the implied single-product lookup from 'one product'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
report_outcomeCInspect
Report what happened to a checkout: placed | delivered | wrong_item | late | refunded | failed.
| Name | Required | Description | Default |
|---|---|---|---|
| note | No | ||
| outcome | Yes | ||
| checkout_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It discloses the valid outcome categories, which is useful, but says nothing about mutation effects, idempotency, permissions, error behavior, or what happens to an existing checkout outcome.
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 compact sentence with no filler, and the critical allowed values are front-loaded. It is appropriately sized for a simple reporting tool.
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?
An output schema exists, so return values need less description, but the definition remains thin for a three-parameter mutation tool with no annotations and no schema descriptions. It omits when to use the tool, what checkout_id identifies, what note is for, and what effect reporting has.
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 0%, so the description must compensate. It usefully enumerates the allowed outcome values even though the schema defines outcome only as a plain string, but it does not explain checkout_id or note, leaving two of three parameters without added 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?
The description gives a specific verb, 'Report', and a specific resource, 'what happened to a checkout', making the tool's job clear. It also lists valid outcome values, but it does not explicitly distinguish this tool from siblings such as create_checkout or shop_scorecard.
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 this is used after a checkout event, but it gives no explicit guidance on when to call it versus alternatives. It names no exclusions, prerequisites, or sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_productsBInspect
Search products for a buyer intent. Returns ranked candidates with price, availability and product_id. Call get_product(product_id) before quoting a specific variant. Prices in major units (USD).
| Name | Required | Description | Default |
|---|---|---|---|
| agent | No | unknown | |
| limit | No | ||
| query | Yes | ||
| country | No | US | |
| max_price_usd | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 disclose return content (ranked candidates, price, availability, product_id) and that prices are in major USD units, but it says nothing about read-only semantics, auth requirements, rate limits, or how ranking is determined.
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?
Three short sentences, front-loaded with purpose and result shape, then the chaining rule and the unit convention. Each sentence carries information; no filler.
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?
An output schema exists, so explaining return values isn't required, and the chaining rule covers the main invocation pitfall. But for a five-parameter search tool with zero schema coverage, missing guidance on limit defaults, country scoping, and the agent field leaves the definition incomplete for correct invocation.
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 0% across five parameters, so the description must compensate and largely doesn't. It clarifies price units for max_price_usd but leaves country, limit, and agent — which materially change results and result count — entirely unexplained in both schema and description.
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 gives a specific verb and resource ('Search products') plus the intent it serves ('for a buyer intent') and the shape of the result (ranked candidates with price, availability, product_id). It names get_product as the follow-up tool, though it doesn't differentiate itself from shop_scorecard or report_outcome.
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?
'Call get_product(product_id) before quoting a specific variant' is an explicit workflow rule that tells the agent when to chain into a sibling rather than trusting search results alone. No exclusion or when-not guidance is given, 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.
shop_scorecardBInspect
Per-shop outcome stats collected through Kaupia (delivered vs problems).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations at all, the description carries the full disclosure burden. The framing ('stats collected through Kaupia') implies a read-only aggregate, and the presence of an output schema covers the return shape, but nothing states scope (all shops vs one shop), time window, freshness, or permissions.
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 tight sentence with the most informative element ('per-shop outcome stats') front-loaded and no filler. It is efficient but so terse that useful scope details are omitted rather than wastefully stated.
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 with an output schema, the description covers what the data represents, which is the main thing needed. It is still thin on aggregation scope and timeframe, which matters for interpreting a scorecard.
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?
Zero parameters, so the baseline is 4 and there is no schema semantics to add. The only mild gap is that the name implies per-shop data yet the tool accepts no shop identifier, leaving the caller to wonder how shop scoping is applied.
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 — per-shop outcome stats, split into delivered vs problems — sourced from Kaupia, which is enough to distinguish it from report_outcome (which writes outcomes) and search_products. It lacks an explicit verb, so an agent must infer this is a retrieval tool rather than a reporting endpoint.
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?
No guidance on when to call this versus report_outcome, or versus any product-discovery sibling. The reader has to guess whether scorecards are fetched before or after reporting outcomes, and there is no stated prerequisite for data to exist.
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.
5 tool updates
- First observed
create_checkout - First observed
get_product - First observed
report_outcome - First observed
search_products - First observed
shop_scorecard
Related MCP Connectors
AI agent product discovery via open marketplace. Search, compare and discover advertiser products.
The E-commerce Marketplace For Every AI Agent. A Governed Catalog Of 600M+ US Products, Plus Four Agent Ready Capabilities Search, Price Comparison, Product-Vs-Product, And Detailed Q&A.
Product search for AI agents: Amazon + Shopify, cart-to-checkout buy path. Pay-per-call, no API key.
AI-agent product catalog: search, lookup & purchase routing over verified merchant data.
Related MCP Servers
- FlicenseNot gradedqualityBmaintenanceEnables AI agents to search and compare products across multiple retailers, build carts, and propose purchases that only a human can authorise, with a self-hosted control panel.-
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to search products across Amazon and live Shopify storefronts, vet merchants, build carts, and obtain checkout URLs via a pay-per-call API with no API key or signup.MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to search, compare, buy, and sell products across multiple e-commerce platforms through 13 marketplace tools.1MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to discover, price, and purchase SaaS products, developer tools, and MCP servers with live Stripe checkout, affiliate program, and AgentTrust verification.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.