Intégration de la recherche sur le Web de Bright Data dans les pipelines d’IA de Vertex

Dans cet article, vous apprendrez

• Ce que sont les pipelines IA de Vertex.
• Pourquoi vous pouvez y intégrer l’API SERP de Bright Data pour la vérification des faits (et de nombreux autres cas d’utilisation).
• Comment construire un pipeline de vérification des faits dans Vertex IA en utilisant l’API SERP de Bright Data pour récupérer un contexte de recherche Web actualisé.

Plongeons dans le vif du sujet !

Qu’est-ce que Vertex IA Pipelines ?

Vertex IA Pipelines est un service géré sur Google Cloud qui automatise, orchestre et reproduit des flux de travail d’apprentissage automatique de bout en bout.

Ce service vous permet de décomposer des processus complexes d’apprentissage automatique, tels que le traitement des données, l’entraînement et le déploiement, en une série de composants modulaires qui peuvent être suivis, versionnés et exécutés dans un environnement sans serveur.

En bref, Vertex IA Pipelines simplifie le cycle de vie des ML, ce qui facilite la construction de systèmes ML reproductibles et évolutifs.

Construire un pipeline de vérification des faits dans Vertex IA : pourquoi et comment ?

Les LLM sont certes puissants, mais leurs connaissances sont statiques. Par conséquent, un LLM formé en 2024 n’a aucune connaissance des mouvements boursiers d’hier, des résultats sportifs de la nuit dernière, etc. Cela conduit à des réponses “périmées” ou “hallucinées”.

Pour remédier à ce problème, vous pouvez construire un système qui “fonde” un LLM sur des données de dernière minute provenant d’Internet. Avant que le LLM ne génère une réponse, il reçoit des informations externes pour s’assurer que son résultat est basé sur des faits actuels. C’est ce que l’on appelle la RAG(Retrieval-Augmented Generation) !

Aujourd’hui, Gemini fournit un outil de base pour relier les modèles Gemini à Google Search. Cependant, cet outil n’est pas prêt pour la production, présente des problèmes d’évolutivité et ne vous donne pas un contrôle total sur la source des données de base. Découvrez cet outil en action dans notre agent d’optimisation de contenu GEO/SEO.

L’API SERP de Bright Data constitue une alternative plus professionnelle et plus flexible. Cette API vous permet d’exécuter de manière programmatique des requêtes sur les moteurs de recherche et de récupérer le contenu complet des SERP. En d’autres termes, elle vous offre une source fiable de contenu frais et vérifiable qui peut être intégrée dans vos flux de travail LLM. Découvrez tout ce qu’il a à offrir en explorant sa documentation.

Par exemple, vous pouvez intégrer l’API SERP à Vertex IA Pipelines dans le cadre d’un pipeline de vérification des faits. Celui-ci se compose de trois étapes :

1. Extraire les requêtes: Un LLM lit le texte d’entrée et identifie les principales affirmations factuelles, en les convertissant en requêtes consultables sur Google.
2. Récupération du contexte de recherche sur le web: Ce composant prend ces requêtes et appelle l’API SERP de Bright Data pour récupérer les résultats de recherche en temps réel.
3. Vérification des faits: Une dernière étape du LLM prend le texte original et le contexte de recherche récupéré et génère un rapport de vérification des faits.

Remarque: il ne s’agit là que de l’un des nombreux cas d’utilisation possibles de l’API SERP dans un pipeline de données/ML.

Comment intégrer l’API SERP de Bright Data pour la recherche sur le Web dans un pipeline Vertex IA ?

Dans cette section, vous découvrirez chaque étape nécessaire à la mise en œuvre d’un pipeline de vérification des faits dans les pipelines Vertex IA. Celui-ci s’appuiera sur l’API SERP de Bright Data, qui sera utilisée pour récupérer le contexte factuel de la recherche sur le Web.

N’oubliez pas que la vérification des faits n’est qu’un des nombreux cas d’utilisation (tels que la découverte d’actualités, le résumé de contenu, l’analyse des tendances ou l’aide à la recherche) dans lesquels vous pouvez utiliser l’API SERP dans un nœud de pipeline Vertex IA. Vous pouvez donc facilement adapter cette mise en œuvre à de nombreux autres scénarios.

Pour en savoir plus, suivez les étapes ci-dessous !

