Scraping Web avec Kimi : Guide Étape par Étape

Dans cet article, vous apprendrez :

• Pourquoi Kimi K3 est un excellent modèle pour le scraping web alimenté par LLM.
• Les principaux obstacles au scraping web alimenté par IA et pourquoi l’API Web Unlocker de Bright Data est la solution.
• Comment effectuer un scraping web alimenté par IA avec Kimi dans un script Python.
• Comment utiliser Kimi K3 pour le scraping web visuel.

Plongeons dans le vif du sujet !

Pourquoi utiliser Kimi pour le Scraping Web ?

Les LLMs introduisent une nouvelle approche du scraping web. Au lieu d’écrire une logique d’analyse complexe pour extraire des données du HTML brut, vous pouvez laisser le modèle IA gérer l’extraction. Cela signifie que votre Scraper n’a pas à reposer sur des sélecteurs CSS fragiles ou des expressions XPath.

Tout ce dont vous avez besoin est une invite bien conçue qui indique au modèle quelles données extraire. Avec seulement quelques lignes de code, vous pouvez demander à Kimi de scraper des données structurées depuis n’importe quelle page web. Cette approche alimentée par IA peut rendre les scrapers web plus flexibles et plus faciles à maintenir.

Kimi K3, le dernier modèle Kimi, est bien adapté à l’extraction de données textuelles. Il offre également des capacités de vision, vous permettant d’extraire des informations à partir de captures d’écran de pages web, d’images et d’autres éléments visuels.

Pour plus de détails, suivez nos guides sur :

1. Utiliser l’IA pour le scraping web.
2. Utiliser l’IA de vision pour le scraping web.

Principaux Défis du Scraping Web par IA et Comment les Surmonter

Les principaux défis du scraping web alimenté par IA sont largement les mêmes que ceux rencontrés avec le scraping web traditionnel. Bien que l’IA rende les changements de structure de page moins problématiques grâce à ses capacités d’extraction flexibles, vous devez toujours gérer le rendu JavaScript, les systèmes anti-bot, l’empreinte numérique, les limites de débit, les CAPTCHA et d’autres restrictions d’accès.

Après tout, le scraping par IA n’élimine pas les obstacles à la récupération de pages web à grande échelle. Avant qu’un LLM puisse analyser une page, votre Scraper doit d’abord en récupérer le contenu, ce qui implique de gérer toutes les mesures qui empêchent les requêtes automatisées de réussir.

De plus, l’utilisation des tokens est importante. L’envoi de grands documents HTML à un modèle puissant comme Kimi K3 peut rapidement devenir coûteux. Dans ce cas, la solution consiste à convertir le HTML brut en Markdown optimisé pour les LLM.

La conversion des pages web en Markdown épuré préserve le contenu et la structure pertinents tout en réduisant considérablement les tokens inutiles par rapport au HTML brut. Il peut également préserver des informations telles que les titres, les listes, les liens et d’autres éléments de page dans un format plus facile à traiter pour les LLM. Consultez notre tutoriel sur comment scraper un site web en Markdown.

L’API Web Unlocker de Bright Data : La Solution

L’API Web Unlocker de Bright Data offre une solution pratique aux principaux défis du scraping web alimenté par IA.

Cet endpoint accepte l’URL d’une page web et retourne son contenu tout en gérant les mécanismes anti-bot et anti-scraping courants. Il peut résoudre les CAPTCHA, rendre les pages à fort contenu JavaScript, aider à surmonter les problèmes d’empreinte numérique de navigateur, gérer les limites de débit, et bien plus encore.

Le Web Unlocker peut également retourner le contenu récupéré dans différents formats, notamment :

1. Markdown optimisé pour les LLM
2. Captures d’écran

La sortie de la requête API Web Unlocker peut ensuite servir d’entrée pour l’extraction textuelle ou visuelle avec Kimi K3.

Remarque : L’API Web Unlocker est incluse dans le niveau gratuit de Bright Data, qui offre 5 000 requêtes gratuites par mois.

Ce qui distingue l’API Web Unlocker, c’est qu’elle fonctionne sur l’infrastructure Proxy à grande échelle de Bright Data, qui comprend plus de 400 millions d’IPs résidentielles et prend en charge une concurrence illimitée. Cela offre une base fiable et hautement évolutive pour le scraping web programmatique.

Comment Effectuer un Scraping Web avec Kimi K3 en Python

Dans cette section guidée, vous apprendrez à créer un script Python qui utilise Kimi pour le scraping web alimenté par IA. La page cible sera une page produit Amazon.

