Shopify : Assistant produit IA pour recommandations

Shopify domine le marche des plateformes e-commerce avec plus de 4 millions de boutiques actives. Un assistant IA capable de comprendre votre catalogue et de recommander les bons produits peut transformer votre taux de conversion. Ce guide vous montre comment deployer un chatbot RAG optimise pour Shopify.

Pourquoi un assistant IA sur Shopify ?

Les limites des outils natifs Shopify

Shopify propose des fonctionnalites de recherche et recommandation, mais elles restent basiques :

• Recherche par mots-cles : Ne comprend pas les requetes naturelles ("je cherche un cadeau pour ma mere qui aime le jardinage")
• Recommandations generiques : Basees sur l'historique de navigation, pas sur les besoins exprimes
• Apps tierces limitees : La plupart sont des chatbots a regles sans intelligence reelle

L'avantage RAG pour Shopify

Un assistant RAG connecte a votre catalogue peut :

Impact mesure sur les conversions

Les boutiques Shopify avec assistant IA rapportent :

• +18-25% de taux de conversion sur les visiteurs engages
• +30% de panier moyen grace aux recommandations croisees
• -35% de tickets support pre-vente
• +40% de temps passe sur le site

Architecture technique

Synchronisation catalogue Shopify

DEVELOPERpython
import shopify
from datetime import datetime

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

    def sync_all_products(self) -> list[dict]:
        """Synchronise tous les produits pour indexation RAG."""
        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:
        """Formate un produit pour l'indexation."""
        # Construire une description riche
        content_parts = [
            f"Nom du produit : {product.title}",
            f"Description : {self._clean_html(product.body_html)}",
            f"Type : {product.product_type}",
            f"Marque/Vendeur : {product.vendor}",
        ]

        # Tags pour la recherche semantique
        if product.tags:
            content_parts.append(f"Tags : {product.tags}")

        # Variantes avec prix et stock
        for variant in product.variants:
            variant_info = f"Variante : {variant.title} - {variant.price}EUR"
            if variant.inventory_quantity is not None:
                stock_status = "En stock" if variant.inventory_quantity > 0 else "Rupture"
                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:
        """Nettoie le HTML des descriptions."""
        from bs4 import BeautifulSoup
        if not html:
            return ""
        return BeautifulSoup(html, "html.parser").get_text(separator=" ")

Webhook pour mises a jour temps reel

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):
    """Webhook Shopify pour mise a jour produit."""
    # Verification signature Shopify
    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()

    # Reformater et reindexer le produit
    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:
    """Verifie l'authenticite du webhook."""
    secret = os.environ["SHOPIFY_WEBHOOK_SECRET"]
    computed = hmac.new(
        secret.encode(),
        body,
        hashlib.sha256
    ).digest()
    return hmac.compare_digest(
        base64.b64encode(computed).decode(),
        signature
    )

Prompt systeme optimise Shopify

DEVELOPERpython
SHOPIFY_ASSISTANT_PROMPT = """Tu es l'assistant shopping de {shop_name}, une boutique Shopify specialisee dans {niche}.

## Ton role
Aider les visiteurs a trouver le produit parfait pour leurs besoins et les guider vers l'achat.

## Regles strictes
1. Recommande UNIQUEMENT des produits du catalogue fourni
2. Ne jamais inventer de prix, caracteristiques ou disponibilites
3. Si un produit n'est pas en stock, propose des alternatives similaires
4. Inclus toujours le lien vers la fiche produit

## Style de conversation
- Chaleureux et professionnel
- Pose des questions pour comprendre le besoin
- Maximum 2-3 produits par recommandation
- Mets en avant les promotions si pertinent

## Format de recommandation
Pour chaque produit :
**[Nom du produit]**
Prix : XX EUR
[Pourquoi ce produit correspond au besoin en 1-2 phrases]
[Voir le produit](/products/handle)

## Catalogue produits disponibles
{context}

## Conversation en cours
{history}

## Question du client
{query}
"""

Cas d'usage specifiques Shopify

Recherche produit conversationnelle

DEVELOPERpython
async def handle_product_search(query: str, context: dict):
    """Gere une recherche produit naturelle."""
    # Exemples de requetes traitees :
    # - "Je cherche un cadeau pour ma mere"
    # - "Quel est votre meilleur produit pour peau seche ?"
    # - "Montrez-moi des robes pour un mariage d'ete"

    # Enrichir la requete avec le contexte
    enriched_query = f"""
    Recherche client : {query}
    Budget indique : {context.get('budget', 'Non precise')}
    Historique navigation : {context.get('viewed_products', [])}
    """

    # Recuperer les produits pertinents
    products = await retriever.search(
        query=enriched_query,
        top_k=10,
        filters={"in_stock": True}
    )

    # Generer la recommandation
    response = await llm.generate(
        prompt=SHOPIFY_ASSISTANT_PROMPT,
        context=format_products(products),
        query=query
    )

    return response