Conditions préalables

Pour suivre cette section du tutoriel, assurez-vous d’avoir :

• Un compte Google Cloud Console.
• Un compte Bright Data avec une clé API active (idéalement avec des autorisations d’administrateur).

Suivez le guide officiel de Bright Data pour savoir comment récupérer votre clé API. Conservez-la dans un endroit sûr, car vous en aurez besoin prochainement.

Étape 1 : Créer et configurer un nouveau projet Google Cloud

Connectez-vous à Google Cloud Console et créez un nouveau projet. Assurez-vous également que la facturation est activée (vous pouvez également utiliser une version d’essai gratuite).

Dans cet exemple, appelez le projet Google Cloud “Bright Data API SERP Pipeline” et définissez l’ID du projet sur bright-data-pipeline:

Une fois le projet créé, sélectionnez-le pour commencer à travailler dessus. Une fois le projet créé, sélectionnez-le pour commencer à travailler dessus :

Sur cette page, vous trouverez le nom, le numéro et l’identifiant de votre projet. Vous aurez besoin du numéro de projet et de l’ID plus tard dans le tutoriel, alors notez-les et conservez-les dans un endroit sûr.

Maintenant que votre projet Google Cloud est prêt, l’étape suivante consiste à activer les API requises. Dans la barre de recherche, tapez “API et services”, atteignez la page et cliquez sur le bouton “Activer les API et les services” :

Recherchez et activez les API suivantes :

• “Vertex IA API“
• “API ordinateurs portables“

Ces deux API sont nécessaires pour utiliser et développer avec Vertex IA dans le Vertex IA Workbench.

Remarque: le pipeline dépend également de plusieurs autres API, qui sont généralement activées par défaut. En cas de problème, vérifiez que ces API sont également activées :

• “Cloud Resource Manager API” (API de gestion des ressources en nuage)
• “API de stockage dans le nuage”
• “API d’utilisation des services”
• “API Compute Engine
• “Gemini for Google Cloud API” (API de Gemini pour Google Cloud)
• “API de journalisation dans le nuage”

Si l’un d’entre eux est désactivé, activez-le manuellement avant de continuer.

C’est fait ! Vous avez maintenant un projet Google Cloud.

Étape 2 : Configurer le réservoir de stockage dans le nuage

Pour exécuter les pipelines de Vertex IA, vous avez besoin d’un espace de stockage dans le cloud. En effet, Vertex IA doit stocker les artefacts des pipelines, tels que les données intermédiaires, les fichiers de modèle, les journaux et les métadonnées générés lors de l’exécution des pipelines. En d’autres termes, le panier configuré sert d’espace de travail où les composants de votre pipeline lisent et écrivent des données.

Pour créer un seau, recherchez “Cloud Storage” dans la Google Cloud Console. Ouvrez le premier résultat, sélectionnez “Buckets” dans le menu de gauche, puis cliquez sur le bouton “Create” :

Dans le formulaire de création d’un seau :

• Donnez-lui un nom unique au monde, tel que bright-data-pipeline-artifacts.
• Choisissez un type d’emplacement et une région. Pour plus de simplicité, nous recommandons de sélectionner l’option “us (plusieurs régions aux États-Unis)”.

Une fois créé, notez le nom du seau, car vous en aurez besoin plus tard dans la configuration du pipeline. Vous devriez maintenant voir quelque chose comme ceci :

Dans ce cas, le nom du seau est :

bright-data-pipeline-artifacts 

Alors que l’URI du seau est : gs://bright-data-pipeline-artifacts

gs://bright-data-pipeline-artifacts

Comme vous avez choisi la multirégion “us”, vous pouvez accéder à ce seau via n’importe quelle région us-* prise en charge. Cela inclut us-central1, us-east1, …, us-west1…, etc. Nous recommandons d’utiliser us-central1.

Maintenant, vous devez donner à Vertex IA la permission de lire et d’écrire des données dans votre bucket. Pour ce faire, cliquez sur le nom du seau pour ouvrir sa page de détails, puis allez dans l’onglet “Permissions” :

Cliquez sur le bouton “Accorder l’accès” et ajoutez une nouvelle règle de permission comme suit :

• Principal: <YOUR_GC_PROJECT_NUMBER>[email protected]
• Role: Administrateur du stockage

