Semantische Suche und Retrieval Augmented Generation durchführen

In dieser Anleitung verwenden Sie ein Remote-Modell mit der Funktion AI.GENERATE_EMBEDDING, um Texteinbettungen in einer BigQuery-Tabelle zu generieren. Anschließend erstellen Sie einen Vektorindex, um die Einbettungen zu indexieren und die Suchleistung zu verbessern.

Sie verwenden die Funktion VECTOR_SEARCH mit den Einbettungen, um nach ähnlichem Text zu suchen. Die Vektorsuche ist eine Technik zum Vergleichen ähnlicher Objekte mithilfe von Einbettungen. Das sind hochdimensionale numerische Vektoren, die eine bestimmte Entität wie einen Text darstellen.

Schließlich führen Sie Retrieval Augmented Generation (RAG) durch, indem Sie Text mit der Funktion AI.GENERATE_TEXT generieren. RAG ist ein KI-Framework, das die Stärken von Systemen zum Informationsabruf (z. B. Suchmaschinen und Datenbanken) mit den Funktionen von generativen Large Language Models (LLMs) kombiniert. Durch die Kombination Ihrer Daten und Ihres Weltwissens mit den Sprachfähigkeiten von LLM ist Grounded Generation genauer, aktueller und relevanter für Ihre spezifischen Anforderungen.

In dieser Anleitung werden Daten aus dem öffentlichen Dataset „Google Patentsuche Research“ verwendet.

Ziele

  • BigQuery ML-Remote-Modell für ein Gemini Enterprise Agent Platform-Einbettungsmodell erstellen
  • Verwenden Sie das Remote-Modell mit der Funktion AI.GENERATE_EMBEDDING, um Einbettungen aus Text in einer BigQuery-Tabelle zu generieren.
  • Erstellen Sie einen Vektorindex, um die Einbettungen zu indexieren und die Suchleistung zu verbessern.
  • Verwenden Sie die Funktion VECTOR_SEARCH mit den Einbettungen, um nach ähnlichem Text zu suchen.
  • Führen Sie RAG durch, indem Sie Text mit der Funktion AI.GENERATE_TEXT generieren und Vektorsuchergebnisse verwenden, um die Prompt-Eingabe zu erweitern und die Ergebnisse zu verbessern.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

  • BigQuery ML: You incur costs for the data that you process in BigQuery.
  • Gemini Enterprise Agent Platform: You incur costs for calls to the Agent Platform service that's represented by the remote model.

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Nutzern von Google Cloud steht möglicherweise eine kostenlose Testversion zur Verfügung.

Weitere Informationen finden Sie auf den folgenden Preisseiten:

Hinweis

  1. Wählen Sie in der Google Cloud Console auf der Seite für die Projektauswahl ein Google Cloud -Projekt aus oder erstellen Sie eines.

    Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

    • Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
    • Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

    Zur Projektauswahl

  2. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

  3. Aktivieren Sie die APIs für BigQuery, Cloud Storage und die Gemini Enterprise Agent Platform, falls sie noch nicht aktiviert sind.

    Rollen, die zum Aktivieren von APIs erforderlich sind

    Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen

    APIs aktivieren

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen dieser Anleitung benötigen:

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Dataset erstellen

Wählen Sie eine der folgenden Optionen aus, um ein BigQuery-Dataset zu erstellen:

Console

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

    BigQuery aufrufen

  2. Klicken Sie im linken Bereich auf Explorer:

    Hervorgehobener Button für den Explorer-Bereich.

    Wenn das linke Steuerfeld nicht angezeigt wird, klicken Sie auf  Linkes Steuerfeld maximieren, um es zu öffnen.

  3. Maximieren Sie im Explorer Ihr Projekt und klicken Sie dann auf Datasets.

  4. Klicken Sie auf der Seite Datasets auf  Dataset erstellen.

  5. Führen Sie im Bereich Dataset erstellen die folgenden Schritte aus:

    • Geben Sie unter Dataset-ID bqml_tutorial ein.

    • Wählen Sie unter Speicherort der Daten die Option USA aus.

    Übernehmen Sie die anderen Standardeinstellungen.

  6. Klicken Sie auf Dataset erstellen.

