In diesem Artikel erfahren Sie:

Warum Kimi K3 ein hervorragendes Modell für LLM-gestütztes Web-Scraping ist.
Die wichtigsten Hindernisse beim KI-gestützten Web-Scraping und warum die Bright Data Web Unlocker API die Lösung ist.
Wie man KI-gestütztes Web-Scraping mit Kimi in einem Python-Skript durchführt.
Wie man Kimi K3 für visuelles Web-Scraping einsetzt.

Legen wir los!

Warum Kimi für Web-Scraping verwenden?

LLMs eröffnen einen neuen Ansatz für Web-Scraping. Anstatt komplexe Parsing-Logik zu schreiben, um Daten aus rohem HTML zu extrahieren, kann das KI-Modell die Extraktion übernehmen. Das bedeutet, dass Ihr Scraper nicht auf fragile CSS-Selektoren oder XPath-Ausdrücke angewiesen ist.

Sie benötigen lediglich einen gut gestalteten Prompt, der dem Modell mitteilt, welche Daten extrahiert werden sollen. Mit nur wenigen Codezeilen können Sie Kimi anweisen, strukturierte Daten von einer beliebigen Webseite zu scrapen. Dieser KI-gestützte Ansatz kann Web-Scraper flexibler und wartungsfreundlicher machen.

Kimi K3, das neueste Kimi-Modell, eignet sich gut für textbasierte Datenextraktion. Es bietet auch Vision-Funktionen, mit denen Sie Informationen aus Screenshots von Webseiten, Bildern und anderen visuellen Elementen extrahieren können.

Weitere Details finden Sie in unseren Anleitungen zu:

Verwendung von KI für Web-Scraping.
Verwendung von Vision-KI für Web-Scraping.

Größte Herausforderungen beim KI-Web-Scraping und wie man sie überwindet

Die größten Herausforderungen beim KI-gestützten Web-Scraping sind weitgehend dieselben wie beim traditionellen Web-Scraping. Während KI Änderungen an der Seitenstruktur dank flexibler Extraktionsfähigkeiten weniger problematisch macht, müssen Sie sich weiterhin mit JavaScript-Rendering, Anti-Bot-Systemen, Fingerprinting, Rate-Limits, CAPTCHAs und anderen Zugriffsbeschränkungen auseinandersetzen.

Schließlich beseitigt KI-Scraping nicht die Hindernisse beim Abrufen von Webseiten in großem Maßstab. Bevor ein LLM eine Seite parsen kann, muss Ihr Scraper zunächst deren Inhalt abrufen, was bedeutet, dass alle Maßnahmen bewältigt werden müssen, die automatisierte Anfragen blockieren.

Darüber hinaus spielt die Token-Nutzung eine Rolle. Das Senden großer HTML-Dokumente an ein leistungsstarkes Modell wie Kimi K3 kann schnell teuer werden. In diesem Fall besteht die Lösung darin, das rohe HTML in LLM-optimiertes Markdown umzuwandeln.

Die Konvertierung von Webseiten in sauberes Markdown bewahrt den relevanten Inhalt und die Struktur, während unnötige Tokens im Vergleich zu rohem HTML erheblich reduziert werden. Es kann auch Informationen wie Überschriften, Listen, Links und andere Seitenelemente in einem Format erhalten, das für LLMs einfacher zu verarbeiten ist. Lesen Sie unser Tutorial über das Scrapen einer Website zu Markdown.

Bright Data Web Unlocker API: Die Lösung

Bright Datas Web Unlocker API bietet eine praktische Lösung für die wichtigsten Herausforderungen beim KI-gestützten Web-Scraping.

Dieser Endpunkt akzeptiert eine Webseiten-URL und gibt deren Inhalt zurück, während er gängige Anti-Bot- und Anti-Scraping-Mechanismen behandelt. Er kann CAPTCHAs lösen, JavaScript-lastige Seiten rendern, Browser-Fingerprinting-Probleme überwinden, Rate-Limits verwalten und vieles mehr.

Web Unlocker kann den abgerufenen Inhalt auch in verschiedenen Formaten zurückgeben, darunter:

Die Ausgabe der Web Unlocker API-Anfrage kann dann als Eingabe für die textbasierte oder visuelle Extraktion mit Kimi K3 dienen.

