Teste os modelos do Gemini 1.5, os modelos multimodais mais recentes na Vertex AI, e veja o que é possível criar com uma janela de contexto de até 2 milhões de tokens . Teste os modelos do Gemini 1.5, os modelos multimodais mais recentes na Vertex AI, e veja o que é possível criar com uma janela de contexto de até 2 milhões de tokens.

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 outubro de 2024
codechat-bison@001	29 de junho de 2023	6 de julho de 2024

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.	`1-4` `Default: 1`
`logprobs` (opcional)	Retorna os principais tokens `logprobs` candidatos com as respectivas probabilidades de registro em cada etapa de geração. Os tokens escolhidos e as probabilidades de registro deles em cada etapa são sempre retornados. O token escolhido pode ou não estar entre os principais candidatos de `logprobs`.	`0-5`
`frequencyPenalty` (opcional)	Valores positivos penalizam tokens que aparecem repetidamente no texto gerado, diminuindo a probabilidade de repetir conteúdo. Os valores aceitáveis são: `-2.0`, `2.0`.	`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. Os valores aceitáveis `-2.0`—`2.0`.	`Minimum value: -2.0 Maximum value: 2.0`
`seed`	O decodificador gera ruído aleatório com um gerador de número pseudoaleatório. O ruído de temperatura * é adicionado aos logits antes da amostragem. O gerador de número pseudoaleatório (prng) usa uma seed como entrada e gera a mesma saída com a mesma seed. Se a seed não for definida, a seed usada no decodificador não será determinista. Portanto, o ruído aleatório gerado não será determinista. Se a seed for definida, o ruído aleatório gerado será determinista.	`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": 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

Antes de testar essa amostra, siga as instruções de configuração para Node.js Guia de início rápido da Vertex AI: 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 essa amostra, siga as instruções de configuração para Java Guia de início rápido da Vertex AI: 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 no conteúdo.
`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.