bq

Verwenden Sie den Befehl bq mk --dataset, um ein neues Dataset zu erstellen.

  1. Erstellen Sie ein Dataset mit dem Namen bqml_tutorial und dem Datenspeicherort US:

    bq mk --dataset \
  --location=US \
  --description "BigQuery ML tutorial dataset." \
  bqml_tutorial

  2. Prüfen Sie, ob das Dataset erstellt wurde:

    bq ls

API

Rufen Sie die Methode datasets.insert mit einer definierten Dataset-Ressource auf:

{
  "datasetReference": {
     "datasetId": "bqml_tutorial"
  }
}

Remote-Modell für die Generierung von Texteinbettungen erstellen

In diesem Abschnitt erstellen Sie ein Remote-Modell, das ein gehostetes Agent Platform-Modell zur Generierung von Texteinbettungen darstellt. Wenn Sie das Modell erstellen, verwenden Sie die DEFAULT-Verbindung, um die Text Embeddings API aufzurufen und Texteinbettungen mit dem text-embedding-005-Modell abzurufen. Wenn Sie keine Standardverbindung haben, wird mit der CREATE MODEL-Anweisung eine für Sie erstellt.

So erstellen Sie das Texteinbettungsmodell:

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

    BigQuery aufrufen

  2. Um das Modell zu erstellen, fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie dann auf  Ausführen:

    CREATE OR REPLACE MODEL `bqml_tutorial.embedding_model`
  REMOTE WITH CONNECTION DEFAULT
  OPTIONS (ENDPOINT = 'text-embedding-005');

    Die Abfrage dauert mehrere Sekunden. Anschließend kann über den Bereich Explorer auf das Modell embedding_model zugegriffen werden.

    Sie erhalten eine Bestätigungsnachricht wie die folgende: Successfully created model named embedding_model.

Texteinbettungen generieren

Generieren Sie mit der Funktion AI.GENERATE_EMBEDDING Texteinbettungen aus Patentabstrakten und schreiben Sie sie dann in eine BigQuery-Tabelle, damit sie durchsucht werden können.

Die Generierung von Einbettungen mit der Funktion AI.GENERATE_EMBEDDING kann aufgrund von Kontingenten für Agent Platform LLM oder der Nichtverfügbarkeit von Diensten fehlschlagen. Wenn der Vorgang fehlschlägt, werden Fehlerdetails in der Spalte status in den Abfrageergebnissen zurückgegeben.

Alternative Methoden zum Generieren von Texteinbettungen in BigQuery finden Sie in der Anleitung zum Einbetten von Text mit vortrainierten TensorFlow-Modellen.

Fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie dann auf  Ausführen, um Texteinbettungen zu generieren:

  CREATE OR REPLACE TABLE bqml_tutorial.embeddings AS
  SELECT * FROM AI.GENERATE_EMBEDDING(
    MODEL bqml_tutorial.embedding_model,
    (
      SELECT *, abstract AS content
      FROM patents-public-data.google_patents_research.publications
      WHERE LENGTH(abstract) > 0 AND LENGTH(title) > 0 AND country = 'Singapore'
    )
  )
  WHERE LENGTH(status) = 0;

Die Ausführung dieser Abfrage kann mehrere Minuten dauern. Sie erhalten eine Bestätigungsmeldung wie die folgende:This statement created a new table named embeddings.

Vektorindex erstellen

Wenn Sie einen Vektorindex für eine Einbettungsspalte erstellen, wird bei einer Vektorsuche in dieser Spalte die Suchmethode Annäherung an den nächsten Nachbarn verwendet. Diese Methode verbessert die Leistung der Vektorsuche und gibt ungefähre Ergebnisse zurück, aber die Trefferquote wird reduziert.