Questions sur les variantes

DEVELOPERpython
async def handle_variant_question(product_id: str, question: str):
    """Repond aux questions sur les variantes d'un produit."""
    # Recuperer le produit avec toutes ses variantes
    product = await get_product_with_variants(product_id)

    prompt = f"""
    Le client pose une question sur ce produit :

    {product['content']}

    Question : {question}

    Reponds precisement en te basant uniquement sur les informations produit.
    Si la reponse n'est pas dans les informations, dis-le clairement.
    """

    return await llm.generate(prompt)

Comparaison de produits

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

    prompt = f"""
    Compare ces produits de maniere objective :

    {format_products_for_comparison(products)}

    {"Criteres de comparaison demandes : " + criteria if criteria else ""}

    Presente la comparaison sous forme de tableau si possible.
    Conclus par une recommandation basee sur le profil type d'acheteur.
    """

    return await llm.generate(prompt)

Integration widget Shopify

Installation via theme.liquid

DEVELOPERliquid
{% comment %} Widget Ailog pour 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 %}

Messages proactifs contextuels

DEVELOPERjavascript
// Configuration des triggers proactifs
const proactiveMessages = {
  // Page produit - aide a la decision
  product: {
    delay: 45000, // 45 secondes
    message: "Des questions sur ce produit ? Je peux vous aider a choisir la bonne taille ou couleur."
  },

  // Page collection - orientation
  collection: {
    delay: 30000,
    message: "Vous cherchez quelque chose de precis dans cette collection ? Je peux vous guider."
  },

  // Panier - reassurance
  cart: {
    delay: 60000,
    condition: (cart) => cart.total_price > 10000, // > 100 EUR
    message: "Besoin d'aide pour finaliser votre commande ? Je suis la pour repondre a vos questions."
  }
};

Mesurer le ROI

KPIs a suivre

Tracking avec Shopify Analytics

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

  // Stocker pour attribution
  sessionStorage.setItem('ailog_conversation', conversationId);
});

// A l'achat, attribuer la 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
    })
  });
}

Bonnes pratiques Shopify

1. Synchronisation catalogue optimisee

• Synchronisation complete toutes les 6 heures
• Webhooks pour mises a jour temps reel
• Exclure les produits draft et archives

2. Gestion des ruptures de stock

Toujours proposer des alternatives quand un produit est indisponible :

DEVELOPERpython
async def handle_out_of_stock(product_id: str):
    """Gere les produits en rupture."""
    # Trouver des alternatives similaires
    alternatives = await find_similar_products(
        product_id=product_id,
        filters={"in_stock": True},
        limit=3
    )

    if alternatives:
        return f"""
        Ce produit n'est malheureusement plus disponible.

        Voici des alternatives similaires que vous pourriez aimer :
        {format_products(alternatives)}

        Souhaitez-vous etre notifie quand le produit sera de retour ?
        """
    else:
        return """
        Ce produit n'est plus disponible et nous n'avons pas
        d'alternative similaire en stock.

        Souhaitez-vous etre notifie quand il sera de retour ?
        """

3. Multi-langue

Shopify supporte plusieurs langues. Adaptez votre assistant :

DEVELOPERpython
def get_prompt_for_locale(locale: str) -> str:
    """Retourne le prompt adapte a la langue."""
    prompts = {
        "fr": SHOPIFY_ASSISTANT_PROMPT_FR,
        "en": SHOPIFY_ASSISTANT_PROMPT_EN,
        "de": SHOPIFY_ASSISTANT_PROMPT_DE,
    }
    return prompts.get(locale, prompts["en"])

Ressources complementaires

• Chatbot E-commerce IA - Guide pilier e-commerce
• Upsell et Cross-sell IA - Recommandations avancees
• Abandon de panier - Strategies de recuperation
• Introduction au RAG - Fondamentaux RAG

Deployer sur Shopify avec Ailog

Integrer un assistant IA sur Shopify demande normalement des semaines de developpement. Avec Ailog, lancez-vous en quelques heures :

• Connecteur Shopify natif : Synchronisation automatique du catalogue
• Widget personnalisable : S'adapte a votre theme Shopify
• App Shopify : Installation en un clic depuis l'App Store
• Analytics integres : Mesurez le ROI directement
• Support francais : Accompagnement a l'integration

Essayez Ailog sur votre boutique Shopify et boostez vos conversions des aujourd'hui.