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, mit der ähnliche Objekte mithilfe von Einbettungen verglichen werden. Einbettungen sind hochdimensionale numerische Vektoren, die eine bestimmte Entität darstellen, z. B. einen Text.

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 (etwa Suchmaschinen und Datenbanken) mit dem generativen Potenzial von 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 über ein Gemini Enterprise Agent Platform-Einbettungsmodell erstellen
  • Mit dem Remote-Modell und der Funktion AI.GENERATE_EMBEDDING Einbettungen aus Text in einer BigQuery-Tabelle 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 Projekt von Google Cloud aus oder erstellen Sie eines.

    Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts

    • 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 „Project Creator“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. 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 BigQuery, Cloud Storage und Gemini Enterprise Agent Platform APIs, 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 Inhaberrolle (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 der linke Bereich nicht angezeigt wird, klicken Sie auf Linken Bereich maximieren, um ihn 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

Wenn Sie ein neues Dataset erstellen möchten, verwenden Sie den Befehl bq mk --dataset.

  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. Beim Erstellen des Modells 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 erstellt.

So erstellen Sie das Texteinbettungsmodell:

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

    BigQuery aufrufen

  2. Fügen Sie den folgenden Befehl in den Abfrageeditor ein, um das Modell zu erstellen, 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 auf das Modell embedding_model über den Bereich Explorer zugegriffen werden.

    Sie erhalten eine Bestätigungsmeldung 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 den folgenden 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 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 für eine Vektorsuche in dieser Spalte die Suchmethode Annäherung an den nächsten Nachbarn verwendet. Diese Technik verbessert die Leistung der Vektorsuche und liefert ungefähre Ergebnisse, aber die Trefferquote wird reduziert.

Verwenden Sie zum Erstellen eines Vektorindex die DDL-Anweisung (Datendefinitionssprache) 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, 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 prüfen Sie den Vektorindex:

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

    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ätigungsmeldung 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 ausgefüllt ist.

  2. Fügen Sie den folgenden Befehl in den Abfrageeditor ein und klicken Sie auf Ausführen, um zu prüfen, ob der Index einsatzbereit ist:

    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 die Spalte index_status in den Ergebnissen zeigt, dass der Index ACTIVE ist, und wenn 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 Textabfrage 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 also 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 in der Vektorindexoption num_lists.

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.

Fügen Sie diesen Befehl in den Abfrageeditor ein und klicken Sie auf Ausführen, um eine Textähnlichkeitssuche durchzufü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-Textgenerierungsmodell 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ätigungsmeldung, die in etwa 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 Ausführen, um die Ergebnisse der Vektorsuche zu erweitern:

  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.

Alternativ können Sie das Projekt beibehalten und die in dieser Anleitung verwendeten Ressourcen löschen. Gehen Sie dazu 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 auf Löschen, um den Vorgang zu bestätigen.

  5. Klicken Sie im linken Bereich auf Verbindungen.

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

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

Nächste Schritte