Remote-KI-Modelle mithilfe der Modellendpunktverwaltung registrieren und aufrufen

Auf dieser Seite wird beschrieben, wie Sie Vorhersagen aufrufen oder Einbettungen mit einem Modell generieren, indem Sie den Modellendpunkt bei der Modellendpunktverwaltung registrieren.

Hinweise

Erweiterung einrichten

  1. Stellen Sie mit dem Nutzer postgres eine Verbindung zu Ihrer Datenbank über psql oder AlloyDB for PostgreSQL Studio her.

  2. Optional: Zugriff auf die Funktionen der KI-Abfrage-Engine für AlloyDB for PostgreSQL (Vorschau) anfordern, einschließlich Unterstützung für multimodale Modelle, Ranking-Modelle und Operatorfunktionen.

  3. Optional: Gewähren Sie einem PostgreSQL-Nutzer, der kein Super Admin ist, die Berechtigung zum Verwalten von Modellmetadaten:

      GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA google_ml TO NON_SUPER_USER;

    Ersetzen Sie die folgende Variable:

    • NON_SUPER_USER: Der PostgreSQL-Nutzername, der kein Superuser ist.

  4. Die ausgehende IP muss aktiviert sein, damit auf Modelle zugegriffen werden kann, die außerhalb Ihrer VPC gehostet werden, z. B. Modelle von Drittanbietern. Weitere Informationen finden Sie unter Ausgehende Verbindung hinzufügen.

Authentifizierung einrichten

In den folgenden Abschnitten wird beschrieben, wie Sie die Authentifizierung einrichten, bevor Sie einen Modellendpunkt registrieren.

Authentifizierung für Vertex AI einrichten

Wenn Sie die Google Vertex AI-Modellendpunkte verwenden möchten, müssen Sie dem IAM-basierten AlloyDB-Dienstkonto, das Sie zum Herstellen einer Verbindung zur Datenbank verwenden, Vertex AI-Berechtigungen hinzufügen. Weitere Informationen zur Integration in Vertex AI finden Sie unter In Vertex AI einbinden.

Authentifizierung mit Secret Manager einrichten

In diesem Abschnitt wird beschrieben, wie Sie die Authentifizierung einrichten, wenn Sie Secret Manager zum Speichern von Authentifizierungsdetails für Drittanbieter verwenden.

Dieser Schritt ist optional, wenn Ihr Modellendpunkt die Authentifizierung nicht über Secret Manager verarbeitet, z. B. wenn Ihr Modellendpunkt HTTP-Header zum Übergeben von Authentifizierungsinformationen verwendet oder überhaupt keine Authentifizierung verwendet.

So erstellen und verwenden Sie einen API-Schlüssel oder ein Bearer-Token:

  1. Erstellen Sie das Secret in Secret Manager. Weitere Informationen finden Sie unter Secret erstellen und auf die Secret-Version zugreifen.

    Der Secret-Pfad wird in der SQL-Funktion google_ml.create_sm_secret() verwendet.

  2. Gewähren Sie dem AlloyDB-Cluster Berechtigungen für den Zugriff auf das Secret.

      gcloud secrets add-iam-policy-binding 'SECRET_NAME' \
      --member="serviceAccount:SERVICE_ACCOUNT_ID" \
      --role="roles/secretmanager.secretAccessor"

    Ersetzen Sie Folgendes:

    • SECRET_NAME: Der Secret-Name im Secret Manager.

    • SERVICE_ACCOUNT_ID: Die ID des IAM-basierten Dienstkontos im Format serviceAccount:service-PROJECT_ID@gcp-sa-alloydb.iam.gserviceaccount.com, z. B. service-212340152456@gcp-sa-alloydb.iam.gserviceaccount.com.

      Sie können diese Rolle dem Dienstkonto auch auf Projektebene zuweisen. Weitere Informationen finden Sie unter IAM-Richtlinienbindung hinzufügen.

Authentifizierung mit Headern einrichten

