Shopify: AI Product Assistant for Recommendations

Shopify dominates the e-commerce platform market with over 4 million active stores. An AI assistant that understands your catalog and recommends the right products can transform your conversion rate. This guide shows you how to deploy a RAG chatbot optimized for Shopify.

Why an AI Assistant on Shopify?

Limitations of Native Shopify Tools

Shopify offers search and recommendation features, but they remain basic:

• Keyword search: Doesn't understand natural queries ("I'm looking for a gift for my mother who loves gardening")
• Generic recommendations: Based on browsing history, not expressed needs
• Limited third-party apps: Most are rule-based chatbots without real intelligence

The RAG Advantage for Shopify

A RAG assistant connected to your catalog can:

Measured Impact on Conversions

Shopify stores with AI assistants report:

• +18-25% conversion rate on engaged visitors
• +30% average order value through cross-recommendations
• -35% pre-sale support tickets
• +40% time spent on site

Technical Architecture

Shopify Catalog Synchronization

DEVELOPERpython
import shopify
from datetime import datetime

class ShopifyProductSync:
    def __init__(self, shop_url: str, access_token: str):
        """Initialize Shopify connection."""
        shopify.ShopifyResource.set_site(shop_url)
        shopify.ShopifyResource.set_headers({
            'X-Shopify-Access-Token': access_token
        })

    def sync_all_products(self) -> list[dict]:
        """Sync all products for RAG indexing."""
        products = []
        page = shopify.Product.find(limit=250, status='active')

        while page:
            for product in page:
                formatted = self._format_for_rag(product)
                products.append(formatted)

            if len(page) < 250:
                break
            page = shopify.Product.find(
                limit=250,
                since_id=page[-1].id
            )

        return products

    def _format_for_rag(self, product) -> dict:
        """Format a product for indexing."""
        # Build rich description
        content_parts = [
            f"Product name: {product.title}",
            f"Description: {self._clean_html(product.body_html)}",
            f"Type: {product.product_type}",
            f"Brand/Vendor: {product.vendor}",
        ]

        # Tags for semantic search
        if product.tags:
            content_parts.append(f"Tags: {product.tags}")

        # Variants with price and stock
        for variant in product.variants:
            variant_info = f"Variant: {variant.title} - ${variant.price}"
            if variant.inventory_quantity is not None:
                stock_status = "In stock" if variant.inventory_quantity > 0 else "Out of stock"
                variant_info += f" ({stock_status})"
            content_parts.append(variant_info)

        return {
            "id": f"shopify_product_{product.id}",
            "title": product.title,
            "content": "\n".join(content_parts),
            "metadata": {
                "source": "shopify",
                "product_id": str(product.id),
                "handle": product.handle,
                "product_type": product.product_type,
                "vendor": product.vendor,
                "price_min": min(float(v.price) for v in product.variants),
                "price_max": max(float(v.price) for v in product.variants),
                "in_stock": any(
                    (v.inventory_quantity or 0) > 0
                    for v in product.variants
                ),
                "url": f"/products/{product.handle}",
                "image": product.images[0].src if product.images else None,
                "created_at": product.created_at,
                "updated_at": product.updated_at
            }
        }

    def _clean_html(self, html: str) -> str:
        """Clean HTML from descriptions."""
        from bs4 import BeautifulSoup
        if not html:
            return ""
        return BeautifulSoup(html, "html.parser").get_text(separator=" ")

Webhook for Real-time Updates

DEVELOPERpython
from fastapi import FastAPI, Request, HTTPException
import hmac
import hashlib

app = FastAPI()

@app.post("/webhooks/shopify/product-update")
async def handle_product_update(request: Request):
    """Shopify webhook for product updates."""
    # Verify Shopify signature
    signature = request.headers.get("X-Shopify-Hmac-SHA256")
    body = await request.body()

    if not verify_shopify_webhook(body, signature):
        raise HTTPException(status_code=401)

    payload = await request.json()

    # Reformat and reindex the product
    product_data = format_product_for_rag(payload)
    await vector_db.upsert(
        collection="products",
        documents=[product_data]
    )

    return {"status": "updated"}

def verify_shopify_webhook(body: bytes, signature: str) -> bool:
    """Verify webhook authenticity."""
    secret = os.environ["SHOPIFY_WEBHOOK_SECRET"]
    computed = hmac.new(
        secret.encode(),
        body,
        hashlib.sha256
    ).digest()
    return hmac.compare_digest(
        base64.b64encode(computed).decode(),
        signature
    )

Optimized Shopify System Prompt

DEVELOPERpython
SHOPIFY_ASSISTANT_PROMPT = """You are the shopping assistant for {shop_name}, a Shopify store specializing in {niche}.

## Your role
Help visitors find the perfect product for their needs and guide them toward purchase.

## Strict rules
1. ONLY recommend products from the provided catalog
2. Never invent prices, features, or availability
3. If a product is out of stock, suggest similar alternatives
4. Always include the link to the product page

## Conversation style
- Warm and professional
- Ask questions to understand the need
- Maximum 2-3 products per recommendation
- Highlight promotions when relevant

## Recommendation format
For each product:
**[Product name]**
Price: $XX
[Why this product matches the need in 1-2 sentences]
[View product](/products/handle)

## Available product catalog
{context}

## Current conversation
{history}

## Customer question
{query}
"""

Shopify-Specific Use Cases

Conversational Product Search

