Générateur de fiches produit en masse avec Claude

Ce que vous saurez faire à la fin

1. Définir un schéma Product structuré (titre, bullets, description longue, balises SEO, attributs)
2. Construire un prompt template paramétrable couvrant 1000+ références produit
3. Industrialiser la génération via la Batch API d’Anthropic à 50% du tarif standard
4. Gérer la diversité catégorielle (couleurs, tailles, matières, usages) sans répétition rédactionnelle
5. Mettre en place un contrôle qualité automatique (longueur, mots interdits, conformité OHADA)

Durée : 4h. Pré-requis : compte Anthropic API actif (clé sk-ant-…), Python 3.10+ avec le SDK anthropic, un fichier CSV ou Google Sheet contenant vos références produit, budget mensuel à partir de 25 000 FCFA pour 1000 fiches en Sonnet.

Étape 1 — Cadrer le besoin business avant d’écrire la moindre ligne

Avant de lancer un générateur de fiches produit, listez les canaux de diffusion : Shopify, WooCommerce, marketplace Jumia, Afrikrea ou catalogue PDF imprimé en agence. Chaque canal impose ses contraintes (titre maximum 60 caractères pour Jumia, 70 pour Google Shopping, 200 pour la fiche WooCommerce détaillée). Pour une PME sénégalaise vendant 1500 références d’accessoires de mode sur trois canaux, prévoyez trois variantes de titre par produit. Le calcul devient simple : 1500 × 3 = 4500 générations. À 0,003 USD par fiche en Claude Sonnet, le coût total tient sous 9 USD soit environ 5 500 FCFA par génération complète du catalogue.

Étape 2 — Préparer le schéma Product de référence

Un schéma figé évite les hallucinations sur les champs manquants. Stockez-le en JSON et utilisez-le comme contrat dans tous vos prompts.

PRODUCT_SCHEMA = {
    "sku": "string, identifiant unique fournisseur",
    "title_short": "string, max 60 car., orienté SEO Google",
    "title_long": "string, max 200 car., orienté conversion",
    "bullets": "array de 5 puces, max 120 car. chacune",
    "description_html": "string, 250-350 mots, balises <p> et <ul> uniquement",
    "attributes": {
        "color": "string ou liste",
        "size": "string ou liste",
        "material": "string",
        "country_of_origin": "string"
    },
    "seo_meta_title": "string, max 65 car.",
    "seo_meta_description": "string, max 160 car.",
    "tags": "array de 5 à 8 tags pertinents"
}

Étape 3 — Construire le prompt template paramétrable

Le prompt template est le coeur du système. Il doit injecter les données brutes (nom commercial, catégorie, prix FCFA, attributs fournisseur) et imposer le format de sortie en JSON strict pour parsing automatique.

PROMPT_TEMPLATE = """Tu es rédacteur e-commerce senior pour une PME sénégalaise.
Génère une fiche produit complète en français professionnel, ton chaleureux mais factuel,
adapté à une clientèle ouest-africaine (références FCFA, livraison Dakar/Thiès/Saint-Louis).

Données brutes du produit :
- Nom commercial : {nom}
- Catégorie : {categorie}
- Sous-catégorie : {sous_categorie}
- Prix de vente : {prix} FCFA
- Couleurs disponibles : {couleurs}
- Tailles : {tailles}
- Matière : {matiere}
- Pays d'origine : {origine}
- Argument différenciant fournisseur : {usp}

Contraintes impératives :
1. Title_short : maximum 60 caractères, contient le mot-clé principal
2. Bullets : 5 puces, chacune commence par un verbe d'action
3. Description : 250-350 mots, structure problème -> solution -> preuve
4. Pas de superlatifs creux ("le meilleur", "incroyable", "révolutionnaire")
5. Mentionner explicitement la disponibilité au Sénégal et le paiement à la livraison
6. Tags : 5 à 8, en minuscules, sans accents

Réponds UNIQUEMENT en JSON valide respectant ce schéma :
{schema}
"""

Étape 4 — Premier appel API en mode synchrone pour valider

Avant de basculer en batch, testez sur 3 à 5 produits réels pour calibrer le ton.

import anthropic
import json

client = anthropic.Anthropic()

def generer_fiche(produit, schema):
    prompt = PROMPT_TEMPLATE.format(
        nom=produit["nom"],
        categorie=produit["categorie"],
        sous_categorie=produit["sous_categorie"],
        prix=produit["prix"],
        couleurs=", ".join(produit["couleurs"]),
        tailles=", ".join(produit["tailles"]),
        matiere=produit["matiere"],
        origine=produit["origine"],
        usp=produit["usp"],
        schema=json.dumps(schema, indent=2, ensure_ascii=False)
    )
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2000,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(response.content[0].text)