(Important : Pour les environnements de production, n’attribuez que les rôles minimums requis. L’utilisation de l’accès complet “Storage Admin” est juste pour des raisons de simplicité dans cette configuration).

Cliquez sur “Enregistrer” pour confirmer le nouveau rôle, qui donne au service Compute Engine de votre projet la possibilité d’accéder et de gérer les objets de votre espace de stockage dans le nuage.

Sans cette autorisation, votre pipeline Vertex IA ne pourrait pas lire ou écrire des données pendant l’exécution, ce qui entraînerait des erreurs 403 Forbidden comme celle ci-dessous :

google.api_core.exceptions.Forbidden : 403 GET https://storage.googleapis.com/storage/v1/b/bright-data-pipeline-artifacts?fields=name&prettyPrint=false : <YOUR_GC_PROJECT_NUMBER>[email protected] n'a pas l'accès storage.buckets.get au seau Google Cloud Storage. La permission 'storage.buckets.get' est refusée sur la ressource (ou elle n'existe peut-être pas).

Incroyable ! Le seau Google Cloud Storage est configuré.

Étape 3 : Configurer les autorisations IAM

Tout comme pour le seau de stockage dans le nuage, vous devez également donner au compte de service Compute Engine de votre projet les autorisations IAM appropriées.

Ces permissions permettent à Vertex IA de créer et de gérer les tâches du pipeline en votre nom. Sans ces autorisations, le pipeline n’aura pas le droit de lancer ou de contrôler son exécution au sein de votre projet Google Cloud.

Pour les configurer, recherchez “IAM & Admin” dans la Google Cloud Console et ouvrez la page.
Cliquez sur le bouton “Accorder l’accès”, puis ajoutez les deux rôles suivants à votre compte de service par défaut Compute Engine (c’est-à-dire <Votre_numéro_de_projet_GC>[email protected]):

• “Utilisateur du compte de service”
• “Utilisateur Vertex IA”

Après avoir attribué les rôles, cliquez sur le bouton “Save”. Ainsi, votre pipeline Vertex IA pourra utiliser les ressources de calcul de votre projet et exécuter des charges de travail gérées.

En bref, cela indique à Google Cloud que vos pipelines Vertex IA sont autorisés à agir au nom du compte de service de calcul de votre projet. Sans ces autorisations, vous rencontrerez des erreurs 403 Forbidden comme celle ci-dessous lorsque vous tenterez de lancer un travail de pipeline :

403 POST https://us-central1-aiplatform.googleapis.com/v1/projects/bright-data-pipeline/locations/us-central1/pipelineJobs?pipelineJobId=XXXXXXXXXXXXXXXXXXXXXXX&%24alt=json%3Benum-encoding%3Dint : Permission 'aiplatform.pipelineJobs.create' denied on resource '//aiplatform.googleapis.com/projects/bright-data-pipeline/locations/us-central1' (or it may not exist) [{'@type' : 'type.googleapis.com/google.rpc.ErrorInfo', 'reason' : 'IAM_PERMISSION_DENIED', 'domain' : 'aiplatform.googleapis.com', 'metadata' : {'resource' : 'projects/bright-data-pipeline/locations/us-central1', 'permission' : 'aiplatform.pipelineJobs.create'}}]

Tout est prêt ! IAM est maintenant configuré et prêt pour l’exécution du pipeline Vertex IA.

Étape 4 : Démarrer avec Vertex IA Workbench

Pour simplifier le développement, vous allez construire notre pipeline Vertex IA directement dans le cloud, sans aucune configuration locale requise.

Plus précisément, vous utiliserez Vertex IA Workbench, un environnement de développement basé sur JupyterLab entièrement géré au sein de la plateforme Vertex IA de Google Cloud. Cet environnement est conçu pour prendre en charge l’ensemble des flux de travail de la science des données, du prototypage au déploiement de modèles.

Remarque: avant de poursuivre, assurez-vous que l'”API Notebooks” est activée, car cette API est nécessaire au fonctionnement de Vertex IA Workbench.

Pour accéder à Vertex IA Workbench, recherchez “Vertex IA Workbench” dans la Google Cloud Console et ouvrez la page. Ensuite, sous l’onglet “Instances”, cliquez sur “Créer nouveau” pour lancer une nouvelle instance :

