Se usó la API de Cloud Translation para traducir esta página.

Chat de texto

El modelo de base PaLM 2 for Chat (chat-bison) es un modelo de lenguaje grande (LLM) que se destaca en la comprensión del lenguaje, la generación del lenguaje y las conversaciones. Este modelo de chat está ajustado para realizar conversaciones naturales de varios turnos y es ideal para tareas de texto sobre código que requieren interacciones recíprocas.

Para tareas de texto que se puedan completar con una respuesta de la API (sin necesidad de una conversación continua), usa el modelo de texto.

Para explorar este modelo en la consola, consulta la tarjeta del modelo PaLM 2 para Chat en el jardín de modelos.
Ir a Model Garden

Casos de uso

Atención al cliente: Indica al modelo que responda como agentes de atención al cliente que solo hablen sobre el producto de tu empresa.
Asistencia técnica: Indica al modelo que interactúe con los clientes como agente de un centro de atención telefónica con parámetros específicos sobre cómo responder y qué no decir.
Personas y personajes: pídele al modelo que responda al estilo de una persona específica (“…en el estilo de Shakespeare”).
Complemento de sitio web: Crea un asistente conversacional para compras, viajes y otros casos de uso.

Para obtener más información, consulta Diseña indicaciones de chat.

Solicitud HTTP

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

Para obtener más información, consulta el método predict.

Versiones del modelo

Para usar la versión más reciente del modelo, especifica el nombre del modelo sin un número de versión, por ejemplo chat-bison.

Para usar una versión del modelo estable, especifica el número de versión del modelo, por ejemplo, chat-bison@002. Cada versión estable está disponible durante seis meses después de la fecha de lanzamiento de la versión estable posterior.

En la tabla siguiente figuran las versiones de modelos estables disponibles:

modelo de chat-bison	Fecha de lanzamiento	Fecha de descontinuación
chat-bison@002	6 de diciembre de 2023	9 de abril de 2025

Para obtener más información, consulta Versiones de modelo y ciclo de vida

Cuerpo de la solicitud

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

En las llamadas a la API de chat, context, examples y messages se combinan a fin de formar la instrucción. En la siguiente tabla, se muestran los parámetros que debes configurar la API de PaLM de Vertex AI para el texto:

Parámetro	Descripción	Valores aceptables
`context` (opcional)	El contexto define cómo responde el modelo a lo largo de la conversación. Por ejemplo, puedes usar el contexto para especificar las palabras que el modelo puede usar o no, los temas en los que se debe enfocar o que debe evitar, o el formato o estilo de respuesta.	Texto
`examples` (opcional)	Ejemplos para que el modelo aprenda a responder a la conversación.	[{ "input": {"content": "provide content"}, "output": {"content": "provide content"} }]
`messages` (obligatorio)	Historial de conversaciones proporcionado al modelo en forma estructurada de autor alternativo. Los mensajes aparecen en orden cronológico: el más antiguo primero y el último. Cuando el historial de mensajes hace que la entrada exceda la longitud máxima, los mensajes más antiguos se quitan hasta que todo el mensaje esté dentro del límite permitido.	[{ "author": "user", "content": "user message" }]
`temperature`	La temperatura se usa para muestreos durante la generación de respuesta, que se genera cuando se aplican `topP` y `topK`. La temperatura controla el grado de aleatorización en la selección de tokens. Las temperaturas más bajas son buenas para los mensajes que requieren una respuesta menos abierta o de creativa, mientras que las temperaturas más altas pueden generar resultados más diversos o creativos. Una temperatura de `0` significa que siempre se seleccionan los tokens de probabilidad más alta. En este caso, las respuestas para un mensaje determinado son, en su mayoría, deterministas, pero es posible que haya una pequeña cantidad de variación. Si el modelo muestra una respuesta demasiado genérica, demasiado corta o el modelo proporciona una respuesta de resguardo, intenta aumentar la temperatura.	`0.0–1.0` `Default: 0.0`
`maxOutputTokens`	Cantidad máxima de tokens que se pueden generar en la respuesta. Un token tiene casi cuatro caracteres. 100 tokens corresponden a casi 60 u 80 palabras. Especifica un valor más bajo para las respuestas más cortas y un valor más alto para las respuestas potencialmente más largas.	`1–2048` `Default: 1024`
`topK`	El parámetro Top-K cambia la manera en la que el modelo selecciona los tokens para el resultado. K superior a `1` significa que el siguiente token seleccionado es el más probable entre todos los tokens en el vocabulario del modelo (también llamado decodificación voraz), mientras que el K superior a `3` significa que el siguiente token se selecciona de los tres tokens más probables mediante la temperatura. Para cada paso de selección de tokens, se muestran los tokens de K superior con las probabilidades más altas. Luego, los tokens se filtran según el superior con el token final seleccionado mediante el muestreo de temperatura. Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.	`1–40` `Default: 40`
`topP`	Top-P cambia la manera en la que el modelo selecciona tokens para la salida. Los tokens se seleccionan desde el más alto (consulta K superior) hasta el menos probable, hasta que la suma de sus probabilidades sea igual al valor de P superior. Por ejemplo, si los tokens A, B y C tienen una probabilidad de 0.3, 0.2 y 0.1, y el valor P superior es `0.5`, el modelo elegirá A o B como el siguiente token mediante la temperatura y excluirá a C como candidato. Especifica un valor más bajo para respuestas menos aleatorias y un valor más alto para respuestas más aleatorias.	`0.0–1.0` `Default: 0.95`
`stopSequences`	Especifica una lista de cadenas que le indica al modelo que deje de generar texto si se encuentra una de las cadenas en la respuesta. Si una cadena aparece varias veces en la respuesta, la respuesta trunca el lugar en que se encontró por primera vez. Las cadenas distinguen entre mayúsculas y minúsculas. Por ejemplo, si la siguiente es la respuesta que se muestra cuando no se especifica `stopSequences`: `public static string reverse(string myString)` Luego, la respuesta que se muestra con `stopSequences` configurada como `["Str", "reverse"]` es la siguiente: `public static string`	`default: []`
`groundingConfig`	Los fundamentos te permiten hacer referencia a datos específicos cuando usas modelos de lenguaje. Cuando basas un modelo, este puede hacer referencia a datos internos, confidenciales y, de otro modo, específicos de tu repositorio, y también incluir los datos en la respuesta. Solo se admiten los almacenes de datos de Vertex AI Search.	La ruta debe seguir el siguiente formato: `projects/{project_id}/locations/global/collections/{collection_name}/dataStores/{DATA_STORE_ID}`.
`candidateCount`	La cantidad de variaciones de respuesta que se mostrarán. Por cada solicitud, se te cobra por los tokens de salida de todos los candidatos, pero solo se te cobra una vez por los tokens de entrada. Especificar varios candidatos es una función de vista previa que funciona con `generateContent` (no se admite `streamGenerateContent`). Se admiten los siguientes modelos: Gemini 1.5 Flash: `1`-`8`, predeterminado: `1` Gemini 1.5 Pro: `1`-`8`, predeterminado: `1` Gemini 1.0 Pro: `1`-`8`, predeterminado: `1`	`1–4` `Default: 1`
`logprobs`	Devuelve las probabilidades de registro de los tokens candidatos principales en cada paso de generación. Es posible que el token elegido del modelo no sea el mismo que el token de candidato principal en cada paso. Especifica la cantidad de candidatos que se mostrarán con un valor de número entero en el rango de `1` a `5`.	`0-5`
`frequencyPenalty`	Los valores positivos penalizan los tokens que aparecen repetidamente en el texto generado, lo que disminuye la probabilidad de repetir contenido. El valor mínimo es `-2.0`. El valor máximo es hasta `2.0`, pero no lo incluye.	`Minimum value: -2.0` `Maximum value: 2.0`
`presencePenalty`	Los valores positivos penalizan los tokens que ya aparecen en el texto generado, lo que aumenta la probabilidad de generar contenido más diverso. El valor mínimo es `-2.0`. El valor máximo es hasta `2.0`, pero no lo incluye.	`Minimum value: -2.0` `Maximum value: 2.0`
`seed`	Cuando el valor semilla se fija en un valor específico, el modelo hace su mejor esfuerzo para proporcionar la misma respuesta para las solicitudes repetidas. No se garantiza un resultado determinístico. Además, cambiar la configuración del modelo o del parámetro, como la temperatura, puede causar variaciones en la respuesta, incluso cuando usas el mismo valor semilla. Según la configuración predeterminada, se usa un valor semilla aleatorio. Esta es una función de versión preliminar.	`Optional`

