Enregistrer et appeler des modèles d'IA distants à l'aide de la gestion des points de terminaison de modèle

Cette page explique comment appeler des prédictions ou générer des embeddings à l'aide d'un modèle, en enregistrant le point de terminaison du modèle avec la gestion des points de terminaison de modèle.

Avant de commencer

Configurer l'extension

  1. Connectez-vous à votre base de données à l'aide de psql ou d'AlloyDB pour PostgreSQL Studio avec l'utilisateur postgres.

  2. Facultatif : demandez l'accès pour interagir avec les fonctionnalités du moteur de requêtes d'IA AlloyDB pour PostgreSQL (preview), y compris la compatibilité avec les modèles multimodaux, les modèles de classement et les fonctions d'opérateur.

  3. Facultatif : accordez à un utilisateur PostgreSQL autre qu'un super-administrateur l'autorisation de gérer les métadonnées du modèle :

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

    Remplacez la variable suivante :

    • NON_SUPER_USER : nom d'utilisateur PostgreSQL non super-utilisateur.

  4. Assurez-vous que l'adresse IP sortante est activée pour accéder aux modèles hébergés en dehors de votre VPC, tels que les modèles tiers. Pour en savoir plus, consultez Ajouter une connectivité sortante.

Configurer l'authentification

Les sections suivantes expliquent comment configurer l'authentification avant d'enregistrer un point de terminaison de modèle.

Configurer l'authentification pour Vertex AI

Pour utiliser les points de terminaison de modèle Google Vertex AI, vous devez ajouter des autorisations Vertex AI au compte de service AlloyDB basé sur IAM que vous utilisez pour vous connecter à la base de données. Pour en savoir plus sur l'intégration à Vertex AI, consultez Intégrer à Vertex AI.

Configurer l'authentification à l'aide de Secret Manager

Cette section explique comment configurer l'authentification si vous utilisez Secret Manager pour stocker les informations d'authentification des fournisseurs tiers.

Cette étape est facultative si votre point de terminaison de modèle ne gère pas l'authentification via Secret Manager, par exemple si votre point de terminaison de modèle utilise des en-têtes HTTP pour transmettre les informations d'authentification ou n'utilise pas du tout l'authentification.

Pour créer et utiliser une clé API ou un jeton du porteur, procédez comme suit :

  1. Créez le secret dans Secret Manager. Pour en savoir plus, consultez Créer un secret et accéder à une version de secret.

    Le chemin secret est utilisé dans la fonction SQL google_ml.create_sm_secret().

  2. Accordez au cluster AlloyDB les autorisations d'accès au secret.

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

    Remplacez les éléments suivants :

    • SECRET_NAME : nom du secret dans Secret Manager.

    • SERVICE_ACCOUNT_ID : ID du compte de service basé sur IAM au format serviceAccount:service-PROJECT_ID@gcp-sa-alloydb.iam.gserviceaccount.com (par exemple, service-212340152456@gcp-sa-alloydb.iam.gserviceaccount.com).

      Vous pouvez également attribuer ce rôle au compte de service au niveau du projet. Pour en savoir plus, consultez Ajouter une association de stratégie Identity and Access Management.

Configurer l'authentification à l'aide d'en-têtes

L'exemple suivant montre comment configurer l'authentification à l'aide d'une fonction. La fonction renvoie un objet JSON contenant les en-têtes requis pour envoyer une requête au modèle d'embedding.

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

Remplacez les éléments suivants :

  • HEADER_GEN_FUNCTION : nom de la fonction de génération d'en-tête que vous pouvez utiliser lors de l'enregistrement d'un modèle.
  • API_KEY : clé API du fournisseur de modèles.

Modèles d'embedding de texte

Cette section explique comment enregistrer des points de terminaison de modèle avec la gestion des points de terminaison de modèle.