Remarque: bien que Vertex IA Workbench prenne en charge Jupyter 4 pour les nouvelles instances, tous les environnements utilisent actuellement JupyterLab 3 par défaut. Cette version est déjà livrée avec les dernières bibliothèques et pilotes NVIDIA GPU et Intel préinstallés. Ainsi, pour ce tutoriel, vous devriez opter pour JupyterLab 3.

Dans le formulaire de création d’instance, laissez toutes les valeurs de configuration par défaut, y compris le type de machine par défaut (qui devrait être n1-standard-4). Cette machine est plus que suffisante pour ce guide.

Cliquez sur “Create” et gardez à l’esprit qu’il faudra quelques minutes pour que l’instance soit provisionnée et démarrée. Une fois qu’elle est prête, vous verrez une nouvelle entrée dans le tableau “Instances” avec un lien intitulé “Open JupyterLab”. Cliquez dessus :

Vous serez redirigé vers votre environnement JupyterLab basé sur le cloud, entièrement hébergé sur Google Cloud :

Cliquez sur “Python 3 (ipykernel)” sous “Notebook” pour créer un nouveau notebook. Ce notebook vous servira d’environnement de développement pour écrire et tester votre pipeline Vertex IA intégré à Bright Data :

Fantastique ! Vous êtes prêt à commencer à coder et à construire la logique de votre pipeline de données Vertex IA.

Étape 5 : Installation et initialisation des bibliothèques Python requises

Dans votre notebook, commencez par ajouter et exécuter la cellule suivante pour installer toutes les bibliothèques Python dont vous aurez besoin pour ce projet :

!pip install kfp google-cloud-aiplatform google-genai brightdata-sdk --quiet --upgrade

Cela peut prendre quelques minutes, alors soyez patient pendant que l’environnement met tout en place.

Voici ce que fait chaque bibliothèque et pourquoi elle est nécessaire :

• kfp: Il s’agit du SDK Kubeflow Pipelines, qui vous permet de définir, de compiler et d’exécuter des pipelines d’apprentissage automatique de manière programmatique en Python. Il est livré avec des décorateurs et des classes pour créer des composants de pipeline.
• Plateforme google-cloud-ai: Le SDK Vertex IA pour Python. Il fournit ce dont vous avez besoin pour interagir directement avec les services Vertex IA de Google Cloud, notamment pour former des modèles, déployer des points de terminaison et exécuter des pipelines.
• google-genai: Le SDK Generative IA de Google, qui vous permet d’utiliser et d’orchestrer Gemini et d’autres modèles génératifs (également dans Vertex IA). C’est utile, car le pipeline comprend des tâches LLM.(N’oubliez pas que le SDK Vertex IA est désormais obsolète).
• brightdata-sdk: Le SDK Bright Data, utilisé pour se connecter et récupérer des données en temps réel via l’API SERP de Bright Data ou d’autres sources de données Web directement à partir de votre pipeline.

Une fois toutes les bibliothèques installées, importez-les et initialisez le SDK Vertex IA avec le code suivant dans une cellule dédiée :

import kfp
from kfp.dsl import component, pipeline, Input, Output, Artifact
from kfp import compiler
from google.cloud import aiplatform
from typing import List

# Remplacer par les secrets de votre projet
PROJECT_ID = "<VOTRE_PROJET_GC_ID>"
REGION = "<VOTRE_REGION>" # (par exemple, "us-central1")
BUCKET_URI = "<VOTRE_BUCKET_URI>" # (par exemple, "gs://bright-data-pipeline-artifacts")

# Initialiser le SDK Vertex IA
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)

La fonction aiplatform.init() configure votre environnement Python pour communiquer avec Vertex IA. Elle configure le projet, la région et le bucket de staging afin que toutes les opérations ultérieures de Vertex IA, telles que la création de pipelines, les tâches de formation ou le déploiement de modèles, utilisent automatiquement le bon contexte.

En bref, cette simple ligne de code connecte votre session notebook à votre projet Google Cloud et indique à Vertex IA où stocker les artefacts de pipeline et les données temporaires. Voilà qui est bien fait !

Étape 6 : Définir le composant d’extraction de requêtes

Rappelez-vous qu’un pipeline Vertex IA est construit à partir de composants, où un composant est juste une fonction Python qui effectue une tâche spécifique. Comme expliqué précédemment, ce pipeline aura trois composants.