Hinweis: Die Web Unlocker API ist im kostenlosen Tarif von Bright Data enthalten, der 5.000 kostenlose Anfragen pro Monat bietet.

Was die Web Unlocker API auszeichnet, ist, dass sie auf Bright Datas großer Proxy-Infrastruktur läuft, die über 400 Millionen Residential-IPs umfasst und unbegrenzte Parallelität unterstützt. Das bietet eine zuverlässige und hochskalierbare Grundlage für programmatisches Web-Scraping.

Web-Scraping mit Kimi K3 in Python durchführen

In diesem Abschnitt erfahren Sie, wie Sie ein Python-Skript erstellen, das Kimi für KI-gestütztes Web-Scraping verwendet. Die Zielseite ist eine Amazon-Produktseite.

Konkret sehen Sie, wie das Produkt “Amazon Basics 20-Pack AA Alkaline Batteries, 1.5 Volt, 10-Year Leak-Free Shelf Life, for Everyday and Household Devices” gescrapt wird. Der Vorteil dieses Ansatzes ist jedoch, dass er mit jeder anderen Amazon-Produktseite funktioniert, unabhängig von deren Struktur oder Layout.

Hinweis: Für produktionsreifes strukturiertes Abrufen von Amazon-Produktdaten empfiehlt sich die Amazon Scraper API.

Der Ablauf ist unkompliziert:

Die Bright Data Web Unlocker API ruft die Zielseite ab und gibt deren Inhalt im Markdown-Format zurück.
Kimi K3 empfängt den Markdown-Inhalt und sammelt die Produktinformationen über die Kimi API.
Die extrahierten Daten werden als strukturiertes JSON basierend auf einem vordefinierten Schema zurückgegeben.
Die gescrapten Produktdaten werden auf dem Datenträger gespeichert.

Folgen Sie den nachstehenden Anweisungen!

Voraussetzungen

Stellen Sie vor dem Start sicher, dass Sie Folgendes haben:

Python 3.10+ lokal installiert.
Ein aufgeladenes Kimi-Konto mit einem konfigurierten API-Schlüssel.
Ein Bright Data-Konto mit einer konfigurierten Web Unlocker API-Zone. Folgen Sie der offiziellen Web Unlocker-Dokumentation, um Ihre Web Unlocker API-Zone einzurichten.

Hier gehen wir davon aus, dass Ihre Web Unlocker API-Zone den Namen web_unlocker trägt:

Hinweis zur Web Unlocker API namens 'web_unlocker'

Schritt #1: Python-Projekt initialisieren

Erstellen Sie zunächst einen neuen Ordner für Ihr Kimi-Web-Scraping-Projekt:

mkdir kimi-scraper

Das Verzeichnis kimi-scraper dient als Projektordner für Web-Scraping mit Kimi.

Navigieren Sie in den Ordner und erstellen Sie darin eine virtuelle Python-Umgebung:

cd kimi-scraper
python -m venv .venv

Laden Sie den Projektordner in Ihre bevorzugte Python-IDE, z. B. Visual Studio Code mit der Python-Erweiterung oder PyCharm Community Edition.

Erstellen Sie im Projektordner eine scraper.py-Datei:

kimi-scraper
├─── .venv/
└─── scraper.py # <-----

scraper.py wird bald die Python-Logik für LLM-Web-Scraping über Kimi enthalten.

Aktivieren Sie als Nächstes die virtuelle Umgebung in Ihrem Terminal. Unter Linux oder macOS führen Sie aus:

source .venv/bin/activate

Unter Windows führen Sie entsprechend aus:

.venv\Scripts\activate

Installieren Sie mit aktivierter virtueller Umgebung alle Projektabhängigkeiten mit:

pip install dotenv requests openai pydantic

Die erforderlichen Pakete sind:

dotenv: Zum Lesen von API-Geheimnissen aus der .env-Datei.
requests: Zum Senden von Webseitenabruf-Anfragen an die Bright Data Web Unlocker API.
openai: Zur Verbindung mit der OpenAI-kompatiblen Kimi API und Verarbeitung der abgerufenen Webseite.
pydantic: Zur Definition des Ausgabemodells für die Web-Scraping-Kimi-Anfragen.

Gut gemacht! Sie haben nun ein Python-Projekt für Web-Scraping mit Kimi.

