PrestaShop: Produktsupport automatisieren

PrestaShop treibt über 300.000 Onlineshops an, hauptsächlich in Europa. Die Automatisierung des Produktsupports über einen KI-Assistenten ermöglicht es, Kundenfragen sofort zu beantworten und gleichzeitig Zeit für Ihr Team freizusetzen. Dieser Leitfaden erklärt im Detail, wie Sie einen für PrestaShop optimierten RAG-Chatbot bereitstellen.

Die Herausforderung im E-Commerce-Support

Wiederkehrende Fragen kosten Zeit

Eine interne Studie zu PrestaShop-Shops zeigt, dass 70 % der Support-Anfragen Folgendes betreffen:

• Produktverfügbarkeit und Lieferzeiten
• Technische Merkmale und Kompatibilität
• Rückgabe- und Umtauschverfahren
• Bestellverfolgung
• Größen und Maßtabellen

Diese Fragen haben standardisierte Antworten, erfordern aber derzeit ein menschliches Eingreifen.

Kosten des manuellen Supports

Der Vorteil von RAG für den Support

Ein mit Ihrer PrestaShop-Datenbank verbundener RAG-Assistent kann:

• Produktfragen präzise beantworten
• Den Lagerbestand in Echtzeit kennen
• Spezifische Rückgabebedingungen erklären
• Durch den Kaufprozess führen
• Bei Bedarf intelligent an einen Mitarbeiter eskalieren

Architektur PrestaShop + RAG

PrestaShop-Katalog-Connector

DEVELOPERphp
<?php
// PrestaShop-Modul für den RAG-Katalogexport

class AilogExportModule extends Module
{
    public function exportCatalog(): array
    {
        $products = [];
        $productList = Product::getProducts(
            $this->context->language->id,
            0,
            0,
            'id_product',
            'ASC',
            false,
            true // Nur aktive Produkte
        );

        foreach ($productList as $productData) {
            $product = new Product(
                $productData['id_product'],
                true,
                $this->context->language->id
            );

            $products[] = $this->formatForRAG($product);
        }

        return $products;
    }

    private function formatForRAG(Product $product): array
    {
        // Angereicherte Beschreibung für RAG
        $content = sprintf(
            "Produkt: %s\n" .
            "Referenz: %s\n" .
            "Beschreibung: %s\n" .
            "Merkmale: %s\n" .
            "Preis: %s EUR\n" .
            "Verfügbarkeit: %s\n" .
            "Kategorien: %s",
            $product->name,
            $product->reference,
            strip_tags($product->description),
            $this->getFeatures($product),
            $product->price,
            $this->getStockStatus($product),
            $this->getCategories($product)
        );

        return [
            'id' => 'prestashop_' . $product->id,
            'title' => $product->name,
            'content' => $content,
            'metadata' => [
                'source' => 'prestashop',
                'product_id' => $product->id,
                'reference' => $product->reference,
                'price' => (float) $product->price,
                'in_stock' => StockAvailable::getQuantityAvailableByProduct($product->id) > 0,
                'url' => $this->context->link->getProductLink($product),
                'image' => $this->getMainImage($product),
                'categories' => $this->getCategoryIds($product)
            ]
        ];
    }

    private function getFeatures(Product $product): string
    {
        $features = $product->getFeatures();
        $featureStrings = [];

        foreach ($features as $feature) {
            $featureName = Feature::getFeatureName($feature['id_feature']);
            $featureValue = FeatureValue::getFeatureValueById($feature['id_feature_value']);
            $featureStrings[] = "$featureName: $featureValue";
        }

        return implode(', ', $featureStrings);
    }

    private function getStockStatus(Product $product): string
    {
        $quantity = StockAvailable::getQuantityAvailableByProduct($product->id);

        if ($quantity > 10) {
            return 'Auf Lager';
        } elseif ($quantity > 0) {
            return "Begrenzter Bestand ($quantity verfügbar)";
        } else {
            return 'Nicht auf Lager';
        }
    }
}

REST-API zur Synchronisierung

DEVELOPERpython
import requests
from typing import List, Dict

