Skip to main content
Glama
davillafer

MCP Merchant Scout

by davillafer

Tools

Tool

Description

discover_merchant

Fetch a merchant's /.well-known/ucp profile and register it

search_products

Search for products across all discovered merchants (query is optional, supports price filters)

get_product

Get full details for a specific product

compare_products

Compare 2-5 products side-by-side

Related MCP server: agentic-commerce

Setup

git clone https://github.com/davillafer/mcp-merchant-scout.git
cd mcp-merchant-scout
npm install
npm run build

Claude Code

Create a .mcp.json file in your project directory:

{
  "mcpServers": {
    "ucp-merchant-scout": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-merchant-scout/dist/index.js"]
    }
  }
}

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "ucp-merchant-scout": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-merchant-scout/dist/index.js"]
    }
  }
}

Usage

Once configured, use natural language in Claude:

  1. Discover a merchant: "Discover the merchant at https://puddingheroes.com"

  2. Search products: "Search for products under $20"

  3. Search with keywords: "Find me a sci-fi book"

  4. Get details: "Get details on pudding-heroes-paperback"

  5. Compare: "Compare these two products side by side"

UCP Spec Compatibility

Supports both the official UCP spec (2026-01-23) and legacy implementations:

Feature

Spec support

Legacy fallback

Discovery

/.well-known/ucp

/api/ucp/discovery

Services

Reverse-domain keyed with transport bindings

Flat string paths

Capabilities

Reverse-domain keyed objects

Flat string arrays

Payment handlers

ucp.payment_handlers (keyed object)

payment.handlers (array)

Catalog search

POST /catalog/search

GET /products

Product lookup

POST /catalog/lookup

GET /products/:id

UCP-Agent header

profile="<discovery-url>" (spec format)

The client tries spec-compliant endpoints first and falls back to legacy formats automatically.

Live UCP Merchants

Endpoint

Format

Description

https://puddingheroes.com

Legacy

Public sandbox with 10 products (books, rentals, memberships)

https://ucp-demo-api.hemanthhm.workers.dev

Spec

Community demo with 5 AI gadget products

Development

npm run dev    # Run with tsx (auto-reload)
npm run build  # Compile TypeScript
npm start      # Run compiled output

Architecture

Claude <--stdio--> MCP Server <--HTTP--> Merchant A (/.well-known/ucp -> /catalog/search)
                               <--HTTP--> Merchant B (/.well-known/ucp -> /products)

The server maintains an in-memory registry of discovered merchants. Product searches fan out to all registered merchants in parallel using Promise.allSettled().

Tech Stack

Available Tools

4 tools
compare_productsA

Compare multiple products side-by-side across merchants. Shows pricing, availability, variants, and options for each product. Results are sorted by lowest price.

ParametersJSON Schema
NameRequiredDescriptionDefault
productsYesArray of products to compare (2-5 products)

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description carries the full burden. It discloses one concrete behavioral trait (results sorted by lowest price) and implies a read-only operation via "Shows", but it does not mention authentication requirements, failure behavior, data freshness, or any side effects. This is some value added, but not comprehensive.

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 three short sentences with no fluff. It leads with the action and resource, then lists outputs and sort order, making it easy to scan and 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?

There is no output schema, but the description enumerates the main result fields (pricing, availability, variants, options) and the ordering. The input side is fully covered by the schema. A full return shape is not specified, but the gaps are minor given the tool's simple comparison nature.

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 for the products array, productId, and merchantUrl, so the schema fully documents the parameters. The description adds no parameter-level semantics, keeping this at the baseline score.

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?

"Compare multiple products side-by-side across merchants" uses a specific verb and resource, and clearly separates it from siblings like get_product and search_products. It also names the key result aspects (pricing, availability, variants, options) and the sort order, making its function unambiguous.

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 when to use the tool (when a side-by-side comparison across merchants is needed), but it does not explicitly state when-not-to-use it or contrast it with alternative tools. An agent has to infer the appropriate context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

discover_merchantA