Schritt #2: Lesen von Umgebungsvariablen einrichten

Ihr Kimi-Web-Scraper verbindet sich mit Drittanbieterdiensten, darunter Bright Data und Kimi. Diese Dienste verwenden API-Schlüssel zur Authentifizierung, und Sie sollten solche Geheimnisse niemals fest in Ihren Quellcode einbetten.

Speichern Sie stattdessen Ihre API-Schlüssel in einer Umgebungsdatei und laden Sie sie zur Laufzeit. Verwenden Sie dafür das Paket python-dotenv, um Umgebungsvariablen aus einer .env-Datei zu lesen.

Importieren Sie in scraper.py load_dotenv() und rufen Sie es auf:

from dotenv import load_dotenv

# Load the environment variables from the .env file
load_dotenv()

Fügen Sie dann eine .env-Datei in Ihrem Projektordner hinzu:

kimi-scraper
├─── .venv/
├─── .env       # <-----
└─── scraper.py

Befüllen Sie sie mit Ihren API-Schlüsseln:

MOONSHOT_API_KEY="<YOUR_MOONSHOT_API_KEY>"
BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"

Ersetzen Sie:

<YOUR_MOONSHOT_API_KEY> durch Ihren Kimi-API-Schlüssel.
<YOUR_BRIGHT_DATA_API_KEY> durch Ihren Bright Data-API-Schlüssel.

Verwenden Sie als Nächstes Pythons os.getenv(), um diese Umgebungsvariablen zu lesen:

import os

MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY")
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")

Gut! Ihre API-Schlüssel sind nun für den Scraper verfügbar, ohne sie preiszugeben.

Tipp: Fügen Sie in einem versionierten Repository .env zu Ihrer .gitignore-Datei hinzu, um ein versehentliches Einbinden Ihrer API-Schlüssel zu verhindern.

Schritt #3: Zielwebseite mit Web Unlocker API abrufen

Der erste Schritt im Kimi-gestützten Scraping-Skript besteht darin, die Zielwebseite in einem LLM-optimierten Markdown-Format abzurufen. Der einfachste Weg dazu ist die Bright Data Web Unlocker API.

Weitere Informationen zur Verbindung mit Web Unlocker finden Sie in der offiziellen Dokumentation oder im Python-Beispiel im Bright Data-Repository.

Verwenden Sie die requests-Bibliothek, um eine HTTP-POST-Anfrage an die Web Unlocker API zu senden und die Zielseite in Markdown abzurufen:

import requests

# Set up the authentication headers for Web Unlocker
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker API name
    "url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
    "format": "raw",
    "country": "us",
    "data_format": "markdown" # To get the web page in Markdown
}

# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)
markdown_page = web_unlocker_response.text

Falls Ihnen dieser Code nicht vertraut ist, lesen Sie unseren Python Requests-Leitfaden.

Beachten Sie das Feld data_format="markdown" in der Anfrage-Payload. Es weist die Web Unlocker API an, die Webseite als Markdown zurückzugeben anstatt als rohes HTML.

Wenn Sie markdown_page ausgeben, erhalten Sie:

Die Markdown-Darstellung der Amazon-Produktseite

Dies entspricht der Markdown-Darstellung der Amazon-Zielproduktseite.

Wie Sie sehen, übernimmt Web Unlocker die schwierigen Teile des Seitenabrufs für Sie:

Zugriff auf die Amazon-Zielseite über die Residential-Proxy-Infrastruktur von Bright Data.
Bewältigung gängiger Anti-Bot-Herausforderungen, einschließlich des Amazon-CAPTCHAs.
Abrufen des gerenderten Seiteninhalts.
Konvertierung der Seite in sauberes Markdown und Rückgabe.

Sie haben nun den Seiteninhalt in einem Format, das Sie an Kimi für KI-gestützte Datenextraktion übergeben können. Bevor wir das tun, definieren wir das Zielausgabemodell, das Kimi erzeugen soll!

Schritt #4: Ausgabedatenmodell definieren

Kimi gibt wie andere LLMs standardmäßig textbasierte Antworten zurück. Das ist für Web-Scraping nicht ideal, wo Sie in der Regel unstrukturierten Webseiteninhalt in strukturierte Daten umwandeln möchten.

