PrestaShop : Automatiser le support produit

PrestaShop equipe plus de 300 000 boutiques en ligne, principalement en Europe. L'automatisation du support produit via un assistant IA permet de repondre instantanement aux questions clients tout en liberant du temps pour votre equipe. Ce guide detaille comment deployer un chatbot RAG optimise pour PrestaShop.

Le defi du support e-commerce

Les questions repetitives consomment du temps

Une etude interne sur les boutiques PrestaShop revele que 70% des questions support concernent :

• Disponibilite des produits et delais de livraison
• Caracteristiques techniques et compatibilites
• Procedures de retour et echange
• Suivi de commande
• Tailles et guides de mesure

Ces questions ont des reponses standardisees mais necessitent actuellement une intervention humaine.

Cout du support manuel

L'avantage RAG pour le support

Un assistant RAG connecte a votre base PrestaShop peut :

• Repondre aux questions produits avec precision
• Connaitre l'etat du stock en temps reel
• Expliquer les politiques de retour specifiques
• Guider dans le processus d'achat
• Escalader intelligemment vers un humain si necessaire

Architecture PrestaShop + RAG

Connecteur catalogue PrestaShop

DEVELOPERphp
<?php
// Module PrestaShop pour export catalogue RAG

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

        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
    {
        // Description enrichie pour le RAG
        $content = sprintf(
            "Produit : %s\n" .
            "Reference : %s\n" .
            "Description : %s\n" .
            "Caracteristiques : %s\n" .
            "Prix : %s EUR\n" .
            "Disponibilite : %s\n" .
            "Categories : %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 'En stock';
        } elseif ($quantity > 0) {
            return "Stock limite ($quantity disponibles)";
        } else {
            return 'Rupture de stock';
        }
    }
}

API REST pour synchronisation

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]:
        """Recupere tous les produits via l'API PrestaShop."""
        products = []

        # Recuperer la liste des IDs
        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:
        """Formate un produit pour l'indexation RAG."""
        # Extraire les textes (gestion multilingue)
        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"Nom du produit : {name}",
            f"Reference : {product.get('reference', '')}",
            f"Description : {self._clean_html(description)}",
            f"Resume : {self._clean_html(description_short)}",
            f"Prix : {product.get('price', '0')} EUR",
        ]

        # Ajouter les caracteristiques
        features = self._get_product_features(product.get('id'))
        if features:
            content_parts.append(f"Caracteristiques : {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:
        """Extrait le texte dans la langue par defaut."""
        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:
        """Nettoie le HTML."""
        from bs4 import BeautifulSoup
        return BeautifulSoup(html or '', 'html.parser').get_text(separator=' ')

Prompt systeme support PrestaShop

DEVELOPERpython
PRESTASHOP_SUPPORT_PROMPT = """Tu es l'assistant support de {shop_name}, une boutique PrestaShop.

## Ta mission
Repondre aux questions des clients sur les produits, commandes et politiques de la boutique.

## Regles de support
1. Reponds UNIQUEMENT avec les informations de la base de connaissances
2. Pour les questions sur une commande specifique, demande le numero de commande
3. Ne jamais communiquer d'informations personnelles ou de paiement
4. Si tu ne peux pas resoudre le probleme, propose de contacter le service client

## Types de questions et reponses

### Questions produits
- Utilise les fiches produits pour repondre precisement
- Indique la disponibilite actuelle
- Propose des alternatives si rupture de stock

### Questions livraison
- Explique les modes de livraison disponibles
- Indique les delais standards
- Pour un suivi precis, demande le numero de commande

### Questions retours/SAV
- Explique la politique de retour de la boutique
- Guide dans la procedure de retour
- Rassure sur les garanties

## Base de connaissances
{context}

## Historique conversation
{history}

## Question client
{query}

## Ta reponse (professionnelle et aidante)
"""

Cas d'usage support PrestaShop

Questions sur les caracteristiques produit

DEVELOPERpython
async def handle_product_question(product_ref: str, question: str):
    """Repond aux questions sur un produit specifique."""
    # Rechercher le produit
    product = await search_by_reference(product_ref)

    if not product:
        return """
        Je n'ai pas trouve de produit avec cette reference.
        Pouvez-vous verifier le numero ou me decrire le produit ?
        """

    prompt = f"""
    Question client sur le produit : {product['title']}

    Informations produit :
    {product['content']}

    Question : {question}

    Reponds precisement. Si l'information n'est pas disponible,
    propose de contacter le service client.
    """

    return await llm.generate(prompt)

Verification de disponibilite

DEVELOPERpython
async def check_availability(query: str):
    """Verifie la disponibilite d'un produit."""
    # Identifier le produit
    products = await retriever.search(query, top_k=3)

    if not products:
        return "Je n'ai pas trouve de produit correspondant. Pouvez-vous preciser ?"

    response_parts = []
    for product in products:
        status = "disponible" if product['metadata']['in_stock'] else "en rupture"
        response_parts.append(
            f"**{product['title']}** : {status}\n"
            f"Prix : {product['metadata']['price']} EUR\n"
            f"[Voir le produit]({product['metadata']['url']})"
        )

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

Guide des tailles

DEVELOPERpython
async def handle_size_question(product_id: str, user_measurements: dict = None):
    """Aide au choix de taille."""
    product = await get_product(product_id)
    size_guide = await get_size_guide(product['metadata']['categories'][0])

    prompt = f"""
    Le client demande conseil pour la taille du produit : {product['title']}

    Guide des tailles de cette categorie :
    {size_guide}

    {"Mensurations du client : " + str(user_measurements) if user_measurements else ""}

    Conseille la taille appropriee. Si les informations sont insuffisantes,
    pose les questions necessaires (taille habituelle, mensurations).
    """

    return await llm.generate(prompt)

Politique de retour

DEVELOPERpython
RETURN_POLICY_CONTEXT = """
## Politique de retour {shop_name}

**Delai de retour** : 30 jours apres reception

**Conditions** :
- Article non utilise, dans son emballage d'origine
- Etiquettes encore attachees
- Accompagne du bon de retour

**Procedure** :
1. Connectez-vous a votre espace client
2. Allez dans "Mes commandes"
3. Cliquez sur "Retourner un article"
4. Imprimez l'etiquette de retour prepayee
5. Deposez le colis dans un point relais

**Remboursement** : Sous 14 jours apres reception du retour
"""

async def handle_return_question(question: str, order_id: str = None):
    """Gere les questions sur les retours."""
    context = RETURN_POLICY_CONTEXT

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

    prompt = f"""
    {context}

    Question du client : {question}

    Reponds de maniere rassurante et guide le client dans la procedure si necessaire.
    """

    return await llm.generate(prompt)

Integration module PrestaShop

Hook pour widget chat

DEVELOPERphp
<?php
class AilogChat extends Module
{
    public function hookDisplayFooter()
    {
        // Configuration du widget
        $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;
    }
}

Template Smarty

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='Posez votre question...' mod='ailogchat'}",
        sendButton: "{l s='Envoyer' mod='ailogchat'}"
    }
};
</script>
<script src="https://widget.ailog.fr/embed.js" async></script>

