Shopify: KI-Produktassistent für Empfehlungen

Shopify dominiert den E-Commerce-Plattformmarkt mit über 5 Millionen aktiven Shops. Ein KI-Assistent, der Ihren Katalog versteht und die richtigen Produkte empfehlen kann, kann Ihre Konversionsrate transformieren. Dieser Leitfaden zeigt Ihnen, wie Sie einen für Shopify optimierten RAG-Chatbot bereitstellen.

Warum ein KI-Assistent auf Shopify?

Die Grenzen der nativen Shopify-Tools

Shopify bietet Such- und Empfehlungsfunktionen, aber diese bleiben grundlegend:

• Stichwortsuche: Versteht keine natürlichen Anfragen ("ich suche ein Geschenk für meine Mutter, die gerne gärtnert")
• Generische Empfehlungen: Basierend auf dem Browserverlauf, nicht auf den geäußerten Bedürfnissen
• Begrenzte Drittanbieter-Apps: Die meisten sind regelbasierte Chatbots ohne echte Intelligenz

Der RAG-Vorteil für Shopify

Ein mit Ihrem Katalog verbundener RAG-Assistent kann:

Gemessener Einfluss auf Conversions

Shopify-Shops mit KI-Assistent berichten:

• +18-25% Konversionsrate bei engagierten Besuchern
• +30% durchschnittlicher Warenkorbwert dank Cross-Selling-Empfehlungen
• -35% Pre-Sales-Support-Tickets
• +40% Verweildauer auf der Website

Technische Architektur

Shopify-Katalogsynchronisation

DEVELOPERpython
import shopify
from datetime import datetime

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

    def sync_all_products(self) -> list[dict]:
        """Synchronisiert alle Produkte für die RAG-Indexierung."""
        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:
        """Formatiert ein Produkt für die Indexierung."""
        # Eine aussagekraeftige Beschreibung erstellen
        content_parts = [
            f"Produktname : {product.title}",
            f"Beschreibung : {self._clean_html(product.body_html)}",
            f"Typ : {product.product_type}",
            f"Marke/Anbieter : {product.vendor}",
        ]

        # Tags für die semantische Suche
        if product.tags:
            content_parts.append(f"Tags : {product.tags}")

        # Varianten mit Preis und Lagerbestand
        for variant in product.variants:
            variant_info = f"Variante : {variant.title} - {variant.price}EUR"
            if variant.inventory_quantity is not None:
                stock_status = "Auf Lager" if variant.inventory_quantity > 0 else "Ausverkauft"
                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:
        """Bereinigt das HTML der Beschreibungen."""
        from bs4 import BeautifulSoup
        if not html:
            return ""
        return BeautifulSoup(html, "html.parser").get_text(separator=" ")

Webhook für Echtzeit-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 für Produktaktualisierungen."""
    # Ueberpruefung der Shopify-Signatur
    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()

    # Produkt neu formatieren und neu indexieren
    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:
    """Ueberprueft die Authentizitaet des Webhooks."""
    secret = os.environ["SHOPIFY_WEBHOOK_SECRET"]
    computed = hmac.new(
        secret.encode(),
        body,
        hashlib.sha256
    ).digest()
    return hmac.compare_digest(
        base64.b64encode(computed).decode(),
        signature
    )

Optimierter Shopify-Systemprompt

DEVELOPERpython
SHOPIFY_ASSISTANT_PROMPT = """Du bist der Shopping-Assistent von {shop_name}, einem Shopify-Shop spezialisiert auf {niche}.

## Deine Rolle
Besuchern helfen, das perfekte Produkt für ihre Bedürfnisse zu finden und sie zum Kauf zu führen.

## Strikte Regeln
1. Empfehle AUSSCHLIESSLICH Produkte aus dem bereitgestellten Katalog
2. Erfinde niemals Preise, Merkmale oder Verfügbarkeiten
3. Wenn ein Produkt nicht auf Lager ist, schlage ähnliche Alternativen vor
4. Füge immer den Link zur Produktseite ein

## Gesprächsstil
- Herzlich und professionell
- Stelle Fragen, um den Bedarf zu verstehen
- Maximal 2-3 Produkte pro Empfehlung
- Hebe Aktionen hervor, wenn relevant

## Empfehlungsformat
Für jedes Produkt:
**[Produktname]**
Preis: XX EUR
[Warum dieses Produkt zum Bedarf passt, in 1-2 Sätzen]
[Produkt ansehen](/products/handle)

## Verfügbarer Produktkatalog
{context}

## Laufende Konversation
{history}

