GoBuy Product Trust
Server Details
Marketplace-evidence trust scores for AI agents: a 0-100 Evidence Score with signal breakdown.
- Status
- Healthy
- Uptime
- 100.0% over 23 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 5 tools
Each tool targets a distinct action: analyzing reviews, checking product trust, checking store score, comparing products, and scanning stores. However, check_store_score and scan_store overlap, as both assess stores (check_store_score is a cached/indexed version, scan_store is a fresh crawl fallback), which could cause confusion about which to use when.
All tool names follow a consistent snake_case verb_noun pattern: analyze_reviews, check_product_trust, check_store_score, compare_products, scan_store. The verbs are clear and the naming is predictable throughout.
With 5 tools, the set is well-scoped for a product trust and store scoring service. Each tool appears to serve a distinct purpose without unnecessary bloat.
The tools cover key operations: analyzing reviews, checking product trust, checking store scores, comparing products, and scanning stores live. However, there is no tool to retrieve details for a single listing (e.g., get_listing) or to access historical score data, which could be useful gaps.
Available Tools
5 toolsanalyze_reviewsAInspect
Analyzes up to 100 recent reviews (~30-90 seconds). Bright Data can take longer. On-demand Amazon sampling without your cookie; reviews are sorted within the returned sample, but the provider does not guarantee the listing's newest 100. Cached for seven days. Heuristics do not prove authenticity.
| Name | Required | Description | Default |
|---|---|---|---|
| retailer | Yes | Marketplace containing the listing. | |
| product_id | Yes | Native retailer product ID, such as an Amazon ASIN. | |
| force_refresh | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds substantial behavior beyond the annotations: 30-90 second latency (longer via Bright Data), on-demand sampling without a user cookie, sort ordering only guaranteed within the returned sample, no guarantee that the listing's newest 100 are returned, a 7-day cache, and an explicit disclaimer that heuristics do not prove authenticity. This is unusually rich disclosure for a network-backed tool.
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?
Front-loaded with the most decision-relevant fact (latency and sample size), and each following clause carries a distinct caveat with no filler. Slightly dense run-on phrasing, but nothing is wasted.
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?
Given there is no output schema, the description still arms the agent with the operational facts it needs: duration, sample scope, cache lifetime, sort reliability, and an explicit caveat that the authenticity signal is heuristic. The only missing piece is the shape of the returned analysis, which is a modest gap.
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 67%; retailer and product_id are documented in the schema itself. force_refresh has no description anywhere, and the description only implies its meaning through 'Cached for seven days' without naming or explaining the override. Marginal added value over the schema.
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 (analyzes) and resource (reviews), with scope quantified as 'up to 100 recent reviews' and a hint at the analytical angle (heuristics/authenticity). However, it never says what the analysis actually returns (sentiment, authenticity score, themes), and it does not distinguish itself from the sibling check_product_trust, which sounds like an overlapping review/trust analysis.
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 guidance and no comparison against siblings such as check_product_trust or check_store_score. The only conditional context is operational (on-demand sampling, 7-day cache), not selection guidance for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_product_trustBRead-onlyInspect
Return the indexed 0–100 marketplace-evidence score and complete available signal breakdown for one retailer listing.
| Name | Required | Description | Default |
|---|---|---|---|
| retailer | Yes | Marketplace containing the listing. | |
| product_id | Yes | Native retailer product ID, such as an Amazon ASIN. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and reach profile is covered. The description adds that the score is "indexed 0–100" and that the breakdown is "complete available" signals, hinting that some signals may be absent — useful, but no mention of auth, rate limits, or caching. Adequate against the lower annotated bar.
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 with no filler; the output shape (score plus signal breakdown) is stated immediately and nothing is repeated from the schema or annotations.
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 must convey return values, and it does name both the 0–100 score and the signal breakdown including its partial nature. It stops short of indicating breakdown structure or what an empty signalless listing returns, but this is largely complete for a read-only diagnostic 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?
Schema description coverage is 100%, with both parameters documented (retailer enum meaning, product_id format) and the enum constrained in-schema. The description only implies the two parameters jointly identify "one retailer listing", adding little beyond the schema — baseline 3.
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 ("Return") and resource ("indexed 0–100 marketplace-evidence score and complete available signal breakdown") scoped to "one retailer listing". This implicitly separates it from the store-level sibling check_store_score, though no sibling is named outright.
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 no when-to-use condition, no prerequisites, and does not contrast itself with check_store_score (store vs. single listing) or compare_products. An agent must infer the product-level vs. store-level distinction entirely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_store_scoreBRead-onlyInspect
Get the GoBuy Score for an independent store or Shopify storefront — what AI shopping agents see when they visit: agent-readiness, trust signals, structured data, review system.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read profile is covered by structured data. The description adds the useful context that the score reflects an external agent's view of the storefront (agent-readiness, trust signals, structured data, reviews), but says nothing about auth needs, rate limits, caching, or freshness.
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?
One front-loaded sentence with the verb and resource first, followed by a compact dimension list. No filler, though the em-dash clause is a bit list-heavy without further structure.
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, and the description lists score dimensions but not the shape, scale, or scoring of the returned value. For a single-parameter read tool with annotations covering safety, this is adequate but leaves the agent guessing what a 'GoBuy Score' result actually contains.
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 single 'domain' parameter is only constrained by a regex pattern with no prose. The description hints at acceptable targets ('independent store or Shopify storefront'), which implies any public domain works, but never explains the domain format (bare host vs. URL vs. www).
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 ('Get the GoBuy Score for an independent store or Shopify storefront') and enumerates the score's dimensions, so the agent knows what comes back. It does not distinguish itself from siblings like scan_store or check_product_trust, and 'GoBuy Score' is a proprietary term that is only loosely defined by the trailing list.
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 guidance and no routing against the siblings (scan_store, compare_products, check_product_trust). The reader must infer that this is the per-store evaluation call versus a store scan or a product-level trust check.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compare_productsARead-onlyInspect
Compare 2–20 retailer listings and rank them by marketplace-evidence score. This is not purchase advice.
| Name | Required | Description | Default |
|---|---|---|---|
| products | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the 2–20 input range and a disclaimer about interpretation, but says nothing about rate limits, cross-retailer availability, or how the evidence score is derived.
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 tight sentences, zero filler, with the scope and ranking behavior front-loaded and the caveat last. Every clause 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 read-only tool with no output schema, the description should describe what comes back; "rank them by marketplace-evidence score" hints at ordering but not the response shape or how many results return. Adequate but with a clear gap on return values.
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?
Top-level schema coverage is 0% for the single `products` parameter, so the description carries some burden; "2–20 retailer listings" conveys the array shape and cardinality. However, the nested retailer/product_id fields are documented in the schema, so the description adds only marginal value beyond 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 names a specific verb (compare) and resource (2–20 retailer listings) and states the ranking basis (marketplace-evidence score). It is distinguishable from siblings like check_store_score and check_product_trust by resource, though it never names or contrasts them explicitly.
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?
"This is not purchase advice" sets a useful boundary on interpretation, but there is no positive guidance on when to reach for this tool versus check_product_trust or check_store_score. Usage is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_storeAInspect
Score any online store live with a fresh crawl (~20 seconds). Use when check_store_score returns 404. Docs: https://docs-gobuy.pages.dev
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds genuinely new context: the operation performs a live external crawl, takes ~20 seconds, and returns fresh (non-cached) data, plus a docs link. It does not describe failure modes beyond the 404 trigger, so not a 5.
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 compact clauses: what it does, the latency cost, when to use it, and where docs live. Front-loaded with the action and cost, 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?
No output schema and one simple parameter, so the description needs only to convey purpose, latency, and trigger — all present. Minor gap: it never states what the returned 'score' looks like in shape or range.
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% for the single url parameter, so the description must carry the burden. 'any online store' loosely implies url is a store URL, but no accepted format, normalization, or domain constraints are given. Marginal compensation over the bare schema.
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 (score) and resource (online store) with the key qualifier 'live with a fresh crawl', which cleanly differentiates it from the cached check_store_score sibling. An agent can tell what this does without opening 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?
Explicitly names the alternative (check_store_score) and the exact condition that selects this tool instead (returns 404). This is a concrete routing rule, not implied usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
- Added
analyze_reviews
2 tool updates
- Added
check_store_score - Added
scan_store
2 tool updates
- First observed
check_product_trust - First observed
compare_products
Related MCP Connectors
Evidence-first trust verdicts for AI-agent services — query one before you transact.
Independent AI-agent reviews: trust checks, evidence scorecards, incident registry, recommendations.
Trust signals for AI agents: an open agent-readiness standard and developer tool guide. Read-only.
AI-agent trust infrastructure for discovery, authority, execution, verification, and receipts.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceTrust and reputation system for AI agents, enabling tracking, verifying, and building trust through scores, interactions, ratings, and reports.MIT
- AlicenseNot gradedqualityNot gradedmaintenanceProvides AI agents with trust scoring and reputation management capabilities for secure interactions. Enables agents to check trust scores, rate interactions, and manage disputes before transacting with other agents.-
- AlicenseNot gradedqualityBmaintenanceEvidence-weighted trust graph for multi-agent systems. Enables querying trust and gating high-risk actions based on time-decayed evidence and endorsements.MIT

RNWY MCP Serverofficial
FlicenseNot gradedqualityFmaintenanceProvides trust intelligence for AI agents across 12 chains, including sybil detection, reviewer wallet analysis, and risk tiers, with tools for trust checks, reviewer analysis, and agent comparison.-
Glama MCP Gateway
Add one secure layer between your agents and this server.