Shopify

That settles the question of whether agents can read your store. It leaves the harder one open: what do they find when they do? Storefront MCP retrieves what you already published. If your returns page is three sentences written in 2023, that is the answer an agent gives a buyer at the moment they decide whether to check out.

What Shopify exposes

Two endpoints, no authentication on either.

Notice the shape of that list. The catalog half is structured data you already maintain in the admin — Shopify keeps it correct. The policy half is prose, and nobody owns prose.

Where Senso fits

The catalog tools return facts you cannot improve by writing better — a SKU is a SKU. But search_shop_policies_and_faqs, and every description field inside the products the catalog tools return, is writing.

Prerequisites

• A Senso API key (create one on the API Keys page)
• Your myshopify.com domain
• Python 3.10+

export SENSO_API_KEY="YOUR_SENSO_KEY"
export SHOP_DOMAIN="your-store.myshopify.com"
pip install requests

Step 1 — read your own catalog the way an agent does

The fastest audit available to you is to call your own store through the tools an agent would use, and read the results as a stranger.

import os, json, requests

SHOP = os.environ["SHOP_DOMAIN"]
UCP = f"https://{SHOP}/api/ucp/mcp"

def mcp_call(url: str, tool: str, args: dict) -> dict:
    resp = requests.post(url, json={
        "jsonrpc": "2.0",
        "id": 1,
        "method": "tools/call",
        "params": {"name": tool, "arguments": args},
    })
    resp.raise_for_status()
    return resp.json()

found = mcp_call(UCP, "search_catalog", {
    "query": "waterproof hiking boots",
    "context": {"country": "US", "language": "EN"},
})
print(json.dumps(found, indent=2)[:2000])

Run that against three queries a real buyer would type. The descriptions that come back are what an agent will paraphrase to a customer. If they read like SEO filler, that is what the customer hears.

Step 2 — mirror the catalog into Senso

POST /org/product-lines takes a name and a free-form details object. Put the SKU, the storefront URL, and the price in details so generation and evaluation both know the product is real and where it lives.

BASE = "https://apiv2.senso.ai/api/v1"
HEADERS = {
    "X-API-Key": os.environ["SENSO_API_KEY"],
    "Content-Type": "application/json",
}

for product in found.get("products", []):
    resp = requests.post(f"{BASE}/org/product-lines", headers=HEADERS, json={
        "name": product["title"],
        "details": {
            "shopify_product_id": product["id"],
            "url": product.get("url"),
            "price": product.get("price"),
            "variants": [v.get("title") for v in product.get("variants", [])],
        },
    })
    # 409 means this product line already exists — a re-run, not a failure.
    if resp.status_code == 409:
        print(f"exists: {product['title']}")
        continue
    resp.raise_for_status()
    print(f"created: {product['title']}")

Run it on a schedule. A product catalog that Senso believes in but the store no longer sells produces confident copy about a discontinued item, which is worse than no copy.

Step 3 — ingest the policies that answer the buying question

search_shop_policies_and_faqs is the tool that fires when a buyer hesitates. Shipping times, returns, warranty, sizing. Those pages are usually the least maintained content in the store and the most load-bearing at checkout.

policies = {
    "Shipping and delivery": open("policies/shipping.md").read(),
    "Returns and exchanges": open("policies/returns.md").read(),
    "Sizing guide": open("policies/sizing.md").read(),
    "Warranty": open("policies/warranty.md").read(),
}

for title, text in policies.items():
    resp = requests.post(f"{BASE}/org/kb/raw", headers=HEADERS,
                         json={"title": title, "text": text})
    resp.raise_for_status()
    print(f"{title} -> {resp.json()['content_id']}")

POST /org/kb/raw returns 202 and compiles in the background. Poll GET /org/kb/nodes/{id}/content until processing_status is complete.

Now you have both halves in one place, and a question like "do these ship to Canada in time for Christmas" can be answered against the shipping document and the product record together — rather than against whichever page the buyer happened to land on.

Step 4 — write what is missing, in your voice

With the catalog mirrored and the Brand Kit set, content types become your output templates: a product FAQ, a comparison page, a buying guide. Generate against a product line, verify the draft, and publish it back to the store so search_shop_policies_and_faqs can find it. Build the Context Layer covers the full sequence.

The ordering is the point. Content generated before the catalog is mirrored invents SKUs. Content generated before the Brand Kit exists sounds like every other store.

Step 5 — check what the models actually say

Publishing is not the end of the loop. Create prompts for the questions buyers ask before they choose a store — "best waterproof hiking boots under $200" — and monitor how ChatGPT, Gemini, Claude and Perplexity answer them. That is Re-observe & Activate, and it is the only measurement that reflects the surface buyers now actually use.

The gap it reveals is usually specific: models recommend a competitor because that competitor published a comparison page and you did not. That is a writing task, and it points at exactly which page to write.

What to watch

• The agent never sees your marketing site. It sees the catalog and the store's policy content. A spec sheet living in a PDF or a blog post on a separate domain is invisible at the moment of purchase.
• Storefront MCP is unauthenticated. Anything reachable through it is public by construction. Treat every product description and policy page as published copy, because it is.
• update_cart is a write. An agent that can build a cart can build the wrong cart. Carts are recoverable, which is why Shopify leaves the tool open, but do not assume a cart an agent assembled reflects what the buyer asked for.

Where to take it next

• Product Catalog — what a product line is and how generation uses it
• Verify & Publish — approving a draft before it reaches a storefront
• Analytics — which product questions models get wrong, and how often