# Test
produit_demo = {
    "nom": "Sandales en cuir Ndombo",
    "categorie": "Chaussures",
    "sous_categorie": "Sandales femme",
    "prix": 18500,
    "couleurs": ["camel", "noir", "bordeaux"],
    "tailles": ["36", "37", "38", "39", "40"],
    "matiere": "cuir pleine fleur tanné végétal",
    "origine": "Atelier de Pikine, Sénégal",
    "usp": "Semelle cousue main, garantie 6 mois"
}
fiche = generer_fiche(produit_demo, PRODUCT_SCHEMA)
print(json.dumps(fiche, indent=2, ensure_ascii=False))

Étape 5 — Calculer le coût et choisir Sonnet ou Haiku

Pour 1000 fiches avec environ 800 tokens en entrée et 1200 en sortie, voici la grille comparative.

Étape 6 — Basculer en Batch API pour diviser le coût par 2

La Batch API d’Anthropic traite jusqu’à 100 000 requêtes en 24h avec une réduction tarifaire de 50%. Idéale pour catalogue mensuel ou lancement saisonnier.

import anthropic

client = anthropic.Anthropic()

def construire_batch(produits, schema):
    requests = []
    for p in produits:
        prompt = PROMPT_TEMPLATE.format(
            nom=p["nom"], categorie=p["categorie"],
            sous_categorie=p["sous_categorie"], prix=p["prix"],
            couleurs=", ".join(p["couleurs"]),
            tailles=", ".join(p["tailles"]),
            matiere=p["matiere"], origine=p["origine"],
            usp=p["usp"],
            schema=json.dumps(schema, ensure_ascii=False)
        )
        requests.append({
            "custom_id": f"sku-{p['sku']}",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 2000,
                "messages": [{"role": "user", "content": prompt}]
            }
        })
    return requests

batch = client.messages.batches.create(requests=construire_batch(catalogue, PRODUCT_SCHEMA))
print("Batch ID :", batch.id, "- Statut :", batch.processing_status)

Étape 7 — Diversifier le ton selon la catégorie

Une fiche de pagne wax et une fiche d’écouteurs Bluetooth ne se rédigent pas pareil. Créez 4 à 6 sous-prompts par grande famille produit, et sélectionnez dynamiquement la variante.

VARIANTES_TON = {
    "Mode": "Vocabulaire sensoriel (toucher, drapé, tombé), références culturelles wolof acceptées",
    "Electronique": "Précision technique, specs en premier, ton expert mais accessible",
    "Maison": "Lifestyle, mise en scène d'usage (salon familial, dîner Korité)",
    "Beauté": "Bénéfices peau, ingrédients actifs, conformité réglementation cosmétique",
    "Alimentation": "Origine, traçabilité, recettes suggérées, mention DLC obligatoire"
}

def selectionner_variante(categorie):
    return VARIANTES_TON.get(categorie, "Ton neutre, factuel, orienté bénéfice client")

Étape 8 — Récupérer et parser les résultats du batch

import time

def attendre_batch(batch_id, timeout=86400):
    debut = time.time()
    while time.time() - debut < timeout:
        b = client.messages.batches.retrieve(batch_id)
        if b.processing_status == "ended":
            return b
        print(f"Statut : {b.processing_status}, requêtes traitées : {b.request_counts.succeeded}")
        time.sleep(60)
    raise TimeoutError("Batch non terminé après 24h")

def telecharger_resultats(batch):
    fiches = {}
    for result in client.messages.batches.results(batch.id):
        if result.result.type == "succeeded":
            sku = result.custom_id.replace("sku-", "")
            try:
                fiches[sku] = json.loads(result.result.message.content[0].text)
            except json.JSONDecodeError:
                fiches[sku] = {"erreur": "JSON invalide", "raw": result.result.message.content[0].text}
        else:
            fiches[result.custom_id] = {"erreur": result.result.error}
    return fiches

Étape 9 — Contrôle qualité automatique des fiches générées

Avant publication, passez chaque fiche dans un validateur qui vérifie longueurs, mots interdits et conformité OHADA (mentions obligatoires sur garantie commerciale).

MOTS_INTERDITS = ["meilleur", "exceptionnel", "révolutionnaire", "magique", "miracle"]
MENTIONS_OBLIGATOIRES = ["FCFA", "livraison", "garantie"]