Plus précisément, vous verrez comment scraper le produit “Amazon Basics 20-Pack AA Alkaline Batteries, 1.5 Volt, 10-Year Leak-Free Shelf Life, for Everyday and Household Devices“. Néanmoins, l’avantage de cette approche est qu’elle fonctionne avec n’importe quelle autre page produit Amazon, quelle que soit sa structure ou sa mise en page.

Remarque : Pour la récupération de données produit Amazon structurées prêtes pour la production, envisagez d’utiliser l’API Amazon Scraper.

Le flux de travail est simple :

1. L’API Web Unlocker de Bright Data récupère la page cible et retourne son contenu au format Markdown.
2. Kimi K3 reçoit le contenu Markdown et collecte les informations produit via l’API Kimi.
3. Les données extraites sont retournées sous forme de JSON structuré basé sur un schéma prédéfini.
4. Les données produit scrapées sont exportées sur le disque.

Suivez les instructions ci-dessous !

Prérequis

Avant de commencer, assurez-vous d’avoir :

• Python 3.10+ installé localement.
• Un compte Kimi approvisionné avec une clé API configurée.
• Un compte Bright Data avec une Zone API Web Unlocker configurée. Suivez la documentation officielle Web Unlocker pour configurer votre Zone API Web Unlocker.

Ici, nous supposerons que votre Zone API Web Unlocker est nommée web_unlocker :

Étape n°1 : Initialiser votre Projet Python

Commencez par créer un nouveau dossier pour votre projet de scraping web Kimi :

mkdir kimi-scraper

Le répertoire kimi-scraper servira de dossier de projet pour le scraping web avec Kimi.

Naviguez vers le dossier et créez un environnement virtuel Python à l’intérieur :

cd kimi-scraper
python -m venv .venv

Chargez le dossier du projet dans votre IDE Python préféré, tel que Visual Studio Code avec l’extension Python ou PyCharm Community Edition.

Dans le dossier du projet, créez un fichier scraper.py :

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

scraper.py contiendra bientôt la logique Python pour le scraping web LLM via Kimi.

Ensuite, activez l’environnement virtuel dans votre terminal. Sur Linux ou macOS, exécutez :

source .venv/bin/activate

De manière équivalente, sur Windows, exécutez :

.venv\Scripts\activate

Avec l’environnement virtuel activé, installez toutes les dépendances du projet avec :

pip install dotenv requests openai pydantic

Les packages requis sont :

• dotenv : Pour lire les secrets API depuis le fichier .env.
• requests : Pour envoyer des requêtes de récupération de pages web à l’API Web Unlocker de Bright Data.
• openai : Pour se connecter à l’API Kimi compatible OpenAI et traiter la page web récupérée.
• pydantic : Pour définir le modèle de sortie des requêtes Kimi de scraping web.

Bien joué ! Vous disposez maintenant d’un projet Python pour le scraping web avec Kimi.

Étape n°2 : Configurer la Lecture des Variables d’Environnement

Votre Scraper web Kimi se connectera à des services tiers, notamment Bright Data et Kimi. Ces services utilisent des clés API pour l’authentification, et vous ne devez jamais coder en dur de tels secrets dans votre code source.

Stockez plutôt vos clés API dans un fichier d’environnement et chargez-les au moment de l’exécution. Pour cela, utilisez le package python-dotenv pour lire les variables d’environnement depuis un fichier .env.

Dans scraper.py, importez load_dotenv() et appelez-la :

from dotenv import load_dotenv

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

Ajoutez ensuite un fichier .env dans votre dossier de projet :

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

Renseignez-le avec vos clés API :

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

Remplacez :

• <YOUR_MOONSHOT_API_KEY> par votre clé API Kimi.
• <YOUR_BRIGHT_DATA_API_KEY> par votre clé API Bright Data.

Ensuite, utilisez os.getenv() de Python pour lire ces variables d’environnement :

import os

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

Excellent ! Vos clés API sont maintenant disponibles pour le Scraper sans les exposer.

Conseil : Dans un dépôt versionné, ajoutez .env à votre fichier .gitignore pour éviter de valider accidentellement vos clés API.

Étape n°3 : Récupérer la Page Web Cible avec l’API Web Unlocker

La première étape du script de scraping alimenté par Kimi est d’obtenir la page web cible dans un format Markdown optimisé pour les LLM. Le moyen le plus simple de le faire est d’utiliser l’API Web Unlocker de Bright Data.

Pour en savoir plus sur la connexion au Web Unlocker, consultez la documentation officielle ou vérifiez l’exemple Python dans le dépôt Bright Data.

Utilisez la bibliothèque requests pour envoyer une requête HTTP POST à l’API Web Unlocker et récupérer la page cible en Markdown :

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

Si vous n’êtes pas familier avec ce code, lisez notre guide Python Requests.