Das folgende Beispiel zeigt, wie die Authentifizierung mithilfe einer Funktion eingerichtet wird. Die Funktion gibt ein JSON-Objekt zurück, das die Header enthält, die für eine Anfrage an das Einbettungsmodell erforderlich sind.

  CREATE OR REPLACE FUNCTION HEADER_GEN_FUNCTION(
    model_id VARCHAR(100),
    input_text TEXT
  )
  RETURNS JSON
  LANGUAGE plpgsql
  AS $$
  #variable_conflict use_variable
  DECLARE
    api_key VARCHAR(255) := 'API_KEY';
    header_json JSON;
  BEGIN
    header_json := json_build_object(
      'Content-Type', 'application/json',
      'Authorization', 'Bearer ' || api_key
    );
    RETURN header_json;
  END;
  $$;

Ersetzen Sie Folgendes:

  • HEADER_GEN_FUNCTION: Der Name der Funktion zur Header-Generierung, die Sie bei der Registrierung eines Modells verwenden können.
  • API_KEY: Der API-Schlüssel des Modellanbieters.

Texteinbettungsmodelle

In diesem Abschnitt wird beschrieben, wie Sie Modellendpunkte bei der Modellendpunktverwaltung registrieren.

Die Modellendpunktverwaltung unterstützt einige Text-Embedding- und generische Vertex AI-Modelle als vorregistrierte Modellendpunkte. Je nach Modelltyp können Sie die Modell-ID direkt verwenden, um Einbettungen zu generieren oder Vorhersagen aufzurufen. Weitere Informationen zu unterstützten vorregistrierten Modellen finden Sie unter Vorregistrierte Vertex AI-Modelle.

Das gemini-embedding-001-Modell ist nur in der Region us-central1 verfügbar.

Wenn Sie beispielsweise das vorregistrierte Modell gemini-embedding-001 aufrufen möchten, können Sie das Modell direkt mit der Einbettungsfunktion aufrufen:

SELECT
      embedding(
        model_id => 'gemini-embedding-001',
        content => 'AlloyDB is a managed, cloud-hosted SQL database service');

Wenn sich Ihr AlloyDB-Cluster und der Vertex AI-Endpunkt in verschiedenen Projekten befinden, legen Sie model_id auf den qualifizierten Pfad des Endpunkts fest, z. B. projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/gemini-embedding-001.

Um das vorregistrierte Modell gemini-1.5-pro:generateContent aufzurufen, können Sie das Modell direkt mit der Vorhersagefunktion aufrufen:

 SELECT google_ml.predict_row(
            model_id => 'gemini-1.5-pro:generateContent',
            request_body => '{
        "contents": [
            {
                "role": "user",
                "parts": [
                    {
                        "text": "For TPCH database schema as mentioned here https://www.tpc.org/TPC_Documents_Current_Versions/pdf/TPC-H_v3.0.1.pdf , generate a SQL query to find all supplier names which are located in the India nation. Only provide SQL query with no explanation."
                    }
                ]
            }
        ]
        }')-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text';

Informationen zum Generieren von Einbettungen finden Sie unter Texteinbettungen generieren. Informationen zum Aufrufen von Vorhersagen finden Sie hier.

Texteinbettungsmodelle mit integrierter Unterstützung

Die Modellendpunktverwaltung bietet integrierte Unterstützung für einige Modelle von Vertex AI und OpenAI. Eine Liste der Modelle mit integrierter Unterstützung finden Sie unter Modelle mit integrierter Unterstützung.

Bei Modellen mit integrierter Unterstützung können Sie den qualifizierten Namen als qualifizierten Modellnamen festlegen und die Anfrage-URL angeben. Bei der automatischen Verwaltung von Modellendpunkten wird das Modell automatisch erkannt und es werden Standardtransformationsfunktionen eingerichtet.

Vertex AI-Modelle für Einbettungen

In den folgenden Schritten wird gezeigt, wie Sie Vertex AI-Modelle mit integrierter Unterstützung registrieren. Als Beispiel wird der Modellendpunkt gemini-embedding-001 und text-multilingual-embedding-002 verwendet.

