Früher war das Aktualisieren von Produktseiten und das Kopieren von Zahlen in Tabellenkalkulationen üblich. Es funktionierte zwar, war aber langsam, chaotisch und man übersah leicht, was wirklich wichtig war. Jetzt haben wir bessere Möglichkeiten. Mit Crawlbase Durch die Extraktion sauberer Produktdaten direkt von Websites und die KI-gestützte Sortierung des Datenrauschens wird das Monitoring deutlich präziser. Es entwickelt sich zu einem System, das plötzliche Preisschwankungen erkennen, Sie bei sinkenden Lagerbeständen warnen und sogar Trends erkennen kann, bevor sie offensichtlich sind. Kurz gesagt: Sie können Produkttrends jetzt mithilfe von Web Scraping erkennen, anstatt zu raten.

Deshalb erstellen wir in diesem Handbuch ein Tool, das eher einem digitalen Analysten ähnelt, der mit Ihnen zusammenarbeitet.

Inhaltsverzeichnis

Der Workflow des AI Product Monitoring Tools

Stellen Sie sich das System, das wir bauen werden, als Relais vor. Crawlbase greift auf Produktseiten von Anbietern wie Amazon, eBay oder anderen Onlineshops zu. Diese Informationen werden dann so gekürzt, dass nur die nützlichen Informationen wie Preis, Produktname und Lagerbestand übrig bleiben. Nach der Bereinigung werden die Daten an Perplexity AI weitergeleitet, das sie analysiert und Dinge erkennt, die übersehen werden könnten: einen plötzlichen Preisanstieg, einen langsam zur Neige gehenden Lagerbestand oder einen sich abzeichnenden Trend.

Abschließend werden diese Erkenntnisse zusammengestellt und als Bericht oder Warnmeldung übermittelt, sodass entsprechende Maßnahmen ergriffen werden können.

Voraussetzungen:

Es ist hilfreich, ein paar Dinge vorbereitet zu haben, bevor man mit dem Bau beginnt. Sie müssen kein Experte sein, aber ein wenig Vorarbeit ist sehr hilfreich.

Mitzubringende Fähigkeiten

  • Grundlagen Python Fähigkeiten: In der Lage sein, Skripte zu lesen, Funktionen zu optimieren und sie auszuführen, ohne den Überblick zu verlieren.
  • Einige Kenntnisse im Umgang mit REST-APIs: Sie sollten mit dem Senden von Anfragen und dem Überprüfen von Antworten vertraut sein.
  • Eine grobe Vorstellung davon, wie KI-Modelle reagieren, wenn Sie ihnen strukturierte Eingabeaufforderungen geben.

Tools zum Erstellen einer KI-Produktüberwachungslösung

  • A Crawlbase Konto bei Ihrem Crawling API Token
  • Ein API-Schlüssel von Perplexity AI.
  • Ein lokaler Computer mit installiertem Python.

Sobald diese vorhanden sind, können wir mit der Erstellung der Skripte zum Extrahieren von Produktdaten beginnen, diese durch KI laufen lassen und das System Veränderungen und Muster für Sie erkennen lassen.

Einrichten der Werkzeuge

Nun bereiten wir die Umgebung vor. Wir richten ein Crawlbase zum Scraping und Perplexity AI zur Analyse.

Crawlbase Einrichtung

  1. Erstelle ein Konto bei Crawlbase und logge dich ein.
  2. Kopieren Sie Ihre Crawling API Normales Anforderungstoken. Dies ist die, die wir im Skript verwenden werden.
  3. Neue Konten beinhalten 1,000 kostenlose Anfragen. Wenn Sie Rechnungsdetails hinzufügen Bevor Sie sie verwenden, schalten Sie zusätzliche 9,000 kostenlose Credits frei.

Perplexity AI-Setup

Verwirrung bietet eine OpenAI-kompatible API, die die Integration vereinfacht.

  1. Holen Sie sich Ihren API-Schlüssel von der Perplexity-Konto-Dashboard.
  2. Konfigurieren Sie den Client in Ihrem Python-Code wie folgt:
1
2
3
4
5
6
importieren öffnen

Client = openai.OpenAI(
    API-Schlüssel =" ",
    base_url="https://api.perplexity.ai"
)

Halten Sie Ihren Schlüssel geheim. Übertragen Sie es nicht auf GitHub und teilen Sie es nicht in öffentlichen Repos.

Schritt 1: Produktdaten abrufen

Bevor wir etwas verfolgen können, müssen wir Produktinformationen von der Website eines Shops extrahieren. Das ist im Grunde das erste Puzzleteil. Kopieren Sie zunächst das folgende Skript. Speichern Sie es unter crawling.py und wir werden später darauf aufbauen.

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
von Anfragen.Ausnahmen importieren RequestException
importieren JSON
importieren Zugriffe