Notez le champ data_format="markdown" dans la charge utile de la requête. Cela indique à l’API Web Unlocker de retourner la page web en Markdown au lieu du HTML brut.

Si vous imprimez markdown_page, vous obtiendrez :

Cela correspond à la représentation Markdown de la page produit Amazon cible.

Comme vous pouvez le voir, Web Unlocker gère les parties difficiles de la récupération de la page pour vous en :

1. Accédant à la page Amazon cible via l’infrastructure de Proxy résidentiel de Bright Data.
2. Gérant les défis anti-bot courants, y compris le CAPTCHA Amazon.
3. Récupérant le contenu de la page rendue.
4. Convertissant la page en Markdown propre et en la retournant.

Vous disposez maintenant du contenu de la page dans un format que vous pouvez transmettre à Kimi pour l’extraction de données alimentée par IA. Avant de le faire, définissons le modèle de sortie cible que Kimi produira !

Étape n°4 : Définir le Modèle de Données de Sortie

Kimi, comme les autres LLM, retourne des réponses textuelles par défaut. Ce n’est pas idéal pour le scraping web, où vous souhaitez généralement transformer le contenu non structuré d’une page web en données structurées.

L’API Kimi prend en charge la sortie structurée via le mode JSON. Cela vous permet de définir la structure de la réponse et d’instruire le modèle pour qu’il retourne des données conformes à ce schéma.

L’un des moyens les plus simples de définir un schéma JSON en Python est d’utiliser Pydantic, une bibliothèque populaire pour la validation et l’analyse des données. Pydantic vous permet de définir la structure et les types attendus de vos données à l’aide de classes Python, qui peuvent ensuite être converties en objet JSON Schema pour l’API Kimi.

Tout d’abord, inspectez la page cible et identifiez les champs que vous souhaitez collecter. Pour la page produit Amazon utilisée dans ce tutoriel, vous pouvez définir un modèle Pydantic comme suit :

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")

Ce modèle associe les champs les plus pertinents de la page produit Amazon à des champs Python typés. Kimi K3 récupérera ensuite les valeurs correspondantes depuis le contenu de la page et les retournera dans un JSON Schema prévisible.

Excellent ! Vous disposez maintenant de tout ce qu’il faut pour utiliser Kimi pour le scraping web.

Étape n°5 : Utiliser Kimi pour l’Analyse des Données

L’API Kimi est compatible avec OpenAI, ce qui signifie que vous pouvez y accéder en utilisant le SDK Python OpenAI. Vous devez uniquement configurer le client OpenAI avec votre clé API Kimi (env MOONSHOT_API_KEY) et l’URL de base de l’API Moonshot.

Utilisez ensuite l’API Chat Completions pour envoyer le contenu Markdown scrapé à Kimi K3 et extraire les données produit selon votre schéma Pydantic :

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

L’invite utilisateur contient la page Markdown récupérée avec l’API Web Unlocker de Bright Data et demande à Kimi de retourner les informations produit pertinentes.

Le paramètre response_format active le mode json_schema. Ici, Product.model_json_schema() convertit le modèle Pydantic en un JSON Schema que Kimi utilisera pour structurer sa réponse.

En conséquence, product_data contient une chaîne JSON avec les données produit extraites dans la structure définie par votre modèle Product. Analysez cette chaîne JSON en un objet Python et enregistrez les données structurées sur le disque comme étape finale !

Étape n°6 : Exporter les Données Scrapées

Enregistrez les données produit scrapées sous forme de fichier JSON avec :

import json

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

Remarque : json.dump(json.loads(...)) garantit que la sortie produite par Kimi est du JSON valide.

Cela crée un fichier product.json contenant les données produit structurées collectées avec Kimi selon le schéma Pydantic Product. Parfait !

Étape n°7 : Tout Assembler

Voici le code final de votre Scraper Kimi :

# 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)

Exécutez le script Python avec :

python scraper.py

L’exécution, depuis la récupération de la page avec l’API Web Unlocker jusqu’au traitement avec le LLM Kimi, prendra un certain temps. Soyez donc patient.

Le résultat sera un fichier product.json contenant les données produit scrapées retournées par Kimi :

Notez comment les données extraites correspondent étroitement aux informations disponibles sur la page produit Amazon cible :

L’API Web Unlocker a géré les mesures anti-bot d’Amazon et récupéré le contenu de la page Markdown optimisé pour les LLM, tandis que Kimi K3 a analysé avec succès ce contenu et l’a converti en données structurées. Mission accomplie !

Comment Effectuer un Scraping Web Visuel avec les Capacités de Vision Kimi K3

