Prova i modelli Gemini 1.5, i nostri più recenti modelli multimodali di Vertex AI, e scopri cosa puoi creare con una finestra di contesto dei token da 1 milione. Prova i modelli Gemini 1.5, i nostri più recenti modelli multimodali di Vertex AI, e scopri cosa puoi creare con una finestra di contesto dei token da 1 milione.

Questa pagina è stata tradotta dall'API Cloud Translation.

Chat di codice

Codey per la chat di codice (codechat-bison) è il nome del modello che supporta la chat di codice. È un modello di base che supporta conversazioni multi-turno specializzate per il codice. Il modello consente agli sviluppatori di chattare con un chatbot per ricevere assistenza in caso di domande relative al codice. L'API Code Chat viene utilizzata per interfacciarsi con il modello Codey for Code Chat.

Codey per la chat di codice è ideale per le attività di codice che vengono completate con interazioni che consentono di interagire in una conversazione continua. Per le attività di codice che richiedono una singola interazione, utilizza l'API per il completamento del codice o l'API per la generazione di codice.

Per esplorare questo modello nella console, consulta la scheda del modello Codey per la chat di codice in Model Garden.
Vai a Model Garden

Casi d'uso

Ecco alcuni casi d'uso comuni per la chat di codice:

Ricevi assistenza per il codice: ricevi assistenza per domande sul codice, ad esempio su un'API, sulla sintassi in un linguaggio di programmazione supportato o sulla versione di una libreria necessaria per il codice che stai scrivendo.
Debug: ricevi assistenza per il debug di codice che non viene compilato o che contiene un bug.
Documentazione: ricevi assistenza per comprendere il codice in modo da documentarlo in modo accurato.
Scopri di più sul codice: ricevi assistenza per imparare il codice che non conosci.

Richiesta HTTP

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

Versioni modello

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

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

La seguente tabella contiene le versioni del modello stabile disponibili:

modello di chat-bisonte	Data di uscita	Data di interruzione
codechat-bison@002	6 dicembre 2023	9 ottobre 2024
codechat-bison@001	29 giugno 2023	6 luglio 2024

Per saperne di più, consulta Versioni e ciclo di vita dei modelli.

Corpo della richiesta

{
  "instances": [
    {
      "context": string,
      "messages": [
        {
          "content": string,
          "author": string
        }
      ]
    }
  ],
  "parameters":{
    "temperature": number,
    "maxOutputTokens": integer,
    "candidateCount": integer,
    "logprobs": integer,
    "presencePenalty": float,
    "frequencyPenalty": float,
    "seed": integer
  }
}

Di seguito sono riportati i parametri per il modello di chat di codice denominato codechat-bison. Il modello codechat-bison è uno dei modelli di Codey. Puoi utilizzare questi parametri per ottimizzare la richiesta di una conversazione con chatbot sul codice. Per maggiori informazioni, consulta Panoramica dei modelli di codice e Creare prompt per chattare sul codice.

