MCP Server Discovery for AI Agents

The Model Context Protocol (MCP) is an open standard that lets AI agents (ChatGPT, Claude, Copilot, custom agents) connect to your data and tools through a structured API. If you run an MCP server, making it discoverable by AI systems is now a GEO responsibility — and most ecommerce sites get this wrong.

The core challenge is not building the MCP server. It is discovery. MCP does not yet have native built-in discovery. AI agents currently find MCP servers through registries, structured metadata files, llms.txt, manifests, and explicit linking from websites. Every tactic on this page addresses that gap.

Priority Order

For any ecommerce site with an MCP server, execute these in order:

Priority	Action	Impact
1	Host MCP on your primary domain	Very High
2	Add MCP to `llms.txt`	Very High
3	Create `.well-known/mcp.json`	High
4	Add `<link>` references to homepage `<head>`	High
5	Add `MCP:` directive to `robots.txt`	High
6	Create a crawlable MCP landing page	High
7	Submit to MCP registries	High
8	Add `Organization` + `WebAPI` schema	Medium
9	Publish an OpenAPI spec	Medium
10	Write highly descriptive tool names	Critical (often missed)

1. Host MCP on Your Primary Domain

This is the single most important improvement and costs nothing once the server exists.

Weak (bigcommerce subdomain):

https://store-qt4zqet5yv-1669563.mybigcommerce.com/api/mcp

Strong (primary domain):

https://www.baits.com/mcp

or as a subdomain:

https://mcp.baits.com

Why the primary domain wins:

Brand and entity alignment — AI systems associate the endpoint with the known entity Baits.com
Crawler trust — first-party domains receive higher credibility scores
AI discoverability — crawlers discovering baits.com will find the MCP endpoint through the tactics below
Future-proofing — AI indexing standards being developed assume first-party hosting

AI systems strongly prefer first-party domains for any API, manifest, or tool endpoint they discover.

2. Add MCP References to `llms.txt`

llms.txt is currently one of the strongest MCP discovery methods. It is an emerging standard (similar to robots.txt for AI systems) that explicitly describes your AI-accessible resources.

Place at: https://www.baits.com/llms.txt

# Baits.com AI Resources

## Product Catalog
Manifest: https://www.baits.com/products-manifest.json
Description: Machine-readable catalog of all fishing tackle products with pricing, availability, and specifications.

## MCP Server
Endpoint: https://www.baits.com/mcp
Transport: streamable-http
Authentication: none

Description:
The Baits.com MCP server provides AI-accessible fishing tackle catalog search,
inventory discovery, product recommendations, taxonomy navigation, and brand exploration.

Capabilities:
- product_search: Search fishing tackle by species, lure type, technique, brand, SKU, or rigging style
- sku_lookup: Retrieve full product details by SKU or GTIN
- inventory_lookup: Check real-time stock availability for specific products or variants
- category_navigation: Browse the product taxonomy by category, sub-category, or brand
- fishing_technique_matching: Find products compatible with a specific fishing technique or rig type
- bait_recommendations: Get bait recommendations based on target species, water clarity, and season

Also reference in robots.txt (see Section 5 below).

3. Create `.well-known/mcp.json`

The .well-known/ path is the established web standard for service discovery metadata. Publishing mcp.json here is where the ecosystem is heading — several AI agent frameworks already check this path.

Host at: https://www.baits.com/.well-known/mcp.json

{
  "name": "Baits.com MCP Server",
  "description": "Fishing tackle and bait product discovery, inventory lookup, and bait recommendation engine for largemouth bass, smallmouth bass, walleye, crappie, and other freshwater species.",
  "endpoint": "https://www.baits.com/mcp",
  "transport": "streamable-http",
  "authentication": "none",
  "version": "1.0",
  "capabilities": [
    "product_search",
    "inventory_lookup",
    "sku_lookup",
    "brand_navigation",
    "bait_recommendations",
    "fishing_technique_matching",
    "category_navigation"
  ],
  "contact": {
    "url": "https://www.baits.com/mcp-info"
  }
}

Requirements:

Must return HTTP 200 with Content-Type: application/json
No authentication required to access the metadata file itself
Keep in sync with actual server capabilities

4. Add `<link>` Tags to Every Page `<head>`

AI crawlers and agent frameworks parse HTML <head> elements during discovery. Adding link tags here ensures any crawler that hits your site finds the MCP endpoint immediately.

Add globally to your site template (every page):

<!-- MCP Server discovery -->
<link rel="service"
      type="application/json"
      href="https://www.baits.com/mcp">

<link rel="alternate"
      type="application/json"
      title="Baits.com MCP Server"
      href="https://www.baits.com/mcp">

Where to add this:

WordPress: add to your theme's functions.php via wp_head action
BigCommerce Stencil: add to templates/layout/base.html inside the <head> block
Next.js / React: add to your global _document.tsx or layout <Head> component
Docusaurus: add to docusaurus.config.ts under headTags

