Embeddings

La API de Gemini ofrece modelos de incorporación de texto para generar incorporaciones de palabras, frases, oraciones y código. Tareas de incorporación, como la búsqueda semántica, la clasificación y la agrupación en clústeres, que 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 productos de IA. 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. Si prefieres usar una solución de RAG administrada, creamos la herramienta Búsqueda de archivos, que facilita la administración de la RAG y la hace más rentable.

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 "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -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 "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    },
    "taskType": "SEMANTIC_SIMILARITY"
    }'

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 pandas as pd
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 = client.models.embed_content(
    model="gemini-embedding-001",
    contents=texts,
    config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")
)

# Create a 3x3 table to show the similarity matrix
df = pd.DataFrame(
    cosine_similarity([e.values for e in result.embeddings]),
    index=texts,
    columns=texts,
)

print(df)

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 "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
    "taskType": "SEMANTIC_SIMILARITY",
    "content": {
        "parts": [
        {
            "text": "What is the meaning of life?"
        },
        {
            "text": "How much wood would a woodchuck chuck?"
        },
        {
            "text": "How does the brain work?"
        }
        ]
    }
    }'

Los fragmentos de código mostrarán qué tan similares son los diferentes fragmentos de texto entre sí cuando se ejecuten.

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 Son 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 las 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 en función de 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 de código y búsqueda
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 las incorporaciones para las declaraciones que se deben verificar, optimizadas 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 de procesamiento para las aplicaciones downstream, 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 'Content-Type: application/json' \
    -H "x-goog-api-key: $GEMINI_API_KEY" \
    -d '{
        "content": {"parts":[{ "text": "What is the meaning of life?"}]},
        "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. Los embeddings normalizados 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
Última actualización Junio de 2025

Para obtener información sobre los modelos de Embeddings que se dieron de baja, visita la página Bajas.

Embeddings por lotes

Si la latencia no es un problema, intenta usar el modelo de Gemini Embeddings con la API de Batch. Esto permite una capacidad de procesamiento mucho mayor con el 50% del precio predeterminado de Embedding. Encuentra ejemplos para comenzar en el recetario de la API de Batch.

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 incorporación 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 las incorporaciones 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.