def valider_fiche(fiche):
    erreurs = []
    if len(fiche.get("title_short", "")) > 60:
        erreurs.append("Title_short dépasse 60 car.")
    if len(fiche.get("bullets", [])) != 5:
        erreurs.append("Doit contenir exactement 5 bullets")
    desc = fiche.get("description_html", "").lower()
    for mot in MOTS_INTERDITS:
        if mot in desc:
            erreurs.append(f"Mot interdit : {mot}")
    for mention in MENTIONS_OBLIGATOIRES:
        if mention.lower() not in desc:
            erreurs.append(f"Mention manquante : {mention}")
    nb_mots = len(desc.split())
    if not (250 <= nb_mots <= 350):
        erreurs.append(f"Description {nb_mots} mots (cible 250-350)")
    return erreurs

Étape 10 — Re-générer automatiquement les fiches non conformes

Implémentez une boucle de remédiation : toute fiche avec plus de 2 erreurs repart automatiquement vers Claude avec le feedback explicite.

def regenerer_avec_feedback(produit, fiche_initiale, erreurs):
    feedback = "\n".join(f"- {e}" for e in erreurs)
    prompt_correction = f"""Voici une fiche produit que tu as générée mais qui contient des erreurs :

{json.dumps(fiche_initiale, indent=2, ensure_ascii=False)}

Erreurs détectées :
{feedback}

Reprends intégralement la fiche en corrigeant ces points. Réponds en JSON strict."""
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2000,
        messages=[{"role": "user", "content": prompt_correction}]
    )
    return json.loads(response.content[0].text)

Étape 11 — Publier dans Shopify ou WooCommerce via API

Pour Shopify, utilisez l’endpoint POST /admin/api/2024-04/products.json. Pour WooCommerce, l’endpoint est POST /wp-json/wc/v3/products. Mappez les champs title_long, description_html et tags directement. Stockez le SKU comme identifiant pivot pour éviter les doublons en cas de réimport.

Étape 12 — Mettre en place un dashboard de suivi

Étape 13 — Industrialiser la mise à jour mensuelle

Planifiez un cron mensuel (le 1er à 02h00 GMT) qui : extrait les nouveaux SKU du PIM, lance le batch, attend le résultat, valide, publie. Ajoutez une alerte Slack ou WhatsApp Business si le taux d’erreur dépasse 8%. Pour 1500 références mensuelles, comptez 12 600 FCFA en API plus 30 minutes de supervision humaine.

Étape 14 — Itérer sur les top 50 produits avec Opus

Identifiez chaque trimestre les 50 produits qui génèrent 80% du chiffre d’affaires. Re-générez ces fiches stratégiques avec Claude Opus en mode synchrone, en injectant en plus les avis clients positifs et négatifs collectés. Le surcoût (environ 3 200 FCFA pour 50 fiches) est amorti dès la première semaine sur l’augmentation du taux de conversion.

Erreurs classiques à éviter

• Lancer un batch de 5000 fiches sans pilote : vous découvrez après 8h que toutes les fiches contiennent un mot interdit, et vous brûlez 18 000 FCFA pour rien.
• Oublier le paramètre ensure_ascii=False : les caractères accentués deviennent illisibles dans la sortie JSON et cassent l’import Shopify.
• Ne pas versionner le prompt template : impossible de comparer les performances entre deux campagnes ou de revenir à une version antérieure.
• Mélanger plusieurs catégories produit dans le même prompt : Claude perd en précision rédactionnelle, le ton devient générique.
• Publier directement sans validation humaine sur le top 20 : une fiche mal cadrée sur un best-seller peut tuer 2 semaines de trafic SEO.

Checklist Générateur de fiches produit

✓ Schéma Product JSON figé et documenté
✓ Prompt template versionné dans Git
✓ Variantes de ton par catégorie produit définies
✓ Test synchrone validé sur 5 produits réels
✓ Coût simulé Sonnet vs Haiku vs Opus calculé
✓ Batch API configuré avec custom_id traçables
✓ Validateur automatique avec mots interdits et mentions obligatoires
✓ Boucle de remédiation pour fiches non conformes
✓ Intégration Shopify ou WooCommerce testée sur 10 SKU
✓ Dashboard KPI (coût, taux d'erreur, conversion) opérationnel
✓ Cron mensuel programmé avec alerting Slack ou WhatsApp
✓ Top 50 produits ré-écrits trimestriellement avec Opus
✓ Sauvegarde des fiches générées dans un bucket S3 ou Drive
✓ Procédure de rollback documentée (versioning catalogue)
✓ Budget mensuel API plafonné dans la console Anthropic