Search and compare 26,000+ UK electronics products across multiple retailers including AO.
Get real-time prices, stock availability, and price comparison across retailers in a single search. Covers laptops, phones, tablets, headphones, TVs, monitors, cameras, gaming, and more.
Scored across 2 tools
get_product and search_products have clearly distinct purposes: one retrieves full details for a single product, the other searches and filters the catalog. The descriptions explicitly guide when to use each, with no real overlap in intent.
Both tools follow a consistent verb_noun snake_case pattern (get_product, search_products). This is predictable and easy to parse.
With only two tools, the set feels thin for a domain involving search, specs, pricing, and retailer offers. While each tool is powerful, the low count borders on insufficient for the apparent complexity.
The core read workflows—searching, filtering, retrieving details, and comparing offers—are covered. Minor gaps exist, such as no explicit tool to list categories or brands, but agents can work around this using the search tool's guidance.
Get full details for a single product by ID. Returns attributes: structured specs read from retailer titles, each name mapping to {status, value, sources}; a conflicting one has values: [{value, sources}] instead of value and sources. Names and units as in the search constraints argument. status: 'confirmed' = two or more retailers state the same value; 'inferred' = one retailer's title states it; 'conflicting' = retailers state different values (none is picked, tell the user they disagree; a retailer can appear under two values, so read offers[].title to see which listing states which); a missing name = unknown. Also returns specs.description, the retailer's own prose: use it only for details attributes do not cover (processor, GPU, ports, weight, battery, features); if it doesn't give a detail, tell the user it isn't listed. It can describe another configuration or a maximum ('up to 32GB'), so it never overrides or fills in an attribute: if an attribute is missing or conflicting, that spec is unknown or unconfirmed, and you may mention what the description says only as 'the retailer's description mentions X, unconfirmed'. It also returns pricing, availability, delivery time, and all retailer offers with per-retailer pricing (offers[].stock is a unit count only when the retailer supplies one, otherwise null). Accepts both canonical product IDs and original retailer offer IDs. Use this after search_products only for your final 1-3 picks, and only when you need what search lacks: details only the description has, or every retailer's offer and buy link. Search results already carry attributes to compare specs.
| Name | Required | Description | Default |
|---|---|---|---|
| product_id | Yes | The unique product ID from search results |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only cover the safe-read profile (readOnly, idempotent, non-destructive); the description goes far beyond them, disclosing the return shape of `attributes`, the meaning of each `status` value, how to behave on conflicts ('tell the user they disagree'), that a retailer can appear under two values, and strict rules for treating specs.description as non-authoritative. This is unusually rich behavioral guidance.
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?
Purpose and scope are front-loaded, and nearly every sentence carries semantic payload (status meanings, conflict handling, description caveats). It is dense and long, but the length is largely justified by the absence of an output schema; only minor tightening is possible.
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?
There is no output schema, so the description carries the full burden of explaining return values — and it does: attributes structure, status semantics, specs.description caveats, plus pricing, availability, delivery time, and offers[].stock nullability. Nothing an agent needs to call and interpret this tool correctly 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?
Schema coverage is 100% for the single required parameter, so the baseline is 3. The description adds real value on top: it states the tool 'Accepts both canonical product IDs and original retailer offer IDs,' which the schema's 'unique product ID from search results' 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?
Opens with a specific verb+resource+scope: 'Get full details for a single product by ID.' It also names the sibling search_products and states the relationship ('Use this after search_products only for your final 1-3 picks'), so an agent can distinguish it from search without opening either 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?
Explicit when-to-use and when-not-to-use: only after search_products, only for the final 1-3 picks, and only when you need what search lacks (description-only details or all retailer offers/buy links). It even notes that search results already carry `attributes`, removing the main reason an agent might over-call this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
HOW TO CALL THIS TOOL — read before every call: Decompose the user's request into filters first. Only what's left over goes in query. STEP 1: brand name → brand filter. STEP 2: product category → category filter. STEP 3: price → min_price/max_price. STEP 4: RAM, storage, screen size, resolution, refresh rate, wattage, Wi-Fi generation → constraints. STEP 5: what remains → query. BAD: query='Sony headphones under £200' | GOOD: brand='Sony', category='Headphones', max_price=200, no query. BAD: query='tablet' | GOOD: category='Tablets', no query. BAD: query='macbook neo' | GOOD: brand='Apple', category='Laptops', query='neo'. BAD: query='Samsung QLED TV' | GOOD: brand='Samsung', category='TVs', query='qled'. If brand+category alone cover what the user wants, omit query entirely. Only put differentiating terms in query: model lines (neo, ultra, oled), variants, model numbers (WH-1000XM5, s25 ultra). Query words must appear in the title, except words naming the category ('router' in Networking) and bare numbers or specs ('4070', '16GB'), which are ignored when finding products and only rank them. Put a model number with its prefix ('RTX 4070', not '4070') and check each title for it. Leave out use-case words like gaming, cheap or best. CROSS-CATEGORY NOTE: Gaming headsets → category='Headphones', query='gaming headset'. The Gaming category is consoles/controllers/accessories only. Always set lite=true (it still carries attributes). If 0 results, broaden the query or drop filters (but never present a near miss as meeting a requirement). Searches 26,000+ UK electronics products across 7 retailers with price comparison. Prices are in GBP. Every listing is new (refurbished and used are excluded). PRICE COMPARISON: for a final pick with offer_count > 1, get_product returns offers[] (sorted in-stock first, then cheapest): show the cheapest in-stock retailer, the other prices with the difference and the exact saving among in-stock offers. Before claiming a saving, read offers[].title (from get_product): they must name the same model; if they differ, don't claim one. Before recommending any pick, check its title is the product type asked for (not a cable, accessory or adapter). COMPARING SPECS: compare products from the attributes in the search results, not by calling get_product on each. Every spec known for a product is there as {status, value}, or {status, values} when conflicting, without sources; names and units are as in constraints. 'confirmed' (two or more retailers state the same value) and 'inferred' (one retailer's title states it) are both the product's spec: state the value. Only conflicting (retailers disagree: say so, don't pick one) or a missing name (unknown) needs a caveat. A product with no attributes has none of these seven specs known: say so only if the user asked about one. Call get_product only for your final 1-3 picks, and only when you need what search lacks: what only the retailer's description has (processor, GPU, ports, weight, battery), or every retailer's offer and buy link (search results carry only the best offer's purchase_url (cheapest in stock)). A pick with offer_count 1 needs no call unless the user asked for a description-only detail. Don't guess those details from titles. SPEC REQUIREMENTS: put exact requirements in constraints, not in query, and always set category (and brand if known) with constraints: a search of only specs is rejected. If a requirement is ambiguous (e.g. '16GB' could be RAM or storage), ask the user or search without that constraint. With constraints, every product has constraint_status per name: 'matched' = a retailer's title states a value that meets it. 'unverified' = not known to meet it: check attributes[name], where conflicting means retailers disagree and missing means unknown. Never treat 'unverified' as a match or say a product meets a requirement because it was returned: tell the user it is unconfirmed. Products whose stated value fails are left out (excluded_by_constraints). Matched results come first, also with sort='price_asc'. With constraints, total counts the products that match every constraint and unverified_total the unverified products that passed the other filters (only some may be in products). If total is 0, say no product is known to meet every requirement and offer the unverified ones only as unconfirmed. If candidates_truncated is true, the first 2,000 candidates in the chosen sort order were checked and more exist: add a brand or category, or a narrower query, and search again before saying nothing matches. If the search was already narrowed, tell the user the results may be incomplete. STOCK: availability is in_stock, low_stock, out_of_stock or unknown (the retailer gave no stock signal: say so, don't assume). When availability is out_of_stock, mention it as an alternative and suggest checking back — do not silently omit it. purchase_url is a trustrails.app/go/ redirect through an affiliate link; TrustRails may earn a commission, and the price is the same. Colour variants have separate barcodes and are separate products: when price matters, search again without the colour or check other colours of the same model.
| Name | Required | Description | Default |
|---|---|---|---|
| lite | No | Return trimmed product objects with only essential fields (id, title, brand, price, currency, availability, image_url, purchase_url, offer_count, attributes (every known spec as {status, value}, without sources) and, with constraints, constraint_status). Always set to true; it still carries attributes. Use false only for ean, category, provenance or all sources at once. | |
| sort | No | Sort order: 'relevance' (default), 'price_asc' (in stock first, then cheapest), 'price_desc' (in stock first, then most expensive). | |
| brand | No | Filter by brand name (exact match, case-insensitive). Examples: Apple, Samsung, Sony, HP, Dell, Lenovo, Anker, Bose, LG | |
| limit | No | Maximum number of products to return (default 50, max 100) | |
| query | No | Refinement terms ONLY — model lines, series, variants, model numbers (e.g. 'neo', 'ultra', 'oled', 'WH-1000XM5', 's25 ultra'). NEVER a category name: BAD query='tablet', query='smartwatch', query='laptop'. Set the category filter instead. NEVER a brand name: BAD query='Sony'. Set the brand filter instead. NEVER a price. Omit entirely when browsing a category or brand — 'show me tablets' = category='Tablets', no query. | |
| category | No | Filter by product category. Use ONLY these exact values: Laptops, Desktops, Tablets, Phones, TVs, Monitors, Headphones, Speakers, Cameras, Keyboards, Mice, Printers, Networking, Storage, Gaming, Wearables, Drones, Audio, Cables & Chargers. NOTE: 'Smartphones' is not valid — use 'Phones'. 'Televisions' is not valid — use 'TVs'. | |
| max_price | No | Maximum price in GBP. | |
| min_price | No | Minimum price in GBP. | |
| constraints | No | Hard spec requirements, checked per product against its attributes. Shape {name: {op: number}} with op eq, gte or lte; a range is {gte, lte}. On every operator, storage matches within 3% and screen size within 0.5 inch; a whole-number screen size N also covers up to N+1 on eq and lte (gte is unchanged); other specs exactly: gte 1024 accepts a 1TB drive, eq 22 a 21.5" screen, eq 13 a 13.6" one, lte 15 a 15.6" one. Example: {"memory_gb": {"gte": 24}, "storage_gb": {"gte": 1000}, "screen_in": {"eq": 15}}. Names and units: memory_gb (RAM, GB), storage_gb (GB, 1TB = 1000), screen_in (inches), resolution_p (pixels high: 4K = 2160, QHD = 1440, Full HD = 1080), refresh_hz (Hz), power_w (W), wifi_gen (Wi-Fi generation: 6, 6E = 6.5, 7). A spec written in query counts only when it says what it is ('24GB RAM', '1TB', '144Hz', '55"') and means at least, except screen size (that size); a bare '24GB' stays a search word. Explicit constraints win over it. A plain '16GB' or '65W' is gte; use eq only when the user says exactly, and for screen size. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly/idempotent/non-destructive, yet the description adds substantial context beyond them: the affiliate redirect and commission disclosure, stock-state semantics including 'unknown', the meaning of constraint_status and unverified_total, candidates_truncated truncation behavior, and the rule that excluded_by_constraints products are dropped. This is well past what the annotations carry.
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 critical guidance is front-loaded under a HOW TO CALL header, but the text is roughly a thousand words with the BAD/GOOD example pattern repeated four times and query rules restated in both description and schema. It is dense and mostly earns its place, but it is substantially over-sized for a search tool and would benefit from compression.
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 carries the full burden of explaining returns and does so thoroughly: lite field contents, attributes as {status, value} with confirmed/inferred/conflicting semantics, constraint_status values, total versus unverified_total, availability states, and purchase_url. Nothing an agent needs to interpret a response 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?
Schema description coverage is 100%, so the schema already documents lite, sort, category enums and the constraints shape in detail, setting a baseline of 3. The description nonetheless adds value the schema does not: the five-step decomposition workflow that maps user phrasing onto specific parameters, and the instruction to always set lite=true. Some of the query/brand/price exclusions are duplicated from the schema rather than extending it.
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 (searches 26,000+ UK electronics products across 7 retailers with price comparison) and explicitly positions itself against its only sibling, telling the agent to reserve get_product for the final 1-3 picks. An agent can tell the two apart without opening either 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?
It gives an explicit decision procedure for routing terms between query, brand, category and constraints, names when query should be omitted entirely, and states when to call get_product versus when a search alone suffices. Exclusions and alternatives are both spelled out rather than implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
search_products2 fields changedInput schema / properties / constraints / descriptionPrevious value: -"Hard spec requirements, checked per product against its attributes. Shape {name: {op: number}} with op eq, gte or lte; a range is {gte, lte}. On every operator, storage matches within 3% and screen size within 0.5 inch; a whole-number screen size N also covers up to N+1 on eq and lte (gte is unchanged); other specs exactly: gte 1024 accepts a 1TB drive, eq 22 a 21.5\" screen, eq 13 a 13.6\" one, lte 15 a 15.6\" one. Example: {\"memory_gb\": {\"gte\": 24}, \"storage_gb\": {\"gte\": 1000}, \"screen_in\": {\"eq\": 15}}. Names and units: memory_gb (RAM, GB), storage_gb (GB, 1TB = 1000), screen_in (inches), resolution_p (pixels high: 4K = 2160, QHD = 1440, Full HD = 1080), refresh_hz (Hz), power_w (W), wifi_gen (Wi-Fi generation: 6, 6E = 6.5, 7). A spec written in query counts only when it says what it is ('24GB RAM', '1TB', '144Hz', '55\"') and means at least, except screen size (that size); a bare '24GB' stays a search word. Explicit constraints win over it."New value: +"Hard spec requirements, checked per product against its attributes. Shape {name: {op: number}} with op eq, gte or lte; a range is {gte, lte}. On every operator, storage matches within 3% and screen size within 0.5 inch; a whole-number screen size N also covers up to N+1 on eq and lte (gte is unchanged); other specs exactly: gte 1024 accepts a 1TB drive, eq 22 a 21.5\" screen, eq 13 a 13.6\" one, lte 15 a 15.6\" one. Example: {\"memory_gb\": {\"gte\": 24}, \"storage_gb\": {\"gte\": 1000}, \"screen_in\": {\"eq\": 15}}. Names and units: memory_gb (RAM, GB), storage_gb (GB, 1TB = 1000), screen_in (inches), resolution_p (pixels high: 4K = 2160, QHD = 1440, Full HD = 1080), refresh_hz (Hz), power_w (W), wifi_gen (Wi-Fi generation: 6, 6E = 6.5, 7). A spec written in query counts only when it says what it is ('24GB RAM', '1TB', '144Hz', '55\"') and means at least, except screen size (that size); a bare '24GB' stays a search word. Explicit constraints win over it. A plain '16GB' or '65W' is gte; use eq only when the user says exactly, and for screen size."Input schema / properties / lite / descriptionPrevious value: -"Return trimmed product objects with only essential fields (id, title, brand, price, currency, availability, image_url, purchase_url, offer_count and, with constraints, constraint_status and the status and value of the constrained names). Always set to true unless full product objects are needed."New value: +"Return trimmed product objects with only essential fields (id, title, brand, price, currency, availability, image_url, purchase_url, offer_count, attributes (every known spec as {status, value}, without sources) and, with constraints, constraint_status). Always set to true; it still carries attributes. Use false only for ean, category, provenance or all sources at once."search_products1 field changedInput schema / properties / sort / descriptionPrevious value: -"Sort order: 'relevance' (default), 'price_asc' (cheapest first), 'price_desc' (most expensive first)."New value: +"Sort order: 'relevance' (default), 'price_asc' (in stock first, then cheapest), 'price_desc' (in stock first, then most expensive)."search_products1 field changedInput schema / properties / constraints / descriptionPrevious value: -"Hard spec requirements, checked per product against its attributes. Shape {name: {op: number}} with op eq, gte or lte; a range is {gte, lte}. On every operator, storage matches within 3% and screen size within 0.5 inch; other specs exactly: gte 1024 accepts a 1TB drive, eq 22 a 21.5\" screen. Example: {\"memory_gb\": {\"gte\": 24}, \"storage_gb\": {\"gte\": 1000}, \"screen_in\": {\"eq\": 15}}. Names and units: memory_gb (RAM, GB), storage_gb (GB, 1TB = 1000), screen_in (inches), resolution_p (pixels high: 4K = 2160, QHD = 1440, Full HD = 1080), refresh_hz (Hz), power_w (W), wifi_gen (Wi-Fi generation: 6, 6E = 6.5, 7). A spec written in query counts only when it says what it is ('24GB RAM', '1TB', '144Hz', '55\"') and means at least, except screen size (that size); a bare '24GB' stays a search word. Explicit constraints win over it."New value: +"Hard spec requirements, checked per product against its attributes. Shape {name: {op: number}} with op eq, gte or lte; a range is {gte, lte}. On every operator, storage matches within 3% and screen size within 0.5 inch; a whole-number screen size N also covers up to N+1 on eq and lte (gte is unchanged); other specs exactly: gte 1024 accepts a 1TB drive, eq 22 a 21.5\" screen, eq 13 a 13.6\" one, lte 15 a 15.6\" one. Example: {\"memory_gb\": {\"gte\": 24}, \"storage_gb\": {\"gte\": 1000}, \"screen_in\": {\"eq\": 15}}. Names and units: memory_gb (RAM, GB), storage_gb (GB, 1TB = 1000), screen_in (inches), resolution_p (pixels high: 4K = 2160, QHD = 1440, Full HD = 1080), refresh_hz (Hz), power_w (W), wifi_gen (Wi-Fi generation: 6, 6E = 6.5, 7). A spec written in query counts only when it says what it is ('24GB RAM', '1TB', '144Hz', '55\"') and means at least, except screen size (that size); a bare '24GB' stays a search word. Explicit constraints win over it."search_products3 fields changedInput schema / properties / category / descriptionPrevious value: -"Filter by product category. Use ONLY these exact values: Laptops, Desktops, Tablets, Phones, TVs, Monitors, Headphones, Speakers, Cameras, Keyboards, Mice, Printers, Networking, Storage, Gaming, Wearables, Drones, Audio, Cables & Chargers. NOTE: 'Smartphones' is not valid — use 'Phones'. 'Televisions' is not valid — use 'TVs'. For TVs, use query: 'smart TV' — it returns far more results than 'TV' alone. Avoid query: 'television'."New value: +"Filter by product category. Use ONLY these exact values: Laptops, Desktops, Tablets, Phones, TVs, Monitors, Headphones, Speakers, Cameras, Keyboards, Mice, Printers, Networking, Storage, Gaming, Wearables, Drones, Audio, Cables & Chargers. NOTE: 'Smartphones' is not valid — use 'Phones'. 'Televisions' is not valid — use 'TVs'."Input schema / properties / constraintsAdded value: +{
+ "description": "Hard spec requirements, checked per product against its attributes. Shape {name: {op: number}} with op eq, gte or lte; a range is {gte, lte}. On every operator, storage matches within 3% and screen size within 0.5 inch; other specs exactly: gte 1024 accepts a 1TB drive, eq 22 a 21.5\" screen. Example: {\"memory_gb\": {\"gte\": 24}, \"storage_gb\": {\"gte\": 1000}, \"screen_in\": {\"eq\": 15}}. Names and units: memory_gb (RAM, GB), storage_gb (GB, 1TB = 1000), screen_in (inches), resolution_p (pixels high: 4K = 2160, QHD = 1440, Full HD = 1080), refresh_hz (Hz), power_w (W), wifi_gen (Wi-Fi generation: 6, 6E = 6.5, 7). A spec written in query counts only when it says what it is ('24GB RAM', '1TB', '144Hz', '55\"') and means at least, except screen size (that size); a bare '24GB' stays a search word. Explicit constraints win over it.",
+ "properties": {
+ "memory_gb": {
+ "properties": {
+ "eq": {
+ "type": "number"
+ },
+ "gte": {
+ "type": "number"
+ },
+ "lte": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "power_w": {
+ "properties": {
+ "eq": {
+ "type": "number"
+ },
+ "gte": {
+ "type": "number"
+ },
+ "lte": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "refresh_hz": {
+ "properties": {
+ "eq": {
+ "type": "number"
+ },
+ "gte": {
+ "type": "number"
+ },
+ "lte": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "resolution_p": {
+ "properties": {
+ "eq": {
+ "type": "number"
+ },
+ "gte": {
+ "type": "number"
+ },
+ "lte": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "screen_in": {
+ "properties": {
+ "eq": {
+ "type": "number"
+ },
+ "gte": {
+ "type": "number"
+ },
+ "lte": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "storage_gb": {
+ "properties": {
+ "eq": {
+ "type": "number"
+ },
+ "gte": {
+ "type": "number"
+ },
+ "lte": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ "wifi_gen": {
+ "properties": {
+ "eq": {
+ "type": "number"
+ },
+ "gte": {
+ "type": "number"
+ },
+ "lte": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ },
+ "type": "object"
+}Input schema / properties / lite / descriptionPrevious value: -"Return trimmed product objects with only essential fields (id, title, brand, price, currency, availability, image_url, purchase_url, offer_count). Always set to true unless full product objects are needed."New value: +"Return trimmed product objects with only essential fields (id, title, brand, price, currency, availability, image_url, purchase_url, offer_count and, with constraints, constraint_status and the status and value of the constrained names). Always set to true unless full product objects are needed."search_products1 field changedInput schema / properties / query / descriptionPrevious value: -"The refinement terms after brand and category are extracted. Use for model lines, series names, variants, or model numbers (e.g. 'neo', 'ultra', 'oled', 'WH-1000XM5'). DO NOT include brand names or prices — use filters. Omit entirely if brand + category fully describe what the user wants."New value: +"Refinement terms ONLY — model lines, series, variants, model numbers (e.g. 'neo', 'ultra', 'oled', 'WH-1000XM5', 's25 ultra'). NEVER a category name: BAD query='tablet', query='smartwatch', query='laptop'. Set the category filter instead. NEVER a brand name: BAD query='Sony'. Set the brand filter instead. NEVER a price. Omit entirely when browsing a category or brand — 'show me tablets' = category='Tablets', no query."get_productsearch_products
Add one secure layer between your agents and this server.