5. Add MCP Directives to `robots.txt`

The MCP: directive is emerging — it is not yet an official standard, but it is directionally correct and being adopted by AI crawlers as the convention forms. Add it now alongside your existing AI discovery declarations.

User-agent: *
Allow: /

# Explicitly allow all major AI crawlers
User-agent: GPTBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Google-Extended
Allow: /

# AI discovery resources — all must be accessible
Allow: /llms.txt
Allow: /products-manifest.json
Allow: /mcp
Allow: /.well-known/mcp.json

# AI resource declarations
LLMs: https://www.baits.com/llms.txt
Manifest: https://www.baits.com/products-manifest.json
MCP: https://www.baits.com/mcp

Sitemap: https://www.baits.com/sitemap.xml

6. Create a Crawlable MCP Landing Page

A human- and machine-readable landing page at a stable URL becomes a crawlable entity page that AI systems can index and cite when reasoning about your AI capabilities.

Recommended URLs:

https://www.baits.com/mcp-info
https://www.baits.com/ai-tools

Page content should cover:

# Baits.com MCP Server

The Baits.com MCP (Model Context Protocol) server provides AI agents with direct access 
to the Baits.com fishing tackle catalog.

## Endpoint

https://www.baits.com/mcp

Transport: streamable-http  
Authentication: none required

## Available Tools

### product_search
Search fishing tackle products by species, lure type, technique, water clarity, season, 
depth, rigging method, brand, SKU, and inventory availability.

### sku_lookup
Retrieve complete product details including specifications, pricing, availability, images, 
and related products by SKU or GTIN.

### inventory_lookup
Check real-time stock levels for specific products or variants.

### category_navigation
Browse the full product taxonomy by category, sub-category, or brand.

### bait_recommendations
Get product recommendations based on target species, water conditions, season, and 
preferred fishing technique.

### fishing_technique_matching
Find all products compatible with a specific technique (wacky rig, Texas rig, drop shot, etc.).

## Machine-Readable Metadata

- MCP metadata: https://www.baits.com/.well-known/mcp.json
- Product catalog: https://www.baits.com/products-manifest.json
- OpenAPI spec: https://www.baits.com/openapi.json

This page also serves as the documentation URL referenced in your .well-known/mcp.json.

7. Submit to MCP Registries

Until native MCP discovery is standardized, registries are how AI agent developers find servers. Submitting to these directories directly exposes your server to developers building fishing, outdoor, and e-commerce AI agents.

Primary registries to submit to:

Registry	URL	Notes
Smithery.ai	smithery.ai	Largest MCP server directory
Glama	glama.ai/mcp	Developer-focused registry
PulseMCP	pulsemcp.com	Actively indexed by AI tools
MCP.so	mcp.so	Community directory
Awesome MCP (GitHub)	github.com/punkpeye/awesome-mcp-servers	High-visibility GitHub list

What to prepare for registry submissions:

Server name: "Baits.com Fishing Tackle MCP Server"
Description: detailed, tool-specific, use-case focused
Endpoint URL: https://www.baits.com/mcp
Transport type: streamable-http (or whichever you support)
Authentication: none / open
Tool list with descriptions
Category tags: ecommerce, fishing, product-catalog, retail

8. Add Organization + WebAPI Schema

Extend your site-level Organization schema to explicitly declare the MCP server as a connected API resource. This helps AI systems connect your brand entity, product catalog, and API into one semantic graph.

Add this to your homepage @graph:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://www.baits.com/#organization",
      "name": "Baits.com",
      "url": "https://www.baits.com",
      "logo": {
        "@type": "ImageObject",
        "url": "https://www.baits.com/logo.png"
      },
      "hasPart": [
        {
          "@type": "WebAPI",
          "name": "Baits.com MCP Server",
          "description": "MCP server providing AI-accessible fishing tackle product search, inventory lookup, and bait recommendations.",
          "url": "https://www.baits.com/mcp",
          "documentation": "https://www.baits.com/mcp-info",
          "serviceType": "Model Context Protocol",
          "availableChannel": {
            "@type": "ServiceChannel",
            "serviceUrl": "https://www.baits.com/mcp"
          }
        },
        {
          "@type": "DataCatalog",
          "name": "Baits.com Product Manifest",
          "description": "Machine-readable catalog of all fishing tackle products.",
          "url": "https://www.baits.com/products-manifest.json"
        }
      ]
    }
  ]
}

This connects:

Your brand (Organization)
Your API (WebAPI)
Your product data (DataCatalog)

into one entity graph that AI systems can traverse and reason about.

9. Publish an OpenAPI Specification

Many AI agent frameworks auto-map OpenAPI specs to tool calls. Publishing a well-structured OpenAPI spec alongside your MCP server dramatically improves interoperability with agents that do not yet support MCP natively.

Host at: https://www.baits.com/openapi.json

