Auparavant, actualiser les pages produits et copier des chiffres dans des feuilles de calcul était la norme. Cela fonctionnait, mais c'était lent, compliqué et on pouvait facilement passer à côté de l'essentiel. Aujourd'hui, nous disposons de meilleures options. Crawlbase En extrayant des données produits propres directement des sites web et en les triant grâce à l'IA, la surveillance devient plus précise. Elle évolue vers un système capable de signaler les variations de prix soudaines, de vous avertir en cas de baisse des stocks et même de repérer les tendances avant qu'elles ne deviennent évidentes. En bref, vous pouvez désormais détecter les tendances produits grâce au web scraping plutôt qu'aux conjectures.

Ainsi, dans ce guide, nous créons un outil qui se rapproche davantage d’un analyste numérique travaillant à vos côtés.

Table des Matières

Le flux de travail de l'outil de surveillance des produits IA

Considérez le système que nous allons construire comme un relais. Crawlbase Il récupère les pages produits d'Amazon, eBay ou de toute autre boutique vers laquelle vous le redirigez. Ces informations sont ensuite épurées pour ne conserver que les informations utiles, comme le prix, le nom du produit et l'état des stocks. Une fois nettoyées, les données sont transmises à Perplexity AI, qui les analyse et détecte des éléments qui pourraient passer inaperçus : une hausse soudaine des prix, une rupture de stock progressive ou une tendance naissante.

Enfin, ces informations sont compilées et transmises sous forme de rapport ou d’alerte, permettant à quelqu’un d’agir en conséquence.

Pré-requis :

Il est utile de préparer quelques éléments avant de se lancer dans la construction. Nul besoin d'être un expert, mais un peu de préparation sera très utile.

Compétences à apporter

  • Basic Python Compétences : Être capable de lire des scripts, de modifier des fonctions et de les exécuter sans se perdre.
  • Un peu de confort avec les API REST : vous devez être familiarisé avec l’envoi de requêtes et la vérification des réponses.
  • Une idée approximative de la manière dont les modèles d’IA réagissent lorsque vous leur donnez des invites structurées.

Outils pour créer une solution de surveillance de produits IA

  • A Crawlbase compte avec votre Crawling API jeton.
  • Une clé API de Perplexity AI.
  • Une machine locale avec Python installé.

Une fois ces éléments en place, nous pouvons commencer à créer les scripts pour extraire les données du produit, les exécuter via l'IA et laisser le système repérer les changements et les modèles pour vous.

Configuration des outils

Maintenant, préparons l'environnement. Nous allons installer Crawlbase pour le scraping et Perplexity AI pour l'analyse.

Crawlbase installation

  1. Créez un compte sur Crawlbase et connectez-vous.
  2. Copiez votre Crawling API jeton de demande normalC'est celui que nous utiliserons dans le script.
  3. Les nouveaux comptes incluent 1,000 XNUMX demandes gratuites. Si vous ajouter les détails de facturation avant de les utiliser, vous débloquez 9,000 XNUMX crédits gratuits supplémentaires.

Configuration de l'IA de Perplexity

Perplexité fournit une API compatible OpenAI, ce qui simplifie l'intégration.

  1. Récupérez votre clé API à partir du Tableau de bord du compte Perplexity.
  2. Dans votre code Python, configurez le client comme ceci :
1
2
3
4
5
6
importer ouvert

client = openai.OpenAI(
    api_key=" ",
    base_url=« https://api.perplexity.ai »
)

Gardez votre clé privéeNe vous engagez pas sur GitHub et ne le partagez pas dans des dépôts publics.

Étape 1 : Récupérer les données du produit

Avant de pouvoir suivre quoi que ce soit, il nous faut un moyen d'extraire les informations produit du site web d'une boutique. C'est la première étape. Pour commencer, copiez le script ci-dessous et enregistrez-le sous crawling.py et nous nous y appuierons plus tard.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
à partir de demandes.exceptions importer DemandeException
importer json
importer demandes

