Remote-KI-Modelle in AlloyDB Omni registrieren und aufrufen

Wählen Sie eine Dokumentationsversion aus:

Wenn Sie Vorhersagen aufrufen oder Einbettungen mit einem Modell generieren möchten, registrieren Sie den Modellendpunkt bei der Modellendpunktverwaltung.

Bevor Sie einen Modellendpunkt bei der Modellendpunktverwaltung registrieren, müssen Sie die Erweiterung google_ml_integration aktivieren und die Authentifizierung basierend auf dem Modellanbieter einrichten, falls für Ihren Modellendpunkt eine Authentifizierung erforderlich ist.

Achten Sie darauf, dass Sie mit dem Standardnutzernamen postgres auf Ihre Datenbank zugreifen.

Erweiterung aktivieren

Sie müssen die google_ml_integration-Erweiterung hinzufügen und aktivieren, bevor Sie die zugehörigen Funktionen verwenden können. Für die Verwaltung von Modellendpunkten muss die Erweiterung google_ml_integration installiert sein.

  1. Prüfen Sie, ob das Datenbank-Flag google_ml_integration.enable_model_support für eine Instanz auf on gesetzt ist. Weitere Informationen zum Festlegen dieser Datenbank-Flags finden Sie unter Datenbank-Flags konfigurieren.

  2. Optional: Wenn die Erweiterung google_ml_integration schon installiert ist, ändern Sie sie, um auf die aktuelle Version zu aktualisieren:

        ALTER EXTENSION google_ml_integration UPDATE;

  3. Fügen Sie die Erweiterung google_ml_integration mit psql hinzu:

      CREATE EXTENSION IF NOT EXISTS google_ml_integration;

  4. 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 NON_SUPER_USER durch den Namen des PostgreSQL-Nutzers, der kein Super Admin sein darf.

  5. Aktivieren Sie die Verwaltung von Modellendpunkten für Ihre Datenbank:

      ALTER SYSTEM SET google_ml_integration.enable_model_support=on;
  SELECT pg_reload_conf();

  6. Achten Sie darauf, dass ausgehende Verbindungen aktiviert sind.

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 Dienstkonto, das Sie bei der Installation von AlloyDB Omni verwendet haben, Vertex AI-Berechtigungen hinzufügen. Weitere Informationen finden Sie unter AlloyDB Omni-Installation für das Abfragen cloudbasierter Modelle konfigurieren.

Authentifizierung mit Secret Manager einrichten

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 Inhabertoken:

  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 Dienstkontos, das Sie im vorherigen Schritt erstellt haben. Achten Sie darauf, dass dies dasselbe Konto ist, das Sie bei der Installation von AlloyDB Omni verwendet haben. Dazu gehört das vollständige Suffix PROJECT_ID.iam.gserviceaccount.com. Beispiel: my-service@my-project.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

Im folgenden Beispiel wird gezeigt, wie die Authentifizierung mit einer Funktion eingerichtet wird, die ein JSON-Objekt mit den Headern zurückgibt, 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 Texteinbettungs- und allgemeine 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.

Wenn Sie beispielsweise das vorregistrierte Modell textembedding-gecko aufrufen möchten, können Sie das Modell direkt mit der Einbettungsfunktion aufrufen:

SELECT
      google_ml.embedding(
        model_id => 'textembedding-gecko',
        content => 'AlloyDB is a managed, cloud-hosted SQL database service');

Um das vorregistrierte Modell gemini-1.5-pro:generateContent aufzurufen, können Sie das Modell direkt mit der Vorhersagefunktion 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';

Informationen zum Generieren von Einbettungen finden Sie unter Einbettungen für vorregistrierte Modellendpunkte generieren. Informationen zum Aufrufen von Vorhersagen finden Sie unter Vorhersagen für vorregistrierte Modellendpunkte aufrufen.

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 werden die Modellendpunkte text-embedding-005 und text-multilingual-embedding-002 verwendet.