Commençons par le premier, le composant extract_queries!

Le composant extract_queries:

1. Prend en entrée le texte à vérifier.
2. Il utilise un modèle Gemini (via la bibliothèque google-genai ) pour générer une liste de requêtes de recherche Google qui permettraient de vérifier les affirmations factuelles contenues dans ce texte.
3. Renvoie cette liste sous la forme d’un tableau Python(List[str]).

Implémentez-le comme suit :

@component(
    base_image="python:3.10",
    packages_to_install=["google-genai"],
)
def extract_queries(
    input_text : str,
    projet : str,
    location : str,
) -> Liste[str] : 
    from google import genai
    from google.genai.types import GenerateContentConfig, HttpOptions
    from typing import List
    import json

    # Initialiser le SDK Google Gen IA avec l'intégration Vertex
    client = genai.Client(
        vertexai=True,
        project=projet, 
        location=location,
        http_options=HttpOptions(api_version="v1")
    )

    # Le schéma de sortie, qui est un tableau de chaînes de caractères
    response_schema = {
        "type" : "ARRAY",
        "items" : {
            "type" : "STRING"
        }
    }

    # L'invite de l'extracteur de requêtes
    prompt = f"""
    Vous êtes un vérificateur de faits professionnel. Votre tâche consiste à lire le texte suivant et à en extraire 
    une liste de requêtes spécifiques, consultables sur Google, qui seraient nécessaires 
    pour vérifier les principales affirmations factuelles.

    Retournez *uniquement* une liste Python de chaînes de caractères, et rien d'autre.

    Exemple :
    Entrée : "La Tour Eiffel, construite en 1889 par Gustave Eiffel, mesure 300 mètres de haut".
    Sortie : ["when was the eiffel tower built", "who built the eiffel tower", "how tall is the eiffel tower"]

    Voici le texte à vérifier :
    ---
    "{input_text}"
    ---
    """

    response = client.models.generate_content(
        model="gemini-2.5-flash",
        contents=prompt,
        config=GenerateContentConfig(
            # Forcer le modèle à retourner un tableau JSON de chaînes de caractères
            response_mime_type="application/json",
            response_schema=response_schema,
        ),
    )

    # Le 'response.text' contiendra de manière fiable une chaîne JSON conforme au schéma (par exemple, '["query_1", ..., "query_n"]')
    query_list : List[str] = json.loads(response.text.strip())

    return query_list

N’oubliez pas que les composants KFP doivent être autonomes. Cela signifie que tous les imports doivent être déclarés à l’intérieur de la fonction du composant, et non globalement.

Notez que les paramètres vertexai=True, project=project et location=location dans genai.Client() sont nécessaires pour connecter le client google-genai à votre environnement Vertex IA. Ils garantissent que le modèle configuré s’exécute dans la même région et le même projet que votre pipeline.

En ce qui concerne le choix du modèle, vous devriez utiliser Gemini 2.5 Flash ici parce qu’il est léger et rapide. Quoi qu’il en soit, vous pouvez configurer un autre modèle Gemini pour une plus grande précision si nécessaire.

Un composant terminé, il en reste deux !

Étape 7 : Créer le composant de récupération de contexte de recherche sur le Web alimenté par l’API SERP

Maintenant que vous avez généré une liste de requêtes exploitables par Google, il est temps de rechercher le contexte sur le Web. Pour ce faire, utilisez l’API SERP de Bright Data, qui vous permet de récupérer de manière programmatique des résultats de recherche (Google, par défaut) de manière structurée et évolutive.

Le moyen le plus simple d’accéder à l’API SERP à partir de Python est d’utiliser le SDK officiel et open-source de Bright Data. Cette bibliothèque vous fournit des méthodes simples pour appeler les produits Bright Data, y compris l’API SERP. Pour en savoir plus, consultez la documentation.

En particulier, le composant fetch_web_search_context:

1. Accepte une liste de requêtes de recherche générées à l’étape précédente.
2. Utilise le SDK Bright Data pour appeler l’API SERP en parallèle pour chaque requête.
3. Récupère les résultats de la recherche (par défaut de Google).
4. Enregistre tous les résultats sous la forme d’un artefact JSON, un fichier que les autres composants du pipeline peuvent utiliser.