Achten Sie darauf, dass sich sowohl der AlloyDB-Cluster als auch das Vertex AI-Modell, das Sie abfragen, in derselben Region befinden.

  1. Verbindung zur Datenbank mit psql herstellen

  2. google_ml_integration-Erweiterung einrichten

  3. Rufen Sie die Funktion zum Erstellen des Modells auf, um den Modellendpunkt hinzuzufügen:

    gemini-embedding-001 

      CALL
    google_ml.create_model(
      model_id => 'gemini-embedding-001',
      model_request_url => 'publishers/google/models/gemini-embedding-001',
      model_provider => 'google',
      model_qualified_name => 'gemini-embedding-001',
      model_type => 'text_embedding',
      model_auth_type => 'alloydb_service_agent_iam');

    text-multilingual-embedding-002 

      CALL
    google_ml.create_model(
      model_id => 'text-multilingual-embedding-002',
      model_request_url => 'publishers/google/models/text-multilingual-embedding-002',
      model_provider => 'google',
      model_qualified_name => 'text-multilingual-embedding-002',
      model_type => 'text_embedding',
      model_auth_type => 'alloydb_service_agent_iam'
      model_in_transform_fn => 'google_ml.vertexai_text_embedding_input_transform',
      model_out_transform_fn => 'google_ml.vertexai_text_embedding_output_transform');

Wenn das Modell in einem anderen Projekt und einer anderen Region als Ihr AlloyDB-Cluster gespeichert ist, legen Sie die Anfrage-URL auf projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/MODEL_ID fest. Dabei ist REGION_ID die Region, in der Ihr Modell gehostet wird, und MODEL_ID der qualifizierte Modellname.

Außerdem müssen Sie dem AlloyDB-Dienstkonto des Projekts, in dem sich die AlloyDB-Instanz befindet, die Rolle „Vertex AI User“ (roles/aiplatform.user) zuweisen, damit AlloyDB auf das im anderen Projekt gehostete Modell zugreifen kann.

Open AI-Modell zur Texteinbettung

Die google_ml_integration-Erweiterung richtet automatisch Standardtransformationsfunktionen ein und ruft die Remote-OpenAI-Modelle auf. Eine Liste der OpenAI-Modelle mit integrierter Unterstützung finden Sie unter Modelle mit integrierter Unterstützung.

Im folgenden Beispiel wird der text-embedding-ada-002-OpenAI-Modellendpunkt hinzugefügt. Sie können die OpenAI-Modellendpunkte text-embedding-3-small und text-embedding-3-large mit denselben Schritten registrieren und die für die Modelle spezifischen qualifizierten Modellnamen festlegen.

  1. Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
  2. google_ml_integration-Erweiterung einrichten
  3. Fügen Sie den OpenAI-API-Schlüssel als Secret in Secret Manager zur Authentifizierung hinzu.

  4. Rufen Sie das im Secret Manager gespeicherte Secret auf:

    CALL
