Cette page décrit la version 18.1.0 d'AlloyDB Omni à l'aide de l'option de déploiement Linux. Choisissez une autre option de déploiement.

Enregistrer et appeler des modèles d'IA distants dans AlloyDB Omni

Sélectionnez une version de la documentation :

Pour appeler des prédictions ou générer des embeddings à l'aide d'un modèle, enregistrez le point de terminaison du modèle avec la gestion des points de terminaison de modèle.

Avant d'enregistrer un point de terminaison de modèle avec la gestion des points de terminaison de modèle, vous devez activer l'extension google_ml_integration et configurer l'authentification en fonction du fournisseur de modèles, si votre point de terminaison de modèle nécessite une authentification.

Assurez-vous d'accéder à votre base de données avec le nom d'utilisateur par défaut postgres.

Activer l'extension

Vous devez ajouter et activer l'extension google_ml_integration avant de pouvoir commencer à utiliser les fonctions associées. La gestion des points de terminaison de modèle nécessite l'installation de l'extension google_ml_integration.

Vérifiez que l'option de base de données google_ml_integration.enable_model_support est définie sur on pour une instance. Pour en savoir plus sur la définition des options de base de données, consultez Configurer des options de base de données.
Facultatif : Si l'extension google_ml_integration est déjà installée, modifiez-la pour passer à la dernière version :
```
    ALTER EXTENSION google_ml_integration UPDATE;
```

Ajoutez l'extension google_ml_integration à l'aide de psql :

  CREATE EXTENSION IF NOT EXISTS google_ml_integration;

Facultatif : Accordez l'autorisation à un utilisateur PostgreSQL non super-utilisateur 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 NON_SUPER_USER par le nom d'utilisateur PostgreSQL non super-utilisateur.

Activez la gestion des points de terminaison de modèle dans votre base de données :

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

Assurez-vous que la connectivité sortante est activée.

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 que vous avez utilisé lors de l'installation d'AlloyDB Omni. Pour en savoir plus, consultez Configurer votre installation AlloyDB Omni pour interroger des modèles basés sur le cloud.

Configurer l'authentification à l'aide de Secret Manager

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 des informations d'authentification ou n'utilise pas d'authentification du tout.

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

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 d'accès au secret est utilisé dans la google_ml.create_sm_secret() fonction SQL.
Accordez des autorisations au cluster AlloyDB pour accéder 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 que vous avez créé à l'étape précédente. Assurez-vous qu'il s'agit du même compte que celui que vous avez utilisé lors de l'installation d'AlloyDB Omni. Cela inclut le suffixe complet PROJECT_ID.iam.gserviceaccount.com. Par exemple : my-service@my-project.iam.gserviceaccount.com
  
  Vous pouvez également accorder ce rôle au compte de service au niveau du projet. Pour en savoir plus, consultez Ajouter une liaison de stratégie de Identity and Access Management accès.

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

L'exemple suivant montre comment configurer l'authentification à l'aide d'une fonction qui 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 textuel

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 textuel 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.

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

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

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

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

Pour générer des embeddings, consultez Générer des embeddings pour des points de terminaison de modèle préenregistrés. Pour appeler des prédictions, consultez comment appeler des prédictions pour des points de terminaison de modèle préenregistrés.

Modèles d'embeddings textuels 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 OpenAI. Pour obtenir la liste des modèles avec prise en charge intégrée, consultez Modèles avec prise en charge intégrée.

Pour les modèles avec prise en charge intégrée, vous pouvez définir le nom complet comme nom complet 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 de modèle text-embedding-005 et text-multilingual-embedding-002 est utilisé comme exemple.

Pour AlloyDB Omni, assurez-vous de configurer AlloyDB Omni pour interroger des modèles Vertex AI basés sur le cloud.

Créez et activez l'extension google_ml_integration.
Connectez-vous à votre base de données à l'aide de psql.

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

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

L'URL de la requête générée par la fonction fait référence au projet associé au compte de service AlloyDB Omni. Si vous souhaitez faire référence à un autre projet, assurez-vous de spécifier explicitement model_request_url.

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 est la région dans laquelle votre modèle est hébergé et MODEL_ID est le nom complet du modèle.

De plus, accordez le rôle Utilisateur Vertex AI (roles/aiplatform.user) au compte de service du projet dans lequel AlloyDB Omni est installé afin que le modèle hébergé dans l'autre projet soit accessible.

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 avec prise en charge intégrée, consultez Modèles avec prise en charge intégrée.

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

Connectez-vous à votre base de données à l'aide de psql.
Créez et activez l'extension google_ml_integration.
Ajoutez la clé API OpenAI en tant que secret à Secret Manager pour l'authentification.
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 de secret que vous définissez 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 de secret défini dans Secret Manager lorsque vous avez créé le secret.
- PROJECT_ID : ID de votre Google Cloud projet.
- VERSION_NUMBER : numéro de version de l'ID de secret.
Appelez la fonction de création de modèle pour enregistrer le point de terminaison de 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 de 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 de modèle a besoin pour générer des embeddings ou appeler des prédictions.
- SECRET_ID : ID de secret que vous avez utilisé précédemment dans la procédure google_ml.create_sm_secret().