class PrestaShopConnector:
    def __init__(self, shop_url: str, api_key: str):
        self.base_url = f"{shop_url}/api"
        self.auth = (api_key, '')

    def get_all_products(self) -> List[Dict]:
        """Ruft alle Produkte über die PrestaShop-API ab."""
        products = []

        # Liste der IDs abrufen
        response = requests.get(
            f"{self.base_url}/products",
            auth=self.auth,
            params={'output_format': 'JSON', 'display': 'full'}
        )
        response.raise_for_status()

        for product in response.json().get('products', []):
            if product.get('active') == '1':
                formatted = self._format_product(product)
                products.append(formatted)

        return products

    def _format_product(self, product: dict) -> dict:
        """Formatiert ein Produkt für die RAG-Indexierung."""
        # Texte extrahieren (mehrsprachige Verwaltung)
        name = self._get_localized_text(product.get('name', []))
        description = self._get_localized_text(product.get('description', []))
        description_short = self._get_localized_text(product.get('description_short', []))

        content_parts = [
            f"Produktname: {name}",
            f"Referenz: {product.get('reference', '')}",
            f"Beschreibung: {self._clean_html(description)}",
            f"Zusammenfassung: {self._clean_html(description_short)}",
            f"Preis: {product.get('price', '0')} EUR",
        ]

        # Merkmale hinzufügen
        features = self._get_product_features(product.get('id'))
        if features:
            content_parts.append(f"Merkmale: {features}")

        return {
            "id": f"prestashop_{product['id']}",
            "title": name,
            "content": "\n".join(content_parts),
            "metadata": {
                "source": "prestashop",
                "product_id": product['id'],
                "reference": product.get('reference'),
                "price": float(product.get('price', 0)),
                "in_stock": int(product.get('quantity', 0)) > 0,
                "ean13": product.get('ean13'),
                "manufacturer": product.get('manufacturer_name'),
                "categories": self._get_category_names(product)
            }
        }

    def _get_localized_text(self, text_data) -> str:
        """Extrahiert den Text in der Standardsprache."""
        if isinstance(text_data, list) and text_data:
            return text_data[0].get('value', '')
        elif isinstance(text_data, dict):
            return text_data.get('value', '')
        return str(text_data) if text_data else ''

    def _clean_html(self, html: str) -> str:
        """Bereinigt HTML."""
        from bs4 import BeautifulSoup
        return BeautifulSoup(html or '', 'html.parser').get_text(separator=' ')

Systemprompt für PrestaShop-Support

DEVELOPERpython
PRESTASHOP_SUPPORT_PROMPT = """Du bist der Support-Assistent von {shop_name}, einem PrestaShop-Shop.

## Deine Aufgabe
Beantworte Kundenfragen zu Produkten, Bestellungen und Shop-Richtlinien.

## Support-Regeln
1. Antworte AUSSCHLIESSLICH mit Informationen aus der Wissensdatenbank
2. Frage bei Fragen zu einer bestimmten Bestellung nach der Bestellnummer
3. Teile niemals persönliche Daten oder Zahlungsinformationen mit
4. Wenn du das Problem nicht lösen kannst, biete an, den Kundenservice zu kontaktieren

## Fragetypen und Antworten

### Produktfragen
- Nutze die Produktdatenblätter für präzise Antworten
- Gib die aktuelle Verfügbarkeit an
- Schlage Alternativen bei Nichtverfügbarkeit vor

### Lieferfragen
- Erkläre die verfügbaren Versandarten
- Gib die Standardlieferzeiten an
- Frage für eine genaue Sendungsverfolgung nach der Bestellnummer

### Rückgabe-/Kundendienstfragen
- Erkläre die Rückgabebedingungen des Shops
- Führe durch das Rückgabeverfahren
- Beruhige bezüglich der Garantien

## Wissensdatenbank
{context}

## Gesprächsverlauf
{history}

## Kundenfrage
{query}

## Deine Antwort (professionell und hilfreich)
"""

Anwendungsfälle für den PrestaShop-Support

Fragen zu Produktmerkmalen

