Integration der Websuche von Bright Data in die KI-Pipelines von Vertex

In diesem Artikel werden Sie lernen:

• Was Vertex KI Pipelines sind.
• Warum Sie die Bright Data SERP-API für Faktenüberprüfungen (und viele andere Anwendungsfälle) in sie integrieren können.
• Wie Sie in Vertex KI eine Pipeline zur Faktenüberprüfung erstellen, indem Sie die Bright Data SERP-API verwenden, um aktuellen Websuchkontext abzurufen.

Lassen Sie uns eintauchen!

Was sind Vertex KI Pipelines?

Vertex KI Pipelines ist ein verwalteter Service in Google Cloud, der End-to-End-Workflows für maschinelles Lernen automatisiert, orchestriert und reproduziert.

Dieser Service ermöglicht es Ihnen, komplexe ML-Prozesse – wie Datenverarbeitung, Training und Bereitstellung – in eine Reihe modularer Komponenten zu zerlegen, die nachverfolgt, versioniert und in einer serverlosen Umgebung ausgeführt werden können.

Kurz gesagt, Vertex KI Pipelines vereinfacht den MLOps-Lebenszyklus und macht es einfacher, wiederholbare und skalierbare ML-Systeme zu erstellen.

Aufbau einer Faktenüberprüfungs-Pipeline in Vertex KI: Warum und wie

LLMs sind sicherlich leistungsstark, aber ihr Wissen ist statisch. Ein LLM, das im Jahr 2024 ausgebildet wird, hat daher keine Kenntnis von den gestrigen Börsenbewegungen, den Sportergebnissen von gestern Abend usw. Dies führt zu “abgestandenen” oder “halluzinierten” Antworten.

Um dieses Problem zu lösen, können Sie ein System entwickeln, das ein LLM mit aktuellen Daten aus dem Internet “erdet”. Bevor das LLM eine Antwort erzeugt, erhält es externe Informationen, um sicherzustellen, dass seine Ausgabe auf aktuellen Fakten beruht. Das ist der Sinn von RAG(Retrieval-Augmented Generation)!

Gemini bietet ein Tool, um Gemini-Modelle mit der Google-Suche zu verbinden. Dieses Tool ist jedoch nicht produktionsreif, hat Probleme mit der Skalierbarkeit und gibt Ihnen nicht die volle Kontrolle über die Quelle der Grounding-Daten. Sehen Sie sich dieses Tool in unserem GEO/SEO-Content-Optimierungsagenten in Aktion an.

Eine professionellere und flexiblere Alternative ist die SERP-API von Bright Data. Mit dieser API können Sie programmatisch Suchanfragen bei Suchmaschinen ausführen und den vollständigen SERP-Inhalt abrufen. Mit anderen Worten: Sie bietet Ihnen eine zuverlässige Quelle für frische, überprüfbare Inhalte, die in Ihre LLM-Workflows integriert werden können. Entdecken Sie alles, was es zu bieten hat, indem Sie die Dokumentation durcharbeiten.

Beispielsweise können Sie die SERP-API in Vertex KI-Pipelines als Teil einer Pipeline zur Faktenüberprüfung integrieren. Diese besteht aus drei Schritten:

1. Abfragen extrahieren: Ein LLM liest den Eingabetext und identifiziert die wichtigsten Tatsachenbehauptungen und wandelt sie in von Google durchsuchbare Abfragen um.
2. Abrufen von Websuchkontext: Diese Komponente nimmt diese Abfragen und ruft die SERP-API von Bright Data auf, um Suchergebnisse in Echtzeit abzurufen.
3. Faktenprüfung: In einem letzten LLM-Schritt wird aus dem Originaltext und dem abgerufenen Suchkontext ein Faktenprüfungsbericht erstellt.

Hinweis: Dies ist nur einer der vielen möglichen Anwendungsfälle für die SERP-API in einer Daten/ML-Pipeline.

So integrieren Sie die SERP-API von Bright Data für die Websuche in eine Vertex KI-Pipeline

In diesem Abschnitt werden Sie durch alle Schritte geführt, die für die Implementierung einer Pipeline zur Faktenüberprüfung in Vertex KI-Pipelines erforderlich sind. Diese basiert auf der SERP-API von Bright Data, die zum Abrufen von faktischem Websuchkontext verwendet wird.

Denken Sie daran, dass die Faktenüberprüfung nur einer von vielen Anwendungsfällen ist (z. B. Nachrichtenerkennung, Inhaltszusammenfassung, Trendanalyse oder Forschungsunterstützung), in denen Sie die SERP-API in einem Vertex KI-Pipeline-Knoten verwenden können. Sie können diese Implementierung also problemlos an viele andere Szenarien anpassen.

