You are an Agentic Commerce consultant.
Please perform a comprehensive AI visibility audit of my website and create an improvement plan.

My website information:
- Domain: [your domain]
- Platform: [Shopify / WooCommerce / custom-built / other]
- Industry: [e-commerce / SaaS / services / other]
- Number of products: [approximate count]

Please follow these steps:

1. Inspect my website for the following:
   - SSL certificate present (https)
   - Schema.org Product or Organization markup (check page source for JSON-LD)
   - llms.txt file (visit domain/llms.txt)
   - agent.json file (visit domain/.well-known/agent.json)
   - sitemap.xml (visit domain/sitemap.xml)
   - robots.txt allows AI crawlers (ChatGPT-User, Claude-Web, etc.)

2. Check DNS security configuration:
   - DNSSEC enabled
   - DMARC record present
   - SPF record present

3. Review policy pages:
   - Privacy policy exists and is complete
   - Return policy exists with clear terms
   - Contact information is complete (email, phone, address)

4. Output format:
   - Present findings in a three-column table: "Present / Missing / Needs Improvement"
   - Provide specific remediation steps for each missing item
   - Sort by priority (highest impact first)
   - Estimate the time required for each item

Deliverable: A complete audit report plus a prioritized action plan.

Please generate a professional llms.txt file for my website.

llms.txt is a Markdown file placed at the website root, following the llmstxt.org specification.
It tells AI agents (ChatGPT, Claude, etc.) what my website is, what it sells,
and what policies are in place — in concise, structured language.

My website information:
- Domain: [domain]
- Brand name: [brand name]
- Business description: [one paragraph describing your business]
- Main products/services: [list main categories]
- Shipping coverage: [regions]
- Return policy: [brief summary]
- Contact info: [email, phone, etc.]

Requirements:
1. Follow the llmstxt.org Markdown format specification
2. First line is the brand name, followed immediately by a blockquote one-liner
3. Include: About Us, Product Categories (with links), Shipping & Returns, Contact
4. Total length 800-1200 words — not too short, not too long
5. Professional, concise tone — no marketing fluff
6. Each product category must have a corresponding URL link

Output plain Markdown text that I can save directly as an llms.txt file.

Please generate Schema.org Product JSON-LD markup for my product page.

Reference: https://schema.org/Product
Format: JSON-LD (inside a <script type="application/ld+json"> tag)

Product information:
- Product name: [name]
- Description: [product description]
- Brand: [brand name]
- SKU: [SKU number]
- Price: [amount]
- Currency: [USD/EUR/GBP]
- Stock status: [in stock / out of stock / pre-order]
- Product image URL: [full image URL]
- Product page URL: [full page URL]
- Seller name: [seller/store name]
- Shipping destination: [country code, e.g. US]
- Delivery time: [min ~ max days]
- Return window: [number of days]
- Barcode (if available): [EAN/UPC]

Requirements:
1. Strictly follow the schema.org/Product specification
2. Use JSON-LD format (not Microdata)
3. Include Offer, Brand, ShippingDetails, and MerchantReturnPolicy
4. All URLs must be complete https addresses
5. Ensure valid JSON syntax (verifiable via Google Rich Results Test)
6. Include validation instructions after the code

If I have multiple products, explain how to generate markup in bulk (provide a code template).

I am a Shopify merchant. Please help me complete Agentic Commerce integration.

My information:
- Shopify store URL: [URL]
- Domain: [domain]
- Domain registrar: [Cloudflare / Namecheap / GoDaddy / other]
- Email provider: [Google Workspace / Microsoft 365 / other]

Please complete all configurations in the following order:

Step 1: Assess current state
- Does my theme output Schema.org Product markup?
- Does my robots.txt allow AI crawlers?
- Does my sitemap include all product pages?

Step 2: DNS security configuration
- Steps to enable DNSSEC in my registrar ([registrar name]) dashboard
- Exact DMARC record content and how to add it
- Exact SPF record content (based on my email provider [provider name])

Step 3: Create llms.txt
- Generate llms.txt content for my Shopify store
- Show me how to deploy llms.txt on Shopify

Step 4: Create agent.json
- Generate the agent.json file content
- Show me how to deploy it on Shopify

Step 5: Optimize robots.txt
- Review the current robots.txt.liquid
- If changes are needed, provide the exact modifications

Deliverables:
- Each step must have specific instructions with UI navigation paths
- All DNS records must be copy-paste ready
- Include verification methods after configuration

I use WordPress + WooCommerce. Please help me complete Agentic Commerce integration.

My information:
- Domain: [domain]
- WordPress version: [version]
- WooCommerce version: [version]
- Current SEO plugin: [Yoast SEO / RankMath / none]
- Domain registrar: [registrar name]
- Email provider: [provider name]
- Server access method: [FTP / SSH / hosting panel]

Please complete all configurations in the following order:

Step 1: Structured data
- If no SEO plugin is installed, recommend one
- Verify the plugin outputs correct Schema.org Product markup
- How to validate the output

Step 2: Create llms.txt
- Generate the llms.txt file content
- How to deploy to the WordPress root directory via [FTP/SSH/panel]

Step 3: Create agent.json
- Generate the agent.json file content
- How to create the .well-known directory and deploy the file