DEVELOPERpython
async def handle_product_question(product_ref: str, question: str):
    """Beantwortet Fragen zu einem bestimmten Produkt."""
    # Produkt suchen
    product = await search_by_reference(product_ref)

    if not product:
        return """
        Ich habe kein Produkt mit dieser Referenz gefunden.
        Können Sie die Nummer überprüfen oder mir das Produkt beschreiben?
        """

    prompt = f"""
    Kundenfrage zum Produkt: {product['title']}

    Produktinformationen:
    {product['content']}

    Frage: {question}

    Antworte präzise. Wenn die Information nicht verfügbar ist,
    biete an, den Kundenservice zu kontaktieren.
    """

    return await llm.generate(prompt)

Verfügbarkeitsprüfung

DEVELOPERpython
async def check_availability(query: str):
    """Prüft die Verfügbarkeit eines Produkts."""
    # Produkt identifizieren
    products = await retriever.search(query, top_k=3)

    if not products:
        return "Ich habe kein passendes Produkt gefunden. Können Sie es genauer beschreiben?"

    response_parts = []
    for product in products:
        status = "verfügbar" if product['metadata']['in_stock'] else "nicht auf Lager"
        response_parts.append(
            f"**{product['title']}**: {status}\n"
            f"Preis: {product['metadata']['price']} EUR\n"
            f"[Produkt ansehen]({product['metadata']['url']})"
        )

    return "\n\n".join(response_parts)

Größenberatung

DEVELOPERpython
async def handle_size_question(product_id: str, user_measurements: dict = None):
    """Hilft bei der Größenwahl."""
    product = await get_product(product_id)
    size_guide = await get_size_guide(product['metadata']['categories'][0])

    prompt = f"""
    Der Kunde bittet um Beratung zur Größe des Produkts: {product['title']}

    Größentabelle dieser Kategorie:
    {size_guide}

    {"Kundenmaße: " + str(user_measurements) if user_measurements else ""}

    Empfehle die passende Größe. Wenn die Informationen unzureichend sind,
    stelle die notwendigen Rückfragen (übliche Größe, Maße).
    """

    return await llm.generate(prompt)

Rückgaberichtlinie

DEVELOPERpython
RETURN_POLICY_CONTEXT = """
## Rückgaberichtlinie {shop_name}

**Rückgabefrist**: 30 Tage nach Erhalt

**Bedingungen**:
- Artikel unbenutzt, in Originalverpackung
- Etiketten noch angebracht
- Beiliegender Rücksendeschein

**Ablauf**:
1. Melden Sie sich in Ihrem Kundenbereich an
2. Gehen Sie zu "Meine Bestellungen"
3. Klicken Sie auf "Artikel zurücksenden"
4. Drucken Sie das vorfrankierte Rücksendeetikett aus
5. Geben Sie das Paket an einer Paketstation ab

**Erstattung**: Innerhalb von 14 Tagen nach Erhalt der Rücksendung
"""

async def handle_return_question(question: str, order_id: str = None):
    """Bearbeitet Fragen zu Rücksendungen."""
    context = RETURN_POLICY_CONTEXT

    if order_id:
        order_info = await get_order_info(order_id)
        if order_info:
            context += f"\n\nBestellinformationen #{order_id}:\n{order_info}"

    prompt = f"""
    {context}

    Kundenfrage: {question}

    Antworte beruhigend und führe den Kunden bei Bedarf durch das Verfahren.
    """

    return await llm.generate(prompt)

Integration des PrestaShop-Moduls

Hook für Chat-Widget

DEVELOPERphp
<?php
class AilogChat extends Module
{
    public function hookDisplayFooter()
    {
        // Widget-Konfiguration
        $this->context->smarty->assign([
            'ailog_channel_id' => Configuration::get('AILOG_CHANNEL_ID'),
            'current_product' => $this->getCurrentProduct(),
            'cart_info' => $this->getCartInfo(),
            'customer_info' => $this->getCustomerInfo()
        ]);

        return $this->display(__FILE__, 'views/templates/hook/chat_widget.tpl');
    }

    private function getCurrentProduct(): ?array
    {
        if ($id_product = Tools::getValue('id_product')) {
            $product = new Product($id_product, true, $this->context->language->id);
            return [
                'id' => $product->id,
                'name' => $product->name,
                'reference' => $product->reference,
                'price' => $product->price
            ];
        }
        return null;
    }
}