Die Kimi API unterstützt strukturierte Ausgabe über den JSON-Modus. Damit können Sie die Struktur der Antwort definieren und das Modell anweisen, Daten zurückzugeben, die diesem Schema entsprechen.

Eine der einfachsten Methoden, ein JSON-Schema in Python zu definieren, ist Pydantic, eine beliebte Bibliothek zur Datenvalidierung und zum Parsing. Mit Pydantic können Sie die erwartete Struktur und die Typen Ihrer Daten mithilfe von Python-Klassen definieren, die dann in ein JSON-Schema-Objekt für die Kimi API umgewandelt werden können.

Sehen Sie sich zunächst die Zielseite an und identifizieren Sie die Felder, die Sie erfassen möchten. Für die in diesem Tutorial verwendete Amazon-Produktseite können Sie ein Pydantic-Modell wie folgt definieren:

from pydantic import BaseModel, Field
from typing import List, Optional

class Product(BaseModel):
    asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
    title: Optional[str] = Field(None, description="The full product title")
    brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
    price: Optional[float] = Field(None, description="One-time purchase price")
    rating: Optional[float] = Field(None, description="Average customer rating out of 5")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews")
    size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
    about_item: Optional[List[str]] = Field(None, description="Bullet points under 'About this item'")
    images: Optional[List[str]] = Field(None, description="URLs for product images")
    category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
    is_in_stock: Optional[bool] = Field(True, description="Availability status")

Dieses Modell ordnet die relevantesten Felder der Amazon-Produktseite typisierten Python-Feldern zu. Kimi K3 ruft dann die entsprechenden Werte aus dem Seiteninhalt ab und gibt sie in einem vorhersehbaren JSON-Schema zurück.

Gut! Sie haben nun alles, was Sie benötigen, um Kimi für Web-Scraping zu verwenden.

Schritt #5: Kimi für Daten-Parsing verwenden

Die Kimi API ist OpenAI-kompatibel, d. h. Sie können über das OpenAI Python SDK darauf zugreifen. Sie müssen lediglich den OpenAI-Client mit Ihrem Kimi-API-Schlüssel (MOONSHOT_API_KEY-Umgebungsvariable) und der API-Basis-URL von Moonshot konfigurieren.

Verwenden Sie dann die Chat Completions API, um den gescrapten Markdown-Inhalt an Kimi K3 zu senden und die Produktdaten gemäß Ihrem Pydantic-Schema zu extrahieren:

from openai import OpenAI

# Initialize the OpenAI client for Kimi
kimi_client = OpenAI(
    api_key=MOONSHOT_API_KEY,
    base_url="https://api.moonshot.ai/v1",
)

# Perform web data parsing with Kimi
response = kimi_client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text":
                        f"""
                        Extract the product information from the following Markdown document
                        and return it according to the provided schema.

                        MARKDOWN:
                        {markdown_page}
                        """,
                },
            ],
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "product",
            "strict": True,
            "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
        },
    },
)

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

Der Benutzer-Prompt enthält die mit der Bright Data Web Unlocker API abgerufene Markdown-Seite und weist Kimi an, die relevanten Produktinformationen zurückzugeben.

Der Parameter response_format aktiviert den json_schema-Modus. Hier konvertiert Product.model_json_schema() das Pydantic-Modell in ein JSON-Schema, das Kimi zur Strukturierung seiner Antwort verwendet.

Als Ergebnis enthält product_data einen JSON-String mit den extrahierten Produktdaten in der durch Ihr Product-Modell definierten Struktur. Parsen Sie diesen JSON-String in ein Python-Objekt und speichern Sie die strukturierten Daten als letzten Schritt auf dem Datenträger!

Schritt #6: Gescrapte Daten exportieren

Speichern Sie die gescrapten Produktdaten als JSON-Datei mit:

import json

with open("product.json", "w", encoding="utf-8") as f:
    json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False)

Hinweis: json.dump(json.loads(...)) stellt sicher, dass die von Kimi erzeugte Ausgabe gültiges JSON ist.

Dadurch wird eine product.json-Datei erstellt, die die strukturierten Produktdaten enthält, die Kimi gemäß dem Product-Pydantic-Schema gesammelt hat. Perfekt!

Schritt #7: Alles zusammenfügen

Nachfolgend finden Sie den endgültigen Code für Ihren Kimi-Scraper:

# pip install dotenv requests openai pydantic

