API de embeddings de texto

En esta guía, se muestra cómo usar la API de Text Embeddings para convertir texto en vectores numéricos. En este documento, se incluyen los siguientes temas:

• Sintaxis: Llama a la API con cURL o el SDK de Python.
• Solicitud y respuesta: Obtén información sobre los parámetros de solicitud y respuesta de los modelos de incorporación de texto.
• Ejemplos: Consulta un muestra de código que muestra cómo incorporar una cadena de texto.
• Próximos pasos: Explora la documentación relacionada.

La API de Text embeddings convierte texto en vectores numéricos llamados embeddings. Estas representaciones vectoriales capturan el significado semántico y el contexto del texto.

Modelos compatibles:

Puedes obtener incorporaciones de texto con los siguientes modelos:

Nombre del modelo	Descripción	Dimensiones de salida	Longitud de secuencia máxima	Lenguajes de texto admitidos
gemini-embedding-001	Rendimiento de vanguardia en tareas de inglés, multilingües y de código Unifica los modelos especializados anteriores, como text-embedding-005 y text-multilingual-embedding-002, y logra un mejor rendimiento en sus respectivos dominios. Lee nuestro Informe técnico para obtener más detalles.	hasta 3072	2,048 tokens	Idiomas de texto admitidos
text-embedding-005	Se especializa en tareas de código y en inglés.	Hasta 768	2,048 tokens	Inglés
text-multilingual-embedding-002	Se especializa en tareas multilingües.	Hasta 768	2,048 tokens	Idiomas de texto admitidos

Para obtener una calidad de incorporación superior, gemini-embedding-001 es nuestro modelo grande diseñado para proporcionar el mayor rendimiento. Ten en cuenta que gemini-embedding-001 admite una instancia por solicitud.

Sintaxis

curl

PROJECT_ID = PROJECT_ID
REGION = us-central1
MODEL_ID = MODEL_ID

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  https://${REGION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${REGION}/publishers/google/models/${MODEL_ID}:predict -d \
  '{
    "instances": [
      ...
    ],
    "parameters": {
      ...
    }
  }'

Python

PROJECT_ID = PROJECT_ID
REGION = us-central1
MODEL_ID = MODEL_ID

import vertexai
from vertexai.language_models import TextEmbeddingModel

vertexai.init(project=PROJECT_ID, location=REGION)

model = TextEmbeddingModel.from_pretrained(MODEL_ID)
embeddings = model.get_embeddings(...)

Solicitud y respuesta

Cuerpo de la solicitud

{
  "instances": [
    {
      "task_type": "RETRIEVAL_DOCUMENT",
      "title": "document title",
      "content": "I would like embeddings for this text!"
    },
  ]
}

parámetros de solicitud

• instances: Obligatorio. Es una lista de objetos que contienen el texto que se incorporará. Se admiten los siguientes campos:
  • content (string): Es el texto para el que se generarán las incorporaciones.
  • task_type (string): Opcional. Especifica la aplicación descendente prevista para ayudar al modelo a producir incorporaciones de mejor calidad. Si no especificas un valor, el valor predeterminado es RETRIEVAL_QUERY. Para obtener más información sobre los tipos de tareas, consulta Elige un tipo de tarea de embeddings.
  • title (string): Opcional. Es un título para el contenido de texto. Este campo solo se aplica cuando task_type es RETRIEVAL_DOCUMENT.
• parameters: Opcional Objeto que contiene los siguientes campos:
  • autoTruncate (bool): Si es true, el texto de entrada se trunca si es más largo que la longitud máxima del modelo. Si es false, se muestra un error para la entrada demasiado grande. El valor predeterminado es true.
  • outputDimensionality (int): Es el tamaño de embedding deseado. Si se establece, los embeddings de salida se truncan a esta dimensión.

Tipos de tareas

En la siguiente tabla, se describen los valores del parámetro task_type y sus casos de uso:

task_type	Descripción	Caso de uso
RETRIEVAL_QUERY	El texto de entrada es una búsqueda en un parámetro de configuración de búsqueda o recuperación.	Se usa para el texto de la búsqueda cuando se busca en una colección de documentos. Vincula con RETRIEVAL_DOCUMENT para los documentos.
RETRIEVAL_DOCUMENT	El texto de entrada es un documento en un parámetro de configuración de búsqueda o recuperación.	Se usa para los documentos de una colección en la que se realizará la búsqueda. Se vincula con RETRIEVAL_QUERY para la búsqueda.
SEMANTIC_SIMILARITY	El texto de entrada se usa para la similitud textual semántica (STS).	Comparar dos fragmentos de texto para determinar su similitud en significado
CLASSIFICATION	La incorporación se usará para tareas de clasificación.	Entrenar un modelo para categorizar texto en clases predefinidas
CLUSTERING	El embedding se usará para tareas de agrupamiento en clústeres.	Agrupa textos similares sin etiquetas predefinidas.
QUESTION_ANSWERING	El texto de entrada es una búsqueda para un sistema de respuesta a preguntas.	Encontrar respuestas a preguntas dentro de un conjunto de documentos Usa RETRIEVAL_DOCUMENT para los documentos.
FACT_VERIFICATION	El texto de entrada es una afirmación que se verificará en función de un conjunto de documentos.	Verificar la precisión fáctica de una declaración Usa RETRIEVAL_DOCUMENT para los documentos.
CODE_RETRIEVAL_QUERY	El texto de entrada es una búsqueda para recuperar fragmentos de código relevantes (Java y Python).	Buscar funciones o fragmentos relevantes en una base de código Usa RETRIEVAL_DOCUMENT para los documentos de código.

• Tareas de recuperación:
  • Búsqueda: Usa task_type=RETRIEVAL_QUERY para el texto de entrada que es una búsqueda.
  • Corpus: Usa task_type=RETRIEVAL_DOCUMENT para el texto de entrada que forma parte de la colección de documentos que se busca.
• Tareas de similitud:
  • Similitud semántica: Usa task_type=SEMANTIC_SIMILARITY para ambos textos de entrada para evaluar su similitud general en significado.
• Nota: SEMANTIC_SIMILARITY no está diseñado para casos de uso de recuperación, como la búsqueda de documentos y la recuperación de información. Para estos casos de uso, usa RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, QUESTION_ANSWERING y FACT_VERIFICATION.

Cuerpo de la respuesta

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": boolean,
          "token_count": integer
        },
        "values": [ number ]
      }
    }
  ]
}

Parámetros de respuesta

• predictions: Es una lista de objetos, en la que cada objeto corresponde a una instancia de entrada de la solicitud. Cada objeto contiene el siguiente campo:
  • embeddings: Es el embedding generado a partir del texto de entrada. Contiene los siguientes campos:
    • values: Es una lista de números de punto flotante que representa el vector de incorporación del texto de entrada.
    • statistics: Son las estadísticas calculadas a partir del texto de entrada. Contiene los siguientes campos:
      • truncated (bool): true si el texto de entrada se truncó porque era más largo que la cantidad máxima de tokens permitidos por el modelo.
      • token_count (int): Es la cantidad de tokens en el texto de entrada.

Respuesta de muestra

{
  "predictions": [
    {
      "embeddings": {
        "values": [
          0.0058424929156899452,
          0.011848051100969315,
          0.032247550785541534,
          -0.031829461455345154,
          -0.055369812995195389,
          ...
        ],
        "statistics": {
          "token_count": 4,
          "truncated": false
        }
      }
    }
  ]
}

Ejemplos

Incorpora una cadena de texto

En el siguiente ejemplo, se muestra cómo obtener la incorporación de una cadena de texto.

REST

Después de configurar tu entorno, puedes usar REST para probar una instrucción de texto. En el siguiente ejemplo, se envía una solicitud 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.
• TEXT: El texto para el que deseas generar incorporaciones. Límite: cinco textos de hasta 2,048 tokens por texto para todos los modelos, excepto textembedding-gecko@001. La longitud máxima del token de entrada para textembedding-gecko@001 es 3,072. En el caso de gemini-embedding-001, cada solicitud solo puede incluir un texto de entrada. Para obtener más información, consulta Límites de los embeddings de texto.
• AUTO_TRUNCATE: Si se establece en false, el texto que excede el límite del token hace que la solicitud falle. El valor predeterminado es true.

HTTP method and URL:

POST https://us-central1-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/publishers/google/models/gemini-embedding-001:predict

Cuerpo JSON de la solicitud:

{
  "instances": [
    { "content": "TEXT"}
  ],
  "parameters": { 
    "autoTruncate": AUTO_TRUNCATE 
  }
}

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/gemini-embedding-001: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/gemini-embedding-001:predict" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la que se muestra a continuación: Ten en cuenta que values se truncó para ahorrar espacio.

Respuesta

{
  "predictions": [
    {
      "embeddings": {
        "statistics": {
          "truncated": false,
          "token_count": 6
        },
        "values": [ ... ]
      }
    }
  ]
}

Ten en cuenta lo siguiente en la URL para esta muestra:

• Usa el método generateContent para solicitar que la respuesta se muestre después de que se haya generado por completo. Para reducir la percepción de latencia a un público humano, transmite la respuesta a medida que se genera; para ello, usa el método streamGenerateContent.
• El ID del modelo multimodal se encuentra al final de la URL antes del método (por ejemplo, gemini-2.0-flash). Esta muestra también puede admitir otros modelos.

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. Para obtener más información, consulta la documentación de referencia de la API de Python.

from __future__ import annotations

from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel


def embed_text() -> list[list[float]]:
    """Embeds texts with a pre-trained, foundational model.

    Returns:
        A list of lists containing the embedding vectors for each input text
    """

    # A list of texts to be embedded.
    texts = ["banana muffins? ", "banana bread? banana muffins?"]
    # The dimensionality of the output embeddings.
    dimensionality = 3072
    # The task type for embedding. Check the available tasks in the model's documentation.
    task = "RETRIEVAL_DOCUMENT"

    model = TextEmbeddingModel.from_pretrained("gemini-embedding-001")
    kwargs = dict(output_dimensionality=dimensionality) if dimensionality else {}

    embeddings = []
    # gemini-embedding-001 takes one input at a time
    for text in texts:
        text_input = TextEmbeddingInput(text, task)
        embedding = model.get_embeddings([text_input], **kwargs)
        print(embedding)
        # Example response:
        # [[0.006135190837085247, -0.01462465338408947, 0.004978656303137541, ...]]
        embeddings.append(embedding[0].values)

    return embeddings

Go

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go 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 Go.

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.

import (
	"context"
	"fmt"
	"io"

	aiplatform "cloud.google.com/go/aiplatform/apiv1"
	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/api/option"
	"google.golang.org/protobuf/types/known/structpb"
)

// embedTexts shows how embeddings are set for gemini-embedding-001 model
func embedTexts(w io.Writer, project, location string) error {
	// location := "us-central1"
	ctx := context.Background()

	apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)
	dimensionality := 3072
	model := "gemini-embedding-001"
	texts := []string{"banana muffins? ", "banana bread? banana muffins?"}

	client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	if err != nil {
		return err
	}
	defer client.Close()

	endpoint := fmt.Sprintf("projects/%s/locations/%s/publishers/google/models/%s", project, location, model)
	allEmbeddings := make([][]float32, 0, len(texts))
	// gemini-embedding-001 takes 1 input at a time
	for _, text := range texts {
		instances := make([]*structpb.Value, 1)
		instances[0] = structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"content":   structpb.NewStringValue(text),
				"task_type": structpb.NewStringValue("QUESTION_ANSWERING"),
			},
		})

		params := structpb.NewStructValue(&structpb.Struct{
			Fields: map[string]*structpb.Value{
				"outputDimensionality": structpb.NewNumberValue(float64(dimensionality)),
			},
		})

		req := &aiplatformpb.PredictRequest{
			Endpoint:   endpoint,
			Instances:  instances,
			Parameters: params,
		}
		resp, err := client.Predict(ctx, req)
		if err != nil {
			return err
		}

		// Process the prediction for the single text
		// The response will contain one prediction because we sent one instance.
		if len(resp.Predictions) == 0 {
			return fmt.Errorf("no predictions returned for text \"%s\"", text)
		}

		prediction := resp.Predictions[0]
		embeddingValues := prediction.GetStructValue().Fields["embeddings"].GetStructValue().Fields["values"].GetListValue().Values

		currentEmbedding := make([]float32, len(embeddingValues))
		for j, value := range embeddingValues {
			currentEmbedding[j] = float32(value.GetNumberValue())
		}
		allEmbeddings = append(allEmbeddings, currentEmbedding)
	}

	if len(allEmbeddings) > 0 {
		fmt.Fprintf(w, "Dimensionality: %d. Embeddings length: %d", len(allEmbeddings[0]), len(allEmbeddings))
	} else {
		fmt.Fprintln(w, "No texts were processed.")
	}
	return nil
}

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.

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.