Parametro	Description	Valori accettati
`context`	Testo che deve essere fornito prima al modello per fondare la risposta.	Testo
`messages` (obbligatorio)	Cronologia delle conversazioni fornita al modello in un modulo strutturato di autore alternativo. I messaggi vengono visualizzati in ordine cronologico: dal meno recente, dal più recente all'ultimo. 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.	List[Structured Message] "author": "user", "content": "user message"
`temperature` (facoltativo)	La temperatura viene utilizzata per il campionamento durante la generazione delle risposte. 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 le 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 dato prompt sono per lo più deterministiche, ma è ancora possibile una piccola variazione.	`0.0–1.0` `Default: 0.2`
`maxOutputTokens` (facoltativo)	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`
`candidateCount` (facoltativo)	Il numero di varianti della risposta da restituire.	`1-4` `Default: 1`
`logprobs` (facoltativo)	Restituisce i primi `logprobs` token candidati con più probabilità con le rispettive probabilità di log a ogni passaggio di generazione. Vengono sempre restituiti i token scelti e le relative probabilità di log in ogni passaggio. Il token scelto potrebbe trovarsi o meno tra i primi `logprobs` candidati con maggiore probabilità.	`0-5`
`frequencyPenalty` (facoltativo)	I valori positivi penalizzano i token che appaiono ripetutamente nel testo generato, diminuendo la probabilità di ripetizione di contenuti. I valori accettati sono `-2.0`-`2.0`.	`Minimum value: -2.0 Maximum value: 2.0`
`presencePenalty` (facoltativo)	I valori positivi penalizzano i token già presenti nel testo generato, aumentando la probabilità di generare contenuti più diversificati. I valori accettati sono `-2.0`-`2.0`.	`Minimum value: -2.0 Maximum value: 2.0`
`seed`	Il decoder genera un rumore casuale con un generatore di numeri pseudo-casuali, il rumore di temperatura * viene aggiunto ai logit prima del campionamento. Il generatore di numeri pseudo-casuali (prng) prende un seme come input, genera lo stesso output con lo stesso seed. Se il seed non è impostato, il seed utilizzato nel decoder non sarà deterministico, quindi il rumore casuale generato non sarà deterministico. Se il seed è impostato, il rumore casuale generato sarà deterministico.	`Optional`

Richiesta di esempio

REST

Per testare un prompt 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.

Corpo della richiesta

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

{
  "instances": [
    {
      "messages": [
        {
          "author": "AUTHOR",
          "content": "CONTENT"
        }
      ]
    }
  ],
  "parameters": {
    "temperature": TEMPERATURE,
    "maxOutputTokens": MAX_OUTPUT_TOKENS,
    "candidateCount": CANDIDATE_COUNT
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Nota: il comando seguente 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 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/codechat-bison:predict"

PowerShell

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

$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/codechat-bison:predict" | Select-Object -Expand Content

Dovresti ricevere una risposta in formato 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 CodeChatModel

# TODO developer - override these parameters as needed:
parameters = {
    "temperature": temperature,  # Temperature controls the degree of randomness in token selection.
    "max_output_tokens": 1024,  # Token limit determines the maximum amount of text output.
}

code_chat_model = CodeChatModel.from_pretrained("codechat-bison@001")
chat = code_chat_model.start_chat()

response = chat.send_message(
    "Please help write a function to calculate the min of two numbers", **parameters
)
print(f"Response from Model: {response.text}")

Node.js

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

Per eseguire l'autenticazione in Vertex AI, configura le 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 = 'codechat-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}`;

  // Learn more about creating prompts to work with a code chat model at:
  // https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-chat-prompts
  const prompt = {
    messages: [
      {
        author: 'user',
        content: 'Hi, how are you?',
      },
      {
        author: 'system',
        content: 'I am doing good. What can I help you in the coding world?',
      },
      {
        author: 'user',
        content:
          'Please help write a function to calculate the min of two numbers',
      },
    ],
  };
  const instanceValue = helpers.toValue(prompt);
  const instances = [instanceValue];

  const parameter = {
    temperature: 0.5,
    maxOutputTokens: 1024,
  };
  const parameters = helpers.toValue(parameter);

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

  // Predict request
  const [response] = await predictionServiceClient.predict(request);
  console.log('Get code chat 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 di Java riportate nella guida rapida di Vertex AI sull'utilizzo delle librerie client. Per maggiori informazioni, consulta la documentazione di riferimento dell'API Java Vertex AI.


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

public class PredictCodeChatSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace this variable before running the sample.
    String project = "YOUR_PROJECT_ID";

    // Learn more about creating prompts to work with a code chat model at:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/code/code-chat-prompts
    String instance =
        "{ \"messages\": [\n"
            + "{\n"
            + "  \"author\": \"user\",\n"
            + "  \"content\": \"Hi, how are you?\"\n"
            + "},\n"
            + "{\n"
            + "  \"author\": \"system\",\n"
            + "  \"content\": \"I am doing good. What can I help you in the coding world?\"\n"
            + " },\n"
            + "{\n"
            + "  \"author\": \"user\",\n"
            + "  \"content\":\n"
            + "     \"Please help write a function to calculate the min of two numbers.\"\n"
            + "}\n"
            + "]}";
    String parameters = "{\n" + "  \"temperature\": 0.5,\n" + "  \"maxOutputTokens\": 1024\n" + "}";
    String location = "us-central1";
    String publisher = "google";
    String model = "codechat-bison@001";

    predictCodeChat(instance, parameters, project, location, publisher, model);
  }

  // Use a code chat model to generate a code function
  public static void predictCodeChat(
      String instance,
      String parameters,
      String project,
      String location,
      String publisher,
      String model)
      throws IOException {
    final String endpoint = String.format("%s-aiplatform.googleapis.com:443", location);
    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).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)) {
      final EndpointName endpointName =
          EndpointName.ofProjectLocationPublisherModelName(project, location, publisher, model);

      Value instanceValue = stringToValue(instance);
      List<Value> instances = new ArrayList<>();
      instances.add(instanceValue);

      Value parameterValue = stringToValue(parameters);

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

  // Convert a Json string to a protobuf.Value
  static Value stringToValue(String value) throws InvalidProtocolBufferException {
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(value, builder);
    return builder.build();
  }
}

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 ]
      },
      "score": float
    }
  ]
}