from dotenv import load_dotenv
import os
import requests
from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI
import json

# Load the environment variables from the .env file
load_dotenv()

# Loading the required secrets from the envs
MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY")
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")

# The output schema for the product information
class Product(BaseModel):
    asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
    title: Optional[str] = Field(None, description="The full product title")
    brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
    price: Optional[float] = Field(None, description="One-time purchase price")
    rating: Optional[float] = Field(None, description="Average customer rating out of 5")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews")
    size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
    about_item: Optional[List[str]] = Field(None, description="Bullet points under 'About this item'")
    images: Optional[List[str]] = Field(None, description="URLs for product images")
    category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
    is_in_stock: Optional[bool] = Field(True, description="Availability status")

# Set up the authentication headers for Web Unlocker
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker API name
    "url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
    "format": "raw",
    "country": "us",
    "data_format": "markdown" # To get the web page in Markdown
}

# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)
markdown_page = web_unlocker_response.text

# Initialize the OpenAI client for Kimi
kimi_client = OpenAI(
    api_key=MOONSHOT_API_KEY,
    base_url="https://api.moonshot.ai/v1",
)

# Perform web data parsing with Kimi
response = kimi_client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text":
                        f"""
                        Extract the product information from the following Markdown document
                        and return it according to the provided schema.

                        MARKDOWN:
                        {markdown_page}
                        """,
                },
            ],
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "product",
            "strict": True,
            "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
        },
    },
)

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

# Export the scraped data to a JSON file
with open("product.json", "w", encoding="utf-8") as f:
    json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False)

Führen Sie das Python-Skript aus mit:

python scraper.py

Die Ausführung, vom Abrufen der Seite mit der Web Unlocker API bis zur Verarbeitung mit dem Kimi-LLM, wird einige Zeit in Anspruch nehmen. Haben Sie also Geduld.

Das Ergebnis ist eine product.json-Datei mit den gescrapten Produktdaten, die Kimi zurückgegeben hat:

Die von Kimi zurückgegebenen gescrapten Daten

Beachten Sie, wie die extrahierten Daten eng mit den Informationen auf der Amazon-Zielproduktseite übereinstimmen:

Die Web Unlocker API hat Amazons Anti-Bot-Maßnahmen bewältigt und den LLM-optimierten Markdown-Seiteninhalt abgerufen, während Kimi K3 diesen Inhalt erfolgreich geparst und in strukturierte Daten umgewandelt hat. Mission erfüllt!

Visuelles Web-Scraping mit den Vision-Funktionen von Kimi K3 durchführen

Kimi K3 ist auch ein Vision-Modell, was bedeutet, dass es visuelles Web-Scraping durchführen kann. Anstatt dem LLM den Textinhalt einer Webseite zu liefern, können Sie einen Screenshot oder ein Bild bereitstellen und Kimi K3 strukturierte Daten daraus extrahieren lassen.

Auch hier ist der Ansatz einfach:

Die Bright Data Web Unlocker API ruft einen Screenshot der Zielwebseite ab (dieselbe Amazon-Produktseite wie zuvor).
Kimi K3 empfängt den Screenshot über die Kimi API und sammelt die Produktinformationen gemäß einem vordefinierten Schema.
Die gescrapten Daten werden als strukturiertes JSON auf dem Datenträger gespeichert.

Hinweis: Der Großteil des Ablaufs bleibt unverändert, daher behandelt dieser Abschnitt nur die Schritte, die für visuelles Web-Scraping aktualisiert werden müssen. Alle zuvor beschriebenen Voraussetzungen und Einrichtungsschritte gelten weiterhin.

Schritt #1: Seiten-Screenshot abrufen

Aktualisieren Sie die Web Unlocker API-Anfrage, um einen Screenshot anstelle des Seiteninhalts im Markdown-Format zurückzugeben:

# Set up the authentication headers for Web Unlocker
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker API name
    "url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
    "format": "raw",
    "country": "us",
    "data_format": "screenshot" # <----- To get the screenshot of the web page
}

# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)
page_screenshot = web_unlocker_response.content

Die wichtigste Änderung ist das Feld data_format, das jetzt auf "screenshot" gesetzt ist. Dies weist die Web Unlocker API an, einen Screenshot zurückzugeben. Insbesondere enthält die API-Antwort den Screenshot als PNG-Bild-Bytes, die die vollständig gerenderte Seite darstellen.

