How to Set Up an MCP Server in Under 10 Minutes

What Is an MCP Server and Why Does Your Store Need One?

An MCP (Model Context Protocol) server is a lightweight API endpoint that allows AI shopping agents to query your product catalog programmatically. Instead of scraping your HTML — which is slow, fragile, and often inaccurate — agents send structured queries to your MCP server and receive clean, formatted responses.

Think of the difference between a tourist trying to navigate a foreign city by reading street signs versus having a local guide who speaks their language. Your website is the street signs. Your MCP server is the guide.

Without an MCP server, AI agents must:

1. Fetch your product page HTML (500KB-2MB per page)
2. Parse through theme markup, plugin-injected code, and dynamic elements
3. Extract data from JSON-LD (if present) or attempt to scrape from HTML elements
4. Handle errors when JavaScript-dependent content fails to load
5. Repeat for every product they want to evaluate

With an MCP server, agents:

1. Send a structured query ("search products: wireless earbuds, price under $100, in stock")
2. Receive a clean JSON response with all matching products, complete with specifications, pricing, availability, and shipping details

The MCP server approach is 10-50x faster, more reliable, and provides richer data. Our scan data shows that stores with functional MCP servers receive 8.4x more AI agent queries than comparable stores without them.

This guide walks you through deploying a functional MCP server for your Shopify or WooCommerce store in under 10 minutes using Cloudflare Workers.

Prerequisites

Before you start, you need:

1. A Cloudflare account (free tier works). Sign up at cloudflare.com if you do not have one.
2. Node.js 18+ installed on your computer. Check with node --version in your terminal.
3. Your store's API credentials:

• Shopify: A Storefront API access token (Settings > Apps and sales channels > Develop apps > Create an app > Configure Storefront API scopes > Install app)
• WooCommerce: REST API consumer key and secret (WooCommerce > Settings > Advanced > REST API > Add key with Read permissions)