def crawl_amazon_product_details(url: str) -> str:
    API_TOKEN = "<Crawlbase Jeton de requêtes normales>"
    API_ENDPOINT = "https://api.crawlbase.com/"

    paramètres = {
        "jeton": API_TOKEN,
        "url": URL,
        "grattoir": « détails-du-produit-Amazon »
    }

    réponse = requêtes.get(API_ENDPOINT, params=params)
    réponse.raise_for_status()

    produit_json = json.loads(response.text)

    données = {
        "url": produit_json["corps"][« canonicalUrl »],
        "prix": produit_json["corps"]["Prix brut"],
        "devise": produit_json["corps"]["devise"],
        "prénom": produit_json["corps"]["prénom"]
    }

    champs_requis = ["prix", "prénom", "url", "devise"]
    missing_fields = [champ pour champ in champs obligatoires if pas data.get(champ)]

    if champs_manquants :
        augmenter ValeurErreur(f"Échec de l'extraction des données : champs obligatoires manquants : {','.join(champs_manquants)}")

    retourner données,

Assurez-vous de remplacer l'espace réservé <Crawlbase Normal requests token> avec votre réel Crawlbase jeton.

Étape 2 : Analyser les données à l'aide de Perplexity AI

Les chiffres seuls ne signifient pas grand-chose si on ne les comprend pas. C'est là qu'intervient Perplexity. Nous allons ajouter une fonction qui récupère les enregistrements de produits, effectue une vérification rapide pour s'assurer que tout est en ordre, puis affiche des statistiques utiles comme le nombre total d'enregistrements, les dates les plus anciennes et les plus récentes, les fourchettes de prix et même les écarts.