import static java.util.stream.Collectors.toList;

import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictRequest;
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.Struct;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.OptionalInt;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PredictTextEmbeddingsSample {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // Details about text embedding request structure and supported models are available in:
    // https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings
    String endpoint = "us-central1-aiplatform.googleapis.com:443";
    String project = "YOUR_PROJECT_ID";
    String model = "gemini-embedding-001";
    predictTextEmbeddings(
        endpoint,
        project,
        model,
        List.of("banana bread?", "banana muffins?"),
        "QUESTION_ANSWERING",
        OptionalInt.of(3072));
  }

  // Gets text embeddings from a pretrained, foundational model.
  public static List<List<Float>> predictTextEmbeddings(
      String endpoint,
      String project,
      String model,
      List<String> texts,
      String task,
      OptionalInt outputDimensionality)
      throws IOException {
    PredictionServiceSettings settings =
        PredictionServiceSettings.newBuilder().setEndpoint(endpoint).build();
    Matcher matcher = Pattern.compile("^(?<Location>\\w+-\\w+)").matcher(endpoint);
    String location = matcher.matches() ? matcher.group("Location") : "us-central1";
    EndpointName endpointName =
        EndpointName.ofProjectLocationPublisherModelName(project, location, "google", model);

    List<List<Float>> floats = new ArrayList<>();
    // You can use this prediction service client for multiple requests.
    try (PredictionServiceClient client = PredictionServiceClient.create(settings)) {
      // gemini-embedding-001 takes one input at a time.
      for (int i = 0; i < texts.size(); i++) {
        PredictRequest.Builder request = 
            PredictRequest.newBuilder().setEndpoint(endpointName.toString());
        if (outputDimensionality.isPresent()) {
          request.setParameters(
              Value.newBuilder()
                  .setStructValue(
                      Struct.newBuilder()
                          .putFields(
                              "outputDimensionality", valueOf(outputDimensionality.getAsInt()))
                          .build()));
        }
        request.addInstances(
            Value.newBuilder()
                .setStructValue(
                    Struct.newBuilder()
                        .putFields("content", valueOf(texts.get(i)))
                        .putFields("task_type", valueOf(task))
                        .build()));
        PredictResponse response = client.predict(request.build());

        for (Value prediction : response.getPredictionsList()) {
          Value embeddings = prediction.getStructValue().getFieldsOrThrow("embeddings");
          Value values = embeddings.getStructValue().getFieldsOrThrow("values");
          floats.add(
              values.getListValue().getValuesList().stream()
                  .map(Value::getNumberValue)
                  .map(Double::floatValue)
                  .collect(toList()));
        }
      }
      return floats;
    }
  }

  private static Value valueOf(String s) {
    return Value.newBuilder().setStringValue(s).build();
  }

  private static Value valueOf(int n) {
    return Value.newBuilder().setNumberValue(n).build();
  }
}

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.

async function main(
  project,
  model = 'gemini-embedding-001',
  texts = 'banana bread?;banana muffins?',
  task = 'QUESTION_ANSWERING',
  dimensionality = 0,
  apiEndpoint = 'us-central1-aiplatform.googleapis.com'
) {
  const aiplatform = require('@google-cloud/aiplatform');
  const {PredictionServiceClient} = aiplatform.v1;
  const {helpers} = aiplatform; // helps construct protobuf.Value objects.
  const clientOptions = {apiEndpoint: apiEndpoint};
  const location = 'us-central1';
  const endpoint = `projects/${project}/locations/${location}/publishers/google/models/${model}`;

  async function callPredict() {
    const instances = texts
      .split(';')
      .map(e => helpers.toValue({content: e, task_type: task}));

    const client = new PredictionServiceClient(clientOptions);
    const parameters = helpers.toValue(
      dimensionality > 0 ? {outputDimensionality: parseInt(dimensionality)} : {}
    );
    const allEmbeddings = []
    // gemini-embedding-001 takes one input at a time.
    for (const instance of instances) {
      const request = {endpoint, instances: [instance], parameters};
      const [response] = await client.predict(request);
      const predictions = response.predictions;

      const embeddings = predictions.map(p => {
        const embeddingsProto = p.structValue.fields.embeddings;
        const valuesProto = embeddingsProto.structValue.fields.values;
        return valuesProto.listValue.values.map(v => v.numberValue);
      });

      allEmbeddings.push(embeddings[0])
    }


    console.log('Got embeddings: \n' + JSON.stringify(allEmbeddings));
  }

  callPredict();
}