def crawl_amazon_product_details(url: str) -> str:
    API_TOKEN = "<Crawlbase Token für normale Anfragen>"
    API_ENDPOINT = "https://api.crawlbase.com/"

    Parameter = {
        "Zeichen": API_TOKEN,
        "URL": URL,
        "Schaber": "amazon-produktdetails"
    }

    Antwort = Anfragen.get(API_ENDPOINT, Parameter=Parameter)
    Response.raise_for_status()

    product_json = json.loads(response.text)

    Daten = {
        "URL": product_json["Karosserie"]["kanonische URL"],
        "Preis": product_json["Karosserie"]["Rohpreis"],
        "Währung": product_json["Karosserie"]["Währung"],
        "Name": product_json["Karosserie"]["Name"]
    }

    erforderliche_Felder = ["Preis", "Name", "URL", "Währung"]
    missing_fields = [Feld für  Feld in erforderliche Felder if kein Frontalunterricht. data.get(Feld)]

    if fehlende_Felder:
        erhöhen WertFehler(f"Datenextraktion fehlgeschlagen: Erforderliche Felder fehlen: {','.join(fehlende_Felder)}")

    Rückkehr frustrierten

Stellen Sie sicher, dass Sie den Platzhalter ersetzen <Crawlbase Normal requests token> mit Ihrem tatsächlichen Crawlbase Token

Schritt 2: Daten mit Perplexity AI analysieren

Zahlen allein sind nicht viel wert, wenn wir sie nicht verstehen. Hier kommt Perplexity ins Spiel. Wir fügen eine Funktion hinzu, die die Produktdatensätze abruft, eine schnelle Überprüfung durchführt, um sicherzustellen, dass alles in Ordnung ist, und dann nützliche Statistiken wie Gesamtzahl der Datensätze, früheste und späteste Daten, Preisspannen und sogar Abweichungen anzeigt.