Um das zu verdeutlichen, folgen Sie den folgenden Schritten!

Voraussetzungen

Um diesem Abschnitt des Tutorials folgen zu können, müssen Sie Folgendes haben

• Ein Google Cloud Console-Konto.
• Ein Bright Data-Konto mit einem aktiven API-Schlüssel (idealerweise mit Admin-Berechtigungen).

Folgen Sie der offiziellen Bright Data-Anleitung, um zu erfahren , wie Sie Ihren API-Schlüssel abrufen können. Bewahren Sie ihn an einem sicheren Ort auf, da Sie ihn in Kürze benötigen werden.

Schritt 1: Erstellen und konfigurieren Sie ein neues Google Cloud-Projekt

Melden Sie sich bei der Google Cloud-Konsole an und erstellen Sie ein neues Projekt. Stellen Sie außerdem sicher, dass die Abrechnung aktiviert ist (Sie können auch eine kostenlose Testversion verwenden).

In diesem Beispiel nennen Sie das Google Cloud-Projekt “Bright Data SERP-API Pipeline” und setzen die Projekt-ID auf bright-data-pipeline:

Sobald das Projekt erstellt ist, wählen Sie es aus, um mit der Arbeit daran zu beginnen. Sie sollten nun eine Ansicht wie die folgende sehen:

Auf dieser Seite finden Sie Ihren Projektnamen, die Projektnummer und die Projekt-ID. Sowohl die Projektnummer als auch die ID werden Sie später im Tutorial benötigen, also notieren Sie sie und bewahren Sie sie an einem sicheren Ort auf.

Jetzt, da Ihr Google Cloud-Projekt fertig ist, müssen Sie im nächsten Schritt die erforderlichen APIs aktivieren. Geben Sie in der Suchleiste “APIs & Services” ein, rufen Sie die Seite auf und klicken Sie auf die Schaltfläche “APIs und Services aktivieren”:

Suchen Sie nach den folgenden APIs und aktivieren Sie diese:

• “Vertex KI API“
• “Notebooks API“

Diese beiden APIs sind notwendig, um Vertex KI in der Vertex KI Workbench zu verwenden und mit ihr zu entwickeln.

Hinweis: Die Pipeline hängt auch von mehreren anderen APIs ab, die normalerweise standardmäßig aktiviert sind. Überprüfen Sie bei Problemen, ob diese ebenfalls aktiviert sind:

• “Cloud Resource Manager API”
• “Cloud-Speicher-API”
• “Service Usage API” (Dienstverwendungs-API)
• “Compute Engine API”
• “Gemini für Google Cloud API”
• “Cloud Logging API”

Wenn eine davon deaktiviert ist, aktivieren Sie sie manuell, bevor Sie fortfahren.

Geschafft! Sie haben nun ein Google Cloud-Projekt.

Schritt #2: Einrichten des Cloud Storage Bucket

Um Vertex KI Pipelines auszuführen, benötigen Sie ein Cloud Storage Bucket. Das liegt daran, dass Vertex KI Pipeline-Artefakte wie Zwischendaten, Modelldateien, Protokolle und während der Pipeline-Ausführung generierte Metadaten speichern muss. Mit anderen Worten: Der konfigurierte Bucket fungiert als Arbeitsbereich, in dem Ihre Pipeline-Komponenten Daten lesen und schreiben.

Um einen Bucket zu erstellen, suchen Sie in der Google Cloud Console nach “Cloud Storage”. Öffnen Sie das erste Ergebnis, wählen Sie “Buckets” aus dem linken Menü und klicken Sie dann auf die Schaltfläche “Erstellen”:

Im Formular zur Erstellung eines Buckets:

• Geben Sie ihm einen weltweit eindeutigen Namen, z. B. bright-data-pipeline-artifacts.
• Wählen Sie einen Standorttyp und eine Region. Der Einfachheit halber empfehlen wir, die Option “us (multiple regions in United States)” zu wählen.

Notieren Sie sich nach der Erstellung den Bucket-Namen, da Sie ihn später in der Pipeline-Konfiguration benötigen. Sie sollten jetzt etwa so etwas sehen:

In diesem Fall lautet der Bucket-Name:

bright-data-pipeline-artifacts 

Der Bucket-URI lautet:

gs://bright-data-pipeline-artifacts

Da Sie die Multi-Region “us” gewählt haben, können Sie auf diesen Bucket über jede unterstützte us-*-Region zugreifen. Dazu gehören us-central1, us-east1, …, us-west1…, usw. Wir empfehlen die Einstellung us-central1.

Nun müssen Sie Vertex KI die Berechtigung erteilen, Daten in Ihrem Bucket zu lesen und zu schreiben. Klicken Sie dazu auf den Bucket-Namen, um die Detailseite zu öffnen, und gehen Sie dann auf die Registerkarte “Berechtigungen”:

Klicken Sie auf die Schaltfläche “Zugriff gewähren” und fügen Sie eine neue Berechtigungsregel wie folgt hinzu:

• Auftraggeber: <Ihre_GC_PROJEKT_NUMMER>[email protected]
• Rolle: Speicherverwalter

(Wichtig! Weisen Sie in Produktionsumgebungen nur die erforderlichen Mindestrollen zu. Die Verwendung des vollen “Storage Admin”-Zugriffs dient in diesem Setup nur der Einfachheit).

Klicken Sie auf “Speichern”, um die neue Rolle zu bestätigen, die dem Compute-Engine-Service Ihres Projekts die Fähigkeit verleiht, auf Objekte in Ihrem Cloud-Storage-Bucket zuzugreifen und diese zu verwalten.

Ohne diese Berechtigung wäre Ihre Vertex KI-Pipeline nicht in der Lage, während der Ausführung Daten zu lesen oder zu schreiben, was zu 403 Forbidden-Fehlern wie dem folgenden führen würde:

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] hat keinen storage.buckets.get Zugriff auf den Google Cloud Storage-Bucket. Die Berechtigung 'storage.buckets.get' wird für die Ressource verweigert (oder sie existiert möglicherweise nicht).

Erstaunlich! Google Cloud Storage-Bucket konfiguriert.

Schritt #3: Konfigurieren Sie die IAM-Berechtigungen

Genau wie beim Cloud-Storage-Bucket müssen Sie auch dem Compute-Engine-Servicekonto Ihres Projekts die richtigen IAM-Berechtigungen erteilen.

Diese Berechtigungen ermöglichen es Vertex KI, Pipeline-Aufträge in Ihrem Namen zu erstellen und zu verwalten. Ohne diese Berechtigungen hat die Pipeline nicht die Berechtigung, ihre Ausführung innerhalb Ihres Google Cloud-Projekts zu starten oder zu steuern.

Um sie einzurichten, suchen Sie in der Google Cloud Console nach “IAM & Admin” und öffnen Sie die Seite.
Klicken Sie auf die Schaltfläche “Grant access” (Zugriff gewähren) und fügen Sie dann die folgenden zwei Rollen zu Ihrem Compute Engine-Standard-Servicekonto hinzu (d. h. <YOUR_GC_PROJECT_NUMBER>[email protected]):

• “Dienstkonto-Benutzer”
• “Vertex KI-Benutzer”

Nachdem Sie die Rollen zugewiesen haben, klicken Sie auf die Schaltfläche “Speichern”. Auf diese Weise kann Ihre Vertex KI-Pipeline die Rechenressourcen Ihres Projekts nutzen und verwaltete Workloads ausführen.

Kurz gesagt: Sie teilen Google Cloud mit, dass Ihre Vertex KI-Pipelines berechtigt sind, im Namen des Compute-Service-Kontos Ihres Projekts zu handeln. Ohne diese Berechtigungen erhalten Sie 403 Forbidden-Fehler wie den folgenden, wenn Sie versuchen, einen Pipeline-Job zu starten:

403 POST https://us-central1-aiplatform.googleapis.com/v1/projects/bright-data-pipeline/locations/us-central1/pipelineJobs?pipelineJobId=XXXXXXXXXXXXXXXXXXXXXXX&%24alt=json%3Benum-encoding%3Dint: Die Berechtigung 'aiplatform.pipelineJobs.create' wurde für die Ressource '//aiplatform.googleapis.com/projects/bright-data-pipeline/locations/us-central1' verweigert (oder sie existiert nicht). [{'@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'}}]

Alles bereit! IAM ist nun konfiguriert und bereit für die Ausführung von Vertex KI-Pipelines.

Schritt 4: Erste Schritte mit Vertex KI Workbench

Um die Entwicklung zu vereinfachen, werden Sie unsere Vertex KI-Pipeline direkt in der Cloud aufbauen, ohne dass eine lokale Einrichtung erforderlich ist.

Dazu verwenden Sie Vertex KI Workbench, eine vollständig verwaltete JupyterLab-basierte Entwicklungsumgebung innerhalb der Vertex KI-Plattform von Google Cloud. Sie wurde entwickelt, um komplette Data-Science-Workflows zu unterstützen, vom Prototyping bis zur Bereitstellung von Modellen.

Hinweis: Bevor Sie fortfahren, stellen Sie sicher, dass die “Notebooks API” aktiviert ist, da diese API für die Funktion von Vertex KI Workbench erforderlich ist.

Um auf Vertex KI Workbench zuzugreifen, suchen Sie in der Google Cloud Console nach “Vertex KI Workbench” und öffnen Sie die Seite. Klicken Sie anschließend auf der Registerkarte “Instanzen” auf “Neu erstellen”, um eine neue Instanz zu starten:

Hinweis: Während Vertex KI Workbench Jupyter 4 für neue Instanzen unterstützt, verwenden alle Umgebungen derzeit standardmäßig JupyterLab 3. In dieser Version sind die neuesten NVIDIA GPU- und Intel-Bibliotheken und -Treiber bereits vorinstalliert. Für dieses Tutorial sollten Sie sich daher für JupyterLab 3 entscheiden.

Belassen Sie im Formular zur Erstellung der Instanz alle Standardkonfigurationswerte, einschließlich des Standard-Maschinentyps ( n1-standard-4). Diese Maschine ist für diesen Leitfaden mehr als ausreichend.

Klicken Sie auf “Erstellen” und bedenken Sie, dass es einige Minuten dauern wird, bis die Instanz bereitgestellt und gestartet ist. Sobald sie fertig ist, sehen Sie einen neuen Eintrag in der Tabelle “Instances” mit einem Link “Open JupyterLab”. Klicken Sie darauf:

Sie werden zu Ihrer Cloud-basierten JupyterLab-Umgebung weitergeleitet, die vollständig auf Google Cloud gehostet wird:

Klicken Sie hier unter “Notizbuch” auf “Python 3 (ipykernel)”, um ein neues Notizbuch zu erstellen. Dieses Notizbuch dient als Entwicklungsumgebung für das Schreiben und Testen Ihrer mit Bright Data integrierten Vertex-KI-Pipeline:

Großartig! Sie können nun mit der Codierung und dem Aufbau der Logik für Ihre Vertex KI-Datenpipeline beginnen.

Schritt Nr. 5: Installieren und Initialisieren der erforderlichen Python-Bibliotheken

Beginnen Sie in Ihrem Notebook mit dem Hinzufügen und Ausführen der folgenden Zelle, um alle Python-Bibliotheken zu installieren, die Sie für dieses Projekt benötigen:

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

Dies kann ein paar Minuten dauern, also haben Sie etwas Geduld, während die Umgebung alles einrichtet.

Hier steht, was jede Bibliothek tut und warum sie benötigt wird:

• kfp: Dies ist das Kubeflow Pipelines SDK, mit dem Sie Pipelines für maschinelles Lernen programmatisch in Python definieren, kompilieren und ausführen können. Es enthält Dekoratoren und Klassen zur Erstellung von Pipeline-Komponenten.
• google-cloud-aiplattform: Das Vertex KI SDK für Python. Es bietet alles, was Sie brauchen, um direkt mit den Vertex KI-Diensten von Google Cloud zu interagieren, einschließlich des Trainings von Modellen, der Bereitstellung von Endpunkten und der Ausführung von Pipelines.
• google-genai: Googles SDK für generative KI, mit dem Sie Gemini und andere generative Modelle (auch in Vertex KI) verwenden und orchestrieren können. Dies ist nützlich, da die Pipeline LLM-Aufgaben enthält.(Zur Erinnerung: Vertex KI SDK ist jetzt veraltet).
• brightdata-sdk: Das Bright Data SDK, mit dem Sie direkt aus Ihrer Pipeline Echtzeitdaten über die SERP-API von Bright Data oder andere Webdatenquellen abrufen können.

Sobald alle Bibliotheken installiert sind, importieren Sie sie und initialisieren Sie das Vertex KI SDK mit dem folgenden Code in einer eigenen Zelle:

kfp importieren
from kfp.dsl import component, pipeline, Input, Output, Artefakt
von kfp importieren Compiler
aus google.cloud importieren aiplatform
from typing import List

# Ersetzen Sie durch die Geheimnisse Ihres Projekts
PROJECT_ID = "<IHRE_GC_PROJECT_ID>"
REGION = "<IHRE_REGION>" # (z.B. "us-central1")
BUCKET_URI = "<IHR_BUCKET_URI>" # (z. B. "gs://bright-data-pipeline-artifacts")

# Initialisieren des Vertex KI SDK
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)

Die Funktion aiplatform.init() konfiguriert Ihre Python-Umgebung für die Kommunikation mit Vertex KI. Sie richtet das Projekt, die Region und den Staging-Bucket ein, damit alle nachfolgenden KI-Vorgänge von Vertex, wie das Erstellen von Pipelines, das Trainieren von Aufträgen oder das Bereitstellen von Modellen, automatisch den richtigen Kontext verwenden.

Kurz gesagt, diese eine Codezeile verbindet Ihre Notebook-Sitzung mit Ihrem Google Cloud-Projekt und teilt Vertex KI mit, wo Pipeline-Artefakte und temporäre Daten gespeichert werden sollen. Gut gemacht!