Créez un tel composant dans une cellule de notebook dédiée comme ceci :

@component(
    base_image="python:3.10",
    packages_to_install=["brightdata-sdk"],
)
def fetch_web_search_context(
    queries : List[str],
    api_key : str,
    fichier_de_sortie : Output[Artifact],
) :
    """
    Prend une liste de requêtes, effectue une recherche dans chacune d'elles à l'aide du SDK Bright Data,
    et écrit tous les résultats sous la forme d'un fichier JSON.
    """
    from brightdata import bdclient
    import json

    # Initialisation du client SDK Bright Data
    client = bdclient(api_token=api_key)
    # Appeler l'API SERP sur les requêtes d'entrée
    results = client.search(
        queries,
        data_format="markdown"
    )

    # Écrire les résultats dans un fichier d'artefact
    with open(output_file.path, "w") as f :
        json.dump(results, f)

Notez que l’API SERP a été configurée pour renvoyer le contenu au format Markdown, ce qui est idéal pour l’ingestion dans les LLM.

En outre, étant donné que le résultat de ce composant peut être assez volumineux, il est préférable de le stocker sous la forme d’un artefact. Les artefacts sont stockés dans votre seau Google Cloud Storage et permettent aux composants d’un pipeline Vertex IA de transmettre des données entre eux de manière efficace sans surcharger la mémoire ou dépasser les limites de transfert de données.

C’est parti ! Grâce à la puissance des capacités de recherche Web de Bright Data, vous disposez maintenant d’un contexte de recherche soutenu par Google, prêt à être utilisé comme entrée pour le composant suivant, où un LLM effectuera une vérification des faits.

Étape n° 8 : mise en œuvre du composant de vérification des faits

Similaire au composant d’extraction de requêtes, cette étape implique également l’appel à un LLM. Cependant, au lieu de générer des requêtes, ce composant utilise les résultats de la recherche sur le Web recueillis à l’étape précédente comme preuve contextuelle pour vérifier les faits du texte d’entrée original.

Essentiellement, il exécute un flux de travail de type SERP basé sur RAG où le contenu Web récupéré guide le processus de vérification du modèle.

Dans une nouvelle cellule de notebook, définissez le composant fact_check_with_web_search_context comme suit :

@component(
    base_image="python:3.10",
    packages_to_install=["google-genai"],
)
def fact_check_with_web_search_context(
    input_text : str,
    fichier_contexte_recherche_web : Input[Artifact],
    projet : str,
    location : str,
) -> str :
    import json
    from google import genai

    # Chargement du contexte de recherche web à partir de l'artefact
    avec open(web_search_context_file.path, "r") as f :
        web_search_context = json.load(f)

    client = genai.Client(
        vertexai=True,
        project=projet, 
        location=location
    )

    prompt = f"""
    Vous êtes un vérificateur de faits de l'IA. Comparez le texte original au contexte de recherche JSON
    et produisez un rapport de vérification des faits en Markdown.

    [Texte original]
    "{input_text}"

    [Contexte de recherche web]
    "{json.dumps(web_search_context)}"
    """

    response = client.models.generate_content(
        model="gemini-2.5-pro",
        contents=prompt
    )

    return response.text

Cette tâche est plus complexe et nécessite de raisonner sur plusieurs sources de preuves. Il est donc préférable d’utiliser un modèle plus performant comme Gemini 2.5 Pro.

Excellent ! Vous avez maintenant défini les trois composants qui constituent votre pipeline Vertex IA.

Étape 9 : Définir et compiler le pipeline

Connectez les trois composants dans un seul pipeline Kubeflow. Chaque composant sera exécuté de manière séquentielle, la sortie d’une étape devenant l’entrée de la suivante.

Voici comment définir le pipeline :