La gestion des points de terminaison de modèle est compatible avec certains modèles d'embedding de texte et Vertex AI génériques en tant que points de terminaison de modèle préenregistrés. Vous pouvez utiliser directement l'ID du modèle pour générer des embeddings ou appeler des prédictions, en fonction du type de modèle. Pour en savoir plus sur les modèles préenregistrés compatibles, consultez Modèles Vertex AI préenregistrés.

Le modèle gemini-embedding-001 n'est disponible que dans la région us-central1.

Par exemple, pour appeler le modèle gemini-embedding-001 préenregistré, vous pouvez appeler directement le modèle à l'aide de la fonction d'intégration :

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

Si votre cluster AlloyDB et le point de terminaison Vertex AI se trouvent dans des projets différents, définissez model_id sur le chemin qualifié du point de terminaison (par exemple, projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/gemini-embedding-001).

De même, pour appeler le modèle gemini-1.5-pro:generateContent préenregistré, vous pouvez appeler directement le modèle à l'aide de la fonction de prédiction :

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

Pour générer des embeddings, découvrez comment générer des embeddings de texte. Pour appeler des prédictions, consultez Appeler des prédictions.

Modèles d'embedding de texte avec prise en charge intégrée

La gestion des points de terminaison de modèle offre une compatibilité intégrée pour certains modèles de Vertex AI et d'OpenAI. Pour obtenir la liste des modèles compatibles, consultez Modèles compatibles.

Pour les modèles avec prise en charge intégrée, vous pouvez définir le nom qualifié comme nom qualifié du modèle et spécifier l'URL de la requête. La gestion des points de terminaison de modèle identifie automatiquement le modèle et configure les fonctions de transformation par défaut.

Modèles d'embedding Vertex AI

Les étapes suivantes montrent comment enregistrer des modèles Vertex AI avec prise en charge intégrée. Le point de terminaison du modèle gemini-embedding-001 et text-multilingual-embedding-002 est utilisé comme exemple.

Assurez-vous que le cluster AlloyDB et le modèle Vertex AI que vous interrogez se trouvent dans la même région.

  1. Connectez-vous à votre base de données à l'aide de psql.

  2. Configurez l'extension google_ml_integration.

  3. Appelez la fonction de création de modèle pour ajouter le point de terminaison du modèle :

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

Si le modèle est stocké dans un autre projet et une autre région que votre cluster AlloyDB, définissez l'URL de la requête sur projects/PROJECT_ID/locations/REGION_ID/publishers/google/models/MODEL_ID, où REGION_ID correspond à la région dans laquelle votre modèle est hébergé et MODEL_ID au nom qualifié du modèle.

De plus, attribuez le rôle Utilisateur Vertex AI (roles/aiplatform.user) au compte de service AlloyDB du projet dans lequel réside l'instance AlloyDB afin qu'AlloyDB puisse accéder au modèle hébergé dans l'autre projet.

Modèle d'embedding textuel Open AI

L'extension google_ml_integration configure automatiquement les fonctions de transformation par défaut et appelle les modèles OpenAI à distance. Pour obtenir la liste des modèles OpenAI compatibles, consultez Modèles compatibles.

L'exemple suivant ajoute le point de terminaison du modèle OpenAI text-embedding-ada-002. Vous pouvez enregistrer les points de terminaison des modèles OpenAI text-embedding-3-small et text-embedding-3-large en suivant les mêmes étapes et en définissant les noms qualifiés de modèle spécifiques aux modèles.

  1. Connectez-vous à votre base de données à l'aide de psql.
  2. Configurez l'extension google_ml_integration.
  3. Ajoutez la clé API OpenAI en tant que secret à Secret Manager pour l'authentification.

  4. Appelez le secret stocké dans Secret Manager :

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

    Remplacez les éléments suivants :

    • SECRET_ID : ID secret que vous avez défini et qui est utilisé par la suite lors de l'enregistrement d'un point de terminaison de modèle (par exemple, key1).
    • SECRET_MANAGER_SECRET_ID : ID du secret défini dans Secret Manager lorsque vous avez créé le secret.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • VERSION_NUMBER : numéro de version de l'ID du secret.

  5. Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle text-embedding-ada-002 :

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

    Remplacez les éléments suivants :

    • MODEL_ID : ID unique du point de terminaison du modèle que vous définissez. Cet ID de modèle est référencé pour les métadonnées dont le point de terminaison du modèle a besoin pour générer des embeddings ou appeler des prédictions.
    • SECRET_ID : ID du secret que vous avez utilisé précédemment dans la procédure google_ml.create_sm_secret().

