Questa pagina è stata tradotta dall'API Cloud Translation.

Chat di testo

Il modello di base PaLM 2 per Chat (chat-bison) è un modello linguistico di grandi dimensioni (LLM) che eccelle nella comprensione del linguaggio, nella generazione di linguaggio e nelle conversazioni. Questo modello di chat è ottimizzato per condurre conversazioni multi-turno naturali ed è ideale per attività di testo relative a codice che richiedono interazioni reciproche.

Per attività di testo che possono essere completate con un'unica risposta dell'API (senza il bisogno di una conversazione continua), utilizza il modello di testo.

Per esplorare questo modello nella console, consulta la scheda del modello PaLM 2 per Chat nella Model Garden.
Vai a Model Garden

Casi d'uso

Assistenza clienti: indica al modello di rispondere come agenti dell'assistenza clienti che parlano solo del prodotto della tua azienda
Assistenza tecnica: fornisci al modello una chiamata per interagire con i clienti dell'agente del centro con parametri specifici su come rispondere e cosa non dire
Utenti tipo e personaggi: indica al modello di rispondere nello stile di una una persona specifica ("...nello stile di Shakespeare")
Companion nel sito web: crea un assistente conversazionale per lo shopping, i viaggi e altri casi d'uso

Per scoprire di più, vedi Progettare prompt di Chat.

Richiesta HTTP

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

Per ulteriori informazioni, consulta il metodo predict.

Versioni modello

Per utilizzare la versione più recente del modello, specifica il nome del modello senza numero di versione, ad esempio chat-bison.

Per utilizzare una versione del modello stabile, specifica il numero di versione del modello, ad esempio chat-bison@002. Ogni versione stabile è disponibile per sei mesi dopo la data di rilascio della versione stabile successiva.

La tabella seguente contiene le versioni dei modelli stabili disponibili:

modello chat-bison	Data di uscita	Data di ritiro
chat-bison@002	6 dicembre 2023	9 aprile 2025

Per ulteriori informazioni, consulta Versioni e ciclo di vita dei modelli.

Corpo della richiesta

{
  "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
  }
}

Per le chiamate all'API Chat, context, examples e messages si combinano per formare il prompt. La tabella seguente mostra i parametri che devi configurare per l'API Vertex AI PaLM per il testo:

Parametro	Descrizione	Valori accettabili
`context` (facoltativo)	Il contesto determina il modo in cui risponde il modello durante la conversazione. Ad esempio, puoi utilizzare il contesto per specificare le parole che il modello può o non può utilizzare, gli argomenti su cui deve concentrarsi o che deve evitare oppure il formato o lo stile della risposta.	Testo
`examples` (facoltativo)	Esempi per consentire al modello di imparare a rispondere alla conversazione.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`messages` (obbligatorio)	Cronologia della conversazione fornita al modello in un formato strutturato di autore alternativo. I messaggi vengono visualizzati in ordine cronologico: dal meno recente al più recente. Quando la cronologia dei messaggi fa sì che l'input superi la lunghezza massima, i messaggi meno recenti vengono rimossi fino a quando l'intero prompt non rientra nel limite consentito.	[{ "author": "user", "content": "user message" }]
`temperature`	La temperatura viene utilizzata per il campionamento durante la generazione della risposta, che si verifica quando vengono applicati `topP` e `topK`. La temperatura controlla il grado di casualità nella selezione dei token. Le temperature più basse sono ideali per prompt che richiedono una risposta meno aperta o creativa, mentre temperature più alte possono portare a risultati più diversificati o creativi. Una temperatura pari a `0` significa che vengono sempre selezionati i token con la probabilità più alta. In questo caso, le risposte per un determinato sono per lo più deterministici, ma è ancora possibile una piccola variazione. Se il modello restituisce una risposta troppo generica, troppo breve, oppure fornisce una risposta di riserva di risposta, prova ad aumentare la temperatura.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Numero massimo di token che possono essere generati nella risposta. Un token equivale a circa quattro caratteri. 100 token corrispondono a circa 60-80 parole. Specifica un valore più basso per risposte più brevi e un valore più alto per risposte potenzialmente più lunghe.	`1–2048` `Default: 1024`
`topK`	Top-K cambia il modo in cui il modello seleziona i token per l'output. Un top-K pari a `1` indica che il token successivo selezionato è il più probabile tra tutti i token nel vocabolario del modello (chiamato anche decodifica greedy). Un top-K pari a `3` indica invece che il token successivo viene selezionato tra i tre token più probabili utilizzando la temperatura. Per ogni fase di selezione dei token, vengono campionati i token Top-K con le probabilità più elevate. Quindi i token vengono ulteriormente filtrati in base a top-p con il token finale selezionato utilizzando il campionamento della temperatura. Specifica un valore più basso per risposte meno casuali e un valore più alto per risposte più casuali.	`1–40` `Default: 40`
`topP`	Top-P cambia il modo in cui il modello seleziona i token per l'output. I token vengono selezionati dal più probabile (vedi Top-K) al meno probabile finché la somma delle loro probabilità non corrisponde al valore di Top-P. Ad esempio, se i token A, B e C hanno una probabilità di 0,3, 0,2 e 0,1 e il valore di top-P è `0.5`, il modello seleziona A o B come token successivo utilizzando la temperatura ed esclude C come candidato. Specifica un valore più basso per risposte meno casuali e un valore più alto per risposte più casuali.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Specifica un elenco di stringhe che indica al modello di interrompere la generazione di testo se viene rilevata una delle stringhe nella risposta. Se una stringa è presente in più volte in una risposta, la risposta viene troncata nel punto in cui viene rilevata per la prima volta. Le stringhe sono sensibili alle maiuscole. Ad esempio, se la seguente è la risposta restituita quando `stopSequences` non è specificato: `public static string reverse(string myString)` La risposta restituita con `stopSequences` impostato su `["Str", "reverse"]` è: `public static string`	`default: []`
`groundingConfig`	La messa a terra ti consente di fare riferimento a dati specifici quando utilizzi i modelli linguistici. Quando basato su un modello, questo può fare riferimento a dati interni, riservati e comunque specifici repository e includere i dati nella risposta. Sono supportati solo i datastore di Vertex AI Search.	Il percorso deve avere il seguente formato: `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	Il numero di varianti di risposta da restituire. Per ogni richiesta ti vengono addebitati i costi i token di output di tutti i candidati, ma vengono addebitati una sola volta per i token di input. La specifica di più candidati è una funzionalità di anteprima che funziona con `generateContent` (`streamGenerateContent` non è supportato). Sono supportati i seguenti modelli: Gemini 1.5 Flash: `1`-`8`, valore predefinito: `1` Gemini 1.5 Pro: `1`-`8`, valore predefinito: `1` Gemini 1.0 Pro: `1`-`8`, valore predefinito: `1`	`1–4` `Default: 1`
`logprobs`	Restituisce le probabilità logaritmiche dei token candidati principali in ogni fase di generazione. I token e le probabilità logaritmiche scelti dal modello vengono sempre restituiti in ogni fase, ma potrebbero non essere presenti nell'elenco dei principali candidati. Specifica il numero di candidati da restituire utilizzando un valore intero nell'intervallo `1`-`5`.	`0-5`
`frequencyPenalty`	I valori positivi penalizzano i token che appaiono ripetutamente nel testo generato, diminuendo la probabilità di ripetere i contenuti. I valori accettati sono `-2.0`-`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	I valori positivi penalizzano i token già presenti nel testo generato, aumentando la probabilità di generare contenuti più diversi. I valori accettati sono `-2.0`-`2.0`.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	Quando il seed è fissato a un valore specifico, il modello fa il possibile per fornire la stessa risposta per le richieste ripetute. L'output deterministico non è garantito. Inoltre, la modifica delle impostazioni del modello o dei parametri, come la temperatura, può causano variazioni nella risposta anche se utilizzi lo stesso valore seed. Di predefinito, viene usato un valore seed casuale. Questa è una funzionalità in anteprima.	`Optional`