Exportieren Sie den Screenshot zur visuellen Fehlersuche auf den Datenträger:

with open("screenshot.png", "wb") as f:
    f.write(page_screenshot)

Dies ist optional, aber nützlich zum visuellen Überprüfen der abgerufenen Seite und zur Fehlersuche im Kimi-Scraping-Ablauf.

Das Ergebnis ist eine screenshot.png-Datei:

Die von der Bright Data Web Unlocker API erzeugte 'screenshot.png'-Datei

Beachten Sie, dass diese einen Screenshot der gesamten Amazon-Produktseite enthält, der von der Bright Data Web Unlocker API aufgenommen wurde. Los geht’s!

Schritt #2: Pydantic-Modell aktualisieren

Durch die Analyse eines Screenshots der Zielseite kann Kimi K3 visuelle Informationen abrufen, die im Markdown-Inhalt der Seite nicht verfügbar sind. Es kann beispielsweise in Bildern eingebetteten Text lesen, wie den Text im Abschnitt “Vom Hersteller”:

Der Abschnitt 'Vom Hersteller' auf der Amazon-Zielproduktseite

Gleichzeitig liefert ein Screenshot keine zugrunde liegenden Bild-URLs. Daher können Felder wie images, die im vorherigen textbasierten Kimi K3-Scraping-Workflow verfügbar waren, nicht befüllt werden.

Passen Sie daher das Product-Pydantic-Modell wie folgt an:

class Product(BaseModel):
    asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
    title: Optional[str] = Field(None, description="The full product title")
    brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
    price: Optional[float] = Field(None, description="One-time purchase price")
    rating: Optional[float] = Field(None, description="Average customer rating out of 5")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews")
    size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
    from_the_manufacturer_info: Optional[str] = Field(None, description="Text of the image in the 'From the manufacturer' section")
    category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
    is_in_stock: Optional[bool] = Field(True, description="Availability status")

Beachten Sie das neue Feld from_the_manufacturer_info. Es weist Kimi gezielt an, den im Bild des Abschnitts “Vom Hersteller” der Produktseite angezeigten Text zu lesen und zu extrahieren.

Wunderbar! Übergeben Sie das neue Pydantic-Modell und den Webseiten-Screenshot an die Kimi API für Web-Scraping.

Schritt #3: Daten aus einem Bild mit Kimi K3 Vision scrapen

Kimi akzeptiert Bilder über den Typ image_url, der entweder eine öffentlich zugängliche Bild-URL oder eine Base64-kodierte Darstellung des Bildes unterstützt.

Da der Screenshot lokal als Bild-Bytes gespeichert ist, müssen Sie ihn zunächst als Base64 kodieren. Verwenden Sie dazu das base64-Paket aus der Python Standard Library:

import base64

screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8")

Sie können dann den kodierten Screenshot zusammen mit Ihrem Extraktions-Prompt an Kimi K3 übergeben:

response = kimi_client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": (
                            f"data:image/png;base64,{screenshot_base64}"
                        ),
                    },
                },
                {
                    "type": "text",
                    "text":
                        """
                        Extract the product information from this Amazon product page screenshot.
                        Return the information according to the provided schema.
                        """,
                },
            ],
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "product",
            "strict": True,
            "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
        },
    },
)

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

Die Anfrage enthält zwei Informationen:

Den Seiten-Screenshot.
Einen Text-Prompt, der Kimi anweist, die Produktinformationen mithilfe des angegebenen Pydantic-Schemas zu extrahieren.

Das Ergebnis ist eine Variable product_data, die einen JSON-String mit den visuell gescrapten Produktinformationen enthält. Sie können ihn mit demselben Ansatz wie im vorherigen Abschnitt beschrieben auf dem Datenträger speichern. Das war’s!

Schritt #4: Den visuellen KI-Scraper testen

Ihr visuelles Web-Scraping-Kimi-Skript enthält:

# pip install dotenv requests openai pydantic

import os
import requests
from pydantic import BaseModel, Field
from typing import List, Optional
from dotenv import load_dotenv
from openai import OpenAI
import base64
import json

# Load the environment variables from the .env file
load_dotenv()