Schritt #6: Definieren Sie die Abfrageextraktionskomponente

Denken Sie daran, dass eine Vertex KI-Pipeline aus Komponenten aufgebaut ist, wobei eine Komponente lediglich eine Python-Funktion ist, die eine bestimmte Aufgabe erfüllt. Wie bereits erläutert, wird diese Pipeline aus drei Komponenten bestehen.

Beginnen wir mit der ersten, der Komponente extract_queries!

Die Komponente extract_queries:

1. Nimmt den zu überprüfenden Text als Eingabe.
2. Verwendet ein Gemini-Modell (über die google-genai-Bibliothek ), um eine Liste von Google-fähigen Suchanfragen zu generieren, die helfen würden, die Tatsachenbehauptungen in diesem Text zu überprüfen.
3. Gibt diese Liste als Python-Array(List[str]) zurück.

Implementieren Sie es wie folgt:

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

    # Initialisierung des Google Gen KI SDK mit Vertex-Integration
    client = genai.Client(
        vertexai=True,
        project=project, 
        location=location,
        http_options=HttpOptions(api_version="v1")
    )

    # Das Ausgabeschema, das ein Array von Strings ist
    response_schema = {
        "type": "ARRAY",
        "items": {
            "type": "STRING"
        }
    }

    # Der Prompt des Abfrageextraktors
    prompt = f"""
    Sie sind ein professioneller Faktenchecker. Ihre Aufgabe ist es, den folgenden Text zu lesen und zu extrahieren 
    eine Liste spezifischer, googelfähiger Suchanfragen zu extrahieren, die nötig wären 
    um die wichtigsten Tatsachenbehauptungen zu überprüfen.

    Geben Sie *nur* eine Python-Liste von Zeichenketten zurück, und sonst nichts.

    Beispiel:
    Eingabe: "Der Eiffelturm wurde 1889 von Gustave Eiffel erbaut und ist 300 Meter hoch."
    Ausgabe: ["wann wurde der Eiffelturm gebaut", "wer hat den Eiffelturm gebaut", "wie hoch ist der Eiffelturm"]

    Hier ist der zu überprüfende Text:
    ---
    "{input_text}"
    ---
    """

    response = client.models.generate_content(
        model="gemini-2.5-flash",
        content=prompt,
        config=GenerateContentConfig(
            # Erzwingt, dass das Modell ein JSON-Array von Strings zurückgibt
            response_mime_type="application/json",
            response_schema=response_schema,
        ),
    )

    # Der 'response.text' enthält zuverlässig einen JSON-String, der dem Schema entspricht (z.B. '["query_1", ..., "query_n"]')
    abfrage_liste: List[str] = json.loads(response.text.strip())

    return abfrage_liste

Beachten Sie, dass KFP-Komponenten in sich geschlossen sein müssen. Das bedeutet, dass alle Importe innerhalb der Komponentenfunktion deklariert werden müssen, nicht global.

Beachten Sie, dass die Parameter vertexai=True, project=project und location=location in genai.Client() erforderlich sind, um den google-genai-Client mit Ihrer Vertex-KI-Umgebung zu verbinden. Sie stellen sicher, dass das konfigurierte Modell in derselben Region und demselben Projekt wie Ihre Pipeline ausgeführt wird.

Was die Wahl des Modells betrifft, so sollten Sie hier Gemini 2.5 Flash verwenden, da es leichtgewichtig und schnell ist. Bei Bedarf können Sie aber auch ein anderes Gemini-Modell für eine höhere Genauigkeit einstellen.

Eine Komponente erledigt, zwei weitere folgen!

Schritt #7: Erstellen der SERP-API-gesteuerten Websuchkontext-Retriever-Komponente

Nachdem Sie nun eine Liste von Google-fähigen Suchanfragen erstellt haben, ist es an der Zeit, das Web nach Kontext zu durchsuchen. Verwenden Sie dazu die SERP-API von Bright Data, mit der Sie Suchergebnisse (standardmäßig Google) auf strukturierte und skalierbare Weise programmatisch abrufen können.

Der einfachste Weg, von Python aus auf die SERP-API zuzugreifen, führt über das offizielle und quelloffene Bright Data SDK. Diese Bibliothek stellt Ihnen einfache Methoden zum Aufrufen von Bright Data-Produkten, einschließlich der SERP-API, zur Verfügung. Weitere Informationen dazu finden Sie in den Dokumenten.

Insbesondere die Komponente fetch_web_search_context:

1. Akzeptiert eine Liste von Suchanfragen, die im vorherigen Schritt erstellt wurden.
2. Verwendet das Bright Data SDK, um die SERP-API parallel für jede Suchanfrage aufzurufen.
3. Ruft die Suchergebnisse ab (standardmäßig von Google).
4. Speichert alle Ergebnisse als JSON-Artefakt, eine Datei, die andere Komponenten in der Pipeline verwenden können.