Solicitud de muestra

REST

Para probar un chat de texto con la API de Vertex AI, envía una solicitud POST al extremo del modelo de publicador.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_ID: El ID del proyecto.

Para otros campos, consulta la tabla Cuerpo de la solicitud a continuación.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "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 tu solicitud, elige una de estas opciones:

curl

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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/chat-bison:predict"

PowerShell

Nota: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente 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/chat-bison:predict" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la respuesta de ejemplo.

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de 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 probar este ejemplo, sigue las instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.


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");
    }
  }
}

Cuerpo de la respuesta

{
  "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 la respuesta	Descripción
`content`	Contenido de texto del mensaje de chat.
`candidates`	El resultado del chat generado a partir de un mensaje determinado.
`categories`	Los nombres visibles de las categorías de atributos de seguridad asociados con el contenido generado. El orden coincide con las puntuaciones.
`author`	Etiqueta de autor para el turno.
`scores`	Las puntuaciones de confianza de cada categoría, un valor más alto significa más confianza.
`blocked`	Una marca que indica si la entrada o salida del modelo se bloqueó.
`startIndex`	Índice en el resultado de la predicción en el que comienza la cita (inclusive). Debe ser >= 0 y < end_index.
`endIndex`	Índice en el resultado de la predicción en el que finaliza la cita (exclusivo). Debe ser > start_index y < len(output).
`url`	URL asociada con esta cita. Si está presente, esta URL vincula a la página web de la fuente de esta cita. Las URLs posibles incluyen sitios web de noticias, repositorios de GitHub, etcétera.
`title`	Título asociado a esta cita. Si está presente, hace referencia al título de la fuente de esta cita. Los posibles títulos incluyen títulos de noticias, de libros, etcétera.
`license`	Licencia asociada con esta repetición. Si está presente, hace referencia a la licencia de la fuente de esta cita. Las posibles licencias incluyen licencias de código, p. ej., Licencia MIT.
`publicationDate`	Es la fecha de publicación asociada con esta cita. Si está presente, hace referencia a la fecha en la que se publicó la fuente de esta cita. Los formatos posibles son AAAA, AAAA-MM y AAAA-MM-DD.
`safetyAttributes`	Una colección de categorías y sus puntuaciones de confianza asociadas. Asignación de 1:1 a `candidates`.
`input_token_count`	Cantidad de tokens de entrada. Esta es la cantidad total de tokens en todos los mensajes, ejemplos y contexto.
`output_token_count`	Cantidad de tokens de salida. Esta es la cantidad total de tokens en `content` de todos los candidatos en la respuesta.
`tokens`	Los tokens de muestra.
`tokenLogProbs`	Las probabilidades de registro de los tokens de muestra.
`topLogProb`	Los tokens de candidatos más probables y sus probabilidades de registro en cada paso.
`logprobs`	Resultados del parámetro “logprobs”. Asignación de 1 a 1 a “candidatos”.

Respuesta de muestra

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

Respuesta de transmisión desde modelos de IA generativa

Los parámetros son los mismos para las solicitudes de transmisión y las de no transmisión a las APIs.

Para ver solicitudes de código y respuestas de muestra con la API de REST, consulta Ejemplos que usan la API de REST de transmisión.

Si deseas ver las solicitudes de código y las respuestas de muestra con el SDK de Vertex AI para Python, consulta Ejemplos que usan el SDK de Vertex AI para Python para la transmisión.