@pipeline(
    name="bright-data-fact-checker-pipeline",
    description="Récupère le contexte SERP pour vérifier les faits d'un document texte."
)
def fact_check_pipeline(
    input_text : str,
    bright_data_api_key : str,
    projet : str = PROJECT_ID,
    location : str = REGION,
) :
    # Etape 1 : Extraire des requêtes Google du texte d'entrée pour les vérifier 
    step1 = extract_queries(
        texte_entrée=texte_entrée,
        projet=projet,
        location=location
    )

    # Étape 2 : Récupérer les résultats des SERP de Bright Data pour les requêtes de recherche
    step2 = fetch_web_search_context(
        queries=step1.output,
        bright_data_api_key=bright_data_api_key
    )

    # Étape 3 : Effectuer une vérification des faits en utilisant le contexte de recherche web récupéré précédemment
    step3 = fact_check_with_web_search_context(
        input_text=input_text,
        web_search_context_file=step2.outputs["output_file"],
        projet=projet,
        location=location
    ) 

Essentiellement, cette fonction relie les trois composants que vous avez construits précédemment. Elle commence par générer des requêtes de vérification des faits, puis récupère les résultats de recherche pour chaque requête à l’aide de l’API SERP de Bright Data, et enfin exécute un modèle Gemini pour vérifier les affirmations sur la base des preuves collectées.

Ensuite, vous devez compiler le pipeline dans une spécification JSON que Vertex IA peut exécuter :

compiler.Compiler().compile(
    pipeline_func=fact_check_pipeline,
    package_path="fact_check_pipeline.json"
)

Cette commande convertit votre définition de pipeline Python en un fichier de spécification de pipeline JSON appelé fact_check_pipeline.json.

Ce fichier JSON est un plan directeur auquel Vertex IA Pipelines fait confiance pour comprendre comment orchestrer le flux de travail. Il décrit chaque composant, ses entrées et sorties, ses dépendances, ses images de conteneur et son ordre d’exécution.

Lors de l’exécution de ce fichier JSON dans Vertex IA, Google Cloud provisionne automatiquement l’infrastructure, exécute chaque composant dans le bon ordre et gère le passage des données entre les étapes. Pipeline terminé !

Étape n° 10 : exécution du pipeline

Supposons que vous souhaitiez tester le pipeline Vertex IA sur une affirmation clairement fausse comme celle-ci :

“Paris est la capitale de l’Allemagne, qui utilise le yen comme monnaie”.

Ajoutez la cellule suivante à votre carnet Jupyter. Cet ajout définit la logique de lancement du pipeline :

TEXT_TO_CHECK = """
Paris est la capitale de l'Allemagne, qui utilise le yen comme monnaie.
"""

# Remplacez par votre clé d'API Bright Data
BRIGHT_DATA_API_KEY = "<VOTRE_CLÉ_D'API_DE_BRIGHT_DATA>"

print("Starting the pipeline job...")

# Définir le travail de pipeline
job = aiplatform.PipelineJob(
    display_name="fact-check-pipeline-run",
    template_path="fact_check_pipeline.json",
    pipeline_root=BUCKET_URI,
    parameter_values={
        "input_text" : TEXT_TO_CHECK,
        "bright_data_api_key" : BRIGHT_DATA_API_KEY
    }
)

# Exécuter le job
job.run()

print("nJob submitted ! You can view its progress in the Vertex IA UI.")

Ce code crée une nouvelle cellule Vertex IA Pipeline, en spécifiant le JSON de pipeline que vous avez compilé plus tôt(fact_check_pipeline.json), votre seau de stockage comme racine du pipeline, et les paramètres requis pour cette exécution particulière (c’est-à-dire le texte d’entrée à vérifier et votre clé API Bright Data).

Une fois que vous aurez exécuté cette cellule, Vertex IA orchestrera automatiquement l’ensemble de votre pipeline dans le cloud.

Note de sécurité: cet exemple code en dur la clé API de Bright Data directement dans le carnet pour plus de simplicité, mais cela n’est pas sécurisé pour les environnements de production. Dans un déploiement réel, vous devriez stocker et récupérer des informations d’identification sensibles comme les clés d’API à l’aide de Google Cloud Secret Manager pour éviter toute exposition accidentelle (par exemple, dans les journaux).

Pour exécuter votre pipeline, sélectionnez toutes les cellules et appuyez sur le bouton “▶” dans votre carnet Jupyter. Vous obtiendrez cette sortie sur la dernière cellule :

Cela signifie que votre pipeline de vérification des faits Vertex IA s’exécute avec succès. Wow !

Étape n° 11 : Surveiller l’exécution du pipeline

Pour vérifier l’état de votre tâche de pipeline, accédez à la page Pipelines Vertex IA dans la Google Cloud Console pour votre projet :