Step 4: DNS security
- DNSSEC activation steps (in [registrar name] dashboard)
- Exact DMARC/SPF/DKIM record values
- How to add the DNS records

Step 5: robots.txt optimization
- Review the current robots.txt
- Add AI crawler allow rules as needed

Step 6: Sitemap optimization
- Confirm WooCommerce sitemap includes all products
- Steps to submit to Google Search Console

Deliverable: Executable commands or step-by-step instructions for each step.

I run a custom-built e-commerce website. Please help me complete Agentic Commerce integration.

Tech stack:
- Frontend: [React / Vue / Next.js / plain HTML / other]
- Backend: [Node.js / Python / PHP / other]
- Hosting: [Vercel / AWS / self-hosted / other]
- Domain registrar: [registrar name]
- Email provider: [provider name]

Please complete the following configurations:

1. Schema.org Product markup
   - Generate a JSON-LD template for my product pages
   - How to render dynamically (from product database)
   - How to integrate with [frontend framework]

2. Schema.org Organization markup
   - Generate Organization markup for my homepage

3. llms.txt
   - Generate the complete llms.txt file content
   - How to deploy to the site root

4. agent.json
   - Generate the agent.json file content
   - Create .well-known directory and deploy

5. robots.txt
   - Generate an AI-friendly robots.txt
   - How to deploy on [hosting platform]

6. Sitemap
   - Code to dynamically generate a sitemap (using [backend stack])
   - Strategy for auto-refreshing the sitemap when products are updated

7. DNS security
   - Complete DNSSEC/DMARC/SPF/DKIM configuration

Deliverables:
- All code must be production-ready (not pseudocode)
- Provide implementation code specific to [tech stack]
- Include deployment paths and verification methods for each file

Please help me create an integration plan for Google UCP (Universal Commerce Protocol).

Preparation:
1. Please review the official UCP documentation: https://ucp.dev
2. Familiarize yourself with the full UCP technical specification

My information:
- Domain: [domain]
- Number of products: [count]
- Tech stack: [tech stack]
- Team size: [number of developers]

Please output:
1. Summary of UCP core concepts (explained in terms of my tech stack)
2. Integration steps broken into phases
3. Specific technical approach for each phase
4. Data mapping plan (my database schema to UCP format)
5. Testing and validation strategy
6. Estimated effort and milestones

Deliverables:
- Ready to use as a technical specification document
- Include code examples and data format samples
- Mark which steps can be completed incrementally

Please help me create a plan to improve my AI trust score.

My domain: [domain]
Current status: (please first query https://orbexa.io/api/otr/verify/[domain] to get the data)

After querying, please analyze:
1. My current overall score and per-dimension scores
2. Which dimension has the lowest score (greatest room for improvement)
3. Which signals show "not_found" (actionable improvements)
4. Improvement recommendations sorted by return on effort

Output format:
- Week 1 action items (quick wins)
- Weeks 2-3 action items (moderate difficulty)
- Week 4 action items (longer-term improvements)
- Specific steps for each action
- Estimated score improvement for each item

Goal: Improve by at least one badge tier from the current score.

Please help me prepare product data for ACP (Agentic Commerce Protocol).

Reference documentation:
1. ACP open specification: https://agenticcommerce.dev
2. OpenAI merchant docs: https://developers.openai.com/commerce

My product data:
- Platform: [Shopify / WooCommerce / custom-built / CSV]
- Number of products: [count]
- Current data format: [CSV / JSON / database]

Please output:
1. Mapping plan to convert my product data to ACP Product object format
2. Format requirements for each field (especially prices in minor currency units, e.g. $79.99 = 7999)
3. How to construct Variant objects (color/size combinations)
4. Media file (image/video) URL and format requirements
5. Required fields checklist
6. A complete JSON example
7. SFTP file naming and sharding strategy (under 500K records per shard)

Please help me build a commerce MCP Server.

Reference documentation: MCP official specification https://modelcontextprotocol.io (spec version 2025-11-25)

My system:
- Tech stack: [Node.js / Python / other]
- Data source: [database / API / files]
- Capabilities to expose: [product search / inventory lookup / order status / price query]

Please output:
1. MCP Server architecture design (Host / Client / Server three-tier model)
2. Tools definitions (name, description, inputSchema, outputSchema for each tool)
3. Resources definitions (URI scheme for product catalog, inventory data)
4. Transport selection (stdio for local, Streamable HTTP for remote)
5. Complete TypeScript or Python implementation
6. Testing approach (using MCP Inspector)
7. Production deployment strategy

Please help me evaluate whether I should use ORBEXA (https://orbexa.io) or implement agentic commerce protocols on my own.

My situation:
- Platform: [Shopify / WooCommerce / WordPress / custom-built]
- Technical team size: [number of people]
- Number of products: [count]
- Budget: [budget range]
- Primary protocol interest: [UCP / ACP / MCP / all]

Please provide a comparative analysis:
1. Effort to implement independently (deploy UCP endpoints, format ACP feeds, build MCP Server, configure SEO files)
2. Effort using ORBEXA (integrate plugin/API, automatic handling)
3. Ongoing technical maintenance cost comparison
4. Data ownership and control comparison
5. Recommended approach with reasoning