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 le attività di testo che possono essere completate con una risposta dell'API (senza la necessità di una conversazione continua), utilizza il modello di testo.

Per esplorare questo modello nella console, consulta la scheda del modello PaLM 2 per Chat in 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: indica al modello di interagire con i clienti come agente di call center con parametri specifici su come rispondere e cosa non dire
Personaggi e personaggi: indica al modello di rispondere nello stile di una persona specifica ("…nello stile di Shakespeare").
Compagno del sito web: crea un assistente conversazionale per shopping, 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 un numero di versione, ad esempio chat-bison.

Per utilizzare una versione stabile del modello, 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 stabili del modello 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 accettati
`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 delle conversazioni fornita al modello in un formato strutturato con autore alternativo. I messaggi vengono visualizzati in ordine cronologico: prima i più vecchi, poi i più recenti. Quando la cronologia dei messaggi fa sì che l'input superi la lunghezza massima, i messaggi meno recenti vengono rimossi finché 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 risposte meno aperte o creative, mentre le temperature più alte possono portare a risultati più diversificati o creativi. Con una temperatura pari a `0` viene sempre selezionato il token con la probabilità più alta. In questo caso, le risposte per un determinato prompt sono per lo più deterministiche, ma è comunque possibile una piccola variazione. Se il modello restituisce una risposta troppo generica, troppo breve o fornisce una risposta di riserva, 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 e il token finale viene selezionato utilizzando il campionamento con 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 viene visualizzata più volte nella 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 basamenti un modello, questo può fare riferimento a dati interni, riservati e comunque specifici del tuo repository e includerli 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 token di output di tutti i candidati, ma solo una 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. Il token scelto dal modello potrebbe non essere uguale al token candidato principale in ogni passaggio. 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. Il valore minimo è `-2.0`. Il valore massimo è fino a, ma non incluso, `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. Il valore minimo è `-2.0`. Il valore massimo può arrivare fino a `2.0`, escluso.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	Quando il seed è fissato a un valore specifico, il modello fa del suo meglio per fornire la stessa risposta per richieste ripetute. L'output deterministico non è garantito. Inoltre, la modifica del modello o delle impostazioni dei parametri, ad esempio la temperatura, può causare variazioni nella risposta anche se utilizzi lo stesso valore seed. Per impostazione predefinita, viene utilizzato 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, apporta le seguenti sostituzioni:

PROJECT_ID: il tuo ID progetto.

Per altri campi, consulta la tabella Corpo 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 seguente comando presuppone che tu abbia eseguito l'accesso all'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. 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:

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, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

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_session = 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_session.send_message(
    "How many planets are there in the solar system?", **parameters
)
print(response.text)
# Example response:
# There are eight planets in the solar system:
# Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune.

Node.js

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

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori 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 Response	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 indicatore che indica se l'input o l'output del modello è stato bloccato.
`startIndex`	Indice nell'output della previsione in cui inizia la citazione (incluso). Deve essere maggiore o uguale a 0 e minore di end_index.
`endIndex`	Indice nell'output di previsione in cui termina la citazione (esclusivo). Deve essere maggiore di start_index e minore di len(output).
`url`	URL associato a questa citazione. Se presente, questo URL rimanda alla pagina web della fonte di questa citazione. I 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 possibili titoli includono titoli di notizie, libri e così via.
`license`	Licenza associata a questa recita. 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à. 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. Si tratta del numero totale di token in `content` in tutti i candidati nella risposta.
`tokens`	I token campionati.
`tokenLogProbs`	Le probabilità in logaritmo dei token campionati.
`topLogProb`	I token candidati più probabili e le relative probabilità in logaritmo in ogni passaggio.
`logprobs`	Risultati del parametro "logprobs". Mappatura 1:1 a "candidates".

Risposta di esempio

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

Streaming della 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 campione che utilizzano l'API REST, consulta Esempi di utilizzo dell'API REST per lo streaming.

Per visualizzare richieste e risposte di codice campione che utilizzano l'SDK Vertex AI per Python, consulta Esempi di utilizzo dell'SDK Vertex AI per Python per lo streaming.