https://console.cloud.google.com/vertex-ai/pipelines?project={ID_PROJET}

Dans ce cas, l’URL est la suivante :

https://console.cloud.google.com/vertex-ai/pipelines?project=bright-data-pipeline.

Collez l’URL dans le navigateur, et vous verrez une page comme celle-ci :

Cliquez sur la première entrée du tableau “Runs” pour ouvrir la page d’exécution de la tâche du pipeline :

Ici, vous pouvez voir visuellement les composants de votre pipeline. Vous pouvez également vérifier l’état de chaque nœud, consulter des journaux détaillés et observer le flux de données du début à la fin du pipeline pendant son exécution.

Étape n° 12 : explorer la sortie

Une fois l’exécution du pipeline terminée, chaque nœud affiche une coche indiquant qu’il a été exécuté avec succès :

Cliquez sur le premier nœud pour inspecter les requêtes exploitables par Google extraites du texte d’entrée. Dans cet exemple, les requêtes générées étaient les suivantes :

• "quelle est la capitale de l'Allemagne"
• "quelle est la monnaie utilisée par l'Allemagne"

Ces requêtes sont parfaitement adaptées à la vérification des affirmations factuelles contenues dans la déclaration d’entrée :

Ensuite, cliquez sur le nœud de l’artefact entre le deuxième et le troisième nœud. Vous obtiendrez un lien vers le fichier JSON stocké dans votre panier Google Cloud Storage configuré (dans ce cas, bright-data-pipeline-artifacts).

Vous pouvez également accéder directement à la page souhaitée en naviguant vers le seau dans la Cloud Console :

À l’intérieur du seau, vous verrez un dossier pour chaque composant. En détail, le dossier du composant fetch_web_search_context contient un fichier JSON avec le contexte de recherche web récupéré via l’API SERP, stocké sous la forme d’un tableau de chaînes formatées en Markdown :

Si vous téléchargez et ouvrez le fichier, vous verrez quelque chose comme ceci :

Ce contenu est la représentation Markdown des SERP récupérées pour chaque requête de recherche identifiée.

De retour dans l’interface utilisateur du pipeline Vertex IA, cliquez sur le nœud de sortie pour inspecter les résultats globaux :

Comme vous pouvez le constater, le résultat est un rapport détaillé de vérification des faits en Markdown. Le même résultat est également enregistré dans le fichier executor_output.json dans le dossier bucket pour l’exécution du pipeline. Téléchargez-le et ouvrez-le dans un IDE comme Visual Studio Code pour l’inspecter :

Copiez la chaîne Markdown dans un fichier .md (par exemple, report.md) pour la visualiser plus clairement :

Le rapport fournit des informations détaillées sur les parties de la déclaration d’entrée qui étaient incorrectes et sur les faits vérifiés.

Et voilà ! Cela démontre la puissance de l’intégration de la recherche web de Bright Data pour la récupération d’informations contextuelles dans un pipeline Vertex IA basé sur RAG.

Prochaines étapes

N’oubliez pas qu’il ne s’agissait que d’un simple exemple pour démontrer la faisabilité de l’utilisation de la récupération des données de recherche web de Bright Data dans un pipeline Vertex IA. Dans des scénarios réels, ces composants feraient probablement partie d’un pipeline beaucoup plus long et plus complexe.

Les données d’entrée peuvent provenir de diverses sources, telles que des documents commerciaux, des rapports internes, des bases de données, des fichiers, etc. En outre, le flux de travail pourrait comprendre de nombreuses autres étapes et ne se terminerait pas nécessairement par un simple rapport de vérification des faits.

Conclusion

Dans cet article de blog, vous avez appris à tirer parti de l’API SERP de Bright Data pour récupérer le contexte des recherches sur le web dans un pipeline Vertex IA. Le flux de travail IA présenté ici est idéal pour tous ceux qui cherchent à construire un pipeline de fact-checking programmatique et fiable pour garantir l’exactitude de leurs données.

Pour créer des flux de travail d’IA avancés similaires, explorez la gamme complète de solutions pour récupérer, valider et transformer des données Web en direct à l’aide de l’infrastructure d’IA de Bright Data.

Créez un compte Bright Data gratuit dès aujourd’hui et commencez à expérimenter nos outils de données web prêts pour l’IA !