Testar solicitações de chat por código

Para projetar um prompt que funcione bem, teste diferentes versões dele e use parâmetros para determinar o que resulta na resposta ideal. É possível testar comandos de maneira programática com as APIs Codey e no console do Google Cloud com o Vertex AI Studio.

Testar solicitações de chat

Para testar os comandos de código, escolha um dos métodos a seguir.

REST

Para testar um comando de chat de código 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.
  • Mensagens: 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 comando esteja dentro do limite permitido. É necessário que haja um número ímpar de mensagens (pares AUTHOR-CONTENT) para o modelo gerar uma resposta.
    • AUTHOR: o autor da mensagem.
    • CONTENT: o conteúdo da mensagem.
  • TEMPERATURE: 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.
  • MAX_OUTPUT_TOKENS: 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.

  • CANDIDATE_COUNT: 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
    O intervalo de valores válidos é um int entre 1 e 4.

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

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

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 a seguinte.

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 = 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();
  }
}

Console

Para testar um comando de chat de código usando o Vertex AI Studio no Console do Google Cloud, faça o seguinte:

  1. Na seção Vertex AI do console do Google Cloud, acesse o Vertex AI Studio.

    Acessar o Vertex AI Studio

  2. Clique em Começar.
  3. Clique em Chat com código.
  4. Em Modelo, selecione o modelo com o nome que começa com codechat-bison. Um número de três dígitos depois de codechat-bison indica o número da versão do modelo.
  5. Ajuste a temperatura e o limite de tokens para testar como eles afetam a resposta. Para mais informações, consulte Parâmetros do modelo de chat de código.
  6. Em Inserir um comando para iniciar uma conversa, digite um comando para iniciar uma conversa sobre o código.
  7. Clique em Continuar a conversa para enviar o comando para o chat.
  8. Depois de receber uma resposta, repita as duas etapas anteriores para continuar a conversa.
  9. Clique em Salvar se quiser salvar um comando.
  10. Clique em Conferir código para consultar o código Python ou um comando curl para seu comando.

Exemplo de solicitação de chat por código

MODEL_ID="codechat-bison"
PROJECT_ID=PROJECT_ID

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://us-central1-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/us-central1/publishers/google/models/${MODEL_ID}:predict -d \
$"{
'instances': [
    {
      'messages': [
        {
          'author': 'user',
          'content': 'Hi, how are you?',
        },
        {
          'author': 'system',
          'content': 'I am doing good. What Can I help you with in the coding world?',
        },
        {
          'author': 'user',
          'content': 'Please help write a function to calculate the min of two numbers',
        }
      ]
    }
  ],
  'parameters': {
    'temperature': 0.2,
    'maxOutputTokens': 1024,
    'candidateCount': 1
  }
}"

Para saber mais sobre como projetar comandos de bate-papo, consulte Comandos de bate-papo.

Resposta de stream do modelo de chat de código

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.

A seguir