Embeddings

La API de Gemini ofrece modelos de incorporación de texto para generar incorporaciones de palabras, frases, oraciones y código. Estos embeddings fundamentales potencian tareas avanzadas de PNL, como la búsqueda semántica, la clasificación y la agrupación, y proporcionan resultados más precisos y contextuales que los enfoques basados en palabras clave.

La creación de sistemas de generación mejorada por recuperación (RAG) es un caso de uso común para los embeddings. Las incorporaciones desempeñan un papel clave en la mejora significativa de los resultados del modelo, ya que aumentan la precisión fáctica, la coherencia y la riqueza contextual. Recuperan de manera eficiente información pertinente de las bases de conocimiento, que se representan con incorporaciones y, luego, se pasan como contexto adicional en la instrucción de entrada a los modelos de lenguaje, lo que los guía para generar respuestas más informadas y precisas.

Para obtener más información sobre las variantes de modelos de embedding disponibles, consulta la sección Versiones del modelo. Para aplicaciones de nivel empresarial y cargas de trabajo de gran volumen, sugerimos usar modelos de incorporación en Vertex AI.

Generación de embeddings

Usa el método embedContent para generar embeddings de texto:

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-001",
        contents="What is the meaning of life?")

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: 'What is the meaning of life?',
    });

    console.log(response.embeddings);
}

main();

Go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "models/gemini-embedding-001",
     "content": {"parts":[{"text": "What is the meaning of life?"}]}
    }'

También puedes generar incorporaciones para varios fragmentos a la vez si los pasas como una lista de cadenas.

Python

from google import genai

client = genai.Client()

result = client.models.embed_content(
        model="gemini-embedding-001",
        contents= [
            "What is the meaning of life?",
            "What is the purpose of existence?",
            "How do I bake a cake?"
        ])

for embedding in result.embeddings:
    print(embedding)

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {

    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: [
            'What is the meaning of life?',
            'What is the purpose of existence?',
            'How do I bake a cake?'
        ],
    });

    console.log(response.embeddings);
}

main();

Go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?"),
        genai.NewContentFromText("How does photosynthesis work?"),
        genai.NewContentFromText("Tell me about the history of the internet."),
    }
    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        nil,
    )
    if err != nil {
        log.Fatal(err)
    }

    embeddings, err := json.MarshalIndent(result.Embeddings, "", "  ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(embeddings))
}

REST

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{"model": "models/gemini-embedding-001",
     "content": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
        ]
    }'

Especifica el tipo de tarea para mejorar el rendimiento

Puedes usar incorporaciones para una amplia variedad de tareas, desde la clasificación hasta la búsqueda de documentos. Especificar el tipo de tarea correcto ayuda a optimizar los embeddings para las relaciones deseadas, lo que maximiza la precisión y la eficiencia. Para obtener una lista completa de los tipos de tareas admitidos, consulta la tabla Tipos de tareas admitidos.

En el siguiente ejemplo, se muestra cómo puedes usar SEMANTIC_SIMILARITY para verificar qué tan similares son en significado las cadenas de texto.

Python

from google import genai
from google.genai import types
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

client = genai.Client()

texts = [
    "What is the meaning of life?",
    "What is the purpose of existence?",
    "How do I bake a cake?"]

result = [
    np.array(e.values) for e in client.models.embed_content(
        model="gemini-embedding-001",
        contents=texts,
        config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")).embeddings
]

# Calculate cosine similarity. Higher scores = greater semantic similarity.

embeddings_matrix = np.array(result)
similarity_matrix = cosine_similarity(embeddings_matrix)

for i, text1 in enumerate(texts):
    for j in range(i + 1, len(texts)):
        text2 = texts[j]
        similarity = similarity_matrix[i, j]
        print(f"Similarity between '{text1}' and '{text2}': {similarity:.4f}")

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as cosineSimilarity from "compute-cosine-similarity";

async function main() {
    const ai = new GoogleGenAI({});

    const texts = [
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?",
    ];

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        contents: texts,
        taskType: 'SEMANTIC_SIMILARITY'
    });

    const embeddings = response.embeddings.map(e => e.values);

    for (let i = 0; i < texts.length; i++) {
        for (let j = i + 1; j < texts.length; j++) {
            const text1 = texts[i];
            const text2 = texts[j];
            const similarity = cosineSimilarity(embeddings[i], embeddings[j]);
            console.log(`Similarity between '${text1}' and '${text2}': ${similarity.toFixed(4)}`);
        }
    }
}

main();

Go

package main

import (
    "context"
    "fmt"
    "log"
    "math"

    "google.golang.org/genai"
)

