Esta página foi traduzida pela API Cloud Translation.

Chat de texto

O modelo de base PaLM 2 para Chat (chat-bison) é um modelo de linguagem grande (LLM) que se destaca em compreensão de idiomas, geração de idiomas e conversas. Esse modelo de chat é ajustado para conduzir conversas naturais de vários turnos e é ideal para tarefas de texto sobre códigos que exigem interações de troca.

Para tarefas de texto que podem ser concluídas com uma resposta de API (sem a necessidade de conversa contínua), use o modelo de texto.

Para explorar esse modelo no console, consulte o card de modelo do PaLM 2 para Chat no Model Garden.
Acessar o Model Garden

Casos de uso

Atendimento ao cliente: instrua o modelo a responder como agentes de atendimento ao cliente que falam apenas sobre o produto da sua empresa
Suporte técnico: instrua o modelo a interagir com os clientes como um agente de call center com parâmetros específicos sobre como responder e o que não dizer
Perfis e personagens: oriente o modelo para responder no estilo de uma pessoa específica ("no estilo de Shakespeare")
Complementar do site: crie um assistente de conversa para compras, viagens e outros casos de uso

Para mais informações, consulte Criar prompts de chat.

Solicitação HTTP

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

Para mais informações, consulte o método 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, chat-bison.

Para usar uma versão de modelo estável, especifique o número da versão de modelo, por exemplo, chat-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 de chat-bison	Data da versão	Data de desativação
chat-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,
      "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
  }
}

Para chamadas de API de chat, context, examples e messages são combinados para formar a solicitação. A tabela a seguir mostra os parâmetros que você precisa configurar para a API Vertex AI PaLM para texto:

Parâmetro	Descrição	Valores aceitáveis
`context` (opcional)	O contexto ajusta as respostas do modelo ao longo da conversa. Por exemplo, com o contexto, é possível especificar as palavras que podem ser usadas pelo modelo, os assuntos a serem tratados ou evitados, assim como o formato ou o estilo das respostas.	Texto
`examples` (opcional)	Exemplos do modelo para saber como responder à conversa.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`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.	[{ "author": "user", "content": "user message" }]
`temperature`	A temperatura é usada para amostragem durante a geração da resposta, que ocorre quando `topP` e `topK` são aplicados. 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 temperaturas 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 das vezes, deterministas, mas uma pequena variação ainda é possível. Se o modelo retornar uma resposta muito genérica, muito curta ou se o modelo fornecer uma resposta alternativa, tente aumentar a temperatura.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	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`
`topK`	O Top-K muda a forma como o modelo seleciona tokens para saída. Um top-K de `1` significa que o próximo token selecionado é o mais provável entre todos os tokens no vocabulário do modelo (também chamado de decodificação gananciosa), enquanto um top-K de `3` significa que o próximo token está selecionado entre os três tokens mais prováveis usando a temperatura. Para cada etapa da seleção de tokens, são amostrados os tokens top-K com as maiores probabilidades. Em seguida, os tokens são filtrados com base no valor de top-P com o token final selecionado por meio da amostragem de temperatura. Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.	`1–40` `Default: 40`
`topP`	O Top-P muda a forma como o modelo seleciona tokens para saída. Os tokens são selecionados do mais provável (veja o top-K) para o menos provável até que a soma das probabilidades seja igual ao valor do top-P. Por exemplo, se os tokens A, B e C tiverem uma probabilidade de 0,3, 0,2 e 0,1 e o valor de top-P for `0.5`, o modelo selecionará A ou B como token seguinte usando temperatura e exclui C como candidato. Especifique um valor mais baixo para respostas menos aleatórias e um valor mais alto para respostas mais aleatórias.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Especifica uma lista de strings que instrui o modelo a parar de gerar texto se uma das strings for encontrada na resposta. Se uma string aparecer várias vezes na resposta, a resposta truncará quando for encontrada pela primeira vez. As strings diferenciam maiúsculas de minúsculas. Por exemplo, se a resposta a seguir for retornada quando `stopSequences` não for especificado: `public static string reverse(string myString)` A resposta retornada com `stopSequences` definida como `["Str", "reverse"]` é: `public static string`	`default: []`
`groundingConfig`	O embasamento permite referenciar dados específicos ao usar modelos de linguagem. Quando você embasa um modelo, ele pode referenciar dados internos, confidenciais e específicos do repositório e os incluir na resposta. Apenas repositórios de dados da Vertex AI para Pesquisa são compatíveis.	O caminho precisa seguir o formato: `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`
`candidateCount`	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`	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`	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`	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 chat 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.

Para outros campos, consulte a tabela Corpo da solicitação abaixo.

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

{
  "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
  }
}

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/chat-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/chat-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 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

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 = '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

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.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 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 ],
        "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 de resposta	Descrição
`content`	Conteúdo de texto da mensagem de chat.
`candidates`	O resultado do chat gerado com a mensagem fornecida.
`categories`	Os nomes de exibição das categorias de atributo de segurança associadas ao conteúdo gerado. A ordem corresponde às pontuações.
`author`	Tag do autor para a vez.
`scores`	As pontuações de confiança de cada categoria, maior valor significa maior confiança.
`blocked`	Uma flag que indica se a entrada ou saída do modelo foi bloqueada.
`startIndex`	Índice na saída de previsão em que a citação começa (inclusive). Precisa ser >= 0 e < end_index.
`endIndex`	Índice na saída da previsão em que a citação termina (exclusiva). Precisa ser > start_index e < len(output).
`url`	URL associado a esta citação. Se presente, esse URL está vinculado à página da Web da fonte da citação. Os possíveis URLs incluem sites de notícias, repositórios do GitHub etc.
`title`	Título associado a esta citação. Se presente, refere-se ao título da fonte desta citação. Os possíveis títulos incluem títulos de notícias, títulos de livros etc.
`license`	Licença associada a esta recitação. Se estiver presente, refere-se à licença da fonte dessa citação. As possíveis licenças incluem licenças de código, como a licença mit.
`publicationDate`	Data de publicação associada a esta citação. Se presente, refere-se à data em que a fonte da citação foi publicada. Os formatos possíveis são AAAA, AAAA-MM, AAAA-MM-DD.
`safetyAttributes`	Uma coleção de categorias e as pontuações de confiança associadas a elas. Mapeamento 1-1 para `candidates`.
`input_token_count`	Número de tokens de entrada. Esse é o número total de tokens em todas as mensagens, exemplos e contextos.
`output_token_count`	Número de tokens de saída. Esse é o número total de tokens em `content` em todos os candidatos na resposta.
`tokens`	Os tokens de amostra.
`tokenLogProbs`	Probabilidades de registro dos tokens de amostra.
`topLogProb`	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": []
      },
      "safetyAttributes": {
        "scores": [
          0.1
        ],
        "categories": [
          "Finance"
        ],
        "blocked": false
      },
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ]
    }
  ]
}

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.