Auf dieser Seite finden Sie die Dokumentation für AlloyDB Omni Version 15.7.0.
Unter Dokumentationsversionen für AlloyDB Omni können Sie eine andere Version auswählen.

Diese Seite wurde von der Cloud Translation API übersetzt.

Remote-KI-Modelle in AlloyDB Omni registrieren und aufrufen

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

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 Endpunktverwaltung von Modellen muss die Erweiterung google_ml_integration installiert sein.

Prüfen Sie, ob das google_ml_integration.enable_model_support-Datenbankflag für eine Instanz auf on festgelegt ist. Weitere Informationen zum Festlegen von Datenbank-Flags finden Sie unter Datenbank-Flags konfigurieren.
Optional: Wenn die google_ml_integration-Erweiterung bereits installiert ist, aktualisieren Sie sie auf die neueste Version:
```
    ALTER EXTENSION google_ml_integration UPDATE;
```

Fügen Sie die google_ml_integration-Erweiterung mit psql hinzu:

  CREATE EXTENSION IF NOT EXISTS google_ml_integration;

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 nicht super PostgreSQL-Nutzernamen.

Aktivieren Sie die Modellendpunktverwaltung in Ihrer Datenbank:

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

Prüfen Sie, ob die ausgehende Konnektivität aktiviert ist.

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 Modellendpunkte von Google Vertex AI 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 Abfragen cloudbasierter Modelle konfigurieren.

Authentifizierung mit Secret Manager einrichten

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

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

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

Der Pfad zum Secret wird in der SQL-Funktion google_ml.create_sm_secret() verwendet.
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 Name des Secrets 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 PROJECT_ID.iam.gserviceaccount.com-Suffix. Beispiel: my-service@my-project.iam.gserviceaccount.com
  
  Sie können diese Rolle dem Dienstkonto auch auf Projektebene zuweisen. Weitere Informationen finden Sie unter Richtlinienbindung für die Identitäts- und Zugriffsverwaltung hinzufügen.

Authentifizierung mit Headern einrichten

Im folgenden Beispiel wird gezeigt, wie die Authentifizierung mit einer Funktion eingerichtet wird, die ein JSON-Objekt zurückgibt, 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 zum Generieren von Headern, die Sie beim Registrieren eines Modells verwenden können.
API_KEY: den API-Schlüssel des Modellanbieters.

Modelle für Texteinbettungen

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

Die Modellendpunktverwaltung unterstützt einige Text-Embeddings und generische Vertex AI-Modelle als vorab registrierte Modellendpunkte. Sie können die Modell-ID direkt verwenden, um basierte auf dem Modelltyp Einbettungen zu generieren oder Vorhersagen aufzurufen. Weitere Informationen zu unterstützten vorab registrierten Modellen finden Sie unter Vorab registrierte Vertex AI-Modelle.

Wenn Sie beispielsweise das vorab registrierte textembedding-gecko-Modell aufrufen möchten, können Sie es direkt über die Einbettungsfunktion aufrufen:

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

Wenn Sie das vorab registrierte gemini-1.5-pro:generateContent-Modell aufrufen möchten, können Sie es auch direkt über die 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 Embeddings für vorab registrierte Modellendpunkte generieren. Informationen zum Aufrufen von Vorhersagen finden Sie unter Vorhersagen für vorab registrierte 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 Modellendpunktverwaltung wird das Modell automatisch erkannt und Standardtransformationsfunktionen eingerichtet.

Vertex AI-Embedding-Modelle

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

Für AlloyDB Omni müssen Sie AlloyDB Omni für Abfragen cloudbasierter Vertex AI-Modelle einrichten.

Erstellen und aktivieren Sie die Erweiterung google_ml_integration.
Verbinden Sie sich mithilfe von psql mit Ihrer Datenbank.

Rufen Sie die Funktion „create model“ 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 bezieht sich 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 Ihrem 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.

Weisen Sie außerdem dem Dienstkonto des Projekts, in dem AlloyDB Omni installiert ist, die Rolle Vertex AI User (roles/aiplatform.user) zu, damit auf das im anderen Projekt gehostete Modell zugegriffen werden kann.