Verwenden Sie zum Erstellen eines Vektorindex die Datendefinitionssprachen-Anweisung (DDL) CREATE VECTOR INDEX. Um zu prüfen, ob der Index verfügbar ist, fragen Sie die Ansicht INFORMATION_SCHEMA.VECTOR_INDEXES ab und prüfen Sie, ob der Wert der Spalte coverage_percentage größer als 0 ist und der Wert der Spalte last_refresh_time nicht NULL ist.

So erstellen und überprüfen Sie den Vektorindex:

  1. Fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie dann auf Ausführen, um den Vektorindex zu erstellen:

    CREATE OR REPLACE VECTOR INDEX my_index
ON `bqml_tutorial.embeddings`(embedding)
OPTIONS(index_type = 'IVF',
  distance_type = 'COSINE',
  ivf_options = '{"num_lists":500}');

    Sie erhalten eine Bestätigungsnachricht wie die folgende: The vector index creation on table bqml_tutorial.embeddings was initiated. Please query bqml_tutorial.INFORMATION_SCHEMA.VECTOR_INDEXES to check the progress of the index.

    Das Erstellen eines Vektorindex dauert in der Regel nur wenige Sekunden. Es dauert weitere zwei bis drei Minuten, bis der Vektorindex asynchron gefüllt wird.

  2. Um zu prüfen, ob der Index verwendet werden kann, fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie auf Ausführen:

    SELECT table_name, index_name, index_status,
coverage_percentage, last_refresh_time, disable_reason
FROM `PROJECT_ID.bqml_tutorial.INFORMATION_SCHEMA.VECTOR_INDEXES`;

    Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

    Nachdem Sie die Abfrage ausgeführt haben, ist der Index verfügbar, wenn in der Spalte index_status der Ergebnisse ACTIVE angezeigt wird und der Wert coverage_percentage 100 ist.

Mit dem Vektorindex eine Suche nach Textähnlichkeiten durchführen

Mit der Funktion VECTOR_SEARCH können Sie nach relevanten Patenten suchen, die mit Einbettungen übereinstimmen, die aus einer Textanfrage generiert wurden.

Das Argument top_k bestimmt die Anzahl der zurückzugebenden Übereinstimmungen, in diesem Fall fünf. Mit der Option fraction_lists_to_search wird der Prozentsatz der zu durchsuchenden Vektorindexlisten festgelegt. Der von Ihnen erstellte Vektorindex hat 500 Listen. Der fraction_lists_to_search-Wert von .01 gibt an, dass bei dieser Vektorsuche fünf dieser Listen gescannt werden. Ein niedrigerer fraction_lists_to_search-Wert, wie hier gezeigt, führt zu einem niedrigeren Recall und einer schnelleren Leistung.

Weitere Informationen zu Vektorindexlisten finden Sie unter der num_lists Option für Vektorindex.

Das Modell, mit dem Sie die Einbettungen in dieser Abfrage erstellen, muss mit dem Modell übereinstimmen, das Sie zum Erzeugen der Einbettungen in der Tabelle verwenden, mit der Sie vergleichen. Andernfalls erhalten Sie ungenaue Suchergebnisse.

Um eine Suche nach Textähnlichkeit durchzuführen, fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie dann auf Ausführen:

  SELECT query.query, base.publication_number, base.title, base.abstract
  FROM VECTOR_SEARCH(
    TABLE bqml_tutorial.embeddings, 'embedding',
    (
    SELECT embedding, content AS query
    FROM AI.GENERATE_EMBEDDING(
    MODEL bqml_tutorial.embedding_model,
    (SELECT 'improving password security' AS content))
    ),
    top_k => 5, options => '{"fraction_lists_to_search": 0.01}');

Die Ausgabe sieht etwa so aus:

+-----------------------------+--------------------+-------------------------------------------------+-------------------------------------------------+
|            query            | publication_number |                       title                     |                      abstract                   |
+-----------------------------+--------------------+-------------------------------------------------+-------------------------------------------------+
| improving password security | SG-120868-A1       | Data storage device security method and a...    | Methods for improving security in data stora... |
| improving password security | SG-10201610585W-A  | Passsword management system and process...      | PASSSWORD MANAGEMENT SYSTEM AND PROCESS ...     |
| improving password security | SG-148888-A1       | Improved system and method for...               | IMPROVED SYSTEM AND METHOD FOR RANDOM...        |
| improving password security | SG-194267-A1       | Method and system for protecting a password...  | A system for providing security for a...        |
| improving password security | SG-120868-A1       | Data storage device security...                 | Methods for improving security in data...       |
+-----------------------------+--------------------+-------------------------------------------------+-------------------------------------------------+

Remote-Modell für die Textgenerierung erstellen

Wenn Sie ein Remote-Modell erstellen möchten, das ein gehostetes Agent Platform-Modell zur Textgenerierung darstellt, fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie dann auf Ausführen:

  CREATE OR REPLACE MODEL bqml_tutorial.text_model
    REMOTE WITH CONNECTION DEFAULT
    OPTIONS (ENDPOINT = 'gemini-2.5-flash');

Sie erhalten eine Bestätigungsnachricht, die so aussieht: Successfully created model named text_model.

Durch Vektorsuchergebnisse erweiterten Text generieren

Geben Sie die Suchergebnisse als Prompts ein, um Text mit der Funktion AI.GENERATE_TEXT zu generieren.

Fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie auf , um die Vektorsuchergebnisse zu erweitern: Ausführen:

  SELECT result AS generated, prompt
  FROM AI.GENERATE_TEXT(
    MODEL bqml_tutorial.text_model,
    (
      SELECT CONCAT(
        'Propose some project ideas to improve user password security using the context below: ',
        STRING_AGG(
          FORMAT("patent title: %s, patent abstract: %s", base.title, base.abstract),
          ',\n')
        ) AS prompt,
      FROM VECTOR_SEARCH(
        TABLE bqml_tutorial.embeddings, 'embedding',
        (
          SELECT embedding, content AS query
          FROM AI.GENERATE_EMBEDDING(
            MODEL bqml_tutorial.embedding_model,
            (SELECT 'improving password security' AS content)
          )
        ),
      top_k => 5, options => '{"fraction_lists_to_search": 0.01}')
    ),
    STRUCT(600 AS max_output_tokens));

Die Ausgabe sieht etwa so aus:

+------------------------------------------------+------------------------------------------------------------+
|            generated                           | prompt                                                     |
+------------------------------------------------+------------------------------------------------------------+
| These patents suggest several project ideas to | Propose some project ideas to improve user password        |
| improve user password security.  Here are      | security using the context below: patent title: Active     |
| some, categorized by the patent they build     | new password entry dialog with compact visual indication   |
| upon:                                          | of adherence to password policy, patent abstract:          |
|                                                | An active new password entry dialog provides a compact     |
| **I. Projects based on "Active new password    | visual indication of adherence to password policies. A     |
| entry dialog with compact visual indication of | visual indication of progress towards meeting all          |
| adherence to password policy":**               | applicable password policies is included in the display    |
|                                                | and updated as new password characters are being...        |
+------------------------------------------------+------------------------------------------------------------+

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

  1. Wechseln Sie in der Google Cloud -Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Wenn Sie das Projekt beibehalten und die in dieser Anleitung verwendeten Ressourcen löschen möchten, gehen Sie so vor:

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im linken Bereich Ihr Projekt und klicken Sie dann auf Datasets.

  3. Klicken Sie für das Dataset bqml_tutorial auf  Aktionen öffnen > Löschen.

  4. Klicken Sie im Dialogfeld Dataset löschen zur Bestätigung auf Löschen.

  5. Klicken Sie im Bereich links auf Verbindungen.

  6. Klicken Sie für die __default_cloudresource_connection__-Verbindung auf Aktionen öffnen > Löschen.

  7. Geben Sie im Dialogfeld Verbindung löschen delete ein und klicken Sie zur Bestätigung auf Löschen.

Nächste Schritte