Kimi K3 est également un modèle de vision, ce qui signifie qu’il peut effectuer un scraping web visuel. Au lieu de fournir au LLM le contenu textuel d’une page web, vous pouvez fournir une capture d’écran ou une image et laisser Kimi K3 extraire des données structurées à partir de celle-ci.

Encore une fois, l’approche est simple :

1. L’API Web Unlocker de Bright Data récupère une capture d’écran de la page web cible (la même page produit Amazon qu’auparavant).
2. Kimi K3 reçoit la capture d’écran via l’API Kimi et collecte les informations produit selon un schéma prédéfini.
3. Les données scrapées sont enregistrées sur le disque sous forme de JSON structuré.

Remarque : La majeure partie du flux de travail reste inchangée, donc cette section couvre uniquement les étapes qui doivent être mises à jour pour le scraping web visuel. Tous les prérequis et étapes de configuration décrits précédemment s’appliquent toujours.

Étape n°1 : Récupérer la Capture d’Écran de la Page

Mettez à jour la requête API Web Unlocker pour retourner une capture d’écran au lieu du contenu de la page au format Markdown :

# 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

Le changement clé est le champ data_format, qui est maintenant défini sur "screenshot". Cela indique à l’API Web Unlocker de retourner une capture d’écran. En particulier, la réponse API contiendra la capture d’écran sous forme d’octets d’image PNG, représentant la page rendue complète.

Pour le débogage visuel, exportez la capture d’écran sur le disque :

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

C’est optionnel mais utile pour inspecter visuellement la page récupérée et résoudre les problèmes du flux de scraping Kimi.

Le résultat est un fichier screenshot.png :

Notez comment il contient une capture d’écran de la page produit Amazon entière, capturée par l’API Web Unlocker de Bright Data. C’est parti !

Étape n°2 : Mettre à Jour le Modèle Pydantic

En analysant une capture d’écran de la page cible, Kimi K3 peut récupérer des informations visuelles non disponibles dans le contenu Markdown de la page. Par exemple, il peut lire le texte intégré dans les images, comme le texte dans la section “From the manufacturer” :

En même temps, une capture d’écran ne fournit pas les URL d’image sous-jacentes. Par conséquent, des champs tels que images, qui étaient disponibles dans le flux de scraping Kimi K3 textuel précédent, ne peuvent pas être renseignés.

Ainsi, adaptez le modèle Pydantic Product comme suit :

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")

Notez le nouveau champ from_the_manufacturer_info. Il demande spécifiquement à Kimi de lire et d’extraire le texte affiché dans l’image de la section “From the manufacturer” de la page produit.

Merveilleux ! Transmettez le nouveau modèle Pydantic et la capture d’écran de la page web à l’API Kimi pour le scraping web.

Étape n°3 : Scraper des Données depuis une Image avec Kimi K3 Vision

Kimi accepte les images via le type image_url, qui prend en charge soit une URL d’image accessible publiquement, soit une représentation encodée en Base64 de l’image.

Comme la capture d’écran est stockée localement sous forme d’octets d’image, vous devez d’abord l’encoder en Base64. Réalisez cela avec le package base64 de la bibliothèque standard Python :

import base64

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

Vous pouvez ensuite transmettre la capture d’écran encodée à Kimi K3 avec votre invite d’extraction :

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

La requête contient deux éléments d’information :

1. La capture d’écran de la page.
2. Une invite textuelle demandant à Kimi d’extraire les informations produit en utilisant le schéma Pydantic spécifié.

Le résultat est une variable product_data contenant une chaîne JSON avec les informations produit visuellement scrapées. Vous pouvez l’enregistrer sur le disque en utilisant la même approche décrite dans la section précédente. C’est tout !

Étape n°4 : Tester le Scraper IA Visuel

Votre script Kimi de scraping web visuel contiendra :

# 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)

Lancez-le, et il produira un fichier image_product.json comme suit :

Voyez comment Kimi K3 a récupéré les données produit depuis la capture d’écran, y compris le texte intégré dans l’image “From the manufacturer”. Fantastique !

Conclusion

Dans cet article de blog, vous avez appris à utiliser Kimi K3 pour créer un Scraper web alimenté par IA. Les principaux défis, à savoir récupérer de manière fiable le contenu web et obtenir des données optimisées pour les LLM sans être bloqué, ont été résolus avec l’API Web Unlocker de Bright Data.

Comme discuté, combiner Kimi K3 avec l’API Web Unlocker vous permet d’extraire des données structurées depuis des pages web ou des captures d’écran de pages à l’aide d’invites simples, sans écrire de logique d’analyse personnalisée. Ce n’est qu’un des nombreux cas d’usage pris en charge par les services prêts pour l’IA de Bright Data.

Inscrivez-vous sur Bright Data et commencez à expérimenter gratuitement avec nos API de scraping web !