Open AI-Modell für die 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.

Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
Erstellen und aktivieren Sie die Erweiterung google_ml_integration.
Fügen Sie den OpenAI API-Schlüssel als Secret zum Secret Manager für die Authentifizierung hinzu.
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 festlegen und die anschließend bei der Registrierung eines Modellendpunkts verwendet wird, z. B. key1.
- SECRET_MANAGER_SECRET_ID: Die Secret-ID, die Sie beim Erstellen des Secrets im Secret Manager festgelegt haben.
- PROJECT_ID: die ID Ihres Google Cloud -Projekts.
- VERSION_NUMBER: die Versionsnummer der Secret-ID.
Rufen Sie die Funktion zum Erstellen von Modellen 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 von Ihnen definierten Modellendpunkt. Auf diese Modell-ID wird für Metadaten verwiesen, die der Modellendpunkt zum Generieren von Einbettungen oder Aufrufen von Vorhersagen benötigt.
- SECRET_ID: die Secret-ID, die Sie zuvor bei der google_ml.create_sm_secret()-Prozedur verwendet haben.

Informationen zum Generieren von Einbettungen finden Sie unter Einbettungen für Modellendpunkte mit integrierter Unterstützung generieren.

Benutzerdefiniert gehostetes Texteinbettungsmodell

In diesem Abschnitt wird beschrieben, wie Sie einen benutzerdefinierten gehosteten Modellendpunkt registrieren und Transformationsfunktionen 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 werden das Eingabe- und Ausgabeformat des Modells in das Eingabe- und Ausgabeformat der Vorhersagefunktion umgewandelt.

So registrieren Sie Endpunkte für benutzerdefinierte gehostete Modelle für Text-Embeddings:

Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
Erstellen und aktivieren Sie die Erweiterung google_ml_integration.
Optional: Fügen Sie den API-Schlüssel zur Authentifizierung als Secret in Secret Manager hinzu.
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 festlegen und die anschließend bei der Registrierung eines Modellendpunkts verwendet wird, z. B. key1.
- SECRET_MANAGER_SECRET_ID: Die Secret-ID, die Sie beim Erstellen des Secrets im Secret Manager festgelegt haben.
- PROJECT_ID: die ID Ihres Google Cloud -Projekts.
- VERSION_NUMBER: die Versionsnummer der Secret-ID.
Hinweis: Secret Manager generiert standardmäßig einen Authorization: Bearer SECRET_VALUE_FROM_SECRET_MANAGER-Header für die Authentifizierung. Wenn dieses Format mit dem Autorisierungs-Bearer-Token-Format Ihres Modellendpunkts übereinstimmt, müssen Sie keine Autorisierungsheader mit der Funktion zum Generieren von Headern generieren.

Erstellen Sie die Eingabe- und Ausgabetransformationsfunktionen anhand der folgenden Signatur für die Vorhersagefunktion für Endpunkte von Modellen für Text-Embeddings. Weitere Informationen zum Erstellen von Transformationsfunktionen finden Sie unter Beispiel für Transformationsfunktionen.

Im Folgenden finden Sie Beispielfunktionen für die Transformation, die speziell für den Endpunkt des custom-embedding-model-Modells 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;
$$;

Rufen Sie die Funktion „create model“ auf, um den Endpunkt des benutzerdefinierten Einbettungsmodells 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 von Ihnen definierten Modellendpunkt, z. B. custom-embedding-model. Auf diese Modell-ID wird für Metadaten verwiesen, die der Modellendpunkt zum Generieren von Einbettungen oder Aufrufen von Vorhersagen benötigt.
- REQUEST_URL: erforderlich. Der modellspezifische Endpunkt beim Hinzufügen von benutzerdefinierten Text-Embeddings und generischen Modellendpunkten, z. B. https://cymbal.com/models/text/embeddings/v1.
- MODEL_QUALIFIED_NAME: Erforderlich, wenn für den Modellendpunkt ein qualifizierter Name verwendet wird. Der vollständige qualifizierte Name, falls der Modellendpunkt mehrere Versionen hat.
- SECRET_ID: die Secret-ID, die Sie zuvor bei der google_ml.create_sm_secret()-Prozedur verwendet haben.