{
  "openapi": "3.1.0",
  "info": {
    "title": "Baits.com Product API",
    "description": "AI-accessible fishing tackle product catalog, inventory, and recommendation API.",
    "version": "1.0.0",
    "contact": {
      "url": "https://www.baits.com/mcp-info"
    }
  },
  "servers": [
    {
      "url": "https://www.baits.com/api",
      "description": "Baits.com API"
    }
  ],
  "paths": {
    "/products/search": {
      "get": {
        "operationId": "product_search",
        "summary": "Search fishing tackle products",
        "description": "Search fishing tackle products by species, lure type, technique, water clarity, season, depth, rigging method, brand, SKU, and inventory availability.",
        "parameters": [
          {
            "name": "q",
            "in": "query",
            "description": "Search query — supports species names, lure types, fishing techniques, brand names, and SKUs",
            "schema": { "type": "string" }
          },
          {
            "name": "species",
            "in": "query",
            "description": "Target fish species (e.g. largemouth bass, walleye, crappie)",
            "schema": { "type": "string" }
          },
          {
            "name": "technique",
            "in": "query",
            "description": "Fishing technique or rigging method (e.g. wacky rig, drop shot, Texas rig)",
            "schema": { "type": "string" }
          }
        ],
        "responses": {
          "200": {
            "description": "Array of matching products with pricing, availability, and specifications"
          }
        }
      }
    }
  }
}

Also add a <link> reference to your OpenAPI spec in the homepage <head>:

<link rel="describedby"
      type="application/json"
      href="https://www.baits.com/openapi.json"
      title="OpenAPI Specification">

10. Write Highly Descriptive Tool Names and Descriptions

This is the most commonly missed GEO improvement for MCP servers. AI agents select tools based entirely on their name and description. A vague tool name means agents skip your tool in favor of one they understand better.

Tool Description Anti-Patterns

// BAD — agents cannot determine when to use this
tool name: search_products
description: "Search for products"

Tool Description Best Practices

// GOOD — agents know exactly when and how to use this
tool name: product_search
description: "Search fishing tackle products by species (e.g. largemouth bass, walleye, 
crappie), lure type (soft plastic, crankbait, jig, topwater), fishing technique 
(wacky rig, Texas rig, drop shot, Carolina rig, ned rig), water clarity (clear, stained, 
muddy), season (spring, summer, fall, winter), depth, brand name, SKU, or a combination 
of these attributes. Returns products with pricing, availability, and technical 
specifications. Use this when a user is looking for product recommendations, 
comparing options, or searching for a specific item."

Tool-by-Tool Description Template

For every MCP tool, your description should answer:

What it does — the specific action performed
What inputs it accepts — specific examples of valid inputs
What it returns — the data fields included in the response
When to use it — the user intent that should trigger this tool

Tool	Description Quality Impact
`product_search`	Highest — most frequently called tool
`bait_recommendations`	High — matches AI "best product" queries
`fishing_technique_matching`	High — matches "how to" adjacent queries
`sku_lookup`	Medium — used when agent already has a SKU
`inventory_lookup`	Medium — used in commerce flows
`category_navigation`	Medium — used for exploratory queries

Full Discovery Checklist

Use this when launching or auditing an MCP server:

Domain and Hosting:

MCP endpoint is on the primary domain (not a third-party subdomain)
Endpoint returns valid MCP responses at https://www.example.com/mcp
HTTPS with valid certificate

Discovery Files:

llms.txt exists and references the MCP endpoint with capability descriptions
.well-known/mcp.json exists and returns HTTP 200 application/json
robots.txt includes Allow: /mcp and MCP: https://www.example.com/mcp
products-manifest.json referenced in llms.txt (see Technical Setup)
OpenAPI spec exists at /openapi.json and is referenced in <head>

HTML Discovery:

Homepage (and ideally all pages) <head> includes <link rel="service"> to MCP endpoint
Homepage includes <link rel="alternate"> to MCP endpoint
Homepage includes <link rel="describedby"> to OpenAPI spec

Schema:

Organization schema includes hasPart WebAPI referencing the MCP endpoint
WebAPI includes documentation URL pointing to the MCP landing page

Landing Page:

Crawlable MCP info page exists at /mcp-info or /ai-tools
Page lists all tools with full descriptions
Page links to .well-known/mcp.json and products-manifest.json

Registry:

Tool Quality:

Every tool has a description of 50+ words
Every tool description includes specific example inputs
Every tool description states when an agent should use it
Every tool description states what data the response contains

Priority Order​

1. Host MCP on Your Primary Domain​

2. Add MCP References to llms.txt​

3. Create .well-known/mcp.json​

4. Add <link> Tags to Every Page <head>​

5. Add MCP Directives to robots.txt​

6. Create a Crawlable MCP Landing Page​

7. Submit to MCP Registries​

8. Add Organization + WebAPI Schema​

9. Publish an OpenAPI Specification​

10. Write Highly Descriptive Tool Names and Descriptions​

Tool Description Anti-Patterns​

Tool Description Best Practices​

Tool-by-Tool Description Template​

Full Discovery Checklist​