Chat écrit

Le modèle de fondation PaLM 2 pour Chat (chat-bison) est un modèle volumineux qui excelle dans la compréhension de la langue, la génération de langues et les conversations. Ce modèle de chat est adapté à la conversation naturelle entre plusieurs tours. Il est parfaitement adapté aux tâches de texte relatives au code qui nécessitent des échanges.

Pour les tâches de texte pouvant être effectuées avec une réponse d'API (sans nécessiter de conversation continue), utilisez le modèle de texte.

Pour explorer ce modèle dans la console, consultez la fiche du modèle PaLM 2 pour Chat dans Model Garden.
Accéder au Model Garden

Cas d'utilisation

Service client : demandez au modèle de répondre en tant qu'agents du service client qui ne parlent que du produit de votre entreprise.
Assistance technique : demandez au modèle d'interagir avec les clients en tant qu'agent de centre d'appels avec des paramètres spécifiques sur la manière de répondre et ce qu'il ne faut pas dire.
Personas et caractères : indiquez au modèle de répondre dans le style d'une personne spécifique ("... dans le style de Shakespeare").
Site Web associé : créez un assistant de conversation pour les achats, les voyages et d'autres cas d'utilisation.

Pour en savoir plus, consultez la section Concevoir des requêtes de chat.

Requête HTTP

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict

Pour en savoir plus, consultez la section sur la méthode predict.

Versions de modèle

Pour utiliser la dernière version de modèle, spécifiez le nom du modèle sans numéro de version, par exemple chat-bison.

Pour utiliser une version de modèle stable, indiquez le numéro de version du modèle, par exemple chat-bison@002. Chaque version stable est disponible pendant six mois après la date de disponibilité de la version stable ultérieure.

Le tableau suivant contient les versions de modèle stable disponibles :

modèle chat-bison	Date de disponibilité	Date d'arrêt
chat-bison@002	6 décembre 2023	9 avril 2025

Pour en savoir plus, consultez la page Versions et cycle de vie des modèles.

Corps de la requête

{
  "instances": [
    {
      "context":  string,
      "examples": [
        {
          "input": { "content": string },
          "output": { "content": string }
        }
      ],
      "messages": [
        {
          "author": string,
          "content": string,
        }
      ],
    }
  ],
  "parameters": {
    "temperature": number,
    "maxOutputTokens": integer,
    "topP": number,
    "topK": integer,
    "groundingConfig": string,
    "stopSequences": [ string ],
    "candidateCount": integer
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "seed": integer
  }
}

Pour les appels d'API de chat, context, examples et messages sont combinés pour former la requête. Le tableau suivant présente les paramètres que vous devez configurer pour l'API Vertex AI PaLM pour le texte :