Generische Modelle

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

Sie können jeden generischen Modellendpunkt registrieren, solange Eingabe und Ausgabe im JSON-Format sind. Je nach Metadaten des Modellendpunkts müssen Sie möglicherweise HTTP-Header generieren oder Anfrage-URLs definieren.

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

Gemini-Modell

Da einige gemini-pro-Modelle vorab registriert sind, können Sie die Modell-ID direkt aufrufen, um Vorhersagen zu erhalten. AlloyDB Omni für Abfragen cloudbasierter Vertex AI-Modelle einrichten

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

Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
Erstellen und aktivieren Sie die Erweiterung google_ml_integration.

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 Endpunkt facebook/bart-large-mnli für das benutzerdefinierte Klassifizierungsmodell hinzugefügt, das auf Hugging Face gehostet wird.

Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
Erstellen und aktivieren Sie die Erweiterung google_ml_integration.
Fügen Sie den OpenAI API-Schlüssel als Secret zum Secret Manager für die Authentifizierung hinzu. Wenn Sie bereits ein Secret für ein anderes OpenAI-Modell erstellt haben, können Sie dasselbe Secret wiederverwenden.
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 geheime ID, die Sie festlegen und die anschließend bei der Registrierung eines Modellendpunkts verwendet wird.
- SECRET_MANAGER_SECRET_ID: Die Secret-ID, die Sie beim Erstellen des Secrets im Secret Manager festgelegt haben.
- PROJECT_ID: die ID Ihres Google Cloud -Projekts.
- VERSION_NUMBER: die Versionsnummer der Secret-ID.
Rufen Sie die Funktion zum Erstellen von Modellen 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 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 Aufrufen von Vorhersagen benötigt.
- REQUEST_URL: Der modellspezifische Endpunkt beim Hinzufügen benutzerdefinierter Text-Embeddings 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 bei der google_ml.create_sm_secret()-Prozedur verwendet haben.

Generisches Anthropic-Modell

Im folgenden Beispiel wird der Modellendpunkt claude-3-opus-20240229 hinzugefügt. Die Modellendpunktverwaltung bietet die Headerfunktion, die zum Registrieren von Anthroponic-Modellen erforderlich ist.

AlloyDB Omni für Abfragen cloudbasierter Vertex AI-Modelle einrichten

Stellen Sie mit psql eine Verbindung zu Ihrer Datenbank her.
Erstellen und aktivieren Sie die Erweiterung google_ml_integration.
Secret Manager
1. Fügen Sie das Bearer-Token als Secret zum Secret Manager für die Authentifizierung 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 geheime ID, die Sie festlegen und die anschließend bei der Registrierung eines Modellendpunkts verwendet wird.
  - SECRET_MANAGER_SECRET_ID: Die Secret-ID, die Sie beim Erstellen des Secrets im Secret Manager festgelegt haben.
  - PROJECT_ID: die ID Ihres Google Cloud -Projekts.
  - VERSION_NUMBER: die Versionsnummer der Secret-ID.
3. Rufen Sie die Funktion „create model“ auf, um den claude-3-opus-20240229-Modellendpunkt 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 Aufrufen von Vorhersagen benötigt.
  - REQUEST_URL: Der modellspezifische Endpunkt beim Hinzufügen benutzerdefinierter Text-Embeddings und generischer Modellendpunkte, z. B. https://api.anthropic.com/v1/messages.
Auth-Header
1. Verwenden Sie die Standardfunktion zum Generieren von google_ml.anthropic_claude_header_gen_fn-Headern oder erstellen Sie eine eigene Funktion.
  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: den Anthropogenic API-Schlüssel.
  - ANTHROPIC_VERSION (optional): die zu verwendende Modellversion, z. B. 2023-06-01.
2. Rufen Sie die Funktion „create model“ auf, um den claude-3-opus-20240229-Modellendpunkt 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 Aufrufen von Vorhersagen benötigt.
  - REQUEST_URL: Der modellspezifische Endpunkt beim Hinzufügen benutzerdefinierter Text-Embeddings und generischer Modellendpunkte, z. B. https://api.anthropic.com/v1/messages.

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