Erstellen Sie eine solche Komponente in einer speziellen Notizbuchzelle wie folgt:

@component(
    base_image="python:3.10",
    packages_to_install=["brightdata-sdk"],
)
def fetch_web_search_context(
    queries: List[str],
    api_key: str,
    output_file: Output[Artefakt],
):
    """
    Nimmt eine Liste von Abfragen, durchsucht jede einzelne mit Bright Data SDK,
    und schreibt alle Ergebnisse als JSON-Datei-Artefakt.
    """
    von brightdata importieren bdclient
    json importieren

    # Initialisieren des Bright Data SDK-Clients
    client = bdclient(api_token=api_key)
    # Aufruf der SERP-API für die Eingabeabfragen
    results = client.search(
        queries,
        data_format="markdown"
    )

    # Ergebnisse in eine Artefaktdatei schreiben
    with open(output_file.path, "w") as f:
        json.dump(results, f)

Beachten Sie, dass die SERP-API so konfiguriert wurde, dass der Inhalt im Markdown-Format zurückgegeben wird, was ideal für die Aufnahme in LLMs ist.

Da die Ausgabe dieser Komponente recht groß sein kann, ist es außerdem am besten, sie als Artefakt zu speichern. Artefakte werden in Ihrem Google Cloud-Storage-Bucket gespeichert und ermöglichen es den Komponenten in einer Vertex-KI-Pipeline, Daten effizient untereinander auszutauschen, ohne den Speicher zu überlasten oder die Grenzen der Datenübertragung zu überschreiten.

Jetzt geht’s los! Dank der leistungsstarken Websuchfunktionen von Bright Data verfügen Sie jetzt über einen von Google unterstützten Suchkontext, der als Eingabe für die nächste Komponente verwendet werden kann, in der ein LLM die Faktenprüfung durchführt.

Schritt Nr. 8: Implementieren der Faktenprüfungskomponente

Ähnlich wie bei der Abfrageextraktionskomponente wird auch bei diesem Schritt ein LLM aufgerufen. Anstatt jedoch Abfragen zu generieren, verwendet diese Komponente die im vorherigen Schritt gesammelten Web-Suchergebnisse als kontextuelle Beweise, um den ursprünglichen Eingabetext auf Fakten zu überprüfen.

Im Wesentlichen führt sie einen SERP-basierten RAG-ähnlichen Arbeitsablauf aus, bei dem die abgerufenen Webinhalte den Verifizierungsprozess des Modells leiten.

Definieren Sie in einer neuen Notizbuchzelle die Komponente fact_check_with_web_search_context wie folgt:

@component(
    base_image="python:3.10",
    packages_to_install=["google-genai"],
)
def fact_check_with_web_search_context(
    input_text: str,
    web_search_context_file: Input[Artifact],
    projekt: str,
    Standort: str,
) -> str:
    json importieren
    von google importieren genai

    # Lade den Websuchkontext aus dem Artefakt
    with open(web_search_context_file.path, "r") as f:
        web_search_context = json.load(f)

    client = genai.Client(
        vertexai=True,
        Projekt=Projekt, 
        ort=ort
    )

    prompt = f"""
    Sie sind ein KI-Faktenchecker. Vergleichen Sie den Originaltext mit dem JSON-Suchkontext
    und erstelle einen Faktencheck-Bericht in Markdown.

    [Originaltext]
    "{input_text}"

    [Web-Suchkontext]
    "{json.dumps(web_search_context)}"
    """

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

    return response.text

Diese Aufgabe ist komplexer und erfordert Schlussfolgerungen über mehrere Beweisquellen. Daher ist es besser, ein leistungsfähigeres Modell wie Gemini 2.5 Pro zu verwenden.

Ausgezeichnet! Sie haben nun alle drei Komponenten definiert, aus denen Ihre Vertex KI-Pipeline besteht.

Schritt #9: Definieren und kompilieren Sie die Pipeline

Verbinden Sie alle drei Komponenten zu einer einzigen Kubeflow-Pipeline. Jede Komponente wird nacheinander ausgeführt, wobei die Ausgabe eines Schritts die Eingabe des nächsten ist.

So definieren Sie die Pipeline:

@pipeline(
    name="bright-data-fact-checker-pipeline",
    description="Holt den SERP-Kontext ab, um ein Textdokument auf Fakten zu prüfen."
)
def fact_check_pipeline(
    input_text: str,
    bright_data_api_key: str,
    projekt: str = PROJEKT_ID,
    Standort: str = REGION,
):
    # Schritt 1: Extrahieren von Google-fähigen Abfragen aus dem Eingabetext zur Überprüfung 
    step1 = extract_queries(
        input_text=input_text,
        project=project,
        ort=ort
    )

    # Schritt 2: Abrufen von Bright Data SERP-Ergebnissen zu den Suchanfragen
    step2 = fetch_web_search_context(
        queries=step1.output,
        bright_data_api_key=bright_data_api_key
    )

    # Schritt 3: Faktenüberprüfung mit dem zuvor abgerufenen Websuchkontext durchführen
    step3 = fact_check_with_web_search_context(
        input_text=input_text,
        web_search_context_file=step2.outputs["output_file"],
        Projekt=Projekt,
        location=Ort
    ) 

Im Wesentlichen verbindet diese Funktion die drei Komponenten, die Sie zuvor erstellt haben. Sie beginnt mit der Erstellung von Abfragen zur Faktenüberprüfung, ruft dann die Suchergebnisse für jede Abfrage mithilfe der SERP-API von Bright Data ab und führt schließlich ein Gemini-Modell aus, um die Behauptungen auf der Grundlage der gesammelten Beweise zu überprüfen.

Als Nächstes müssen Sie die Pipeline in eine JSON-Spezifikation kompilieren, die Vertex KI ausführen kann:

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

Dieser Befehl konvertiert Ihre Python-Pipeline-Definition in eine JSON-Pipeline-Spezifikationsdatei namens fact_check_pipeline.json.

Diese JSON-Datei ist eine Blaupause, auf die sich Vertex KI Pipelines verlässt, um zu verstehen, wie der Workflow orchestriert werden soll. Sie beschreibt jede Komponente, ihre Eingaben und Ausgaben, Abhängigkeiten, Container-Images und die Ausführungsreihenfolge.

Wenn diese JSON-Datei in Vertex KI ausgeführt wird, stellt Google Cloud automatisch die Infrastruktur bereit, führt jede Komponente in der richtigen Reihenfolge aus und kümmert sich um die Datenübergabe zwischen den Schritten. Die Pipeline ist fertig!

Schritt Nr. 10: Ausführen der Pipeline

Angenommen, Sie möchten die Vertex KI-Pipeline anhand einer eindeutig falschen Aussage wie dieser testen:

“Paris ist die Hauptstadt von Deutschland, das den Yen als Währung verwendet.”

Fügen Sie die folgende Zelle zu Ihrem Jupyter-Notizbuch hinzu. Dieses Add definiert die Logik zum Starten der Pipeline:

TEXT_TO_CHECK = """
Paris ist die Hauptstadt von Deutschland, das den Yen als Währung verwendet.
"""

# Ersetzen Sie durch Ihren Bright Data API-Schlüssel
BRIGHT_DATA_API_KEY = "<IHR_BRIGHT_DATA_API_KEY>"

print("Starten des Pipeline-Jobs...")

# Definieren Sie den Pipeline-Job
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
    }
)

# Den Auftrag ausführen
job.run()

print("nJob submitted! Sie können seinen Fortschritt in der Vertex KI UI sehen.")

Dieser Code erstellt einen neuen Vertex KI-Pipeline-Job, der das zuvor kompilierte Pipeline-JSON(fact_check_pipeline.json), Ihren Speicher-Bucket als Pipeline-Root und die für diesen speziellen Lauf erforderlichen Parameter (d. h. den zu überprüfenden Eingabetext und Ihren Bright Data API-Schlüssel) angibt.

Sobald Sie diese Zelle ausführen, wird Vertex KI automatisch Ihre gesamte Pipeline in der Cloud orchestrieren.

Sicherheitshinweis: In diesem Beispiel wird der API-Schlüssel von Bright Data der Einfachheit halber direkt in das Notebook codiert, was jedoch für Produktionsumgebungen nicht sicher ist. In einer realen Bereitstellung sollten Sie sensible Anmeldeinformationen wie API-Schlüssel mit Google Cloud Secret Manager speichern und abrufen, um eine versehentliche Aufdeckung (z. B. in Protokollen) zu vermeiden.

Um Ihre Pipeline auszuführen, wählen Sie alle Zellen aus und drücken Sie die Schaltfläche “▶” in Ihrem Jupyter-Notebook. Sie erhalten diese Ausgabe für die letzte Zelle:

Dies bedeutet, dass Ihre Vertex KI-Pipeline zur Faktenüberprüfung erfolgreich läuft. Toll!

Schritt #11: Überwachen Sie die Pipeline-Ausführung

Um den Status Ihres Pipeline-Jobs zu überprüfen, rufen Sie die Vertex KI Pipelines-Seite in der Google Cloud Console für Ihr Projekt auf:

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

In diesem Fall lautet die URL also:

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

Fügen Sie die URL in den Browser ein, und Sie werden eine Seite wie die folgende sehen:

Klicken Sie auf den ersten Eintrag in der Tabelle “Runs”, um die Seite zur Ausführung von Pipeline-Jobs zu öffnen:

Hier können Sie die Komponenten, aus denen Ihre Pipeline besteht, visuell erkennen. Sie können auch den Status jedes Knotens überprüfen, detaillierte Protokolle anzeigen und den Datenfluss vom Anfang bis zum Ende der Pipeline während der Ausführung beobachten.

Schritt Nr. 12: Untersuchen Sie die Ausgabe

Sobald die Ausführung der Pipeline abgeschlossen ist, zeigt jeder Knoten ein Häkchen an, das den erfolgreichen Abschluss anzeigt:

Klicken Sie auf den ersten Knoten, um die aus dem Eingabetext extrahierten Google-fähigen Abfragen zu prüfen. In diesem Beispiel wurden die folgenden Abfragen generiert:

• "Was ist die Hauptstadt von Deutschland"
• "Welche Währung wird in Deutschland verwendet?

Diese Abfragen sind perfekt geeignet, um die Tatsachenbehauptungen im Eingabetext zu überprüfen:

Klicken Sie anschließend auf den Artefakt-Knoten zwischen dem zweiten und dem dritten Knoten. Sie erhalten einen Link auf die JSON-Datei, die in Ihrem konfigurierten Google Cloud Storage Bucket (in diesem Fall bright-data-pipeline-artifacts) gespeichert ist.

Sie können auch direkt auf die gewünschte Seite zugreifen, indem Sie in der Cloud Console zu dem Bucket navigieren:

Innerhalb des Buckets sehen Sie einen Ordner für jede Komponente. Im Einzelnen enthält der Ordner für die Komponente fetch_web_search_context eine JSON-Datei mit dem über die SERP-API abgerufenen Websuchkontext, der als Array von Markdown-formatierten Strings gespeichert ist:

Wenn Sie die Datei herunterladen und öffnen, sehen Sie etwa so aus:

Dieser Inhalt ist die Markdown-Darstellung der SERPs, die für jede identifizierte Suchanfrage abgerufen wurden.

Zurück in der Vertex KI Pipeline UI, klicken Sie auf den Ausgabeknoten, um die Gesamtergebnisse zu prüfen:

Wie Sie sehen können, handelt es sich bei der Ausgabe um einen detaillierten Markdown-Faktencheck-Bericht. Die gleiche Ausgabe wird auch in der Datei executor_output.json im Bucket-Ordner für den Pipeline-Lauf gespeichert. Laden Sie sie herunter und öffnen Sie sie in einer IDE wie Visual Studio Code, um sie zu prüfen:

Kopieren Sie die Markdown-Zeichenfolge in eine .md-Datei (z. B. report.md), um sie übersichtlicher zu gestalten:

Der Bericht enthält detaillierte Informationen darüber, welche Teile der Eingabeanweisung falsch waren und was die verifizierten Fakten sind.

Et voilà! Dies zeigt die Leistungsfähigkeit der Websuchintegration von Bright Data für den Abruf von Kontextinformationen in einer RAG-basierten Vertex-KI-Pipeline.

Nächste Schritte

Vergessen Sie nicht, dass dies nur ein einfaches Beispiel war, um die Machbarkeit des Abrufs von Websuchdaten von Bright Data in einer Vertex-KI-Pipeline zu demonstrieren. In realen Szenarien würden diese Komponenten wahrscheinlich Teil einer viel längeren, komplexeren Pipeline sein.

Die Eingabedaten könnten aus verschiedenen Quellen stammen, z. B. aus Geschäftsdokumenten, internen Berichten, Datenbanken, Dateien und mehr. Darüber hinaus könnte der Arbeitsablauf viele weitere Schritte umfassen und würde nicht unbedingt nur mit einem Bericht zur Faktenüberprüfung enden.

Fazit

In diesem Blogbeitrag haben Sie erfahren, wie Sie die SERP-API von Bright Data nutzen können, um Websuchkontext innerhalb einer Vertex-KI-Pipeline abzurufen. Der hier vorgestellte KI-Workflow ist ideal für alle, die eine programmatische, zuverlässige Faktenprüfungspipeline aufbauen möchten, um die Richtigkeit ihrer Daten sicherzustellen.

Wenn Sie ähnliche fortschrittliche KI-Workflows erstellen möchten, sollten Sie die gesamte Palette der Lösungen zum Abrufen, Validieren und Umwandeln von Live-Webdaten mit der KI-Infrastruktur von Bright Data kennenlernen.

Erstellen Sie noch heute ein kostenloses Bright Data-Konto und experimentieren Sie mit unseren KI-fähigen Webdaten-Tools!