Chat de código

Codey para Code Chat (codechat-bison) es el nombre del modelo que admite el chat de código. Es un modelo de base que admite conversaciones de varios turnos que se especializan para el código. El modelo permite que los desarrolladores chateen con un chatbot para obtener ayuda con preguntas relacionadas con el código. La API de chat de código se usa para interactuar con el modelo de Codey for Code Chat.

Codey para Code Chat es ideal para tareas de código que se completan con interacciones de ida y vuelta para que puedas participar en una conversación continua. En las tareas de código que requieren una sola interacción, usa la API para completar el código o la API para la generación de código.

Para explorar este modelo en la consola, consulta la tarjeta del modelo de Codey for Code en Model Garden.
Ir a Model Garden

Casos de uso

Estos son algunos casos de uso comunes del chat de código:

Obtén ayuda sobre el código: Obtén ayuda con preguntas sobre el código, como preguntas sobre una API, una sintaxis en un lenguaje de programación compatible o qué versión de una biblioteca se requiere para código que escribes.
Depuración: Obtén ayuda con el código de depuración que no se compila o que contiene un error.
Documentación: Obtén ayuda para comprender el código a fin de documentarlo con precisión.
Más información sobre el código: Obtén ayuda para aprender sobre un código con el que no estás familiarizado.

Solicitud HTTP

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/codechat-bison: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 codechat-bison.

Para usar una versión del modelo estable, especifica el número de versión del modelo, por ejemplo, codechat-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 codechat-bison	Fecha de lanzamiento	Fecha de descontinuación
codechat-bison@002	6 de diciembre de 2023	9 de octubre de 2024.
codechat-bison@001	29 de junio de 2023	6 julio de 2024

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

Cuerpo de la solicitud

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

Los siguientes son los parámetros del modelo de chat de código llamado codechat-bison. El modelo codechat-bison es uno de los modelos en Codey. Puedes usar estos parámetros para optimizar tu instrucción de una conversación de chatbot sobre el código. Para obtener más información, consulta Descripción general de los modelos de código y Crea instrucciones para chatear sobre el código.

Parámetro	Descripción	Valores aceptables
`context`	Texto que se debe proporcionar primero al modelo para fundamentar la respuesta.	Texto
`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.	List[Structured Message] "author": "user", "content": "user message"
`temperature` (opcional)	La temperatura se usa para realizar muestreos durante la generación de respuesta. 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 creativa, mientras que las temperaturas más altas pueden generar resultados más diversos o creativos. Una temperatura de `0` significa que siempre se eligen 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.	`0.0–1.0` `Default: 0.2`
`maxOutputTokens` (opcional)	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`
`candidateCount` (opcional)	La cantidad de variaciones de respuesta que se mostrarán.	`1-4` `Default: 1`
`logprobs` (opcional)	Devuelve los tokens principales candidatos de `logprobs` más probables con sus probabilidades de registro en cada paso de generación. Los tokens elegidos y sus probabilidades de registro en cada paso siempre se muestran. El token elegido puede o no estar en los `logprobs` principales con más probabilidades de ser candidatos.	`0-5`
`frequencyPenalty` (opcional)	Los valores positivos penalizan los tokens que aparecen repetidamente en el texto generado, lo que disminuye la probabilidad de repetir contenido. Los valores aceptables son: `-2.0`—`2.0`	`Minimum value: -2.0 Maximum value: 2.0`
`presencePenalty` (opcional)	Los valores positivos penalizan los tokens que ya aparecen en el texto generado, lo que aumenta la probabilidad de generar contenido más diverso. Los valores aceptables son: `-2.0`—`2.0`	`Minimum value: -2.0 Maximum value: 2.0`
`seed`	El decodificador genera ruido aleatorio con un generador de números pseudoaleatorios, se agrega temperatura * ruido a los logits antes del muestreo. El generador de números pseudoaleatorios (prng) toma un valor inicial como entrada y genera el mismo resultado con el mismo valor inicial. Si no se establece el valor inicial, el valor inicial usado en el decodificador no será determinista, por lo que el ruido aleatorio generado no será determinístico. Si se establece el valor inicial, el ruido aleatorio generado será determinístico.	`Optional`

Solicitud de muestra

REST

Para probar un mensaje 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.

Cuerpo de la solicitud

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

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

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/codechat-bison:predict"

PowerShell

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/codechat-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 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 CodeChatModel

def write_a_function(temperature: float = 0.5) -> object:
    """Example of using Codey for Code Chat Model to write a function."""

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

    return response

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

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 ]
      },
      "score": float
    }
  ]
}

Elemento de la respuesta	Descripción
`author`	Una `string` que indica el autor de una respuesta de chat.
`blocked`	Una marca `boolean` asociada con un atributo de seguridad que indica si la entrada o salida del modelo se bloqueó. Si `blocked` es `true`, el campo `errors` en la respuesta contiene uno o más códigos de error. Si `blocked` es `false`, la respuesta no incluye el campo `errors`.
`categories`	Enumerar los nombres de las categorías de atributos de seguridad que están asociados con el contenido generado. El orden de las puntuaciones en el parámetro `scores` coincide con el orden de las categorías. Por ejemplo, la primera puntuación en el parámetro `scores` indica la probabilidad de que la respuesta infrinja la primera categoría en la lista `categories`.
`content`	El contenido de una respuesta de chat.
`endIndex`	Un número entero que especifica dónde termina una cita en `content`.
`errors`	Un array de códigos de error. El campo de respuesta `errors` se incluye en la respuesta solo cuando el campo `blocked` en la respuesta es `true`. Para obtener más información sobre los códigos de error, consulta Errores de seguridad.
`license`	Es la licencia asociada con una cita.
`publicationDate`	La fecha en que se publicó una cita. Sus formatos válidos son `YYYY`, `YYYY-MM` y `YYYY-MM-DD`.
`safetyAttributes`	Un array de atributos de seguridad. El array contiene un atributo de seguridad para cada candidato de respuesta.
`score`	Un valor `float` menor que cero. Cuanto más alto sea el valor de `score`, mayor será la confianza del modelo en su respuesta.
`scores`	Un array de valores `float`. Cada valor es una puntuación que indica la probabilidad de que la respuesta infrinja la categoría de seguridad con la que se comprueba. Cuanto más bajo sea el valor, más seguro será el modelo según la respuesta. El orden de las puntuaciones en el array corresponde al orden de los atributos de seguridad en el elemento de respuesta `categories`.
`startIndex`	Un número entero que especifica dónde comienza una cita en el contenido.
`title`	Es el título de una fuente de cita. Los ejemplos de títulos de origen pueden ser los de un artículo de noticias o un libro.
`url`	Es la URL de una fuente de cita. Los ejemplos de una fuente de URL pueden ser un sitio web de noticias o un repositorio de GitHub.
`tokens`	Los tokens de muestra.
`tokenLogProbs`	Las probabilidades de registro de los tokens de muestra.
`topLogProbs`	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": []
        }
      ],
      "candidates": [
        {
          "author": "AUTHOR",
          "content": "RESPONSE"
        }
      ],
      "safetyAttributes": {
        "categories": [],
        "blocked": false,
        "scores": []
      },
      "score": -1.1161688566207886
    }
  ]
}

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.