## Frage des Kunden
{query}
"""

Shopify-spezifische Anwendungsfälle

Konversationelle Produktsuche

DEVELOPERpython
async def handle_product_search(query: str, context: dict):
    """Verarbeitet eine natürliche Produktsuche."""
    # Beispiele verarbeiteter Anfragen:
    # - "Ich suche ein Geschenk für meine Mutter"
    # - "Was ist Ihr bestes Produkt für trockene Haut?"
    # - "Zeigen Sie mir Kleider für eine Sommerhochzeit"

    # Die Anfrage mit Kontext anreichern
    enriched_query = f"""
    Kundenanfrage: {query}
    Angegebenes Budget: {context.get('budget', 'Nicht angegeben')}
    Browserverlauf: {context.get('viewed_products', [])}
    """

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

    # Die Empfehlung generieren
    response = await llm.generate(
        prompt=SHOPIFY_ASSISTANT_PROMPT,
        context=format_products(products),
        query=query
    )

    return response

Fragen zu Varianten

DEVELOPERpython
async def handle_variant_question(product_id: str, question: str):
    """Beantwortet Fragen zu den Varianten eines Produkts."""
    # Das Produkt mit allen Varianten abrufen
    product = await get_product_with_variants(product_id)

    prompt = f"""
    Der Kunde stellt eine Frage zu diesem Produkt:

    {product['content']}

    Frage: {question}

    Antworte präzise, ausschließlich basierend auf den Produktinformationen.
    Wenn die Antwort nicht in den Informationen enthalten ist, sage es klar.
    """

    return await llm.generate(prompt)

Produktvergleich

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

    prompt = f"""
    Vergleiche diese Produkte objektiv:

    {format_products_for_comparison(products)}

    {"Angeforderte Vergleichskriterien: " + criteria if criteria else ""}

    Stelle den Vergleich wenn möglich als Tabelle dar.
    Schließe mit einer Empfehlung basierend auf dem typischen Käuferprofil ab.
    """

    return await llm.generate(prompt)

Widget-Integration in Shopify

Installation über theme.liquid

DEVELOPERliquid
{% comment %} Ailog-Widget für 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 %}

Kontextuelle proaktive Nachrichten

DEVELOPERjavascript
// Konfiguration der proaktiven Trigger
const proactiveMessages = {
  // Produktseite - Entscheidungshilfe
  product: {
    delay: 45000, // 45 Sekunden
    message: "Fragen zu diesem Produkt? Ich kann Ihnen helfen, die richtige Größe oder Farbe zu wählen."
  },

  // Kollektionsseite - Orientierung
  collection: {
    delay: 30000,
    message: "Suchen Sie etwas Bestimmtes in dieser Kollektion? Ich kann Sie führen."
  },

  // Warenkorb - Bestärkung
  cart: {
    delay: 60000,
    condition: (cart) => cart.total_price > 10000, // > 100 EUR
    message: "Brauchen Sie Hilfe beim Abschluss Ihrer Bestellung? Ich bin hier, um Ihre Fragen zu beantworten."
  }
};

Den ROI messen

Zu verfolgende KPIs

Tracking mit Shopify Analytics

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

  // Für Attribution speichern
  sessionStorage.setItem('ailog_conversation', conversationId);
});

// Beim Kauf die Konversation zuordnen
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
    })
  });
}

Best Practices für Shopify

1. Optimierte Katalogsynchronisation

• Vollständige Synchronisation alle 6 Stunden
• Webhooks für Echtzeit-Updates
• Entwurfs- und archivierte Produkte ausschließen

2. Umgang mit Lagerengpässen

Bei nicht verfügbaren Produkten immer Alternativen vorschlagen:

DEVELOPERpython
async def handle_out_of_stock(product_id: str):
    """Behandelt Produkte, die nicht auf Lager sind."""
    # Ähnliche Alternativen finden
    alternatives = await find_similar_products(
        product_id=product_id,
        filters={"in_stock": True},
        limit=3
    )

    if alternatives:
        return f"""
        Dieses Produkt ist leider nicht mehr verfügbar.

        Hier sind ähnliche Alternativen, die Ihnen gefallen könnten:
        {format_products(alternatives)}

        Möchten Sie benachrichtigt werden, sobald das Produkt wieder verfügbar ist?
        """
    else:
        return """
        Dieses Produkt ist nicht mehr verfügbar und wir haben
        keine ähnliche Alternative auf Lager.

        Möchten Sie benachrichtigt werden, sobald es wieder verfügbar ist?
        """

3. Mehrsprachigkeit

Shopify unterstützt mehrere Sprachen. Passen Sie Ihren Assistenten an:

DEVELOPERpython
def get_prompt_for_locale(locale: str) -> str:
    """Gibt den an die Sprache angepassten Prompt zurück."""
    prompts = {
        "fr": SHOPIFY_ASSISTANT_PROMPT_FR,
        "en": SHOPIFY_ASSISTANT_PROMPT_EN,
        "de": SHOPIFY_ASSISTANT_PROMPT_DE,
    }
    return prompts.get(locale, prompts["en"])

Ergänzende Ressourcen

• KI-E-Commerce-Chatbot - E-Commerce-Hauptleitfaden
• KI-Upsell und Cross-Sell - Fortgeschrittene Empfehlungen
• Warenkorbabbruch - Rückgewinnungsstrategien
• Einführung in RAG - RAG-Grundlagen

Auf Shopify mit Ailog bereitstellen

Die Integration eines KI-Assistenten auf Shopify erfordert normalerweise Wochen an Entwicklung. Mit Ailog starten Sie in wenigen Stunden:

• Nativer Shopify-Connector: Automatische Katalogsynchronisation
• Anpassbares Widget: Passt sich Ihrem Shopify-Theme an
• Shopify-App: Ein-Klick-Installation aus dem App Store
• Integrierte Analytics: Messen Sie den ROI direkt
• Französischer Support: Begleitung bei der Integration

Testen Sie Ailog auf Ihrem Shopify-Shop und steigern Sie Ihre Conversions noch heute.