1. Wrangler CLI (Cloudflare's deployment tool). Install with npm install -g wrangler.

Step 1: Clone the MCP Server Template (2 Minutes)

Open your terminal and clone the SignalixIQ MCP Starter repository:

```bash

git clone https://github.com/signalixiq/mcp-commerce-starter.git

cd mcp-commerce-starter

npm install

`

The repository contains a pre-configured MCP server with four tools that AI agents can call:

• search_products: Full-text search across your product catalog with optional filters (price range, category, availability)
• get_product: Retrieve complete product details including all variants, pricing, images, and specifications
• check_inventory: Real-time inventory status for a specific product or variant
• list_categories: Browse your store's product category hierarchy

These four tools cover 90%+ of what AI shopping agents need when evaluating your products.

Step 2: Configure Your Store Connection (3 Minutes)

Copy the environment template and fill in your store details:

```bash

cp .env.example .env

`

Edit the .env file with your store's information:

For Shopify:

`

PLATFORM=shopify

STORE_URL=https://your-store.myshopify.com

STOREFRONT_API_TOKEN=your_storefront_api_token_here

API_VERSION=2026-01

`

For WooCommerce:

`

PLATFORM=woocommerce

STORE_URL=https://your-store.com

WC_CONSUMER_KEY=ck_your_consumer_key_here

WC_CONSUMER_SECRET=cs_your_consumer_secret_here

`

Step 3: Test Locally (2 Minutes)

Before deploying, verify the server works with your store data:

```bash

npm run dev

`

This starts the MCP server locally on port 8787. Test it with a curl command:

```bash

curl -X POST http://localhost:8787/mcp \

-H "Content-Type: application/json" \

-d '{

"method": "tools/call",

"params": {

"name": "search_products",

"arguments": { "query": "shirt", "limit": 3 }

}

}'

`

You should see a JSON response with product data from your store. If you see an error, check:

• Is your API token/key correct?
• Is your store URL correct (include https://)?
• For Shopify: Did you grant Storefront API access to your app?
• For WooCommerce: Did you create the API key with Read permissions?

Step 4: Deploy to Cloudflare Workers (2 Minutes)

First, authenticate with Cloudflare:

```bash

wrangler login

`

This opens a browser window. Log in and authorize Wrangler.

Set your store's secrets in Cloudflare (these are encrypted, not stored in code):

For Shopify:

```bash

wrangler secret put STOREFRONT_API_TOKEN

`

For WooCommerce:

```bash

wrangler secret put WC_CONSUMER_KEY

wrangler secret put WC_CONSUMER_SECRET

`

Now deploy:

```bash

npm run deploy

`

Wrangler will output your server's URL, something like:

`

https://mcp-commerce-starter.your-account.workers.dev

`

Test the deployed server:

```bash

curl -X POST https://mcp-commerce-starter.your-account.workers.dev/mcp \

-H "Content-Type: application/json" \

-d '{

"method": "tools/call",

"params": {

"name": "search_products",

"arguments": { "query": "shirt", "limit": 3 }

}

}'

`

If you get product data back, your MCP server is live and serving AI agent queries.

Step 5: Publish Your MCP Manifest (1 Minute)

AI agents discover your MCP server through a manifest file at /.well-known/mcp.json on your store's domain. The template includes a manifest generator:

```bash

npm run generate-manifest

`

This outputs a JSON file. You need to make it accessible at https://your-store.com/.well-known/mcp.json.

For Shopify:

The easiest method is a Cloudflare Worker route that serves the manifest. If your domain is already on Cloudflare, add a route rule:

• Route: your-store.com/.well-known/mcp.json
• Worker: Create a small worker that returns the manifest JSON with proper CORS headers

Alternatively, some Shopify apps allow you to serve static files from the .well-known path. Check if your current setup supports this.

For WooCommerce:

Add the manifest file directly to your WordPress root directory via FTP or your hosting file manager. Add CORS headers via your .htaccess or Nginx configuration:

`

<Files "mcp.json">

Header set Access-Control-Allow-Origin "*"

Header set Content-Type "application/json"

</Files>

`

What the MCP Server Exposes (And What It Does Not)

Exposed Data (Read-Only)

Your MCP server provides read-only access to:

• Product names, descriptions, and specifications
• Pricing (including sale prices and variant-specific pricing)
• Inventory status (in stock / out of stock / limited stock)
• Product images and media
• Category and collection assignments
• Product variants with their specific attributes

Not Exposed

The starter template does NOT expose:

• Customer data (no access to customer accounts or order history)
• Write operations (no ability to modify products, prices, or inventory)
• Payment information (no access to payment processing)
• Admin functions (no access to store settings or configuration)
• Internal analytics or business metrics

The MCP server is strictly a read-only product catalog endpoint. AI agents can look at your products but cannot modify anything or access sensitive data.

Customization Options

Adding Custom Product Fields

If your products have custom attributes (sustainability scores, compatibility data, certifications), you can expose them through the MCP server by editing the product transformer in src/transformers/:

The transformer maps your store's product data to the MCP response format. Add additional fields by pulling from:

• Shopify: Product metafields (accessible via Storefront API)
• WooCommerce: Product meta, custom fields, and ACF fields (accessible via REST API)

Adding Search Filters

The default search_products tool supports text search, price range, and availability filters. To add more filters (brand, color, material, etc.):

1. Add the filter parameter to the tool schema in src/tools/search.ts
2. Map the filter to the corresponding API query parameter
3. Redeploy with npm run deploy

Rate Limiting

The Cloudflare Workers free tier includes 100,000 requests per day, which handles most stores' agent traffic. If you exceed this limit:

• Upgrade to Cloudflare Workers Paid ($5/month for 10 million requests)
• Add caching with Cloudflare KV to reduce API calls to your store (the template includes optional KV caching configuration)

Analytics

The template includes built-in request logging. Enable analytics by setting:

`

ENABLE_ANALYTICS=true

ANALYTICS_KV_NAMESPACE=your_kv_namespace_id

`

This logs every agent query with timestamp, tool called, query parameters, and response status. Access analytics through the included dashboard endpoint at /analytics or export to your preferred analytics platform.

Troubleshooting

"Connection refused" on local testing

• Ensure no other process is using port 8787
• Check that npm install completed without errors

Empty search results

• Verify your API token has the correct permissions
• For Shopify: Ensure the Storefront API app has "Products" scope enabled
• For WooCommerce: Ensure the API key has Read permissions
• Try a broader search query (single common word like "shirt" or "shoe")

CORS errors when agents access the manifest

• Verify the Access-Control-Allow-Origin: * header is set on your manifest endpoint
• Check that the manifest URL is accessible from an incognito browser window
• For Cloudflare-proxied domains, ensure the worker route is configured correctly

Slow response times

• Enable KV caching (reduces API calls to your store)
• Check your store's API response time independently — if your store API is slow, the MCP server will be slow
• Cloudflare Workers have a 30ms cold start; subsequent requests are faster

Deployment fails

• Run wrangler whoami to verify you are authenticated
• Check that your wrangler.toml has the correct account ID
• Ensure Node.js version is 18 or higher

Verifying Your MCP Server Works

After deployment, verify from three perspectives:

1. Direct API Test

Use curl or Postman to call each tool endpoint and verify response data matches your store's current products. Check that prices, availability, and product details are current.

2. MCP Client Test

Use an MCP-compatible client (like the MCP Inspector tool or Claude Desktop with MCP support) to connect to your server and test natural language product queries.

3. SignalixIQ Scanner

Run your store through SignalixIQ's scanner after deployment. The scanner detects MCP server presence, tests each tool endpoint, and includes MCP readiness in your GEO score. This is the most comprehensive verification because it tests your MCP server the same way AI agents will interact with it.

What Happens After Deployment

Once your MCP server is live and your manifest is published:

1. AI agents begin discovering your server through the manifest. Discovery typically happens within 1-2 weeks as agents recrawl your domain.
2. Agent query volume ramps up gradually. Expect initial queries within days; meaningful volume within 2-4 weeks.
3. Your GEO score improves immediately upon deployment (SignalixIQ detects the manifest and functional endpoints).
4. Product recommendations increase as agents can now query your catalog reliably instead of scraping HTML.

Monitor your MCP server analytics to track query volume, identify which products agents ask about most, and spot any data quality issues that might affect recommendation accuracy.

Next Steps After MCP

Deploying an MCP server is the highest-impact single action for AI commerce readiness. Once it is running, your next priorities should be:

1. Complete your structured data — add GTIN, shipping details, return policy, and review schema to your product pages. The MCP server handles agent queries, but structured data handles agent crawls of your website.
2. Optimize product content — rewrite your top products' descriptions to lead with specifications. Agents use both MCP data and page content for recommendations.
3. Set up agent traffic tracking — configure server-side analytics to measure agent visits and correlate MCP queries with website conversions.
4. Consider UCP implementation — Google's Unified Commerce Protocol builds on MCP with commerce-specific features. Your MCP server is 60-70% of the way to UCP compliance.

Your MCP server is now the foundation of your AI commerce strategy. Everything else builds on top of it.

Frequently Asked Questions

Related Articles