Esta página foi traduzida pela API Cloud Translation.

Chat de código

Codey for Code Chat (codechat-bison) é o nome do modelo que oferece suporte a esse recurso. É um modelo de fundação compatível com conversas de várias rodadas especializadas em código. O modelo permite que os desenvolvedores conversem com um chatbot para receber ajuda com questões relacionadas ao código. A API de chat de código é usada para interagir com o modelo do Codey for Code Chat.

O Codey for Code Chat é ideal para tarefas de código que são concluídas com interações de ida e volta para que você possa se envolver em uma conversa contínua. Para tarefas de código que exigem uma única interação, use a API para preenchimento automático ou a API para geração de código.

Para explorar esse modelo no console, consulte o card de modelo Codey for Code Chat no Model Garden.
Acessar o Model Garden

Casos de uso

Alguns casos comuns usados para bate-papo de código são:

Receba ajuda sobre código: receba ajuda com dúvidas sobre código, como perguntas sobre uma API, sintaxe em uma linguagem de programação compatível ou qual versão de uma biblioteca é necessária para o código que você está escrevendo.
Depuração: receba ajuda com a depuração do código que não é compilado ou contém um bug.
Documentação: receba ajuda para entender o código e documentá-lo com precisão.
Saiba mais sobre códigos: receba ajuda para aprender sobre códigos que você não conhece.

Solicitação HTTP

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

Versões do modelo

Para usar a versão de modelo mais recente, especifique o nome do modelo sem um número de versão. Por exemplo, codechat-bison.

Para usar uma versão de modelo estável, especifique o número da versão de modelo, por exemplo, codechat-bison@002. Cada versão estável está disponível por seis meses após a data de lançamento da versão estável subsequente.

A tabela a seguir contém as versões de modelo estável disponíveis:

modelo codechat-bison	Data da versão	Data de desativação
codechat-bison@002	6 de dezembro de 2023	9 de Abril de 2025

Para mais informações, consulte Versões e ciclo de vida do modelo.

Corpo da solicitação

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

Veja a seguir os parâmetros do modelo de chat de código chamado codechat-bison. O modelo codechat-bison é um dos modelos do Codey. Use esses parâmetros para otimizar o prompt de uma conversa do chatbot sobre o código. Para mais informações, consulte Visão geral dos modelos de código e Criar solicitações para bater papo sobre código.

Parâmetro	Descrição	Valores aceitáveis
`context`	Texto que deve ser fornecido ao modelo primeiro para fundamentar a resposta.	Texto
`messages` (obrigatório)	Histórico de conversas fornecido ao modelo em um formulário estruturado de autor alternativo. As mensagens aparecem em ordem cronológica: a mais antiga primeiro e a mais recente por último. Quando o histórico de mensagens faz com que a entrada exceda o tamanho máximo, as mensagens mais antigas são removidas até que todo o prompt esteja dentro do limite permitido.	List[Structured Message] "author": "user", "content": "user message"
`temperature` (opcional)	A temperatura é usada para amostragem durante a geração da resposta. A temperatura controla o grau de aleatoriedade na seleção do token. Temperaturas mais baixas são boas para solicitações que exigem uma resposta menos aberta ou criativa, enquanto as mais altas podem levar a resultados mais diversos ou criativos. Uma temperatura de `0` significa que os tokens de maior probabilidade são sempre selecionados. Nesse caso, as respostas para uma determinada solicitação são, na maioria, deterministas, mas uma pequena quantidade de variação ainda é possível.	`0.0–1.0` `Default: 0.2`
`maxOutputTokens` (opcional)	Número máximo de tokens que podem ser gerados na resposta. Um token tem cerca de quatro caracteres. 100 tokens correspondem a cerca de 60 a 80 palavras. Especifique um valor mais baixo para respostas mais curtas e um valor mais alto para respostas potencialmente mais longas.	`1–2048` `Default: 1024`
`candidateCount` (opcional)	O número de variações de resposta a serem retornadas. Para cada solicitação, você paga pelos tokens de saída de todos os candidatos, mas são cobrados apenas uma vez pelos tokens de entrada. Especificar vários candidatos é um recurso em fase de pré-lançamento que funciona com `generateContent` (`streamGenerateContent` não é compatível). Os seguintes modelos são compatíveis: Gemini 1.5 Flash: `1`-`8`, padrão: `1` Gemini 1.5 Pro: `1`-`8`, padrão: `1` Gemini 1.0 Pro: `1`-`8`, padrão: `1`	`1-4` `Default: 1`
`logprobs` (opcional)	Retorna as probabilidades de registro dos principais tokens candidatos em cada etapa de geração. O token escolhido pelo modelo pode não ser o mesmo que o principal candidato em cada etapa. Especifique o número de candidatos a serem retornados usando um valor inteiro no intervalo de `1` a `5`.	`0-5`
`frequencyPenalty` (opcional)	Valores positivos penalizam tokens que aparecem repetidamente no texto gerado, diminuindo a probabilidade de repetir conteúdo. O valor mínimo é `-2.0`. O valor máximo é até `2.0`, mas não inclui.	`Minimum value: -2.0 Maximum value: 2.0`
`presencePenalty` (opcional)	Valores positivos penalizam tokens que já aparecem no texto gerado, aumentando a probabilidade de gerar conteúdo mais diversificado. O valor mínimo é `-2.0`. O valor máximo é até `2.0`, mas não inclui.	`Minimum value: -2.0 Maximum value: 2.0`
`seed`	Quando a semente é fixada em um valor específico, o modelo se esforça para fornecer a mesma resposta para solicitações repetidas. A saída determinista não é garantida. Além disso, mudar as configurações do modelo ou do parâmetro, como a temperatura, pode causar variações na resposta, mesmo quando você usa o mesmo valor de semente. Por padrão, um valor de semente aleatório é usado. Este é um recurso em fase de pré-lançamento.	`Optional`