# Loading the required secrets from the envs
MOONSHOT_API_KEY = os.environ.get("MOONSHOT_API_KEY")
BRIGHT_DATA_API_KEY = os.environ.get("BRIGHT_DATA_API_KEY")

# The output schema for the product information
class Product(BaseModel):
    asin: Optional[str] = Field(None, description="The Amazon Standard Identification Number (e.g., B00NTCH52W)")
    title: Optional[str] = Field(None, description="The full product title")
    brand: Optional[str] = Field(None, description="Brand name (e.g., Amazon Basics)")
    price: Optional[float] = Field(None, description="One-time purchase price")
    rating: Optional[float] = Field(None, description="Average customer rating out of 5")
    review_count: Optional[int] = Field(None, description="Total number of customer reviews")
    size_options: Optional[List[str]] = Field(None, description="Available pack sizes or variants")
    from_the_manufacturer_info: Optional[str] = Field(None, description="Text of the image in the 'From the manufacturer' section")
    category_path: Optional[List[str]] = Field(None, description="Breadcrumb navigation list")
    is_in_stock: Optional[bool] = Field(True, description="Availability status")

# Set up the authentication headers for Web Unlocker
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {BRIGHT_DATA_API_KEY}"
}

# Define the request payload for the Web Unlocker API call
payload = {
    "zone": "web_unlocker", # Replace with your Web Unlocker zone name
    "url": "https://www.amazon.com/Amazon-Basics-Batteries-Leak-Free-Household/dp/B00NTCH52W/",
    "format": "raw",
    "country": "us",
    "data_format": "screenshot" # To get the screenshot of the web page
}

# Fetch the unlocked content of the target page
web_unlocker_response = requests.post(
    "https://api.brightdata.com/request",
    json=payload,
    headers=headers
)
page_screenshot = web_unlocker_response.content

# Export the screenshot to a PNG file
with open("screenshot.png", "wb") as f:
    f.write(page_screenshot)

# Convert the screenshot to base64 for Kimi processing
screenshot_base64 = base64.b64encode(page_screenshot).decode("utf-8")

# Initialize the OpenAI client for Kimi
kimi_client = OpenAI(
    api_key=MOONSHOT_API_KEY,
    base_url="https://api.moonshot.ai/v1",
)

# Perform visual web data parsing with Kimi
response = kimi_client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": (
                            f"data:image/png;base64,{screenshot_base64}"
                        ),
                    },
                },
                {
                    "type": "text",
                    "text":
                        """
                        Extract the product information from this Amazon product page screenshot.
                        Return the information according to the provided schema.
                        """,
                },
            ],
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "product",
            "strict": True,
            "schema": Product.model_json_schema(), # Transform the Pydantic schema in a JSON Schema object
        },
    },
)

# Get the parsed data in the defined schema format
product_data = response.choices[0].message.content

# Export the scraped data to a JSON file
with open("image_product.json", "w", encoding="utf-8") as f:
    json.dump(json.loads(product_data), f, indent=2, ensure_ascii=False)

Starten Sie es, und es wird eine image_product.json-Datei erzeugen:

Die visuell gescrapten Daten, die Kimi zurückgegeben hat

Sehen Sie, wie Kimi K3 die Produktdaten aus dem Screenshot abgerufen hat, einschließlich des im “Vom Hersteller”-Bild eingebetteten Textes. Großartig!

Fazit

In diesem Blogbeitrag haben Sie gelernt, wie Sie Kimi K3 verwenden, um einen KI-gestützten Web-Scraper zu erstellen. Die größten Herausforderungen – zuverlässiges Abrufen von Webinhalten und Erhalt LLM-optimierter Daten ohne Blockierung – wurden mit Bright Datas Web Unlocker API bewältigt.

Wie besprochen, ermöglicht die Kombination von Kimi K3 mit der Web Unlocker API, strukturierte Daten aus Webseiten oder Seiten-Screenshots mithilfe einfacher Prompts zu extrahieren, ohne benutzerdefinierte Parsing-Logik zu schreiben. Dies ist nur einer der vielen Anwendungsfälle, die von Bright Datas KI-fähigen Diensten unterstützt werden.

Registrieren Sie sich bei Bright Data und beginnen Sie kostenlos mit unseren Web-Scraping-APIs zu experimentieren!

Vertrieb kontaktieren Gratis testen