Créez un nouveau fichier appelé perplexity_ai.py et déposez le script là-dedans.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
importer json
importer ouvert
à partir de datetime importer dateheure, timedelta
def analyser_données(produits purs):
    if len(produits) 2:
        augmenter ValeurErreur(« Pas assez de données à analyser »)
    données_d'analyse = {
                "total_enregistrements": len(produits),
                "plage_de_dates": {
                    "le plus tôt": produits[-1]["horodatage"],
                    "dernier": produits[0]["horodatage"]
                },
                "historique_des_prix":[]
            }
    pour produits in renversé(produits):
        données_d'analyse["historique_des_prix"].ajouter({
            "horodatage": produit["horodatage"],
            "prix": produit["prix"],
            "devise": produit["devise"]
        })
    prix = [p["prix"] pour p in données_d'analyse["historique_des_prix"]]
    données_d'analyse["statistiques"] = {
        "prix_min": min(prix),
        "prix_max": max(prix),
        "prix_actuel": prix[-1],
        "gamme_de_prix": max(prix) - min(prix),
        « variance_de_prix »: somme((p - somme(prix)/len(prix))**2 pour p in prix) / len(prix)
    }
    rapide = f"""
    Analysez les données de prix des produits suivants et fournissez des informations au format JSON :
    Données du produit:
    {json.dumps(données_d'analyse, indent=2)}
    Veuillez analyser ces données et renvoyer une réponse JSON avec la structure suivante :
    {{
        « anomalies » : [
            {{
                "type": "pic_de_prix|baisse_de_prix|modèle_inhabituel",
                "description": "Description de l'anomalie",
                « gravité » : « faible|moyenne|élevée »,
                "timestamp": "Quand cela s'est produit",
                « confiance » : 0.85
            }}
        ],
        « tendances » : [
            {{
                "type": "croissant|décroissant|stable|volatile",
                "description": "Résumé de la tendance",
                "pourcentage_change": -5.2,
                "time_period": "la semaine dernière|le mois dernier|global",
                « confiance » : 0.90
            }}
        ],
        "motifs": [
            {{
                "type": "saisonnier|hebdomadaire|quotidien|aléatoire",
                "description": "Description du motif",
                « fréquence » : « quotidien|hebdomadaire|mensuel »,
                « confiance » : 0.75
            }}
        ],
        « recommandations » : [
            « Recommandation exploitable basée sur une analyse »
        ]
    }}
    Se concentrer sur:
    1. Détecter les variations de prix inhabituelles (anomalies) - rechercher des pics ou des baisses soudaines
    2. Identifier les tendances - direction générale des prix et variations en pourcentage
    3. Classer les modèles - modèles saisonniers, hebdomadaires ou autres modèles récurrents
    4. Fournir des informations exploitables
    Renvoie uniquement du JSON valide, aucun texte supplémentaire.
    "" "

    Essai:
        client = openai.OpenAI(api_key=" ", base_url=« https://api.perplexity.ai »)
        réponse = client.chat.completions.create(
            modèle =« sonar-pro »,
            message=[
                {
                    "rôle": "système",
                    "teneur": Vous êtes analyste de données spécialisé dans l'analyse des prix. Fournissez des informations précises et basées sur les données au format JSON.
                },
                {
                    "rôle": "utilisateur",
                    "teneur": rapide
                }
            ],
            température=0.1,
            max_tokens=2000
        )

        analyse_résultat = json.loads(response.choices[0]contenu du message)
        résultat_analyse[« métadonnées »] = {
            "analyse_horodatage": datetime.now().isoformat(),
            « points_de_données_analysés »: données_d'analyse["total_enregistrements"],
            "modèle_utilisé": « sonar-pro »
        }

        retourner résultat_d'analyse

    sauf openai.AuthenticationError :
        retourner {
            "Erreur": « L'authentification API OpenAI a échoué. Veuillez vérifier votre clé API. »,
            « anomalies »: []
            « tendances »: []
            "motifs":[]
        }
    sauf json.JSONDecodeError :
        retourner {
            "Erreur": « Échec de l'analyse de la réponse OpenAI. Le modèle a peut-être renvoyé un JSON non valide. »,
            « anomalies »: []
            « tendances »: []
            "motifs":[]
        }
    sauf Exception as e:
        retourner {
            "Erreur": f"L'analyse a échoué : {str(e)}",
            « anomalies »: []
            « tendances »: []
            "motifs":[]
        }

Ce script transforme les données brutes sur les prix des produits en un ensemble de données structuré, demande à un modèle d'IA de les analyser pour détecter les anomalies, les tendances et les modèles, puis renvoie ces informations au format JSON, tout en gérant les erreurs en toute sécurité.

Gardez à l'esprit que l'invite n'est pas figée. Vous pouvez ajuster sa formulation, la raccourcir ou même demander différents angles d'approche selon vos objectifs. Il vous suffit de modifier le texte dans le code, et l'IA ajustera sa réponse en conséquence.

Étape 3 : Comment générer un rapport d’analyse d’IA

Avant d'exécuter le code, nous avons besoin de données de test pour ce blog. Suivez les étapes ci-dessous :

  1. Obtenez l'exemple de script à partir du GitHub référentiel et enregistrez-le sous dummy_data.py pour peupler la base de données.
  2. Exécutez le script en exécutant :
1
python dummy_data.py

Cela devrait insérer des enregistrements dans votre base de données comme ceci :

  1. Une fois les données factices insérées, copiez le script ci-dessous et enregistrez-le sous price_monitoring.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
à partir de base de données importer requête_produits;
à partir de perplexité_ai importer analyser_données;
importer json

def prix_du_moniteur†
    Essai:
        produits = query_products()
        analyse_résultat = analyser_données(produits)

        impression("=" * 80)
        impression(« RÉSULTATS D'ANALYSE DE SUIVI DES PRODUITS »)
        impression("=" * 80)
        impression()

        impression(json.dumps(résultat_d'analyse, indent=2, assurer_ascii=Faux))

        impression()
        impression("=" * 80)
        impression(« FIN DES RÉSULTATS D'ANALYSE »)
        impression("=" * 80)

    sauf Exception as e:
        impression(f"Prix de surveillance des erreurs : {str(e)}")

if __nom__ == "__principale__":
    # # Décommentez le code ci-dessous si vous ne souhaitez pas utiliser de données factices
    # à partir de l'importation crawl_amazon_product_details
    # depuis la base de données importer add_products_to_db

    # product_data = crawl_amazon_product_details("https://www.amazon.com/Apple-iPhone-16-Version-128GB/dp/B0DHJH2GZL/ref=sr_1_1")
    # add_products_to_db(données_produit)
    moniteur_prix()

Une fois tout en place, exécutez le code :

1
python price_monitoring.py

Voici l'exemple de sortie produit par Perplexity AI :

Étape 4 : Automatiser et planifier les rapports d’IA

Pour la démo, nous avons gardé les choses légères avec un petit script appelé schedule.py (vous pouvez le trouver dans le GitHub repo). Il est configuré pour s'exécuter une fois par jour à 10h00. Pour le lancer manuellement, exécutez simplement :

1
programme python.py

Si vous souhaitez une solution fiable en utilisation réelle, utilisez le planificateur natif de votre système. Sous Linux, cela implique généralement la configuration d'un CronSous Windows, vous choisiriez probablement Planificateur de tâches.

Étape 5 : Visualisation des résultats de l’IA

Obtenir les prix n'est que la moitié du travail. Le plus difficile est de comprendre ce qu'ils disent réellement en regardant l'ensemble. C'est là que quelques visuels peuvent grandement vous simplifier la vie.

Si vous recherchez un outil élégant et interactif, un tableau de bord léger avec Plotly ou Bokeh fera l'affaire. Vous disposez de graphiques sur lesquels vous pouvez survoler, zoomer et déposer directement sur une page web.

Alternativement, si vous voulez quelque chose de plus rapide, utilisez matplotlib or marinIls existent depuis toujours, sont infiniment flexibles et vous pouvez les habiller pour qu'ils correspondent au look que vous recherchez.

Si vous n'avez pas envie de regarder des chiffres ou des barres trop longtemps, vous pouvez même vous appuyer sur l'IA. Des services comme Perplexity produiront des résumés concis et clairs de votre ensemble de données. Ainsi, au lieu de passer au crible un mur de valeurs, vous disposerez de quelques conclusions claires et précises, juste à côté de vos visuels.

Récapitulation

Le scraping d'une page n'est que le point de départ. Une fois que vous avez Crawlbase avec Python et un peu d'IA, l'ensemble du processus se transforme en quelque chose de beaucoup plus grand : vous ne collectez pas seulement des données, vous les transformez en informations sur lesquelles vous pouvez agir.

Si vous êtes curieux de voir à quoi cela ressemble dans le monde réel, cela vaut la peine de le tester sur vos concurrents. Crawlbase En gérant la complexité, vous pouvez extraire les données dont vous avez besoin et laisser l'IA signaler les changements sur le marché avant que quiconque ne le remarque. Donner Crawlbase un essai aujourd'hui et prenez une longueur d'avance.

Foire aux questions

Q. Que se passe-t-il si mes demandes continuent d’être bloquées ?

A. Être bloqué est l'un des plus gros obstacles au web scraping. Crawlbase, ce processus est géré automatiquement grâce à la rotation des adresses IP et à de nouveaux agents utilisateurs. Chaque requête est unique, comme un véritable visiteur, ce qui assure le bon fonctionnement de votre crawl et un taux de réussite élevé.

Q. Que se passe-t-il si un site Web modifie sa mise en page ou sa structure de données ?

A. Les sites web évoluent ; leurs mises en page et leurs structures HTML sont fréquemment mises à jour. Dans ce cas, vos sélecteurs existants peuvent cesser de fonctionner. La solution est généralement rapide : ajustez vos sélecteurs à la nouvelle structure. Parce que Crawlbase renvoie toujours le code HTML complet, vous n'avez pas besoin de reconstruire votre robot à partir de zéro ; il suffit d'affiner la logique d'analyse.

Q. Les modèles d’IA peuvent-ils « halluciner » lors de l’analyse des données récupérées ?

A. L'IA génère parfois des réponses faciles à lire, mais qui ne correspondent pas aux données sous-jacentes. La meilleure façon d'éviter ce problème est de donner au modèle des instructions claires et structurées et de limiter la créativité. Les invites demandant des résultats spécifiques, comme un résumé ou un tableau, permettent généralement à l'IA de rester en phase avec votre jeu de données réel.