Auf dieser Seite wird beschrieben, wie Sie Vorhersagen aufrufen oder mithilfe eines Modells Einbettungen generieren, indem Sie den Modellendpunkt in der Modellendpunktverwaltung registrieren.
Hinweise
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 aufongesetzt ist. Weitere Informationen zum Festlegen von Datenbank-Flags finden Sie unter Datenbank-Flags einer Instanz konfigurieren.Stellen Sie über
psqloder AlloyDB for PostgreSQL Studio eine Verbindung zu Ihrer Datenbank her.Fügen Sie die
google_ml_integration-Erweiterung mit psql hinzu:CREATE EXTENSION IF NOT EXISTS google_ml_integration;Optional: Wenn die
google_ml_integration-Erweiterung bereits installiert ist, aktualisiere sie auf die neueste Version:ALTER EXTENSION google_ml_integration UPDATE;Optional: Fordern Sie Zugriff auf die Funktionen der KI-Abfrage-Engine von AlloyDB for PostgreSQL (Vorabversion) an, einschließlich Unterstützung für multimodale Modelle, Ranking-Modelle und Operatorfunktionen.
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_USERdurch den nicht super PostgreSQL-Nutzernamen.Achten Sie darauf, dass ausgehende IP-Adressen für den Zugriff auf Modelle aktiviert sind, die außerhalb Ihrer VPC gehostet werden, z. B. Modelle von Drittanbietern. Weitere Informationen finden Sie unter Ausgehende Konnektivität 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 Modellendpunkte von Google Vertex AI verwenden möchten, müssen Sie dem IAM-basierten AlloyDB-Dienstkonto, mit dem Sie eine Verbindung zur Datenbank herstellen, Vertex AI-Berechtigungen hinzufügen. Weitere Informationen zur Einbindung in Vertex AI finden Sie unter Mit Vertex AI verknüpfen.
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 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 in Secret Manager.SERVICE_ACCOUNT_ID: Die ID des IAM-basierten Dienstkontos im FormatserviceAccount: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 Richtlinienbindung für die Identitäts- und Zugriffsverwaltung hinzufügen.
Authentifizierung mit Headern einrichten
Das folgende Beispiel zeigt, wie die Authentifizierung mit 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 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.
Das text-embedding-large-exp-03-07-Modell ist nur in der us-central1-Region verfügbar.
Wenn Sie beispielsweise das vorab registrierte text-embedding-large-exp-03-07-Modell aufrufen möchten, können Sie es direkt über die Einbettungsfunktion aufrufen:
SELECT
embedding(
model_id => 'text-embedding-large-exp-03-07',
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 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 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.
Achten Sie darauf, dass sich sowohl der AlloyDB-Cluster als auch das Vertex AI-Modell, das Sie abfragen, in derselben Region befinden.
Erstellen und aktivieren Sie die Erweiterung
google_ml_integration.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');
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.
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 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
psqleine 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 „create model“ 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 dergoogle_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:
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.
Erstellen Sie die Eingabe- und Ausgabetransformationsfunktionen anhand der folgenden Signatur für die Vorhersagefunktion für Endpunkte von Modelleinbettungen. Weitere Informationen zum Erstellen von Transformationsfunktionen finden Sie im 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 die Texteinbettung 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. Achten Sie darauf, dass der Modellendpunkt über eine interne IP-Adresse zugänglich ist. Die Endpunktverwaltung für Modelle unterstützt keine öffentlichen IP-Adressen.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 dergoogle_ml.create_sm_secret()-Prozedur verwendet haben.
Multimodales Modell mit integrierter Unterstützung
Da die Modellendpunktverwaltung eine integrierte Unterstützung für das multimodalembedding@001-Modell von Vertex AI bietet, können Sie die Modell-ID direkt aufrufen, um multimodale Einbettungen zu generieren.
Im folgenden Beispiel wird der qualifizierte Modellname multimodalembedding@001 als Modell-ID verwendet, um multimodale Bild-Embeddings zu generieren:
- Stellen Sie mit
psqleine Verbindung zu Ihrer Datenbank her. - Erstellen und aktivieren Sie die Erweiterung
google_ml_integration. 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 dem Cloud Storage-Pfad zum Bild, z. B.
gs://cymbal_user_data/image-85097193-cd9788aacebb.jpeg, um es in ein Vektor-Embedding oder einen Base64-String des Bildes umzuwandeln. - MIMETYPE durch den MIME-Typ des Bildes.
Ranking-Modelle
In diesem Abschnitt wird gezeigt, wie Sie das semantic-ranker-512-002-Vertex AI-Rankingmodell mit integrierter Unterstützung registrieren. Sowohl das semantic-ranker-512-002- als auch das semantic-ranker-512-003-Modell haben eine integrierte Unterstützung.
Vertex AI-Rangfolgemodelle
In diesem Abschnitt wird beschrieben, wie Sie Ranking-Endpunkte mit der Modellendpunktverwaltung registrieren.
So registrieren Sie die semantic-ranker-512-002-Modellendpunkte:
Erstellen Sie ein Dienstkonto, das vom AlloyDB-Dienstkonto getrennt ist.
Aktivieren Sie die Discovery Engine API in dem Projekt, in dem Sie den Endpunkt des Ranking-Modells registrieren.
Weisen Sie dem Dienstkonto die folgenden Rollen zu.
Discovery Engine Admin (roles/discoveryengine.admin)Vertex AI Administrator (roles/aiplatform.admin)
Weisen Sie dem Dienstkonto die folgenden Dienstkontorollen zu:
Service Account Token Creator role (roles/iam.serviceAccountTokenCreator)Service Account User role (roles/iam.serviceAccountUser)
Generieren Sie ein Zugriffstoken für das Dienstkonto mit einer längeren Gültigkeitsdauer.
gcloud auth print-access-token \ --impersonate-service-account="service-PROJECT_NUMBER@gcp-sa-alloydb.iam.gserviceaccount.com" \ --lifetime=43200Erstellen und aktivieren Sie die Erweiterung
google_ml_integration.So erstellen Sie ein Secret, das im Secret Manager gespeichert wird:
CALL google_ml.create_sm_secret( secret_id => 'SECRET_ID', secret_path => 'projects/project-id/secrets/SECRET_MANAGER_SECRET_ID/versions/latest;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. Da die neueste Secret-Version verwendet wird, müssen Sie die Version in AlloyDB nicht noch einmal aktualisieren, wenn Ihr Secret-Token abläuft und Sie es in Secret Manager aktualisieren.
Rufen Sie die Funktion „create model“ auf, um den Modellendpunkt hinzuzufügen:
CALL google_ml.create_model( model_id => 'semantic-ranker-512-002', model_type => 'reranking', model_provider => 'custom', model_request_url => 'https://discoveryengine.googleapis.com/v1/projects/PROJECT_ID/locations/global/rankingConfigs/default_ranking_config:rank', model_qualified_name => 'semantic-ranker-512@002', model_auth_type => 'secret_manager', model_auth_id => 'SECRET_ID', model_in_transform_fn => 'google_ml.vertexai_reranking_input_transform', model_out_transform_fn => 'google_ml.vertexai_reranking_output_transform', generate_headers_fn => 'google_ml.vertexai_reranking_header_gen_fn');Ersetzen Sie PROJECT_ID durch die ID Ihres Projekts.
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.
Generische Gemini-Modelle
In diesem Abschnitt wird beschrieben, wie Sie generische Gemini-Modelle registrieren.
gemini-1.5-pro model
Da einige gemini-pro-Modelle vorab registriert sind, können Sie die Modell-ID direkt aufrufen, um Vorhersagen aufzurufen.
Im folgenden Beispiel wird der Modellendpunkt gemini-1.5-pro:generateContent aus dem Vertex AI Model Garden verwendet.
- Stellen Sie mit
psqleine 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
psqleine 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 „create model“ 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 dergoogle_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.
- Stellen Sie mit
psqleine Verbindung zu Ihrer Datenbank her. Erstellen und aktivieren Sie die Erweiterung
google_ml_integration.Secret Manager
- Fügen Sie das Bearer-Token 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 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
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
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.
Rufen Sie die Funktion zum Erstellen von Modellen 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.
Nächste Schritte
- Referenz zur Endpunktverwaltung für Modelle
- Beispielvorlagen zum Registrieren von Modellendpunkten verwenden
- Multimodale Einbettungen generieren
- Suchergebnisse für RAG ranken und bewerten
- Natürliche Sprache in SQL-Operatoren verwenden