Exemplo de solicitação

REST

Para testar um prompt de texto usando a API Vertex AI, envie uma solicitação POST para o endpoint do modelo do editor.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

PROJECT_ID: o ID do projeto.

Corpo da solicitação

Método 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 da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

curl

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login, ou usando o Cloud Shell, que faz login automaticamente na CLI gcloud. . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

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

Observação: o comando a seguir pressupõe que você fez login na CLI gcloud com sua conta de usuário executando gcloud init ou gcloud auth login . É possível verificar a conta ativa atual executando gcloud auth list.

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir:

$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

Você receberá uma resposta JSON semelhante à amostra de resposta.

Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python.

from vertexai.language_models import CodeChatModel

# TODO developer - override these parameters as needed:
parameters = {
    "temperature": 0.5,  # 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_session = code_chat_model.start_chat()

response = chat_session.send_message(
    "Please help write a function to calculate the min of two numbers", **parameters
)
print(f"Response from Model: {response.text}")
# Response from Model: Sure, here is a function that you can use to calculate the minimum of two numbers:
# ```
# def min(a, b):
#   """
#   Calculates the minimum of two numbers.
#   Args:
#     a: The first number.
# ...

Node.js

Antes de testar esse exemplo, siga as instruções de configuração para Node.js no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 = '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

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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 da resposta

{
  "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 de resposta	Descrição
`author`	Um `string` que indica o autor de uma resposta de bate-papo.
`blocked`	Uma flag `boolean` associada a um atributo de segurança que indica se a entrada ou a saída do modelo foi bloqueada. Se `blocked` for `true`, o campo `errors` na resposta conterá um ou mais códigos de erro. Se `blocked` for `false`, a resposta não conterá o campo `errors`.
`categories`	Uma lista dos nomes das categorias de atributo de segurança associadas ao conteúdo gerado. A ordem das pontuações no parâmetro `scores` corresponde à ordem das categorias. Por exemplo, a primeira pontuação no parâmetro `scores` indica a probabilidade de a resposta violar a primeira categoria na lista `categories`.
`content`	O conteúdo de uma resposta de bate-papo.
`endIndex`	Um número inteiro que especifica onde uma citação termina em `content`.
`errors`	Uma matriz de códigos de erro. O campo de resposta `errors` está incluso na resposta somente quando o campo `blocked` nela é `true`. Para saber mais sobre como entender códigos de erro, consulte Erros de segurança.
`license`	A licença associada a uma citação.
`publicationDate`	A data em que uma citação foi publicada. Os formatos válidos são `YYYY`, `YYYY-MM` e `YYYY-MM-DD`.
`safetyAttributes`	Uma matriz de atributos de segurança. A matriz contém um atributo de segurança para cada candidato a resposta.
`score`	Um valor `float` menor que zero. Quanto maior o valor de `score`, maior a confiança do modelo na resposta.
`scores`	Uma matriz de valores `float`. Cada valor é uma pontuação que indica a probabilidade de a resposta violar a categoria de segurança em que é verificada. Quanto menor o valor, mais seguro o modelo considera a resposta. A ordem das pontuações na matriz corresponde à ordem dos atributos de segurança no elemento de resposta `categories`.
`startIndex`	Um número inteiro que especifica onde começa uma citação em `content`.
`title`	O título de uma fonte de citação. Alguns exemplos de títulos de fontes são os de artigos de notícias ou livros.
`url`	O URL de uma fonte de citação. Exemplos de uma fonte de URL podem ser um site de notícias ou um repositório do GitHub.
`tokens`	Os tokens de amostra.
`tokenLogProbs`	Probabilidades de registro dos tokens de amostra.
`topLogProbs`	Os tokens candidatos mais prováveis e as probabilidades de registro deles em cada etapa.
`logprobs`	Resultados do parâmetro `logprobs`. Mapeamento de 1-1 para "candidatos".

Exemplo de resposta

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

Resposta de stream de modelos de IA generativa

Os parâmetros são os mesmos para streaming e solicitações sem streaming para as APIs.

Para conferir exemplos de solicitações de código e respostas usando a API REST, consulte Exemplos usando a API REST de streaming.

Para conferir exemplos de código de solicitações e respostas usando o SDK da Vertex AI para Python, consulte Exemplos que usam o SDK da Vertex AI para Python para streaming.