Erstellen Sie eine neue Datei mit dem Namen perplexity_ai.py und fügen Sie das Skript dort ein.

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
importieren JSON
importieren öffnen
von datetime importieren Datum/Uhrzeit, Zeitdelta
def Daten analysieren(Produkte):
    if len(Produkte) 2:
        erhöhen WertFehler(„Nicht genügend Daten zur Analyse“)
    Analysedaten = {
                "Gesamtdatensätze": len(Produkte),
                "Datumsbereich": {
                    "frühestens": Produkte[-1][„Zeitstempel“],
                    "letzte": Produkte[0][„Zeitstempel“]
                },
                "Preisverlauf": []
            }
    für  PRODUKTE in umgekehrt(Produkte):
        Analysedaten["Preisverlauf"].anhängen({
            „Zeitstempel“: Produkt[„Zeitstempel“],
            "Preis": Produkt["Preis"],
            "Währung": Produkt["Währung"]
        })
    Preise = [p["Preis"] für  p in Analysedaten["Preisverlauf"]]
    Analysedaten["Statistiken"] = {
        "Mindestpreis": min(Preise),
        "max_price": max(Preise),
        "aktueller_Preis": Preise[-1],
        "Preisspanne": max(Preise) - min(Preise),
        "Preisabweichung": Summe((P - Summe(Preise)/len(Preise))**2 für  p in Preise) / len(Preise)
    }
    Eingabeaufforderung = F"""
    Analysieren Sie die folgenden Produktpreisdaten und stellen Sie Erkenntnisse im JSON-Format bereit:
    Produktdaten:
    {json.dumps(Analysedaten, Einzug=2)}
    Bitte analysieren Sie diese Daten und geben Sie eine JSON-Antwort mit der folgenden Struktur zurück:
    {{
        "Anomalien": [
            {{
                "Typ": "Preisanstieg|Preisrückgang|ungewöhnliches Muster",
                "description": "Beschreibung der Anomalie",
                "Schweregrad": "niedrig|mittel|hoch",
                "timestamp": "Wann es passiert ist",
                "Vertrauen": 0.85
            }}
        ],
        "Trends": [
            {{
                "Typ": "zunehmend|abnehmend|stabil|flüchtig",
                "description": "Zusammenfassung des Trends",
                "prozentuale_Änderung": -5.2,
                "Zeitraum": "letzte Woche|letzter Monat|insgesamt",
                "Vertrauen": 0.90
            }}
        ],
        "Muster": [
            {{
                "Typ": "saisonal|wöchentlich|täglich|zufällig",
                "description": "Beschreibung des Musters",
                "Frequenz": "täglich|wöchentlich|monatlich",
                "Vertrauen": 0.75
            }}
        ],
        "Empfehlungen": [
            „Umsetzbare Empfehlung basierend auf Analyse“
        ]
    }}
    Konzentrieren Sie sich auf:
    1. Erkennen Sie ungewöhnliche Preisänderungen (Anomalien) – achten Sie auf plötzliche Spitzen oder Einbrüche
    2. Trends erkennen – allgemeine Preisrichtung und prozentuale Veränderungen
    3. Klassifizieren Sie Muster – saisonale, wöchentliche oder andere wiederkehrende Muster
    4. Liefern Sie umsetzbare Erkenntnisse
    Gibt nur gültiges JSON zurück, keinen zusätzlichen Text.
    "" "

    versuchen:
        client = openai.OpenAI(api_key=" ", Basis-URL="https://api.perplexity.ai")
        Antwort = Client.Chat.Completions.create(
            Modell ="Sonar-Pro",
            Nachrichten=[
                {
                    "Rolle": "System",
                    "Inhalt": „Sie sind ein auf Preisanalysen spezialisierter Datenanalyst. Stellen Sie genaue, datengesteuerte Erkenntnisse im JSON-Format bereit.“
                },
                {
                    "Rolle": "Nutzer",
                    "Inhalt": prompt
                }
            ],
            Temperatur=0.1,
            max_tokens=2000
        )

        Analyseergebnis = json.loads(Antwort.Auswahl[0].message.content)
        Analyseergebnis[„Metadaten“] = {
            "Analysezeitstempel": datetime.now().isoformat(),
            "analysierte Datenpunkte": Analysedaten["Gesamtdatensätze"],
            "verwendetes Modell": "Sonar-Pro"
        }

        Rückkehr Analyseergebnis

    ausgeschlossen openai.AuthenticationError:
        Rückkehr {
            "Error": „OpenAI-API-Authentifizierung fehlgeschlagen. Bitte überprüfen Sie Ihren API-Schlüssel.“,
            „Anormalitäten“[],
            "Trends"[],
            "Muster": []
        }
    ausgeschlossen json.JSONDecodeError:
        Rückkehr {
            "Error": „Die OpenAI-Antwort konnte nicht analysiert werden. Das Modell hat möglicherweise ungültiges JSON zurückgegeben.“,
            „Anormalitäten“[],
            "Trends"[],
            "Muster": []
        }
    ausgeschlossen Exception as e:
        Rückkehr {
            "Error": f"Analyse fehlgeschlagen: {str(e)}",
            „Anormalitäten“[],
            "Trends"[],
            "Muster": []
        }

Dieses Skript wandelt Rohdaten zu Produktpreisen in einen strukturierten Datensatz um, fordert ein KI-Modell auf, diese auf Anomalien, Trends und Muster zu analysieren, und gibt diese Erkenntnisse dann in JSON zurück, wobei Fehler sicher behandelt werden.

Beachten Sie, dass die Eingabeaufforderung nicht festgelegt ist. Sie können mit der Formulierung experimentieren, sie kürzen oder sogar nach verschiedenen Perspektiven fragen, je nachdem, was Sie erreichen möchten. Sie müssen lediglich den Text im Code anpassen, und die KI passt ihre Antwort entsprechend an.

Schritt 3: So erstellen Sie einen KI-Analysebericht

Bevor wir den Code ausführen können, benötigen wir für diesen Blog einige Testdaten. Sie können die folgenden Schritte ausführen:

  1. Holen Sie sich das Beispielskript von der GitHub-Repository und speichern Sie es als dummy_data.py um die Datenbank zu füllen.
  2. Führen Sie das Skript aus, indem Sie Folgendes ausführen:
1
python dummy_data.py

Dadurch sollten Datensätze wie folgt in Ihre Datenbank eingefügt werden:

  1. Nachdem die Dummy-Daten eingefügt wurden, kopieren Sie das folgende Skript und speichern Sie es als 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
von Datenbank importieren Abfrageprodukte;
von perplexity_ai importieren Daten analysieren;
importieren JSON

def monitor_price†
    versuchen:
        Produkte = Abfrageprodukte()
        Analyseergebnis = Analysedaten (Produkte)

        drucken("=" * 80)
        drucken(„ERGEBNISSE DER PRODUKTÜBERWACHUNGSANALYSE“)
        drucken("=" * 80)
        drucken()

        drucken(json.dumps(Analyseergebnis, Einzug=2, secure_ascii=falsch))

        drucken()
        drucken("=" * 80)
        drucken("ENDE DER ANALYSEERGEBNISSE")
        drucken("=" * 80)

    ausgeschlossen Exception as e:
        drucken(f"Fehlerüberwachungspreis: {str(e)}")

if __name__ == "__hauptsächlich__":
    # # Entfernen Sie die Kommentarzeichen aus dem Code unten, wenn Sie keine Dummy-Daten verwenden möchten
    # vom Crawling-Import crawl_amazon_product_details
    # aus der Datenbank importieren add_products_to_db

    # Produktdaten = crawl_amazon_product_details("https://www.amazon.com/Apple-iPhone-16-Version-128GB/dp/B0DHJH2GZL/ref=sr_1_1")
    # add_products_to_db(Produktdaten)
    monitor_price()

Wenn alles an seinem Platz ist, führen Sie den Code aus:

1
python price_monitoring.py

Hier ist die Beispielausgabe von Perplexity AI:

Schritt 4: KI-Berichte automatisieren und planen

Für die Demo haben wir es mit einem kleinen Skript namens schedule.py (Sie finden es im GitHub Repo). Es ist so eingerichtet, dass es einmal täglich um 10:00 Uhr ausgeführt wird. Um es manuell zu starten, führen Sie einfach Folgendes aus:

1
Python-Zeitplan.py

Wenn Sie ein System wünschen, das im Alltag zuverlässig läuft, sollten Sie den systemeigenen Scheduler verwenden. Unter Linux bedeutet das normalerweise die Einrichtung eines cron-Job. Unter Windows würden Sie wahrscheinlich mit Taskplaner.

Schritt 5: Visualisierung der KI-Ergebnisse

Das Heraussuchen der Preise ist nur die halbe Miete. Schwieriger ist es, herauszufinden, was die Preise im Gesamtbild tatsächlich aussagen. Hier können ein paar visuelle Elemente die Arbeit deutlich erleichtern.

Wenn Sie etwas Elegantes und Interaktives wünschen, ist ein leichtes Dashboard mit Plotly oder Bokeh genau das Richtige. Sie erhalten Diagramme, über die Sie mit der Maus fahren, hineinzoomen und sie direkt in eine Webseite einfügen können.

Alternativ, wenn Sie es schneller wollen, verwenden Sie Matplotlib or Seegeboren. Es gibt sie schon ewig, sie sind unendlich flexibel und Sie können sie so stylen, dass sie zu dem Look passen, den Sie anstreben.

Wenn Sie keine Lust haben, lange auf Zahlen oder Balken zu starren, können Sie sich sogar auf KI verlassen. Dienste wie Perplexity erstellen kurze, verständliche Zusammenfassungen Ihres Datensatzes. So müssen Sie sich nicht durch eine Wand aus Werten wühlen, sondern erhalten direkt neben Ihren visuellen Darstellungen ein paar klare, wichtige Erkenntnisse.

Fazit

Das Scraping einer Seite ist nur der Ausgangspunkt. Sobald Sie Crawlbase Zusammen mit Python und ein wenig KI wird der gesamte Prozess zu etwas viel Größerem: Sie sammeln nicht nur Daten, sondern formen sie zu Erkenntnissen um, auf deren Grundlage Sie handeln können.

Wenn Sie neugierig sind, wie das in der realen Welt aussieht, lohnt es sich, es an Ihren Konkurrenten zu testen. Mit Crawlbase Durch die Bewältigung der Komplexität können Sie die benötigten Daten abrufen und die KI auf die Marktveränderungen hinweisen lassen, bevor es jemand anderes bemerkt. ABSICHT Crawlbase heute mal einen Versuch und verschaffen Sie sich einen Schritt Vorsprung.

Häufig gestellte Fragen (FAQ)

F: Was passiert, wenn meine Anfragen immer wieder blockiert werden?

A. Eine Blockierung ist eine der größten Hürden beim Web Scraping. Mit CrawlbaseDies geschieht automatisch durch rotierende IP-Adressen und neue Benutzeragenten. Jede Anfrage sieht einzigartig aus, genau wie ein echter Besucher, wodurch Ihr Crawling am Laufen bleibt und Ihre Erfolgsquote hoch ist.

F: Was passiert, wenn eine Website ihr Layout oder ihre Datenstruktur ändert?

A. Websites entwickeln sich weiter; Layouts und HTML-Strukturen werden häufig aktualisiert. In diesem Fall funktionieren Ihre vorhandenen Selektoren möglicherweise nicht mehr. Die Lösung ist in der Regel schnell gefunden: Passen Sie Ihre Selektoren an die neue Struktur an. Denn Crawlbase gibt immer das vollständige HTML zurück. Sie müssen Ihren Crawler nicht von Grund auf neu erstellen. Optimieren Sie einfach die Analyselogik.

F: Können KI-Modelle bei der Analyse von Scraped-Daten „halluzinieren“?

A. Manchmal generiert KI Antworten, die zwar gut lesbar sind, aber nicht mit den zugrunde liegenden Daten übereinstimmen. Dies lässt sich am besten vermeiden, indem Sie dem Modell klare, strukturierte Anweisungen geben und freie Kreativität einschränken. Eingabeaufforderungen, die bestimmte Ergebnisse wie eine Zusammenfassung oder eine Tabelle erfordern, sorgen in der Regel dafür, dass die KI mit Ihrem tatsächlichen Datensatz übereinstimmt.