Escalade vers support humain

Detection des cas d'escalade

DEVELOPERpython
def should_escalate(conversation: list, last_response: dict) -> bool:
    """Determine si l'escalade est necessaire."""
    escalation_triggers = [
        # Mots-cles explicites
        any(kw in msg['text'].lower() for msg in conversation[-2:]
            for kw in ['parler humain', 'responsable', 'reclamation', 'avocat']),

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

        # Question hors perimetre
        last_response.get('confidence', 1) < 0.4,

        # Probleme commande non resolu
        'commande' in conversation[-1]['text'].lower() and len(conversation) > 6
    ]

    return any(escalation_triggers)

async def escalate_to_human(conversation: list, reason: str):
    """Transfere vers un agent humain."""
    # Creer un ticket dans PrestaShop
    ticket = await create_support_ticket(
        subject=f"Escalade chatbot - {reason}",
        conversation=conversation,
        priority='high'
    )

    return f"""
    Je comprends que vous avez besoin d'une assistance plus approfondie.

    J'ai cree un ticket de support (#{ticket['id']}) et un conseiller
    va vous recontacter dans les plus brefs delais.

    En attendant, vous pouvez aussi nous joindre :
    - Par email : support@{shop_domain}
    - Par telephone : {support_phone}

    Merci de votre patience.
    """

Mesurer l'efficacite

Metriques cles

Dashboard analytics

DEVELOPERpython
def get_support_metrics(period_days: int = 30) -> dict:
    """Calcule les metriques de performance support."""
    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)
    }

Ressources complementaires

• Chatbot E-commerce IA - Guide pilier e-commerce
• FAQ dynamique e-commerce - Generer des reponses contextuelles
• Support Client IA - Strategies de support
• Introduction au RAG - Fondamentaux

Automatisez votre support PrestaShop avec Ailog

Deployer un assistant support sur PrestaShop peut prendre des semaines. Avec Ailog, lancez-vous rapidement :

• Module PrestaShop : Installation simplifiee
• Synchronisation catalogue : Automatique et temps reel
• Base de connaissances : Integrez FAQ et politiques
• Escalade intelligente : Transfert fluide vers vos agents
• Conformite RGPD : Hebergement France

Testez Ailog sur votre boutique PrestaShop et reduisez votre charge support des aujourd'hui.