MCP for eCommerce

Model Context Protocol (MCP) is an open-source protocol released by Anthropic in November 2024 that standardizes how large language models connect to external data sources and tools. An MCP server exposes structured first-party data — catalog, inventory, sizing logic, policy lookups, custom business rules — that an LLM can query directly through a defined set of tool calls. Adopted by Anthropic (Claude), OpenAI (announced 2025), Google (Gemini), and a wide developer-tooling ecosystem through 2025-2026.

Structurally, MCP is a standardized protocol layer that sits on top of whatever data source the server is exposing — your Shopify catalog, your ERP, your custom inventory system, a third-party shipping API. The value is standardization: the LLM doesn't need to know how to authenticate against your specific API, parse your specific response format, or handle your specific error patterns. MCP defines a uniform tool-call interface across servers, so the same client (Claude, ChatGPT Agent, Gemini, Copilot) can query thousands of MCP servers without per-server custom integration. Think of it like USB for LLM data sources.

For most consumer eCommerce, no — schema sitewide, llms.txt at root, and the standard AI SEO program already covers most use cases without the engineering investment. The categories where MCP earns its keep: B2B and technical (long research journeys inside LLMs), complex-compatibility (auto parts, OEM replacements), high-AOV apparel/footwear (sizing recommendation is the killer use case), and branded research surfaces (consumer electronics, mattresses, e-bikes, high-end kitchen) where buyers spend hours researching inside an LLM. We'll tell you straight if your category warrants one.

• lookup_product: resolve product by SKU/GTIN/query, return live price, availability, variants, image.
• check_inventory: live inventory state per location/fulfillment partner.
• size_recommendation: fit logic given user measurements or comparable-brand sizing.
• compatible_products: accessory or replacement-part compatibility logic.
• shipping_estimate: cost, carrier, delivery window given cart and destination.
• policy_lookup: return window, warranty, exchange terms.

Shopify: MCP server typically runs as a separate Node service that authenticates against the Shopify Admin API for catalog and inventory; sizing and policy logic lives in the MCP server itself or in a Metafield-backed configuration. BigCommerce: same pattern via the BigCommerce Storefront and Catalog APIs, with our Elite-Partner-since-2012 team handling the API quota and rate-limit considerations. Adobe Commerce / Magento: MCP server as an external service authenticating via REST/GraphQL, or as an integration module inside Adobe Commerce's services framework for tenants who want it bundled. The MCP server itself is platform-agnostic; the integration work is wiring it to your data sources.

The simplest possible illustrative example, sketched in pseudocode for clarity:

tool: lookup_product
description: "Resolve a product by SKU, GTIN, or natural-language query"
input_schema:
  type: object
  properties:
    query: { type: string, description: "SKU, GTIN, or natural-language query" }
  required: [query]
output_schema:
  type: object
  properties:
    name: { type: string }
    price: { type: number }
    currency: { type: string }
    availability: { type: string, enum: [in_stock, out_of_stock, preorder] }
    variants: { type: array }
    image_url: { type: string }
    canonical_url: { type: string }

The actual MCP spec uses JSON Schema for input/output validation; the server returns structured responses an LLM can parse deterministically and cite accurately. The real spec lives at modelcontextprotocol.io.

Anthropic Claude: native support — Claude.ai, Claude Code, Claude Computer Use, and the Claude API all consume MCP servers as first-class tools. OpenAI: announced MCP support in 2025; ChatGPT and the OpenAI Agents framework consume MCP servers. Google Gemini: support announced as part of Gemini's agent capabilities; production-quality integration continues to mature through 2026. Microsoft Copilot: Microsoft's Semantic Kernel and Copilot Studio both include MCP integration paths. The protocol is broadly portable, which is what makes it a durable investment versus engine-specific integrations.

• schema.org structured data: machine-readable annotation embedded in HTML; static; describes what a page means. Foundation layer.
• llms.txt: a single Markdown file at site root; curates which pages an LLM should read. Discovery layer.
• MCP: a server an LLM queries directly; dynamic; bypasses the page-fetch step entirely. Direct data layer.
• Together: schema everywhere for foundation, llms.txt at root for discovery, MCP only where the category warrants direct data exposure. Three complementary layers, not competing ones.

Server-side logs of MCP tool calls: which tools get called, by which engine's client, on which buyer-stage queries. We instrument the MCP server to log every call with anonymized context (which tool, which engine's user-agent, response time, success/failure). The leading-indicator metric: tool-call volume per category — when buyers are increasingly resolving research questions inside the agent rather than on your site, MCP becomes the dominant first-touch surface for that segment. Pairs with the standard prompt-panel citation-share monitoring to see how MCP exposure correlates with citation lift.

Different layers. MCP is the data-exchange layer — how an LLM gets answers from your systems. ACP and AP2 are the transaction layer — how an LLM, once it's decided to buy, authenticates as the user's delegate and completes payment. A full agentic-commerce stack uses both: MCP to answer pre-purchase questions accurately and surface the right SKU, then ACP or AP2 to complete the purchase. Most merchants implement them separately and in stages; the protocol depth lives on /agentic-commerce.