Paramètre	Description	Valeurs acceptables
`context` (facultatif)	Le contexte façonne la réponse du modèle tout au long de la conversation. Par exemple, vous pouvez vous servir du contexte pour spécifier les mots que le modèle est autorisé ou non à utiliser, les sujets sur lesquels se concentrer ou à éviter, ou encore le format ou le style de réponse.	Texte
`examples` (facultatif)	Exemples permettant au modèle d'apprendre à répondre à la conversation.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`messages` (obligatoire)	Historique de conversation fourni au modèle sous une forme alternative structurée. Les messages s'affichent dans l'ordre chronologique : le plus ancien en premier, le plus récent en dernier. Lorsque l'historique des messages entraîne un dépassement de la longueur maximale autorisée pour les entrées, les messages les plus anciens sont supprimés jusqu'à ce que l'intégralité de la requête respecte la limite autorisée.	[{ "author": "user", "content": "user message" }]
`temperature`	La température est utilisée pour l'échantillonnage pendant la génération des réponses, qui se produit lorsque `topP` et `topK` sont appliqués. La température permet de contrôler le degré de hasard dans la sélection des jetons. Les températures inférieures sont idéales pour les requêtes qui nécessitent une réponse moins ouverte ou créative, tandis que des températures plus élevées peuvent conduire à des résultats plus diversifiés ou créatifs. Une température de `0` signifie que les jetons de probabilité les plus élevés sont toujours sélectionnés. Dans ce cas, les réponses pour une requête donnée sont principalement déterministes, mais une petite quantité de variation est toujours possible. Si le modèle renvoie une réponse trop générique ou trop courte, ou s'il renvoie une réponse de remplacement, essayez d'augmenter la température.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Nombre maximal de jetons pouvant être générés dans la réponse. Un jeton correspond environ à quatre caractères. 100 jetons correspondent à environ 60-80 mots. Spécifiez une valeur inférieure pour obtenir des réponses plus courtes et une valeur supérieure pour des réponses potentiellement plus longues.	`1–2048` `Default: 1024`
`topK`	Top-K modifie la façon dont le modèle sélectionne les jetons pour la sortie. Une valeur top-K de `1` signifie que le prochain jeton sélectionné est le plus probable parmi tous les jetons du vocabulaire du modèle (également appelé décodage glouton), tandis qu'une valeur top-K de `3` signifie que le jeton suivant est sélectionné parmi les trois jetons les plus probables en utilisant la température. Pour chaque étape de sélection du jeton, les jetons top-K avec les probabilités les plus élevées sont échantillonnés. Les jetons sont ensuite filtrés en fonction du top-P avec le jeton final sélectionné à l'aide de l'échantillonnage de température. Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.	`1–40` `Default: 40`
`topP`	Top-P modifie la façon dont le modèle sélectionne les jetons pour la sortie. Les jetons sont sélectionnés de la valeur la plus élevée (voir top-K) à la moins probable jusqu'à ce que la somme de leurs probabilités soit égale à la valeur top-P. Par exemple, si les jetons A, B et C ont une probabilité de 0,3, 0,2 et 0,1 et que la valeur de top-P est supérieure à `0.5`, le modèle sélectionne A ou B comme jeton suivant en utilisant la température et exclut C comme candidat. Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Spécifie une liste de chaînes qui indiquent au modèle d'arrêter de générer du texte si l'une des chaînes est détectée dans la réponse. Si une chaîne apparaît plusieurs fois dans la réponse, celle-ci effectue une troncation lors de la première rencontre. Les chaînes sont sensibles à la casse. Par exemple, si la réponse suivante est renvoyée lorsque `stopSequences` n'est pas spécifié : `public static string reverse(string myString)` La réponse renvoyée avec `stopSequences` défini sur `["Str", "reverse"]` est alors la suivante : `public static string`	`default: []`
`groundingConfig`	L'ancrage vous permet de faire référence à des données spécifiques lorsque vous utilisez des modèles de langage. Lorsque vous ancrez un modèle, celui-ci peut utiliser des données internes, confidentielles et spécifiques de votre dépôt comme référentiel et inclure ces données dans la réponse. Seuls les data stores de Vertex AI Search sont compatibles.	Le chemin d'accès doit respecter le format suivant : `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	Nombre de variantes de réponse à renvoyer. Pour chaque requête, vous êtes facturé pour les jetons de sortie de tous les candidats, mais vous ne payez qu'une seule fois pour les jetons d'entrée. La spécification de plusieurs candidats est une fonctionnalité bêta qui fonctionne avec `generateContent` (`streamGenerateContent` n'est pas disponible). Les modèles suivants sont compatibles : Gemini 1.5 Flash : `1`-`8` (par défaut : `1`) Gemini 1.5 Pro : `1`-`8` (par défaut : `1`) Gemini 1.0 Pro : `1`-`8` (par défaut : `1`)	`1–4` `Default: 1`
`logprobs`	Renvoie les probabilités logarithmiques des principaux jetons candidats à chaque étape de génération. Les jetons et les probabilités logarithmiques choisis par le modèle sont toujours renvoyés à chaque étape, et peuvent ne pas figurer dans la liste des principaux candidats. Spécifiez le nombre de candidats à renvoyer à l'aide d'une valeur entière comprise entre `1` et `5`.	`0-5`
`frequencyPenalty`	Les valeurs positives pénalisent les jetons qui apparaissent de manière répétée dans le texte généré, ce qui réduit la probabilité de répétition du contenu. Les valeurs acceptées sont `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Les valeurs positives pénalisent les jetons qui apparaissent déjà dans le texte généré, ce qui augmente la probabilité de générer un contenu plus diversifié. Les valeurs acceptées sont `-2.0`—`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	Lorsque la graine est fixée à une valeur spécifique, le modèle s'efforce de fournir la même réponse pour les requêtes répétées. La sortie déterministe n'est pas garantie. De plus, la modification du modèle ou des paramètres, comme la température, peut entraîner des variations dans la réponse, même si vous utilisez la même valeur de graine. Par défaut, une valeur de graine aléatoire est utilisée. Il s'agit d'une fonctionnalité en preview.	`Optional`

Exemple de requête

REST

Pour tester un chat écrit à l'aide de l'API Vertex AI, envoyez une requête POST au point de terminaison du modèle de l'éditeur.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : l'ID de votre projet.

Pour les autres champs, consultez le tableau Corps de la requête ci-dessous.

Méthode HTTP et URL :

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict

Corps JSON de la requête :

{
  "instances": [{
      "context":  "CONTEXT",
      "examples": [
       { 
          "input": {"content": "EXAMPLE_INPUT"},
          "output": {"content": "EXAMPLE_OUTPUT"}
       }],
      "messages": [
       { 
          "author": "AUTHOR",
          "content": "CONTENT",
       }],
   }],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "topP": TOP_P,
    "topK": TOP_K
  }
}

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict"

PowerShell

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/chat-bison:predict" | Select-Object -Expand Content

Vous devriez recevoir une réponse JSON semblable à l'exemple de réponse.

Python

Pour savoir comment installer ou mettre à jour le SDK Vertex AI pour Python, consultez la section Installer le SDK Vertex AI pour Python. Pour en savoir plus, consultez la documentation de référence de l'API Python.



def send_chat() -> str:
    from vertexai.language_models import ChatModel, InputOutputTextPair

    chat_model = ChatModel.from_pretrained("chat-bison@002")

    parameters = {
        "temperature": 0.2,
        "max_output_tokens": 256,
        "top_p": 0.95,
        "top_k": 40,
    }

    chat = chat_model.start_chat(
        context="My name is Miles. You are an astronomer, knowledgeable about the solar system.",
        examples=[
            InputOutputTextPair(
                input_text="How many moons does Mars have?",
                output_text="The planet Mars has two moons, Phobos and Deimos.",
            ),
        ],
    )

    response = chat.send_message(
        "How many planets are there in the solar system?", **parameters
    )
    print(response.text)

    return response.text

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Node.js.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};
const publisher = 'google';
const model = 'chat-bison@001';

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function callPredict() {
  // Configure the parent resource
  const endpoint = `projects/${project}/locations/${location}/publishers/${publisher}/models/${model}`;

  const prompt = {
    context:
      'My name is Miles. You are an astronomer, knowledgeable about the solar system.',
    examples: [
      {
        input: {content: 'How many moons does Mars have?'},
        output: {
          content: 'The planet Mars has two moons, Phobos and Deimos.',
        },
      },
    ],
    messages: [
      {
        author: 'user',
        content: 'How many planets are there in the solar system?',
      },
    ],
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.2,
    maxOutputTokens: 256,
    topP: 0.95,
    topK: 40,
  };
  const parameters = helpers.toValue(parameter);

  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  console.log('Get chat prompt response');
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const prediction of predictions) {
    console.log(`\t\tPrediction : ${JSON.stringify(prediction)}`);
  }
}

callPredict();

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI Java.


import com.google.cloud.aiplatform.v1beta1.EndpointName;
import com.google.cloud.aiplatform.v1beta1.PredictResponse;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1beta1.PredictionServiceSettings;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

// Send a Predict request to a large language model to test a chat prompt
public class PredictChatPromptSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String instance =
        "{\n"
            + "   \"context\":  \"My name is Ned. You are my personal assistant. My favorite movies"
            + " are Lord of the Rings and Hobbit.\",\n"
            + "   \"examples\": [ { \n"
            + "       \"input\": {\"content\": \"Who do you work for?\"},\n"
            + "       \"output\": {\"content\": \"I work for Ned.\"}\n"
            + "    },\n"
            + "    { \n"
            + "       \"input\": {\"content\": \"What do I like?\"},\n"
            + "       \"output\": {\"content\": \"Ned likes watching movies.\"}\n"
            + "    }],\n"
            + "   \"messages\": [\n"
            + "    { \n"
            + "       \"author\": \"user\",\n"
            + "       \"content\": \"Are my favorite movies based on a book series?\"\n"
            + "    }]\n"
            + "}";
    String parameters =
        "{\n"
            + "  \"temperature\": 0.3,\n"
            + "  \"maxDecodeSteps\": 200,\n"
            + "  \"topP\": 0.8,\n"
            + "  \"topK\": 40\n"
            + "}";
    String project = "YOUR_PROJECT_ID";
    String publisher = "google";
    String model = "chat-bison@001";

    predictChatPrompt(instance, parameters, project, publisher, model);
  }

  static void predictChatPrompt(
      String instance, String parameters, String project, String publisher, String model)
      throws IOException {
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings)) {
      String location = "us-central1";
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      Value.Builder instanceValue = Value.newBuilder();
      JsonFormat.parser().merge(instance, instanceValue);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue.build());

      Value.Builder parameterValueBuilder = Value.newBuilder();
      JsonFormat.parser().merge(parameters, parameterValueBuilder);
      Value parameterValue = parameterValueBuilder.build();

      PredictResponse predictResponse =
          predictionServiceClient.predict(endpointName, instances, parameterValue);
      System.out.println("Predict Response");
    }
  }
}

Corps de la réponse

{
  "predictions": [
    {
      "candidates": [
        {
          "author": string,
          "content": string
        }
      ],
      "citationMetadata": {
        "citations": [
          {
            "startIndex": integer,
            "endIndex": integer,
            "url": string,
            "title": string,
            "license": string,
            "publicationDate": string
          }
        ]
      },
      "logprobs": {
        "tokenLogProbs": [ float ],
        "tokens": [ string ],
        "topLogProbs": [ { map<string, float> } ]
      },
      "safetyAttributes": {
        "categories": [ string ],
        "blocked": false,
        "scores": [ float ],
        "errors": [ int ]
      }
    }
  ],
  "metadata": {
    "tokenMetadata": {
      "input_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      },
      "output_token_count": {
        "total_tokens": integer,
        "total_billable_characters": integer
      }
    }
  }
}

Élément de réponse	Description
`content`	Contenu textuel du message de chat.
`candidates`	Résultat de chat généré à partir du message donné.
`categories`	Noms à afficher des catégories d'attributs de sécurité associées au contenu généré. L'ordre correspond aux scores.
`author`	Balise de l'auteur pour le tour.
`scores`	Les scores de confiance de chaque catégorie, une valeur supérieure, signifie une confiance plus élevée.
`blocked`	Option indiquant si l'entrée ou la sortie du modèle a été bloquée.
`startIndex`	Index dans le résultat de la prédiction où la citation commence (inclus). Doit être supérieur ou égal à 0 et < end_index.
`endIndex`	Index de la sortie de prédiction où la citation se termine (exclusive). Doit être > start_index et < len(sortie).
`url`	URL associée à cette citation. Si elle est présente, cette URL renvoie vers la page Web de la source de la citation. Les URL possibles incluent les sites d'actualités, les dépôts GitHub, etc.
`title`	Titre associé à cette citation. Si elle est présente, il s'agit du titre de la source de cette citation. Les titres possibles sont les titres des actualités et des livres, etc.
`license`	Licence associée à cette référence. Se elle est présente, il s'agit de la licence de la source de cette citation. Les licences possibles incluent les licences de code, par exemple licence MIT.
`publicationDate`	Date de publication associée à cette citation. Le cas échéant, il s'agit de la date à laquelle la source de cette citation a été publiée. Les formats possibles sont AAAA, AAAA-MM, AAAA-MM-JJ.
`safetyAttributes`	Ensemble de catégories et de leurs scores de confiance associés. Le mappage 1-1 correspond à `candidates`.
`input_token_count`	Nombre de jetons d'entrée. Il s'agit du nombre total de jetons pour l'ensemble des messages, exemples et contextes.
`output_token_count`	Nombre de jetons de sortie. Il s'agit du nombre total de jetons dans `content` pour tous les candidats dans la réponse.
`tokens`	Jetons échantillonnés.
`tokenLogProbs`	Probabilités logarithmiques des journaux échantillonnés.
`topLogProb`	Jetons candidats les plus probables et leurs probabilités logarithmiques à chaque étape.
`logprobs`	Résultats du paramètre "logprobs". Le mappage 1-1 correspond aux candidats.

Exemple de réponse

{
  "predictions": [
    {
      "citationMetadata": {
        "citations": []
      },
      "safetyAttributes": {
        "scores": [
          0.1
        ],
        "categories": [
          "Finance"
        ],
        "blocked": false
      },
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ]
    }
  ]
}

Réponse en streaming des modèles Generative AI

Les paramètres sont identiques pour les requêtes en streaming et sans streaming vers les API.

Pour afficher des exemples de requêtes et de réponses de code à l'aide de l'API REST, consultez la page Exemples d'utilisation de l'API REST en streaming.

Pour afficher des exemples de requêtes et de réponses de code à l'aide du SDK Vertex AI pour Python, consultez la page Exemples d'utilisation du SDK Vertex AI pour Python pour le streaming.