Richiesta di esempio

REST

Per testare una chat di testo utilizzando l'API Vertex AI, invia una richiesta POST all'endpoint del modello del publisher.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.

Per gli altri campi, consulta la tabella Testo della richiesta di seguito.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

{
  "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
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: Il comando seguente presuppone che tu abbia eseguito l'accesso a l'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando gcloud di Google. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list

Salva il corpo della richiesta in un file denominato request.json. ed esegui questo comando:

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

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

$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

Dovresti ricevere una risposta JSON simile alla risposta di esempio.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta documentazione di riferimento dell'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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Node.js Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * 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

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta API Java Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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");
    }
  }
}

Corpo della risposta

{
  "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
      }
    }
  }
}

Elemento risposta	Descrizione
`content`	Contenuto del testo del messaggio della chat.
`candidates`	Il risultato della chat generato dal messaggio specificato.
`categories`	I nomi visualizzati delle categorie di attributi di sicurezza associati ai contenuti generati. L'ordine corrisponde ai punteggi.
`author`	Tag autore per la svolta.
`scores`	I punteggi di affidabilità di ogni categoria. Un valore più alto indica una maggiore affidabilità.
`blocked`	Un flag che indica se l'input o l'output del modello è stato bloccato.
`startIndex`	Indice nell'output della previsione dove inizia la citazione (inclusa). Deve essere maggiore o uguale a 0 e minore di end_index.
`endIndex`	Indice nell'output della previsione dove termina la citazione (esclusa). Deve avere > start_index e < len(output).
`url`	URL associato a questa citazione. Se presente, questo URL rimanda alla pagina web della fonte di questa citazione. Possibili URL includono siti web di notizie, repository GitHub e così via.
`title`	Titolo associato a questa citazione. Se presente, si riferisce al titolo della fonte di questa citazione. I titoli possibili includono quelli di notizie, libri e così via.
`license`	Licenza associata a questo suggerimento. Se presente, si riferisce alla licenza della fonte di questa citazione. Le licenze possibili includono licenze di codice, ad esempio la licenza MIT.
`publicationDate`	Data di pubblicazione associata a questa citazione. Se presente, si riferisce alla data di pubblicazione della fonte di questa citazione. I formati possibili sono AAAA, AAAA-MM, AAAA-MM-GG.
`safetyAttributes`	Una raccolta di categorie e i relativi punteggi di affidabilità associati. Mappatura 1:1 a `candidates`.
`input_token_count`	Numero di token di input. Si tratta del numero totale di token in tutti i messaggi, gli esempi e il contesto.
`output_token_count`	Numero di token di output. Questo è il numero totale di token in `content` tra tutti i candidati nella risposta.
`tokens`	I token campionati.
`tokenLogProbs`	I token campionati registrare le probabilità.
`topLogProb`	I token candidati più probabili e le relative probabilità in logaritmo in ogni passaggio.
`logprobs`	Risultati del parametro "logprobs". Mappatura 1:1 sui "candidati".

Risposta di esempio

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

Trasmetti la risposta dai modelli di IA generativa

I parametri sono gli stessi per le richieste in streaming e non in streaming alle API.

Per visualizzare richieste e risposte di codice di esempio che utilizzano l'API REST, consulta Esempi di utilizzo dell'API REST in streaming.

Per visualizzare richieste di codice e risposte di esempio utilizzando l'SDK Vertex AI per Python, consulta Esempi di utilizzo dell'SDK Vertex AI per Python per i flussi.