DEVELOPERpython
async def handle_product_search(query: str, context: dict):
    """Handle natural product search."""
    # Examples of handled queries:
    # - "I'm looking for a gift for my mother"
    # - "What's your best product for dry skin?"
    # - "Show me dresses for a summer wedding"

    # Enrich query with context
    enriched_query = f"""
    Customer search: {query}
    Indicated budget: {context.get('budget', 'Not specified')}
    Browsing history: {context.get('viewed_products', [])}
    """

    # Retrieve relevant products
    products = await retriever.search(
        query=enriched_query,
        top_k=10,
        filters={"in_stock": True}
    )

    # Generate recommendation
    response = await llm.generate(
        prompt=SHOPIFY_ASSISTANT_PROMPT,
        context=format_products(products),
        query=query
    )

    return response

Variant Questions

DEVELOPERpython
async def handle_variant_question(product_id: str, question: str):
    """Answer questions about product variants."""
    # Get product with all variants
    product = await get_product_with_variants(product_id)

    prompt = f"""
    The customer is asking about this product:

    {product['content']}

    Question: {question}

    Answer precisely based only on the product information.
    If the answer isn't in the information, say so clearly.
    """

    return await llm.generate(prompt)

Product Comparison

DEVELOPERpython
async def compare_products(product_ids: list[str], criteria: str = None):
    """Compare multiple products."""
    products = await get_products_by_ids(product_ids)

    prompt = f"""
    Compare these products objectively:

    {format_products_for_comparison(products)}

    {"Requested comparison criteria: " + criteria if criteria else ""}

    Present the comparison as a table if possible.
    Conclude with a recommendation based on typical buyer profile.
    """

    return await llm.generate(prompt)

Shopify Widget Integration

Installation via theme.liquid

DEVELOPERliquid
{% comment %} Ailog Widget for Shopify {% endcomment %}
{% if template != 'cart' %}
<script>
  window.AilogConfig = {
    channelId: "{{ shop.metafields.ailog.channel_id }}",
    shopifyContext: {
      shopName: "{{ shop.name }}",
      currentProduct: {% if product %}{{ product | json }}{% else %}null{% endif %},
      cartItems: {{ cart.items | json }},
      customer: {% if customer %}{{ customer | json }}{% else %}null{% endif %}
    }
  };
</script>
<script src="https://widget.ailog.fr/embed.js" async></script>
{% endif %}

Contextual Proactive Messages

DEVELOPERjavascript
// Proactive trigger configuration
const proactiveMessages = {
  // Product page - help with decision
  product: {
    delay: 45000, // 45 seconds
    message: "Questions about this product? I can help you choose the right size or color."
  },

  // Collection page - guidance
  collection: {
    delay: 30000,
    message: "Looking for something specific in this collection? I can guide you."
  },

  // Cart - reassurance
  cart: {
    delay: 60000,
    condition: (cart) => cart.total_price > 10000, // > $100
    message: "Need help completing your order? I'm here to answer your questions."
  }
};

Measuring ROI

KPIs to Track

Tracking with Shopify Analytics

DEVELOPERjavascript
// Track assisted conversion
document.addEventListener('ailog:conversation_end', (event) => {
  const conversationId = event.detail.conversationId;

  // Store for attribution
  sessionStorage.setItem('ailog_conversation', conversationId);
});

// On purchase, attribute the conversation
if (Shopify.checkout && sessionStorage.getItem('ailog_conversation')) {
  fetch('/apps/ailog/track-conversion', {
    method: 'POST',
    body: JSON.stringify({
      conversationId: sessionStorage.getItem('ailog_conversation'),
      orderId: Shopify.checkout.order_id,
      orderValue: Shopify.checkout.total_price
    })
  });
}

Shopify Best Practices

1. Optimized Catalog Sync

• Full sync every 6 hours
• Webhooks for real-time updates
• Exclude draft and archived products

2. Out-of-Stock Handling

Always offer alternatives when a product is unavailable:

DEVELOPERpython
async def handle_out_of_stock(product_id: str):
    """Handle out-of-stock products."""
    # Find similar alternatives
    alternatives = await find_similar_products(
        product_id=product_id,
        filters={"in_stock": True},
        limit=3
    )

    if alternatives:
        return f"""
        This product is unfortunately no longer available.

        Here are similar alternatives you might like:
        {format_products(alternatives)}

        Would you like to be notified when the product is back?
        """
    else:
        return """
        This product is no longer available and we don't have
        a similar alternative in stock.

        Would you like to be notified when it's back?
        """

3. Multi-language Support

Shopify supports multiple languages. Adapt your assistant:

DEVELOPERpython
def get_prompt_for_locale(locale: str) -> str:
    """Return prompt adapted to language."""
    prompts = {
        "fr": SHOPIFY_ASSISTANT_PROMPT_FR,
        "en": SHOPIFY_ASSISTANT_PROMPT_EN,
        "de": SHOPIFY_ASSISTANT_PROMPT_DE,
    }
    return prompts.get(locale, prompts["en"])

Related Resources

• E-commerce AI Chatbot - E-commerce pillar guide
• AI Upsell and Cross-sell - Advanced recommendations
• Cart Abandonment - Recovery strategies
• Introduction to RAG - RAG fundamentals

---

Deploy on Shopify with Ailog

Integrating an AI assistant on Shopify normally takes weeks of development. With Ailog, get started in hours:

• Native Shopify connector: Automatic catalog synchronization
• Customizable widget: Adapts to your Shopify theme
• Shopify App: One-click installation from the App Store
• Built-in analytics: Measure ROI directly
• Dedicated support: Integration assistance

Try Ailog on your Shopify store and boost your conversions today.