google_ml.create_sm_secret(
  secret_id => 'SECRET_ID',
  secret_path => 'projects/PROJECT_ID/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

    Ersetzen Sie Folgendes:

    • SECRET_ID: Die Secret-ID, die Sie festgelegt haben und die später bei der Registrierung eines Modellendpunkts verwendet wird, z. B. key1.
    • SECRET_MANAGER_SECRET_ID: Die Secret-ID, die beim Erstellen des Secrets im Secret Manager festgelegt wurde.
    • PROJECT_ID: die ID Ihres Google Cloud Projekts.
    • VERSION_NUMBER: Die Versionsnummer der Secret-ID.

  5. Rufen Sie die Funktion zum Erstellen des Modells auf, um den text-embedding-ada-002-Modellendpunkt zu registrieren:

    CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'open_ai',
    model_type => 'text_embedding',
    model_qualified_name => 'text-embedding-ada-002',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID');

    Ersetzen Sie Folgendes:

    • MODEL_ID: Eine eindeutige ID für den Modellendpunkt, die Sie definieren. Auf diese Modell-ID wird für Metadaten verwiesen, die der Modellendpunkt zum Generieren von Einbettungen oder zum Aufrufen von Vorhersagen benötigt.
    • SECRET_ID: Die Secret-ID, die Sie zuvor im google_ml.create_sm_secret()-Verfahren verwendet haben.

Informationen zum Generieren von Einbettungen finden Sie unter Texteinbettungen generieren.

Benutzerdefiniert gehostetes Texteinbettungsmodell

In diesem Abschnitt wird beschrieben, wie Sie einen benutzerdefinierten gehosteten Modellendpunkt registrieren, Transformationsfunktionen erstellen und optional benutzerdefinierte HTTP-Header erstellen. Alle benutzerdefinierten gehosteten Modellendpunkte werden unterstützt, unabhängig davon, wo sie gehostet werden.

Im folgenden Beispiel wird der benutzerdefinierte Modellendpunkt custom-embedding-model hinzugefügt, der von Cymbal gehostet wird. Mit den Transformationsfunktionen cymbal_text_input_transform und cymbal_text_output_transform wird das Ein- und Ausgabeformat des Modells in das Ein- und Ausgabeformat der Vorhersagefunktion transformiert.

So registrieren Sie benutzerdefinierte Endpunkte für selbst gehostete Modelle für Texteinbettungen:

  1. Verbindung zur Datenbank mit psql herstellen

  2. google_ml_integration-Erweiterung einrichten

  3. Optional: API-Schlüssel als Secret zur Authentifizierung in Secret Manager hinzufügen

  4. Rufen Sie das im Secret Manager gespeicherte Secret auf:

    CALL
  google_ml.create_sm_secret(
    secret_id => 'SECRET_ID',
    secret_path => 'projects/project-id/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

    Ersetzen Sie Folgendes:

    • SECRET_ID: Die Secret-ID, die Sie festgelegt haben und die später bei der Registrierung eines Modellendpunkts verwendet wird, z. B. key1.
    • SECRET_MANAGER_SECRET_ID: Die Secret-ID, die beim Erstellen des Secrets im Secret Manager festgelegt wurde.
    • PROJECT_ID: die ID Ihres Google Cloud Projekts.
    • VERSION_NUMBER: Die Versionsnummer der Secret-ID.

  5. Erstellen Sie die Transformationsfunktionen für Ein- und Ausgabe basierend auf der folgenden Signatur für die Vorhersagefunktion für Endpunkte von Modelle für Texteinbettungen. Weitere Informationen zum Erstellen von Transformationsfunktionen finden Sie unter Beispiel für Transformationsfunktionen.

    Im Folgenden finden Sie Beispieltransformationsfunktionen, die speziell für den Endpunkt des Texteinbettungsmodells custom-embedding-model gelten:

    -- Input Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION cymbal_text_input_transform(model_id VARCHAR(100), input_text TEXT)
RETURNS JSON
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_input JSON;
  model_qualified_name TEXT;
BEGIN
  SELECT json_build_object('prompt', json_build_array(input_text))::JSON INTO transformed_input;
  RETURN transformed_input;
END;
$$;
-- Output Transform Function corresponding to the custom model endpoint
CREATE OR REPLACE FUNCTION cymbal_text_output_transform(model_id VARCHAR(100), response_json JSON)
RETURNS REAL[]
LANGUAGE plpgsql
AS $$
DECLARE
  transformed_output REAL[];
BEGIN
  SELECT ARRAY(SELECT json_array_elements_text(response_json->0)) INTO transformed_output;
  RETURN transformed_output;
END;
$$;

  6. Rufen Sie die Funktion zum Erstellen von Modellen auf, um den benutzerdefinierten Endpunkt für das Einbettungsmodell zu registrieren:

    CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_request_url => 'REQUEST_URL',
    model_provider => 'custom',
    model_type => 'text_embedding',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID',
    model_qualified_name => 'MODEL_QUALIFIED_NAME',
    model_in_transform_fn => 'cymbal_text_input_transform',
    model_out_transform_fn => 'cymbal_text_output_transform');

    Ersetzen Sie Folgendes:

    • MODEL_ID: erforderlich. Eine eindeutige ID für den Modellendpunkt, den Sie definieren, z. B. custom-embedding-model. Auf diese Modell-ID wird für Metadaten verwiesen, die der Modellendpunkt zum Generieren von Einbettungen oder zum Aufrufen von Vorhersagen benötigt.
    • REQUEST_URL: erforderlich. Der modellspezifische Endpunkt beim Hinzufügen von benutzerdefinierten Texteinbettungs- und generischen Modellendpunkten, z. B. https://cymbal.com/models/text/embeddings/v1. Achten Sie darauf, dass der Modellendpunkt über eine interne IP-Adresse zugänglich ist. Die Verwaltung von Modellendpunkten unterstützt keine öffentlichen IP-Adressen.
    • MODEL_QUALIFIED_NAME: Erforderlich, wenn für Ihren Modellendpunkt ein qualifizierter Name verwendet wird. Der vollständig qualifizierte Name, falls der Modellendpunkt mehrere Versionen hat.
    • SECRET_ID: Die Secret-ID, die Sie zuvor im google_ml.create_sm_secret()-Verfahren verwendet haben.

Multimodales Modell mit integriertem Support

In Vertex AI einbinden und Erweiterung installieren

  1. In Vertex AI einbinden
  2. Prüfen Sie, ob die aktuelle Version von google_ml_integration installiert ist.

    1. Führen Sie den folgenden Befehl aus, um die installierte Version zu prüfen:

              SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
        extversion
        ------------
        1.4.3
        (1 row)

    2. Wenn die Erweiterung nicht installiert ist oder die installierte Version älter als 1.4.3 ist, aktualisieren Sie die Erweiterung mit den folgenden Befehlen:

              CREATE EXTENSION IF NOT EXISTS google_ml_integration;
        ALTER EXTENSION google_ml_integration UPDATE;

      Wenn beim Ausführen der vorherigen Befehle Probleme auftreten oder die Erweiterung nach dem Ausführen der vorherigen Befehle nicht auf Version 1.4.3 aktualisiert wird, wenden Sie sich an den AlloyDB-Support.

    3. Nachdem Sie sichergestellt haben, dass die Version aktuell ist, installieren Sie die Vorschaufunktion, indem Sie die Prozedur upgrade_to_preview_version ausführen:

              CALL google_ml.upgrade_to_preview_version();
        SELECT extversion FROM pg_extension WHERE extname = 'google_ml_integration';
        extversion
        ------------
        1.4.4
        (1 row)

Modell aufrufen, um multimodale Einbettungen zu generieren

Da die Verwaltung von Modellendpunkten integrierte Unterstützung für das multimodalembedding@001-Modell von Vertex AI bietet, können Sie das Modell direkt aufrufen, um multimodale Einbettungen zu generieren.

Im folgenden Beispiel wird der qualifizierte Modellname multimodalembedding@001 als Modell-ID verwendet, um multimodale Bildeinbettungen zu generieren:

  1. Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
  2. google_ml_integration-Erweiterung einrichten

  3. Multimodale Bildeinbettungen generieren:

    SELECT
  ai.image_embedding(
    model_id => 'multimodalembedding@001',
    image => 'IMAGE_PATH_OR_TEXT',
    mimetype => 'MIMETYPE');

Ersetzen Sie Folgendes:

  • IMAGE_PATH_OR_TEXT mit Cloud Storage-Pfad zum Bild, z. B. gs://cymbal_user_data/image-85097193-cd9788aacebb.jpeg, um in eine Vektoreinbettung oder einen Base64-String des Bildes übersetzt zu werden.
  • MIMETYPE durch den MIME-Typ des Bildes.

Ranking-Modelle

Vertex AI-Rankingmodelle

Sie können die in Unterstützte Modelle aufgeführten Vertex AI-Modelle ohne Registrierung verwenden.

Informationen zum Sortieren von Suchergebnissen mit einem Vertex AI-Rankingmodell finden Sie unter Suchergebnisse sortieren.

Drittanbieter-Rankingmodell registrieren

Im folgenden Beispiel wird gezeigt, wie ein Reranking-Modell von Cohere registriert wird.

CREATE OR REPLACE FUNCTION cohere_rerank_input_transform(
    model_id VARCHAR(100),
    search_string TEXT,
    documents TEXT[],
    top_n INT DEFAULT NULL
)
RETURNS JSON
LANGUAGE plpgsql
AS $$
#variable_conflict use_variable
DECLARE
  transformed_input JSONB;
BEGIN
  -- Basic Input Validation
  IF search_string IS NULL OR search_string = '' THEN
    RAISE EXCEPTION 'Invalid input: search_string cannot be NULL or empty.';
  END IF;

  IF documents IS NULL OR array_length(documents, 1) IS NULL OR array_length(documents, 1) = 0 THEN
    RAISE EXCEPTION 'Invalid input: documents array cannot be NULL or empty.';
  END IF;

  IF top_n IS NOT NULL AND top_n < 0 THEN
    RAISE EXCEPTION 'Invalid input: top_n must be greater than or equal to zero. Provided value: %', top_n;
  END IF;

  -- Construct the base JSON payload for Cohere Rerank API
  transformed_input := jsonb_build_object(
    'model', google_ml.model_qualified_name_of(model_id),
    'query', search_string,
    'documents', to_jsonb(documents), -- Convert TEXT[] directly to JSON array
    'return_documents', false -- Explicitly set to false (optional, as its default)
  );

  -- Add top_n to the payload only if it's provided and valid
  IF top_n IS NOT NULL THEN
     transformed_input := transformed_input || jsonb_build_object('top_n', top_n);
  END IF;

  -- Return the final JSON payload
  RETURN transformed_input::JSON;

END;
$$;

CREATE OR REPLACE FUNCTION cohere_rerank_output_transform(
    model_id VARCHAR(100),
    response_json JSON
)
RETURNS TABLE (index INT, score REAL)
LANGUAGE plpgsql
AS $$
DECLARE
  result_item JSONB;
  response_jsonb JSONB;
  cohere_index INT; -- 0-based index from Cohere response
BEGIN
  -- Validate response_json
  IF response_json IS NULL THEN
    RAISE EXCEPTION 'Invalid model response: response cannot be NULL.';
  END IF;

  -- Convert JSON to JSONB for easier processing
  response_jsonb := response_json::JSONB;

  -- Check top-level structure
  IF jsonb_typeof(response_jsonb) != 'object' THEN
    RAISE EXCEPTION 'Invalid model response: response must be a JSON object. Found: %', jsonb_typeof(response_jsonb);
  END IF;

  -- Check for the 'results' array
  IF response_jsonb->'results' IS NULL OR jsonb_typeof(response_jsonb->'results') != 'array' THEN
    -- Check for potential Cohere error structure
    IF response_jsonb->'message' IS NOT NULL THEN
       RAISE EXCEPTION 'Cohere API Error: %', response_jsonb->>'message';
    ELSE
       RAISE EXCEPTION 'Invalid model response: response does not contain a valid "results" array.';
    END IF;
  END IF;

  -- Loop through the 'results' array (JSONB array indices are 0-based)
  FOR i IN 0..jsonb_array_length(response_jsonb->'results') - 1 LOOP
    result_item := response_jsonb->'results'->i;

    -- Validate individual result item structure
    IF result_item IS NULL OR jsonb_typeof(result_item) != 'object' THEN
      RAISE WARNING 'Skipping invalid result item at array index %.', i;
      CONTINUE;
    END IF;

    IF result_item->'index' IS NULL OR jsonb_typeof(result_item->'index') != 'number' THEN
       RAISE WARNING 'Missing or invalid "index" field in result item at array index %.', i;
       CONTINUE;
    END IF;

    IF result_item->'relevance_score' IS NULL OR jsonb_typeof(result_item->'relevance_score') != 'number' THEN
       RAISE WARNING 'Missing or invalid "relevance_score" field in result item at array index %.', i;
       CONTINUE;
    END IF;

    -- Extract values
    BEGIN
      cohere_index := (result_item->>'index')::INT;
      -- Assign values to the output table columns
      -- Cohere returns 0-based index, map it to 1-based for consistency
      -- with input document array position
      index := cohere_index + 1;
      score := (result_item->>'relevance_score')::REAL;
      RETURN NEXT; -- Return the current row
    EXCEPTION WHEN others THEN
      RAISE WARNING 'Error processing result item at array index %: %', i, SQLERRM;
      CONTINUE; -- Skip this item and continue with the next
    END;
  END LOOP;

  RETURN; -- End of function
END;
$$;

CALL
  google_ml.create_sm_secret(
    '<SECRET_ID>',
    'projects/<PROJECT_NUMBER>/secrets/<SECRET_ID>/versions/latest');

CALL
  google_ml.create_model(
    model_id => 'cohere-reranker',
    model_type => 'reranking',
    model_provider => 'custom',
    model_request_url => 'https://api.cohere.com/v2/rerank',
    model_qualified_name => 'rerank-v3.5',
    model_auth_type => 'secret_manager',
    model_auth_id => '<SECRET_ID>',
    model_in_transform_fn => 'cohere_rerank_input_transform',
    model_out_transform_fn => 'cohere_rerank_output_transform'
  );

Generische Modelle

In diesem Abschnitt wird beschrieben, wie Sie einen beliebigen generischen Modellendpunkt registrieren, der bei einem gehosteten Modellanbieter wie Hugging Face, OpenAI, Vertex AI, Anthropic oder einem anderen Anbieter verfügbar ist. In diesem Abschnitt finden Sie Beispiele für die Registrierung eines generischen Modellendpunkts, der auf Hugging Face gehostet wird, eines generischen gemini-pro-Modells aus Vertex AI Model Garden und des claude-haiku-Modellendpunkts.

Sie können jeden generischen Modellendpunkt registrieren, sofern die Ein- und Ausgabe im JSON-Format erfolgt. Je nach den Metadaten Ihres Modellendpunkts müssen Sie möglicherweise HTTP-Header generieren oder Anfrage-URLs definieren.

Weitere Informationen zu vorregistrierten generischen Modellen und Modellen mit integrierter Unterstützung finden Sie unter Unterstützte Modelle.

Generische Gemini-Modelle

In diesem Abschnitt wird beschrieben, wie Sie generische Gemini-Modelle registrieren.

Gemini 1.5 Pro-Modell

Da einige gemini-pro-Modelle vorab registriert sind, können Sie die Modell-ID direkt aufrufen, um Vorhersagen zu generieren.

Im folgenden Beispiel wird der Modellendpunkt gemini-1.5-pro:generateContent aus dem Vertex AI Model Garden verwendet.

  1. Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
  2. google_ml_integration-Erweiterung einrichten

  3. Vorhersagen mit der vorregistrierten Modell-ID aufrufen:

    SELECT
    json_array_elements(
    google_ml.predict_row(
        model_id => 'gemini-1.5-pro:generateContent',
        request_body => '{
    "contents": [
        {
            "role": "user",
            "parts": [
                {
                    "text": "For TPCH database schema as mentioned here https://www.tpc.org/TPC_Documents_Current_Versions/pdf/TPC-H_v3.0.1.pdf , generate a SQL query to find all supplier names which are located in the India nation."
                }
            ]
        }
    ]
    }'))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text';

Generisches Modell bei Hugging Face

Im folgenden Beispiel wird der benutzerdefinierte Klassifizierungsmodellendpunkt facebook/bart-large-mnli hinzugefügt, der auf Hugging Face gehostet wird.

  1. Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
  2. google_ml_integration-Erweiterung einrichten
  3. Fügen Sie den OpenAI-API-Schlüssel als Secret in Secret Manager zur Authentifizierung hinzu. Wenn Sie bereits ein Secret für ein anderes OpenAI-Modell erstellt haben, können Sie dasselbe Secret wiederverwenden.

  4. Rufen Sie das im Secret Manager gespeicherte Secret auf:

    CALL
  google_ml.create_sm_secret(
    secret_id => 'SECRET_ID',
    secret_path => 'projects/project-id/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

    Ersetzen Sie Folgendes:

    • SECRET_ID: Die von Ihnen festgelegte geheime ID, die später bei der Registrierung eines Modellendpunkts verwendet wird.
    • SECRET_MANAGER_SECRET_ID: Die Secret-ID, die beim Erstellen des Secrets im Secret Manager festgelegt wurde.
    • PROJECT_ID: die ID Ihres Google Cloud Projekts.
    • VERSION_NUMBER: Die Versionsnummer der Secret-ID.

  5. Rufen Sie die Funktion zum Erstellen des Modells auf, um den facebook/bart-large-mnli-Modellendpunkt zu registrieren:

    CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'hugging_face',
    model_request_url => 'REQUEST_URL',
    model_qualified_name => 'MODEL_QUALIFIED_NAME',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID');

    Ersetzen Sie Folgendes:

    • MODEL_ID: Eine eindeutige ID für den Modellendpunkt, den Sie definieren, z. B. custom-classification-model. Auf diese Modell-ID wird für Metadaten verwiesen, die der Modellendpunkt zum Generieren von Einbettungen oder zum Aufrufen von Vorhersagen benötigt.
    • REQUEST_URL: Der modellspezifische Endpunkt beim Hinzufügen benutzerdefinierter Texteinbettungen und generischer Modellendpunkte, z. B. https://api-inference.huggingface.co/models/facebook/bart-large-mnli.
    • MODEL_QUALIFIED_NAME: Der voll qualifizierte Name der Modellendpunktversion, z. B. facebook/bart-large-mnli.
    • SECRET_ID: Die Secret-ID, die Sie zuvor im google_ml.create_sm_secret()-Verfahren verwendet haben.

Generisches Modell von Anthropic

Im folgenden Beispiel wird der Modellendpunkt claude-3-opus-20240229 hinzugefügt. Die Verwaltung von Modellendpunkten bietet die Header-Funktion, die für die Registrierung von Anthropic-Modellen erforderlich ist.

  1. Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.

  2. Erstellen und aktivieren Sie die google_ml_integration-Erweiterung.

    Secret Manager

    1. Fügen Sie das Bearertoken als Secret zur Authentifizierung in Secret Manager hinzu.

    2. Rufen Sie das im Secret Manager gespeicherte Secret auf:

      CALL
  google_ml.create_sm_secret(
    secret_id => 'SECRET_ID',
    secret_path => 'projects/PROJECT_ID/secrets/SECRET_MANAGER_SECRET_ID/versions/VERSION_NUMBER');

      Ersetzen Sie Folgendes:

      • SECRET_ID: Die von Ihnen festgelegte geheime ID, die später bei der Registrierung eines Modellendpunkts verwendet wird.
      • SECRET_MANAGER_SECRET_ID: Die Secret-ID, die beim Erstellen des Secrets im Secret Manager festgelegt wurde.
      • PROJECT_ID: die ID Ihres Google Cloud Projekts.
      • VERSION_NUMBER: Die Versionsnummer der Secret-ID.

    3. Rufen Sie die Funktion zum Erstellen von Modellen auf, um den Modellendpunkt claude-3-opus-20240229 zu registrieren.

      CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'anthropic',
    model_request_url => 'REQUEST_URL',
    model_auth_type => 'secret_manager',
    model_auth_id => 'SECRET_ID',
    generate_headers_fn => 'google_ml.anthropic_claude_header_gen_fn');

      Ersetzen Sie Folgendes:

      • MODEL_ID: Eine eindeutige ID für den Modellendpunkt, den Sie definieren, z. B. anthropic-opus. Auf diese Modell-ID wird für Metadaten verwiesen, die der Modellendpunkt zum Generieren von Einbettungen oder zum Aufrufen von Vorhersagen benötigt.
      • REQUEST_URL: Der modellspezifische Endpunkt beim Hinzufügen benutzerdefinierter Texteinbettungen und generischer Modellendpunkte, z. B. https://api.anthropic.com/v1/messages.

    Auth-Header

    1. Verwenden Sie die Standardfunktion zum Generieren von Headern google_ml.anthropic_claude_header_gen_fn oder erstellen Sie eine Funktion zum Generieren von Headern.

        CREATE OR REPLACE FUNCTION anthropic_sample_header_gen_fn(model_id VARCHAR(100), request_body JSON)
  RETURNS JSON
  LANGUAGE plpgsql
  AS $$
  #variable_conflict use_variable
  BEGIN
        RETURN json_build_object('x-api-key', 'ANTHROPIC_API_KEY', 'anthropic-version', 'ANTHROPIC_VERSION')::JSON;
  END;
  $$;

      Ersetzen Sie Folgendes:

      • ANTHROPIC_API_KEY: Der Anthropic-API-Schlüssel.
      • ANTHROPIC_VERSION (optional): Die spezifische Modellversion, die Sie verwenden möchten, z. B. 2023-06-01.

    2. Rufen Sie die Funktion zum Erstellen von Modellen auf, um den Modellendpunkt claude-3-opus-20240229 zu registrieren.

      CALL
  google_ml.create_model(
    model_id => 'MODEL_ID',
    model_provider => 'anthropic',
    model_request_url => 'REQUEST_URL',
    generate_headers_fn => 'google_ml.anthropic_claude_header_gen_fn');

      Ersetzen Sie Folgendes:

      • MODEL_ID: Eine eindeutige ID für den Modellendpunkt, den Sie definieren, z. B. anthropic-opus. Auf diese Modell-ID wird für Metadaten verwiesen, die der Modellendpunkt zum Generieren von Einbettungen oder zum Aufrufen von Vorhersagen benötigt.
      • REQUEST_URL: Der modellspezifische Endpunkt beim Hinzufügen benutzerdefinierter Texteinbettungen und generischer Modellendpunkte, z. B. https://api.anthropic.com/v1/messages.

Weitere Informationen finden Sie unter Vorhersagen für generische Modellendpunkte aufrufen.

Nächste Schritte