Lenguajes de texto admitidos

Todos los modelos de incorporación de texto admiten texto en inglés y se evaluaron en él.

El modelo text-multilingual-embedding-002 también admite los siguientes idiomas. Se evaluó en los idiomas de la lista Idiomas evaluados.

• Idiomas evaluados: Arabic (ar), Bengali (bn), English (en), Spanish (es), German (de), Persian (fa), Finnish (fi), French (fr), Hindi (hi), Indonesian (id), Japanese (ja), Korean (ko), Russian (ru), Swahili (sw), Telugu (te), Thai (th), Yoruba (yo), Chinese (zh)
• Idiomas compatibles: Afrikaans, Albanian, Amharic, Arabic, Armenian, Azerbaijani, Basque, Belarusiasn, Bengali, Bulgarian, Burmese, Catalan, Cebuano, Chichewa, Chinese, Corsican, Czech, Danish, Dutch, English, Esperanto, Estonian, Filipino, Finnish, French, Galician, Georgian, German, Greek, Gujarati, Haitian Creole, Hausa, Hawaiian, Hebrew, Hindi, Hmong, Hungarian, Icelandic, Igbo, Indonesian, Irish, Italian, Japanese, Javanese, Kannada, Kazakh, Khmer, Korean, Kurdish, Kyrgyz, Lao, Latin, Latvian, Lithuanian, Luxembourgish, Macedonian, Malagasy, Malay, Malayalam, Maltese, Maori, Marathi, Mongolian, Nepali, Norwegian, Pashto, Persian, Polish, Portuguese, Punjabi, Romanian, Russian, Samoan, Scottish Gaelic, Serbian, Shona, Sindhi, Sinhala, Slovak, Slovenian, Somali, Sotho, Spanish, Sundanese, Swahili, Swedish, Tajik, Tamil, Telugu, Thai, Turkish, Ukrainian, Urdu, Uzbek, Vietnamese, Welsh, West Frisian, Xhosa, Yiddish, Yoruba, Zulu.

El modelo gemini-embedding-001 admite los siguientes idiomas:

Arabic, Bengali, Bulgarian, Chinese (Simplified and Traditional), Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, German, Greek, Hebrew, Hindi, Hungarian, Indonesian, Italian, Japanese, Korean, Latvian, Lithuanian, Norwegian, Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swahili, Swedish, Thai, Turkish, Ukrainian, Vietnamese, Afrikaans, Amharic, Assamese, Azerbaijani, Belarusian, Bosnian, Catalan, Cebuano, Corsican, Welsh, Dhivehi, Esperanto, Basque, Persian, Filipino (Tagalog), Frisian, Irish, Scots Gaelic, Galician, Gujarati, Hausa, Hawaiian, Hmong, Haitian Creole, Armenian, Igbo, Icelandic, Javanese, Georgian, Kazakh, Khmer, Kannada, Krio, Kurdish, Kyrgyz, Latin, Luxembourgish, Lao, Malagasy, Maori, Macedonian, Malayalam, Mongolian, Meiteilon (Manipuri), Marathi, Malay, Maltese, Myanmar (Burmese), Nepali, Nyanja (Chichewa), Odia (Oriya), Punjabi, Pashto, Sindhi, Sinhala (Sinhalese), Samoan, Shona, Somali, Albanian, Sesotho, Sundanese, Tamil, Telugu, Tajik, Uyghur, Urdu, Uzbek, Xhosa, Yiddish, Yoruba, Zulu.

Versiones del modelo

Para usar un modelo estable actual, especifica el número de versión del modelo, por ejemplo, gemini-embedding-001.

No se recomienda especificar un modelo sin un número de versión, ya que es un puntero heredado a otro modelo y no es estable.

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

¿Qué sigue?

Obtén más información sobre las incorporaciones de texto:

• Incorporaciones de texto