Pour générer des embeddings, consultez comment générer des embeddings pour des points de terminaison de modèle avec prise en charge intégrée.

Modèle d'embedding textuel hébergé sur mesure

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

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

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

Connectez-vous à votre base de données à l'aide de psql.
Créez et activez l'extension google_ml_integration.
Facultatif : Ajoutez la clé API en tant que secret à Secret Manager pour l'authentification.
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 de secret que vous définissez 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 de secret défini dans Secret Manager lorsque vous avez créé le secret.
- PROJECT_ID : ID de votre Google Cloud projet.
- VERSION_NUMBER : numéro de version de l'ID de secret.
Remarque : Secret Manager génère un en-tête Authorization: Bearer SECRET_VALUE_FROM_SECRET_MANAGER pour l'authentification par défaut. Si ce format correspond au format de jeton porteur d'autorisation de votre point de terminaison de modèle, vous n'avez pas besoin de générer d'en-têtes d'authentification à l'aide de la fonction de génération d'en-tête.

Créez les fonctions de transformation d'entrée et de sortie en fonction de la signature suivante pour la fonction de prédiction pour les points de terminaison des modèles d'embeddings textuels. 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 de modèle d'embedding textuel 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;
$$;

Appelez la fonction de création de modèle pour enregistrer le point de terminaison de 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 de 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 de 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 utilisé lors de l'ajout de points de terminaison d'embeddings textuels et de modèle générique personnalisés, par exemple https://cymbal.com/models/text/embeddings/v1.
- MODEL_QUALIFIED_NAME : obligatoire si votre point de terminaison de modèle utilise un nom complet. Nom complet si le point de terminaison de modèle comporte plusieurs versions.
- SECRET_ID : ID de secret que vous avez utilisé précédemment dans la procédure google_ml.create_sm_secret().

Modèles génériques

Cette section explique comment enregistrer n'importe quel point de terminaison de modèle générique disponible auprès d'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 tant que l'entrée et la sortie sont au format JSON. En fonction des métadonnées de votre point de terminaison de 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èle Gemini

Étant donné que certains modèles gemini-pro sont préenregistrés, vous pouvez appeler directement l'ID du modèle pour appeler des prédictions. Assurez-vous de configurer AlloyDB Omni pour interroger des modèles Vertex AI basés sur le cloud.

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

Connectez-vous à votre base de données à l'aide de psql.
Créez et activez l'extension google_ml_integration.

Appelez des prédictions à l'aide de l'ID de 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 de modèle de classification personnalisé facebook/bart-large-mnli hébergé sur Hugging Face.

Connectez-vous à votre base de données à l'aide de psql.
Créez et activez l'extension google_ml_integration.
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.
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 de secret que vous définissez et qui est utilisé par la suite lors de l'enregistrement d'un point de terminaison de modèle.
- SECRET_MANAGER_SECRET_ID : ID de secret défini dans Secret Manager lorsque vous avez créé le secret.
- PROJECT_ID : ID de votre Google Cloud projet.
- VERSION_NUMBER : numéro de version de l'ID de secret.
Appelez la fonction de création de modèle pour enregistrer le point de terminaison de 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 de 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 de 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 utilisé lors de l'ajout de points de terminaison d'embeddings textuels et de modèle générique personnalisés, par exemple https://api-inference.huggingface.co/models/facebook/bart-large-mnli.
- MODEL_QUALIFIED_NAME : nom complet de la version du point de terminaison de modèle, par exemple facebook/bart-large-mnli.
- SECRET_ID : ID de 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 de 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.

Assurez-vous de configurer AlloyDB Omni pour interroger des modèles Vertex AI basés sur le cloud.

Connectez-vous à votre base de données à l'aide de psql.
Créez et activez l'extension google_ml_integration.
Secret Manager
1. Ajoutez le jeton 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 de secret que vous définissez et qui est utilisé par la suite lors de l'enregistrement d'un point de terminaison de modèle.
  - SECRET_MANAGER_SECRET_ID : ID de secret défini dans Secret Manager lorsque vous avez créé le secret.
  - PROJECT_ID : ID de votre Google Cloud projet.
  - VERSION_NUMBER : numéro de version de l'ID de secret.
3. Appelez la fonction de création de modèle pour enregistrer le point de terminaison de 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 de 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 de 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 utilisé lors de l'ajout de points de terminaison d'embeddings textuels et de modèle générique personnalisés, 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 de modèle spécifique 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 de 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 de 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 de 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 utilisé lors de l'ajout de points de terminaison d'embeddings textuels et de modèle générique personnalisés, par exemple https://api.anthropic.com/v1/messages.

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

Étape suivante

En savoir plus sur la documentation de référence sur la gestion des points de terminaison de modèle.
Utiliser des exemples de modèles pour enregistrer des points de terminaison de modèle.