Discover a UCP-enabled merchant by fetching their /.well-known/ucp profile. Returns supported capabilities, services, and payment handlers. The merchant is registered for subsequent search and lookup operations.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesThe base URL of the merchant (e.g. https://store.example.com)

TDQS

A4.2/5.0
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. It discloses the network fetch behavior, the returned data categories, and the side effect of registering the merchant. It does not cover failure modes or persistence details, but is transparent enough for a simple discovery 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?

Two sentences, no filler, with the core action and output front-loaded. Every sentence contributes meaningful context.

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?

For a single-parameter tool, the description covers what it does, what it returns, and the registration side effect. It could mention error behavior for non-UCP-enabled merchants, but the provided information is sufficient for an agent 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 baseline is 3. The description does not add parameter-level detail beyond what the schema already provides for the 'url' parameter, but the schema already explains the base URL format and provides an example.

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 states a specific action ('Discover a UCP-enabled merchant'), the mechanism (fetching the /.well-known/ucp profile), and the expected output (capabilities, services, payment handlers). This clearly distinguishes it from the product-focused sibling tools like search_products and get_product.

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 as a prerequisite: 'The merchant is registered for subsequent search and lookup operations.' This tells the agent when to call it relative to sibling tools, though it does not explicitly name alternatives or state when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_productA

Get full details for a specific product from a UCP merchant, including all variants, pricing, media, and availability.

ParametersJSON Schema
NameRequiredDescriptionDefault
productIdYesThe product ID (e.g. 'gid://shopify/Product/123')
merchantUrlYesThe merchant's base URL (must be previously discovered)

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the behavioral burden. It discloses what data is returned (all variants, pricing, media, availability) and a precondition for merchantUrl, but doesn't mention auth requirements, error behavior, rate limits, or explicit read-only confirmation.

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?

A single, front-loaded sentence with no filler. The verb and object appear first, followed by a compact list of included detail types, making the tool's purpose immediately scannable.

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 low complexity (2 required params, no nested objects) and no output schema, the description covers the main expected return categories and the key prerequisite. It could be more complete with error/not-found behavior, but that is a minor gap for a simple retrieval tool.

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 both params (merchantUrl, productId) are already documented. The description adds no parameter-level detail beyond the schema; it only reiterates the merchant URL must be previously discovered, which is already in 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 uses a specific verb ('Get') and resource ('full details for a specific product from a UCP merchant'), and lists the detail types (variants, pricing, media, availability). The phrase 'specific product' distinguishes it from the sibling search_products, which suggests finding products rather than retrieving one.

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 by stating merchantUrl 'must be previously discovered', hinting that discover_merchant should be run first. However, it does not explicitly state when to use this tool over search_products or compare_products, nor name alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_productsA

Search for products across all discovered UCP merchants (or a specific one). Returns matching products with prices, availability, and merchant info. Requires at least one merchant to be discovered first.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryNoSearch query (e.g. 'mechanical keyboard', 'coffee grinder'). Omit to list all products.
currencyNoCurrency code (default: USD)
maxPriceNoMaximum price filter in dollars (e.g. 150)
merchantNoSpecific merchant URL to search (searches all if omitted)
minPriceNoMinimum price filter in dollars (e.g. 50)

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of behavioral disclosure. It adds useful context by mentioning the merchant-discovery prerequisite and the returned data fields, but it does not explicitly state that the operation is read-only, describe pagination or limits, or explain error behavior when no merchants exist.

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 with no redundant filler. It front-loads the core action and scope, then provides return information and the key prerequisite, making every sentence valuable.

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?

For a search tool with five fully documented optional parameters and no output schema, the description covers the essential return information and prerequisite. It does not mention pagination, result limits, or behavior when no merchant is discovered, but the core calling context is adequately captured.

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%, and the schema already documents each of the five parameters, their types, and examples. The description adds only high-level context about search scope and prerequisites, not additional parameter-level detail, so 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.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource: 'Search for products across all discovered UCP merchants (or a specific one)'. It also states what is returned ('matching products with prices, availability, and merchant info'), which clearly distinguishes it from sibling tools like get_product and compare_products.

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 a clear prerequisite: 'Requires at least one merchant to be discovered first', which signals that discover_merchant must be called before this tool. It does not explicitly name alternative tools or when not to use them, but the singleton search scope and prerequisite establish clear usage context.

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. 4 tool updatesv1.0.0
    • First observedcompare_products
    • First observeddiscover_merchant
    • First observedget_product
    • First observedsearch_products

TDQS

A4.1/5.0

Scored across 4 tools

Disambiguation4/5

Each tool has a distinct primary purpose: discovery, search, detailed lookup, and comparison. There is minor overlap between search_products and compare_products since both return pricing/availability across merchants, but their intents are clear enough to avoid serious misselection.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern using snake_case: discover_merchant, search_products, get_product, compare_products. The naming is predictable and clearly indicates the action and target resource.

Tool Count5/5

Four tools is a well-scoped size for a merchant discovery and product research server. Each tool supports a distinct stage of the workflow without unnecessary bloat or redundancy.

Completeness4/5

The core workflow of discovering merchants, searching products, retrieving details, and comparing across merchants is fully covered. Minor gaps exist, such as no way to list or remove already-discovered merchants, but these do not break the primary use case.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    A custom MCP server that turns Claude into an agentic shopping assistant for searching products, comparing options, managing a cart, and checking out with built-in guardrails for safe autonomous commerce.
    -
  • A
    license
    A
    quality
    C
    maintenance
    A UCP-compliant MCP storefront server that exposes product catalog operations (search, cart, checkout) as MCP tools, following UCP schema version 2026-04-08.
    5
    MIT
  • A
    license
    Not graded
    quality
    F
    maintenance
    MCP server for the BuyWhere product catalog. Lets Claude Desktop, Cursor, Windsurf, and other MCP-compatible agents search and retrieve products without writing any HTTP code.
    71 npm
    MIT