Pour générer des embeddings, consultez Générer des embeddings de texte.

Modèle d'embedding de texte hébergé sur mesure

Cette section explique comment enregistrer un point de terminaison de modèle hébergé personnalisé, créer des fonctions de transformation et, éventuellement, des en-têtes HTTP personnalisés. Tous les points de terminaison de modèles hébergés personnalisés sont acceptés, quel que soit leur emplacement d'hébergement.

L'exemple suivant ajoute le point de terminaison du modèle personnalisé custom-embedding-model hébergé par Cymbal. Les fonctions de transformation cymbal_text_input_transform et cymbal_text_output_transform permettent de transformer le format d'entrée et de sortie du modèle en format d'entrée et de sortie de la fonction de prédiction.

Pour enregistrer des points de terminaison de modèles d'embedding de texte hébergés sur mesure, procédez comme suit :

  1. Connectez-vous à votre base de données à l'aide de psql.

  2. Configurez l'extension google_ml_integration.

  3. Facultatif : Ajoutez la clé API en tant que secret à Secret Manager pour l'authentification.

  4. Appelez le secret stocké dans Secret Manager :

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

    Remplacez les éléments suivants :

    • SECRET_ID : ID secret que vous avez défini et qui est utilisé par la suite lors de l'enregistrement d'un point de terminaison de modèle (par exemple, key1).
    • SECRET_MANAGER_SECRET_ID : ID du secret défini dans Secret Manager lorsque vous avez créé le secret.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • VERSION_NUMBER : numéro de version de l'ID du secret.

  5. Créez les fonctions de transformation d'entrée et de sortie en fonction de la signature suivante pour la fonction de prédiction des points de terminaison du modèle d'embedding de texte. Pour savoir comment créer des fonctions de transformation, consultez Exemple de fonctions de transformation.

    Voici des exemples de fonctions de transformation spécifiques au point de terminaison du modèle d'embedding de texte custom-embedding-model :

    -- 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. Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle d'embedding personnalisé :

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

    Remplacez les éléments suivants :

    • MODEL_ID : Obligatoire. ID unique du point de terminaison du modèle que vous définissez (par exemple, custom-embedding-model). Cet ID de modèle est référencé pour les métadonnées dont le point de terminaison du modèle a besoin pour générer des embeddings ou appeler des prédictions.
    • REQUEST_URL : Obligatoire. Point de terminaison spécifique au modèle lors de l'ajout d'embeddings de texte personnalisés et de points de terminaison de modèle génériques (par exemple, https://cymbal.com/models/text/embeddings/v1). Assurez-vous que le point de terminaison du modèle est accessible via une adresse IP interne. La gestion des points de terminaison de modèle n'est pas compatible avec les adresses IP publiques.
    • MODEL_QUALIFIED_NAME : obligatoire si le point de terminaison de votre modèle utilise un nom qualifié. Nom complet si le point de terminaison du modèle comporte plusieurs versions.
    • SECRET_ID : ID du secret que vous avez utilisé précédemment dans la procédure google_ml.create_sm_secret().

Modèle multimodal avec prise en charge intégrée

Intégrer Vertex AI et installer l'extension

  1. Intégration à Vertex AI
  2. Assurez-vous que la dernière version de google_ml_integration est installée.

    1. Pour vérifier la version installée, exécutez la commande suivante :

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

    2. Si l'extension n'est pas installée ou si la version installée est antérieure à la version 1.4.3, mettez-la à jour en exécutant les commandes suivantes :

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

      Si vous rencontrez des problèmes lors de l'exécution des commandes précédentes ou si l'extension n'est pas mise à jour vers la version 1.4.3 après l'exécution des commandes précédentes, contactez l'assistance AlloyDB.

    3. Une fois que vous avez vérifié que la version est à jour, installez la fonctionnalité d'aperçu en exécutant la procédure upgrade_to_preview_version :

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

Appeler le modèle pour générer des embeddings multimodaux

Étant donné que la gestion des points de terminaison de modèle fournit une assistance intégrée pour le modèle multimodalembedding@001 de Vertex AI, vous pouvez appeler directement le modèle pour générer des embeddings multimodaux.

L'exemple suivant utilise le nom de modèle qualifié multimodalembedding@001 comme ID de modèle pour générer des embeddings d'images multimodales :

  1. Connectez-vous à votre base de données à l'aide de psql.
  2. Configurez l'extension google_ml_integration.

  3. Générez des embeddings d'images multimodaux :

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

Remplacez les éléments suivants :

  • IMAGE_PATH_OR_TEXT avec le chemin d'accès Cloud Storage à l'image, par exemple gs://cymbal_user_data/image-85097193-cd9788aacebb.jpeg, pour la traduire en un embedding vectoriel ou une chaîne base64 de l'image.
  • MIMETYPE par le type MIME de l'image.

Modèles de classement

Modèles de classification Vertex AI

Vous pouvez utiliser les modèles Vertex AI mentionnés dans Modèles compatibles sans les enregistrer.

Pour savoir comment classer vos résultats de recherche à l'aide d'un modèle de classement Vertex AI, consultez Classer les résultats de recherche.

Enregistrer un modèle de classement tiers

L'exemple suivant montre comment enregistrer un modèle de réorganisation de Cohere.

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

Modèles génériques

Cette section explique comment enregistrer un point de terminaison de modèle générique disponible chez un fournisseur de modèles hébergés tel que Hugging Face, OpenAI, Vertex AI, Anthropic ou tout autre fournisseur. Cette section présente des exemples d'enregistrement d'un point de terminaison de modèle générique hébergé sur Hugging Face, d'un modèle gemini-pro générique de Vertex AI Model Garden et du point de terminaison de modèle claude-haiku.

Vous pouvez enregistrer n'importe quel point de terminaison de modèle générique, à condition que l'entrée et la sortie soient au format JSON. En fonction des métadonnées du point de terminaison de votre modèle, vous devrez peut-être générer des en-têtes HTTP ou définir des URL de requête.

Pour en savoir plus sur les modèles génériques préenregistrés et les modèles avec prise en charge intégrée, consultez Modèles compatibles.

Modèles Gemini génériques

Cette section explique comment enregistrer des modèles Gemini génériques.

Modèle Gemini 1.5 Pro

Étant donné que certains modèles gemini-pro sont préenregistrés, vous pouvez appeler directement l'ID du modèle pour appeler les prédictions.

L'exemple suivant utilise le point de terminaison du modèle gemini-1.5-pro:generateContent de Vertex AI Model Garden.

  1. Connectez-vous à votre base de données à l'aide de psql.
  2. Configurez l'extension google_ml_integration.

  3. Appelez des prédictions à l'aide de l'ID du modèle préenregistré :

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

Modèle générique sur Hugging Face

L'exemple suivant ajoute le point de terminaison du modèle de classification personnalisé facebook/bart-large-mnli hébergé sur Hugging Face.

  1. Connectez-vous à votre base de données à l'aide de psql.
  2. Configurez l'extension google_ml_integration.
  3. Ajoutez la clé API OpenAI en tant que secret à Secret Manager pour l'authentification. Si vous avez déjà créé un secret pour un autre modèle OpenAI, vous pouvez le réutiliser.

  4. Appelez le secret stocké dans Secret Manager :

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

    Remplacez les éléments suivants :

    • SECRET_ID : ID secret que vous avez défini et qui est utilisé par la suite lors de l'enregistrement d'un point de terminaison de modèle.
    • SECRET_MANAGER_SECRET_ID : ID du secret défini dans Secret Manager lorsque vous avez créé le secret.
    • PROJECT_ID : ID de votre projet Google Cloud .
    • VERSION_NUMBER : numéro de version de l'ID du secret.

  5. Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle facebook/bart-large-mnli :

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

    Remplacez les éléments suivants :

    • MODEL_ID : ID unique du point de terminaison du modèle que vous définissez (par exemple, custom-classification-model). Cet ID de modèle est référencé pour les métadonnées dont le point de terminaison du modèle a besoin pour générer des embeddings ou appeler des prédictions.
    • REQUEST_URL : point de terminaison spécifique au modèle lors de l'ajout d'embeddings de texte personnalisés et de points de terminaison de modèle génériques (par exemple, https://api-inference.huggingface.co/models/facebook/bart-large-mnli).
    • MODEL_QUALIFIED_NAME : nom complet de la version du point de terminaison du modèle, par exemple facebook/bart-large-mnli.
    • SECRET_ID : ID du secret que vous avez utilisé précédemment dans la procédure google_ml.create_sm_secret().

Modèle générique Anthropic

L'exemple suivant ajoute le point de terminaison du modèle claude-3-opus-20240229. La gestion des points de terminaison de modèle fournit la fonction d'en-tête requise pour enregistrer les modèles Anthropic.

  1. Connectez-vous à votre base de données à l'aide de psql.

  2. Créez et activez l'extension google_ml_integration.

    Secret Manager

    1. Ajoutez le jeton du porteur en tant que secret à Secret Manager pour l'authentification.

    2. Appelez le secret stocké dans Secret Manager :

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

      Remplacez les éléments suivants :

      • SECRET_ID : ID secret que vous avez défini et qui est utilisé par la suite lors de l'enregistrement d'un point de terminaison de modèle.
      • SECRET_MANAGER_SECRET_ID : ID du secret défini dans Secret Manager lorsque vous avez créé le secret.
      • PROJECT_ID : ID de votre projet Google Cloud .
      • VERSION_NUMBER : numéro de version de l'ID du secret.

    3. Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle claude-3-opus-20240229.

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

      Remplacez les éléments suivants :

      • MODEL_ID : ID unique du point de terminaison du modèle que vous définissez (par exemple, anthropic-opus). Cet ID de modèle est référencé pour les métadonnées dont le point de terminaison du modèle a besoin pour générer des embeddings ou appeler des prédictions.
      • REQUEST_URL : point de terminaison spécifique au modèle lors de l'ajout d'embeddings de texte personnalisés et de points de terminaison de modèle génériques (par exemple, https://api.anthropic.com/v1/messages).

    En-tête d'autorisation

    1. Utilisez la fonction de génération d'en-tête par défaut google_ml.anthropic_claude_header_gen_fn ou créez une fonction de génération d'en-tête.

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

      Remplacez les éléments suivants :

      • ANTHROPIC_API_KEY : clé API Anthropic.
      • ANTHROPIC_VERSION (facultatif) : version spécifique du modèle que vous souhaitez utiliser (par exemple, 2023-06-01).

    2. Appelez la fonction de création de modèle pour enregistrer le point de terminaison du modèle claude-3-opus-20240229.

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

      Remplacez les éléments suivants :

      • MODEL_ID : ID unique du point de terminaison du modèle que vous définissez (par exemple, anthropic-opus). Cet ID de modèle est référencé pour les métadonnées dont le point de terminaison du modèle a besoin pour générer des embeddings ou appeler des prédictions.
      • REQUEST_URL : point de terminaison spécifique au modèle lors de l'ajout d'embeddings de texte personnalisés et de points de terminaison de modèle génériques (par exemple, https://api.anthropic.com/v1/messages).

Pour en savoir plus, consultez Appeler des prédictions pour les points de terminaison de modèles génériques.

Étapes suivantes