// cosineSimilarity calculates the similarity between two vectors.
func cosineSimilarity(a, b []float32) (float64, error) {
    if len(a) != len(b) {
        return 0, fmt.Errorf("vectors must have the same length")
    }

    var dotProduct, aMagnitude, bMagnitude float64
    for i := 0; i < len(a); i++ {
        dotProduct += float64(a[i] * b[i])
        aMagnitude += float64(a[i] * a[i])
        bMagnitude += float64(b[i] * b[i])
    }

    if aMagnitude == 0 || bMagnitude == 0 {
        return 0, nil
    }

    return dotProduct / (math.Sqrt(aMagnitude) * math.Sqrt(bMagnitude)), nil
}

func main() {
    ctx := context.Background()
    client, _ := genai.NewClient(ctx, nil)
    defer client.Close()

    texts := []string{
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?",
    }

    var contents []*genai.Content
    for _, text := range texts {
        contents = append(contents, genai.NewContentFromText(text, genai.RoleUser))
    }

    result, _ := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{TaskType: genai.TaskTypeSemanticSimilarity},
    )

    embeddings := result.Embeddings

    for i := 0; i < len(texts); i++ {
        for j := i + 1; j < len(texts); j++ {
            similarity, _ := cosineSimilarity(embeddings[i].Values, embeddings[j].Values)
            fmt.Printf("Similarity between '%s' and '%s': %.4f\n", texts[i], texts[j], similarity)
        }
    }
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]},
        {"parts": [{"text": "What is the purpose of existence?"}]},
        {"parts": [{"text": "How do I bake a cake?"}]}
    ],
    "embedding_config": {
        "task_type": "SEMANTIC_SIMILARITY"
    }
}'

A continuación, se muestra un ejemplo del resultado de este fragmento de código:

Similarity between 'What is the meaning of life?' and 'What is the purpose of existence?': 0.9481

Similarity between 'What is the meaning of life?' and 'How do I bake a cake?': 0.7471

Similarity between 'What is the purpose of existence?' and 'How do I bake a cake?': 0.7371

Tipos de tareas compatibles

Tipo de tarea Descripción Ejemplos
SEMANTIC_SIMILARITY Son embeddings optimizados para evaluar la similitud del texto. Sistemas de recomendación, detección de duplicados
CLASSIFICATION Son embeddings optimizados para clasificar textos según etiquetas predeterminadas. Análisis de opiniones y detección de spam
CLUSTERING Embeddings optimizados para agrupar textos en función de sus similitudes. Organización de documentos, investigación de mercado y detección de anomalías
RETRIEVAL_DOCUMENT Son embeddings optimizados para la búsqueda de documentos. Indexar artículos, libros o páginas web para la búsqueda
RETRIEVAL_QUERY Son embeddings optimizados para búsquedas generales. Usa RETRIEVAL_QUERY para las búsquedas y RETRIEVAL_DOCUMENT para los documentos que se recuperarán. Búsqueda personalizada
CODE_RETRIEVAL_QUERY Son embeddings optimizados para recuperar bloques de código basados en consultas en lenguaje natural. Usa CODE_RETRIEVAL_QUERY para las consultas y RETRIEVAL_DOCUMENT para los bloques de código que se recuperarán. Sugerencias y búsqueda de código
QUESTION_ANSWERING Son embeddings para preguntas en un sistema de respuesta de preguntas, optimizados para encontrar documentos que respondan la pregunta. Usa QUESTION_ANSWERING para las preguntas y RETRIEVAL_DOCUMENT para los documentos que se recuperarán. Cuadro de chat
FACT_VERIFICATION Son embeddings para las declaraciones que se deben verificar, optimizados para recuperar documentos que contienen evidencia que respalda o refuta la declaración. Usa FACT_VERIFICATION para el texto objetivo y RETRIEVAL_DOCUMENT para los documentos que se recuperarán. Sistemas automatizados de verificación de datos

Cómo controlar el tamaño del embedding

El modelo de incorporación de Gemini, gemini-embedding-001, se entrena con la técnica de aprendizaje de representación de Matryoshka (MRL), que enseña a un modelo a aprender incorporaciones de alta dimensión que tienen segmentos iniciales (o prefijos) que también son versiones útiles y más simples de los mismos datos.

Usa el parámetro output_dimensionality para controlar el tamaño del vector de incorporación de salida. Seleccionar una dimensionalidad de salida más pequeña puede ahorrar espacio de almacenamiento y aumentar la eficiencia computacional para las aplicaciones posteriores, sin sacrificar mucho en términos de calidad. De forma predeterminada, genera una incorporación de 3,072 dimensiones, pero puedes truncarla a un tamaño más pequeño sin perder calidad para ahorrar espacio de almacenamiento. Recomendamos usar dimensiones de salida de 768, 1536 o 3072.

Python

from google import genai
from google.genai import types

client = genai.Client()

result = client.models.embed_content(
    model="gemini-embedding-001",
    contents="What is the meaning of life?",
    config=types.EmbedContentConfig(output_dimensionality=768)
)

[embedding_obj] = result.embeddings
embedding_length = len(embedding_obj.values)