Elemento risposta	Descrizione
`author`	Un `string` che indica l'autore di una risposta via chat.
`blocked`	Un flag `boolean` associato a un attributo di sicurezza che indica se l'input o l'output del modello è stato bloccato. Se `blocked` è `true`, il campo `errors` nella risposta contiene uno o più codici di errore. Se `blocked` è `false`, la risposta non include il campo `errors`.
`categories`	Un elenco di nomi delle categorie di attributi di sicurezza associati ai contenuti generati. L'ordine dei punteggi nel parametro `scores` corrisponde all'ordine delle categorie. Ad esempio, il primo punteggio nel parametro `scores` indica la probabilità che la risposta violi la prima categoria nell'elenco `categories`.
`content`	I contenuti di una risposta via chat.
`endIndex`	Un numero intero che specifica dove termina una citazione con `content`.
`errors`	Un array di codici di errore. Il campo della risposta `errors` viene incluso nella risposta solo quando il campo `blocked` nella risposta è `true`. Per informazioni sulla comprensione dei codici di errore, consulta Errori di sicurezza.
`license`	La licenza associata a una citazione.
`publicationDate`	La data di pubblicazione di una citazione. I formati validi sono `YYYY`, `YYYY-MM` e `YYYY-MM-DD`.
`safetyAttributes`	Un array di attributi di sicurezza. L'array contiene un attributo di sicurezza per ogni candidato di risposta.
`score`	Un valore `float` inferiore a zero. Più elevato è il valore di `score`, maggiore è l'affidabilità del modello nella sua risposta.
`scores`	Un array di valori `float`. Ogni valore è un punteggio che indica la probabilità che la risposta violi la categoria di sicurezza in base a cui è stata confrontata. Più basso è il valore, più sicuro il modello prende in considerazione la risposta. L'ordine dei punteggi nell'array corrisponde all'ordine degli attributi di sicurezza nell'elemento di risposta `categories`.
`startIndex`	Un numero intero che specifica il punto in cui inizia una citazione nel contenuto.
`title`	Il titolo della fonte della citazione. Esempi di titoli di origine potrebbero essere quelli di un articolo o di un libro.
`url`	L'URL della fonte di una citazione. Un URL può essere, ad esempio, un sito web di notizie o un repository GitHub.
`tokens`	I token campionati.
`tokenLogProbs`	Le probabilità di log dei token campionati.
`topLogProbs`	I token candidati più probabili e le relative probabilità di log in ogni passaggio.
`logprobs`	Risultati del parametro "logprobs". Mappatura 1-1 ai "candidati".

Esempio di risposta

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

Risposta in streaming dai modelli di IA generativa

I parametri sono gli stessi per le richieste in modalità flusso e non in modalità flusso alle API.

Per visualizzare le richieste di codice e le risposte di esempio utilizzando l'API REST, consulta Esempi di utilizzo dell'API REST per i flussi di dati.

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 di dati.