Smarty-Template

DEVELOPERsmarty
{* views/templates/hook/chat_widget.tpl *}
<script>
window.AilogConfig = {
    channelId: "{$ailog_channel_id}",
    context: {
        platform: "prestashop",
        {if $current_product}
        currentProduct: {$current_product|json_encode},
        {/if}
        cartItemsCount: {$cart_info.items_count|default:0},
        isLoggedIn: {if $customer_info}true{else}false{/if}
    },
    labels: {
        placeholder: "{l s='Stellen Sie Ihre Frage...' mod='ailogchat'}",
        sendButton: "{l s='Senden' mod='ailogchat'}"
    }
};
</script>
<script src="https://widget.ailog.fr/embed.js" async></script>

Eskalation an den menschlichen Support

Erkennung von Eskalationsfällen

DEVELOPERpython
def should_escalate(conversation: list, last_response: dict) -> bool:
    """Bestimmt, ob eine Eskalation notwendig ist."""
    escalation_triggers = [
        # Explizite Schlüsselwörter
        any(kw in msg['text'].lower() for msg in conversation[-2:]
            for kw in ['mit mensch sprechen', 'verantwortlicher', 'beschwerde', 'anwalt']),

        # Erkannte Frustration
        last_response.get('sentiment') == 'negative' and len(conversation) > 4,

        # Frage außerhalb des Zuständigkeitsbereichs
        last_response.get('confidence', 1) < 0.4,

        # Ungelöstes Bestellproblem
        'bestellung' in conversation[-1]['text'].lower() and len(conversation) > 6
    ]

    return any(escalation_triggers)

async def escalate_to_human(conversation: list, reason: str):
    """Leitet an einen menschlichen Mitarbeiter weiter."""
    # Ticket in PrestaShop erstellen
    ticket = await create_support_ticket(
        subject=f"Chatbot-Eskalation - {reason}",
        conversation=conversation,
        priority='high'
    )

    return f"""
    Ich verstehe, dass Sie eine ausführlichere Unterstützung benötigen.

    Ich habe ein Support-Ticket (#{ticket['id']}) erstellt, und ein Berater
    wird sich schnellstmöglich bei Ihnen melden.

    In der Zwischenzeit erreichen Sie uns auch:
    - Per E-Mail: support@{shop_domain}
    - Telefonisch: {support_phone}

    Vielen Dank für Ihre Geduld.
    """

Erfolg messen

Wichtige Kennzahlen

Analytics-Dashboard

DEVELOPERpython
def get_support_metrics(period_days: int = 30) -> dict:
    """Berechnet die Support-Leistungskennzahlen."""
    return {
        "total_conversations": count_conversations(period_days),
        "resolved_autonomously": count_resolved(period_days),
        "resolution_rate": calculate_resolution_rate(period_days),
        "avg_response_time": avg_response_time_ms(period_days),
        "avg_satisfaction": avg_csat_score(period_days),
        "top_topics": get_top_topics(period_days),
        "escalation_reasons": get_escalation_breakdown(period_days),
        "cost_savings": estimate_cost_savings(period_days)
    }

Weiterführende Ressourcen

• KI-Chatbot für E-Commerce - Leitfaden E-Commerce
• Dynamische FAQ für E-Commerce - Kontextbezogene Antworten generieren
• KI-Kundensupport - Support-Strategien
• Einführung in RAG - Grundlagen

Automatisieren Sie Ihren PrestaShop-Support mit Ailog

Die Bereitstellung eines Support-Assistenten auf PrestaShop kann Wochen dauern. Mit Ailog starten Sie schnell:

• PrestaShop-Modul: Vereinfachte Installation
• Katalogsynchronisierung: Automatisch und in Echtzeit
• Wissensdatenbank: FAQ und Richtlinien integrieren
• Intelligente Eskalation: Reibungslose Weiterleitung an Ihre Mitarbeiter
• DSGVO-Konformität: Hosting in Frankreich

Testen Sie Ailog in Ihrem PrestaShop-Shop und reduzieren Sie noch heute Ihre Support-Belastung.