Für AlloyDB Omni müssen Sie AlloyDB Omni so einrichten, dass cloudbasierte Vertex AI-Modelle abgefragt werden.

  1. Erstellen und aktivieren Sie die Erweiterung google_ml_integration.

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

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

    text-embedding-005 

      CALL
    google_ml.create_model(
      model_id => 'text-embedding-005',
      model_request_url => 'publishers/google/models/text-embedding-005',
      model_provider => 'google',
      model_qualified_name => 'text-embedding-005',
      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');

Die von der Funktion generierte Anfrage-URL verweist auf das Projekt, das mit dem AlloyDB Omni-Dienstkonto verknüpft ist. Wenn Sie auf ein anderes Projekt verweisen möchten, müssen Sie model_request_url explizit angeben.

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, wobei REGION_ID die Region ist, in der Ihr Modell gehostet wird, und MODEL_ID der qualifizierte Modellname.

Außerdem müssen Sie dem Dienstkonto des Projekts, in dem AlloyDB Omni installiert ist, die Rolle „Vertex AI User“ (roles/aiplatform.user) zuweisen, damit auf das im anderen Projekt gehostete Modell zugegriffen werden kann.

OpenAI-Modell zur Texteinbettung

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

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

  1. Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
  2. Erstellen und aktivieren Sie die Erweiterung google_ml_integration.
  3. Fügen Sie den OpenAI-API-Schlüssel zur Authentifizierung als Secret in Secret Manager 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 Projekts in Google Cloud .
    • VERSION_NUMBER: Die Versionsnummer der Secret-ID.

  5. Rufen Sie die Funktion zum Erstellen von Modellen auf, um den Modellendpunkt text-embedding-ada-002 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 Einbettungen für Modellendpunkte mit integrierter Unterstützung generieren.

Benutzerdefiniertes 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 vom Kunden gehostete Modellendpunkte für Texteinbettungen:

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

  2. Erstellen und aktivieren Sie die Erweiterung google_ml_integration.

  3. Optional: Fügen Sie den API-Schlüssel zur Authentifizierung als Secret in Secret Manager 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 Projekts in Google Cloud .
    • 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 Modellendpunkte für Texteinbettungen. Weitere Informationen zum Erstellen von Transformationsfunktionen finden Sie unter Beispiel für Transformationsfunktionen.

    Im Folgenden finden Sie Beispiel-Transformationsfunktionen, die speziell für den Modellendpunkt custom-embedding-model für Texteinbettungen 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 Texteinbettungen und allgemeinen Modellendpunkten, z. B. https://cymbal.com/models/text/embeddings/v1.
    • 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.

Allgemeine Modelle

In diesem Abschnitt wird beschrieben, wie Sie einen beliebigen allgemeinen 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 allgemeinen Modellendpunkts, der auf Hugging Face gehostet wird, eines allgemeinen Modells vom Typ gemini-pro aus Vertex AI Model Garden und des Modellendpunkts claude-haiku.

Sie können jeden allgemeinen 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 allgemeinen Modellen sowie Modellen mit integrierter Unterstützung finden Sie unter Unterstützte Modelle.

Gemini-Modell

Da einige gemini-pro-Modelle vorregistriert sind, können Sie die Modell-ID direkt aufrufen, um Vorhersagen zu generieren. Richten Sie AlloyDB Omni für das Abfragen cloudbasierter Vertex AI-Modelle ein.

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. Erstellen und aktivieren Sie die Erweiterung google_ml_integration.

  3. Rufen Sie Vorhersagen mit der vorregistrierten Modell-ID auf:

    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';

Allgemeines 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. Erstellen und aktivieren Sie die Erweiterung google_ml_integration.
  3. Fügen Sie den OpenAI-API-Schlüssel zur Authentifizierung als Secret in Secret Manager 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 Secret-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 Projekts in Google Cloud .
    • VERSION_NUMBER: Die Versionsnummer der Secret-ID.

  5. Rufen Sie die Funktion zum Erstellen von Modellen auf, um den Modellendpunkt facebook/bart-large-mnli 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 von Ihnen definierten Modellendpunkt, 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 allgemeiner 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.

Allgemeines Modell von Anthropic

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

Richten Sie AlloyDB Omni für das Abfragen cloudbasierter Vertex AI-Modelle ein.

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

  2. Erstellen und aktivieren Sie die Erweiterung google_ml_integration.

    Secret Manager

    1. Fügen Sie das Inhabertoken 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 Secret-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 Projekts in Google Cloud .
      • 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 von Ihnen definierten Modellendpunkt, 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 allgemeiner Modellendpunkte, z. B. https://api.anthropic.com/v1/messages.

    Auth-Header

    1. Verwenden Sie die Standardfunktion google_ml.anthropic_claude_header_gen_fn zum Erzeugen von Headern oder erstellen Sie eine Funktion zum Erzeugen 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 von Ihnen definierten Modellendpunkt, 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 allgemeiner Modellendpunkte, z. B. https://api.anthropic.com/v1/messages.

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

Nächste Schritte