print(f"Length of embedding: {embedding_length}")

JavaScript

import { GoogleGenAI } from "@google/genai";

async function main() {
    const ai = new GoogleGenAI({});

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-001',
        content: 'What is the meaning of life?',
        outputDimensionality: 768,
    });

    const embeddingLength = response.embedding.values.length;
    console.log(`Length of embedding: ${embeddingLength}`);
}

main();

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
)

func main() {
    ctx := context.Background()
    // The client uses Application Default Credentials.
    // Authenticate with 'gcloud auth application-default login'.
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()

    contents := []*genai.Content{
        genai.NewContentFromText("What is the meaning of life?", genai.RoleUser),
    }

    result, err := client.Models.EmbedContent(ctx,
        "gemini-embedding-001",
        contents,
        &genai.EmbedContentRequest{OutputDimensionality: 768},
    )
    if err != nil {
        log.Fatal(err)
    }

    embedding := result.Embeddings[0]
    embeddingLength := len(embedding.Values)
    fmt.Printf("Length of embedding: %d\n", embeddingLength)
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
-H "x-goog-api-key: YOUR_GEMINI_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
    "contents": [
        {"parts": [{"text": "What is the meaning of life?"}]}
    ],
    "embedding_config": {
        "output_dimensionality": 768
    }
}'

Ejemplo de resultado del fragmento de código:

Length of embedding: 768

Garantiza la calidad para dimensiones más pequeñas

El embedding de 3,072 dimensiones está normalizado. Las incorporaciones normalizadas producen una similitud semántica más precisa, ya que comparan la dirección del vector, no su magnitud. Para otras dimensiones, incluidas 768 y 1536, debes normalizar las incorporaciones de la siguiente manera:

Python

import numpy as np
from numpy.linalg import norm

embedding_values_np = np.array(embedding_obj.values)
normed_embedding = embedding_values_np / np.linalg.norm(embedding_values_np)

print(f"Normed embedding length: {len(normed_embedding)}")
print(f"Norm of normed embedding: {np.linalg.norm(normed_embedding):.6f}") # Should be very close to 1

Ejemplo de resultado de este fragmento de código:

Normed embedding length: 768
Norm of normed embedding: 1.000000

En la siguiente tabla, se muestran las puntuaciones de MTEB, una comparativa comúnmente utilizada para las incorporaciones, para diferentes dimensiones. En particular, el resultado muestra que el rendimiento no está estrictamente vinculado al tamaño de la dimensión del embedding, ya que las dimensiones más bajas logran puntuaciones comparables a las de sus contrapartes de dimensiones más altas.

Dimensión del MRL Puntuación de MTEB
2048 68.16
1536 68.17
768 67.99
512 67.55
256 66.19
128 63.31

Casos de uso

Las incorporaciones de texto son fundamentales para una variedad de casos de uso comunes de la IA, como los siguientes:

Almacenamiento de embeddings

A medida que llevas los embeddings a producción, es común usar bases de datos vectoriales para almacenar, indexar y recuperar de manera eficiente embeddings de alta dimensión. Google Cloud ofrece servicios de datos administrados que se pueden usar para este propósito, incluidos BigQuery, AlloyDB y Cloud SQL.

En los siguientes instructivos, se muestra cómo usar otras bases de datos de vectores de terceros con Gemini Embedding.

Versiones del modelo

Propiedad Descripción
Código del modelo

API de Gemini

gemini-embedding-001
Tipos de datos admitidos

Entrada

Texto

Resultado

Incorporaciones de texto
Límites de tokens[*]

Límite de tokens de entrada

2,048

Tamaño de la dimensión de salida

Flexible, admite: 128 a 3072, recomendado: 768, 1536, 3072
Versiones
Lee los patrones de versiones de modelos para obtener más detalles.
  • Estable: gemini-embedding-001
  • Experimental: gemini-embedding-exp-03-07
Última actualización Junio de 2025

Aviso de uso responsable

A diferencia de los modelos de IA generativa que crean contenido nuevo, el modelo de Gemini Embedding solo está diseñado para transformar el formato de tus datos de entrada en una representación numérica. Si bien Google es responsable de proporcionar un modelo de embedding que transforme el formato de tus datos de entrada al formato numérico solicitado, los usuarios conservan la responsabilidad total de los datos que ingresan y los embeddings resultantes. Si utilizas el modelo de Gemini Embedding, confirmas que tienes los derechos necesarios sobre cualquier contenido que subas. No generes contenido que infrinja la propiedad intelectual o los derechos de privacidad de otras personas. El uso de este servicio está sujeto a nuestra Política de Uso Prohibido y a las Condiciones del Servicio de Google.

Comienza a compilar con embeddings

Consulta el notebook de inicio rápido de las incorporaciones para explorar las capacidades del modelo y aprender a personalizar y visualizar tus incorporaciones.