Gemini 4 Argon ya está disponible. Pruébalo.

Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Embeddings

La API de Gemini ofrece modelos de embeddings para generar embeddings de texto, imágenes, video y otro contenido. Estas incorporaciones resultantes se pueden usar para tareas como la búsqueda semántica, la clasificación y el agrupamiento en clústeres, lo que proporciona resultados más precisos y adaptados al contexto que los enfoques basados en palabras clave.

El modelo más reciente, gemini-embedding-2, es el primer modelo de embeddings multimodal en la API de Gemini. Asigna texto, imágenes, video, audio y documentos a un espacio de embedding unificado, lo que permite la búsqueda, la clasificación y el agrupamiento en clústeres intermodales en más de 100 idiomas. Consulta la sección de incorporaciones multimodales para obtener más información. Para los casos de uso de solo texto, gemini-embedding-001 sigue estando disponible.

La compilación de sistemas de generación mejorada por recuperación (RAG) es un caso de uso común para los productos de IA. Los embeddings desempeñan un papel clave en la mejora significativa de los resultados del modelo con una mayor exactitud fáctica, coherencia y 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-2",
        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-2',
        contents: 'What is the meaning of life?',
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", null);

System.out.println(response.embeddings().orElse(null));

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-2",
        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-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "model": "models/gemini-embedding-2",
        "content": {
        "parts": [{
            "text": "What is the meaning of life?"
        }]
        }
    }'

Especifica el tipo de tarea para mejorar el rendimiento

Puedes usar embeddings 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 previstas, lo que maximiza la exactitud y la eficiencia.

Tipos de tareas con Embeddings 2

Para las tareas de solo texto con gemini-embedding-2, te recomendamos que agregues la instrucción de la tarea en tu instrucción. Para ello, se puede dar formato a la consulta y al documento con el prefijo de tarea correcto.

Cuando generes una incorporación única basada en una entrada multimodal, por lo general, no recomendamos anteponer una instrucción de tarea a la parte de texto de la entrada. En algunos casos, mejora el rendimiento, pero en otros, lo reduce.

En las siguientes tablas, se muestran ejemplos de cómo dar formato a las consultas y los documentos para casos de uso simétricos y asimétricos con el modelo gemini-embedding-2.

Casos de uso de recuperación (formato asimétrico)

En los casos de uso asimétricos, agrega el prefijo de la tarea a la consulta y aplica la estructura del documento para el contenido que deseas incorporar y recuperar.

Caso de uso	Estructura de una consulta	Estructura del documento
Búsqueda	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Si no hay título, usa `title: none`.
Búsqueda de respuestas	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Verificación de datos	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Recuperación de código	`task: code retrieval \| query: {content}`	`title: {title} \| text: {content}`

Ejemplo de uso

Python

# Generate embedding for a task's query. Use your correct task here:
def prepare_query(query):
    # return f"task: question answering | query: {query}"
    # return f"task: fact checking | query: {query}"
    # return f"task: code retrieval | query: {query}"
    return f"task: search result | query: {query}"

# Generate embedding for document of an asymmetric retrieval task:
def prepare_document(content, title=None):
    if title is None:
        title = "none"
    return f"title: {title} | text: {content}"

Casos de uso de entrada única (formato simétrico)

En los casos de uso simétricos, para la misma tarea, usa el mismo formato para la consulta y el documento.

Caso de uso	Estructura de entrada
Clasificación	`task: classification \| query: {content}`
Agrupamiento en clústeres	`task: clustering \| query: {content}`
Similitud semántica	`task: sentence similarity \| query: {content}` No uses este tipo para la búsqueda o la recuperación. Está diseñado para la similitud textual semántica.

Ejemplo de uso

Python

# Generate embedding for query & document of your task.
def prepare_query_and_document(content):
    # return f'task: clustering | query: {content}'
    # return f'task: sentence similarity | query: {content}'
    return f'task: classification | query: {content}'

Es importante que la tarea se use de manera coherente. Por ejemplo, si los documentos se incorporan con f'task: classification | query: {content}', la consulta también se debe incorporar siguiendo este formato de tarea.

Tipos de tareas con embeddings 1

Para gemini-embedding-001, puedes especificar el task_type en el método embedContent. 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 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";
// npm i compute-cosine-similarity
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,
        config: { 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();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;
import java.util.List;

Client client = new Client();

List<String> texts =
    Arrays.asList(
        "What is the meaning of life?",
        "What is the purpose of existence?",
        "How do I bake a cake?");

EmbedContentConfig config =
    EmbedContentConfig.builder().taskType("SEMANTIC_SIMILARITY").build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-001", texts, config);

List<ContentEmbedding> embeddings = response.embeddings().get();

for (int i = 0; i < texts.size(); i++) {
  for (int j = i + 1; j < texts.size(); j++) {
    List<Float> v1 = embeddings.get(i).values().get();
    List<Float> v2 = embeddings.get(j).values().get();
    double dotProduct = 0.0;
    double normA = 0.0;
    double normB = 0.0;
    for (int k = 0; k < v1.size(); k++) {
      dotProduct += v1.get(k) * v2.get(k);
      normA += v1.get(k) * v1.get(k);
      normB += v2.get(k) * v2.get(k);
    }
    double similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
    System.out.printf(
        "Similarity between '%s' and '%s': %.4f%n", texts.get(i), texts.get(j), similarity);
  }
}

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 ejecutan.

Tipos de tareas compatibles

Tipos de tareas compatibles con gemini-embedding-001:

Tipo de tarea	Descripción	Ejemplos
SEMANTIC_SIMILARITY	Embeddings optimizados para evaluar la similitud del texto.	Sistemas de recomendación, detección de duplicados
CLASSIFICATION	Embeddings optimizados para clasificar textos según las etiquetas predeterminadas.	Análisis de opiniones, detección de spam
AGRUPAMIENTO EN CLÚSTERES	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	Embeddings optimizados para la búsqueda de documentos.	Indexar artículos, libros o páginas web para la búsqueda
RETRIEVAL_QUERY	Embeddings optimizados para consultas de búsqueda generales. Usa `RETRIEVAL_QUERY` para las consultas 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 de código y búsqueda
QUESTION_ANSWERING	Embeddings para preguntas en un sistema de respuesta a 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	Embeddings para declaraciones que deben verificarse, optimizados para recuperar documentos que contengan evidencia que respalde o refute la declaración. Usa `FACT_VERIFICATION` para el texto de destino y `RETRIEVAL_DOCUMENT` para los documentos que se recuperarán.	Sistemas automatizados de verificación de datos

Controla el tamaño de los embeddings

Tanto gemini-embedding-001 como gemini-embedding-2 se entrenan con la técnica de aprendizaje de representaciones 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 más simples y útiles de los mismos datos.

Usa el parámetro output_dimensionality para controlar el tamaño del vector de embedding 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, ambos modelos generan 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 768, 1536 o 3072 dimensiones de salida.

Python

from google import genai
from google.genai import types

client = genai.Client()

result = client.models.embed_content(
    model="gemini-embedding-2",
    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-2',
        contents: 'What is the meaning of life?',
        config: { outputDimensionality: 768 },
    });

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

main();

Java

import com.google.genai.Client;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentConfig;
import com.google.genai.types.EmbedContentResponse;

Client client = new Client();

EmbedContentConfig config =
    EmbedContentConfig.builder().outputDimensionality(768).build();

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", "What is the meaning of life?", config);

ContentEmbedding embeddingObj = response.embeddings().get().get(0);
int embeddingLength = embeddingObj.values().get().size();

System.out.println("Length of embedding: " + embeddingLength);

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-2",
        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-2: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 de las dimensiones más pequeñas

Si bien los embeddings predeterminados de 3072 dimensiones siempre se normalizan, Gemini Embedding 2 también normaliza automáticamente las dimensiones truncadas (p.ej., 768, 1536). Esto garantiza que la similitud semántica se calcule a través de la dirección del vector en lugar de la magnitud, lo que proporciona resultados más precisos de inmediato.

Modelos más antiguos: Si usas gemini-embedding-001, debes normalizar de forma manual las dimensiones que no sean 3072 de la siguiente manera:

Python

import numpy as np
from numpy.linalg import norm

# Only for embeddings from `gemini-embedding-001`
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

Este es un ejemplo del 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 de uso frecuente para los embeddings, para diferentes dimensiones. En particular, el resultado muestra que el rendimiento no está estrictamente vinculado al tamaño de la dimensión de embedding, ya que las dimensiones más bajas obtienen puntuaciones comparables a las de sus contrapartes de dimensiones más altas.

Dimensión de MRL	Puntuación de MTEB (Gemini Embedding 001)
2048	68.16
1536	68.17
768	67.99
512	67.55
256	66.19
128	63.31

Embeddings multimodales

El modelo gemini-embedding-2 admite entradas multimodales, lo que te permite incorporar imágenes, videos, audio y contenido de documentos junto con texto. Todas las modalidades se asignan al mismo espacio de embedding, lo que permite la búsqueda y la comparación intermodales.

Modalidades y límites admitidos

El límite máximo general de tokens de entrada es de 8,192 tokens.

Modalidad	Especificaciones y límites
Texto	Admite hasta 8,192 tokens.
Imagen	Máximo de 6 imágenes por solicitud. Formatos admitidos: PNG y JPEG.
Audio	La duración máxima es de 180 segundos. Formatos admitidos: MP3 y WAV.
Video	Duración máxima de 120 segundos Formatos compatibles: MP4 y MOV. Códecs compatibles: H264, H265, AV1 y VP9. El sistema procesa un máximo de 32 fotogramas por video: los videos cortos (≤32 s) se muestrean a 1 fps, mientras que los videos más largos se muestrean de manera uniforme a 32 fotogramas. No se procesan las pistas de audio en los archivos de video.
Documentos (PDF)	Máximo de 1 archivo por solicitud, hasta 6 páginas.

Incorporación de imágenes

En el siguiente ejemplo, se muestra cómo incorporar una imagen con gemini-embedding-2.

Las imágenes se pueden proporcionar como datos intercalados o como archivos subidos a través de la API de Files.

Python

from google import genai
from google.genai import types

with open('example.png', 'rb') as f:
    image_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("example.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'image/png',
                data: imgBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("example.png"));

Content content = Content.fromParts(Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

IMG_PATH="/path/to/your/image.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "image/png",
                    "data": "'"${IMG_BASE64}"'"
                }
            }]
        }
    }'

Agregación de embeddings

Cuando trabajas con contenido multimodal, la forma en que estructuras la entrada afecta el resultado de la incorporación:

Varias partes (agregadas): Agregar varias entradas directamente al parámetro contents produce una incorporación agregada para todas las entradas.
Varios objetos Content (separados): Unir cada entrada en un objeto Content y pasarlos en el parámetro contents devuelve incorporaciones separadas para cada entrada.
Representación a nivel de la publicación: Para objetos complejos, como publicaciones de redes sociales con varios elementos multimedia, recomendamos agregar incorporaciones independientes (por ejemplo, con un promedio) para crear una representación coherente a nivel de la publicación.

En el siguiente ejemplo, se muestra cómo crear una incorporación agregada para la entrada de texto y de imagen. Simplemente agrega varias entradas al parámetro contents:

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('dog.png', 'rb') as f:
    image_bytes = f.read()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        "An image of a dog",
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

# This produces one embedding
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            'An image of a dog',
            {
                inlineData: {
                    mimeType: 'image/png',
                    data: imgBase64,
                },
            },
        ],
    });

    // This produces one embedding
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

Content content =
    Content.fromParts(
        Part.fromText("An image of a dog"),
        Part.fromBytes(imageBytes, "image/png"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

// This produces one embedding
for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
  System.out.println(embedding.values().orElse(Collections.emptyList()));
}

REST

IMG_PATH="/path/to/your/dog.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [
                {"text": "An image of a dog"},
                {
                    "inline_data": {
                        "mime_type": "image/png",
                        "data": "'"${IMG_BASE64}"'"
                    }
                }
            ]
        }
    }'

Por otro lado, si usas objetos Content dentro del parámetro contents, se devuelven embeddings independientes. En este ejemplo, se crean varios embeddings en una llamada de embedding:

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('dog.png', 'rb') as f:
    image_bytes = f.read()

result = client.models.embed_content(
    model="gemini-embedding-2",
    contents=[
        types.Content(parts=[types.Part.from_text(text="task: classification | query: An image of a dog")]),
        types.Content(
            parts=[
                types.Part.from_bytes(
                    data=image_bytes,
                    mime_type="image/png",
                ),
            ]
        ),
    ],
)

# This produces two embeddings
for embedding in result.embeddings:
    print(embedding.values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const imgBase64 = fs.readFileSync("dog.png", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [
            { parts: [{ text: 'task: classification | query: An image of a dog' }] },
            {
                parts: [{
                    inlineData: {
                        mimeType: 'image/png',
                        data: imgBase64,
                    },
                }],
            },
        ],
    });

    // This produces two embeddings
    for (const embedding of response.embeddings) {
        console.log(embedding.values);
    }
}

main();

Java

import java.util.Arrays;
import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.ContentEmbedding;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;

Client client = new Client();

byte[] imageBytes = Files.readAllBytes(Paths.get("dog.png"));

List<Content> contents =
    Arrays.asList(
        Content.fromParts(Part.fromText("task: classification | query: An image of a dog")),
        Content.fromParts(Part.fromBytes(imageBytes, "image/png")));

// Embed each Content object separately to produce separate embeddings
for (Content content : contents) {
  EmbedContentResponse response =
      client.models.embedContent("gemini-embedding-2", content, null);
  for (ContentEmbedding embedding : response.embeddings().orElse(Collections.emptyList())) {
    System.out.println(embedding.values().orElse(Collections.emptyList()));
  }
}

REST

IMG_PATH="/path/to/your/dog.png"
IMG_BASE64=$(base64 -w0 "${IMG_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:batchEmbedContents" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "requests": [
            {
                "model": "models/gemini-embedding-2",
                "content": {"parts": [{"text": "task: classification | query: An image of a dog"}]}
            },
            {
                "model": "models/gemini-embedding-2",
                "content": {"parts": [{"inline_data": {"mime_type": "image/png", "data": "'"${IMG_BASE64}"'"}}]}
            }
        ]
    }'

Incorpora audio

En el siguiente ejemplo, se muestra cómo incorporar un archivo de audio con gemini-embedding-2.

Los archivos de audio se pueden proporcionar como datos intercalados o como archivos subidos a través de la API de Files.

Python

from google import genai
from google.genai import types

with open('example.mp3', 'rb') as f:
    audio_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=audio_bytes,
            mime_type='audio/mpeg',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const audioBase64 = fs.readFileSync("example.mp3", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'audio/mpeg',
                data: audioBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] audioBytes = Files.readAllBytes(Paths.get("example.mp3"));

Content content = Content.fromParts(Part.fromBytes(audioBytes, "audio/mpeg"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

AUDIO_PATH="/path/to/your/example.mp3"
AUDIO_BASE64=$(base64 -w0 "${AUDIO_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "audio/mpeg",
                    "data": "'"${AUDIO_BASE64}"'"
                }
            }]
        }
    }'

Incorporando video

En el siguiente ejemplo, se muestra cómo incorporar un video con gemini-embedding-2.

Los videos se pueden proporcionar como datos intercalados o como archivos subidos a través de la API de Files.

Python

from google import genai
from google.genai import types

client = genai.Client()

with open('example.mp4', 'rb') as f:
    video_bytes = f.read()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=video_bytes,
            mime_type='video/mp4',
        ),
    ]
)

print(result.embeddings[0].values)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const videoBase64 = fs.readFileSync("example.mp4", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'video/mp4',
                data: videoBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;

Client client = new Client();

byte[] videoBytes = Files.readAllBytes(Paths.get("example.mp4"));

Content content = Content.fromParts(Part.fromBytes(videoBytes, "video/mp4"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(
    response.embeddings().get().get(0).values().orElse(Collections.emptyList()));

REST

VIDEO_PATH="/path/to/your/video.mp4"
VIDEO_BASE64=$(base64 -w0 "${VIDEO_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "video/mp4",
                    "data": "'"${VIDEO_BASE64}"'"
                }
            }]
        }
    }'

Si necesitas incorporar videos de más de 120 segundos, puedes dividirlos en segmentos superpuestos y, luego, incorporarlos de forma individual.

Incorpora documentos

Los documentos en formato PDF se pueden incorporar directamente. El modelo procesa el contenido visual y de texto de cada página.

Los archivos PDF se pueden proporcionar como datos intercalados o como archivos subidos a través de la API de Files.

Cómo procesa el modelo los archivos PDF

Cuando incorporas un PDF, el modelo procesa el documento con funciones visuales y de texto:

Representación visual: El modelo renderiza cada página como una imagen, lo que consume 258 tokens por página.
Extracción de texto: El modelo extrae texto del documento. En el caso de los PDF nativos (que contienen texto digital), el modelo extrae el texto directamente. En el caso de los PDF escaneados (que contienen imágenes de texto), el modelo ejecuta automáticamente el reconocimiento óptico de caracteres (OCR) para extraer el texto.

Para calcular el recuento total de tokens de un PDF, agrega los tokens visuales (258 por página) a los tokens de texto. Tus entradas deben ajustarse al límite de 8,192 tokens del modelo (compartido entre todas las modalidades). El sistema trunca de forma silenciosa las entradas que superan este límite.

Límites de PDF

Archivos por solicitud: Puedes enviar un máximo de 1 archivo PDF.
Límite de páginas: Puedes enviar un máximo de 6 páginas por archivo. Para obtener la mejor calidad, te recomendamos que uses 1 página por PDF.

En el siguiente ejemplo, se muestra cómo incorporar un PDF con gemini-embedding-2:

Python

from google import genai
from google.genai import types

with open('example.pdf', 'rb') as f:
    pdf_bytes = f.read()

client = genai.Client()

result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        types.Part.from_bytes(
            data=pdf_bytes,
            mime_type='application/pdf',
        ),
    ]
)

print(result.embeddings)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

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

    const pdfBase64 = fs.readFileSync("example.pdf", { encoding: "base64" });

    const response = await ai.models.embedContent({
        model: 'gemini-embedding-2',
        contents: [{
            inlineData: {
                mimeType: 'application/pdf',
                data: pdfBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

Java

import com.google.genai.Client;
import com.google.genai.types.Content;
import com.google.genai.types.EmbedContentResponse;
import com.google.genai.types.Part;
import java.nio.file.Files;
import java.nio.file.Paths;

Client client = new Client();

byte[] pdfBytes = Files.readAllBytes(Paths.get("example.pdf"));

Content content = Content.fromParts(Part.fromBytes(pdfBytes, "application/pdf"));

EmbedContentResponse response =
    client.models.embedContent("gemini-embedding-2", content, null);

System.out.println(response.embeddings().orElse(null));

REST

PDF_PATH="/path/to/your/example.pdf"
PDF_BASE64=$(base64 -w0 "${PDF_PATH}")

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2:embedContent" \
    -H "Content-Type: application/json" \
    -H "x-goog-api-key: ${GEMINI_API_KEY}" \
    -d '{
        "content": {
            "parts": [{
                "inline_data": {
                    "mime_type": "application/pdf",
                    "data": "'"${PDF_BASE64}"'"
                }
            }]
        }
    }'

Casos de uso

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

Generación mejorada por recuperación (RAG): Los embeddings mejoran la calidad del texto generado, ya que recuperan y, luego, incorporan información pertinente en el contexto de un modelo.
Recuperación de información: Busca el texto o los documentos más similares semánticamente según un fragmento de texto de entrada.

Instructivo de búsqueda de documentos
Cambio de clasificación de la búsqueda: Prioriza los elementos más relevantes asignando una puntuación semántica a los resultados iniciales en relación con la consulta.

Instructivo para volver a clasificar los resultados de la búsqueda
Detección de anomalías: Comparar grupos de embeddings puede ayudar a identificar tendencias ocultas o valores atípicos.

Instructivo sobre la detección de anomalías
Clasificación: Categoriza automáticamente el texto según su contenido, como el análisis de sentimiento o la detección de spam.

Instructivo de clasificación
Agrupamiento en clústeres: Comprende de forma eficaz las relaciones complejas creando clústeres y visualizaciones de tus incorporaciones.

Instructivo de visualización de agrupamiento en clústeres

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 forma eficiente embeddings de alta dimensión. Google Cloud ofrece servicios de datos administrados que se pueden usar para este propósito, incluidos Gemini Enterprise Agent Platform Vector Search 2.0, 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

Gemini Embedding 2

Propiedad	Descripción
Código del modelo	API de Gemini `gemini-embedding-2`
Tipos de datos admitidos	Entrada Texto, imagen, video, audio, PDF Resultado Embeddings de textos
Límites de tokens^[*]	Límite de tokens de entrada 8,192 Tamaño de la dimensión de salida Flexible, admite: 128-3072, recomendado: 768, 1536, 3072
Versiones	Lee los patrones de versiones de modelos para obtener más detalles. Estable: `gemini-embedding-2`
Última actualización	Abril de 2026

Embedding de Gemini

Propiedad	Descripción
Código del modelo	API de Gemini `gemini-embedding-001`
Tipos de datos admitidos	Entrada Texto Resultado Embeddings de textos
Límites de tokens^[*]	Límite de tokens de entrada 2,048 Tamaño de la dimensión de salida Flexible, admite: 128-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 conocer los modelos de Embeddings obsoletos, visita la página Bajas

Migración desde gemini-embedding-001

Los espacios de embedding entre gemini-embedding-001 y gemini-embedding-2 son incompatibles. Esto significa que no puedes comparar directamente los embeddings generados por un modelo con los generados por el otro. Si actualizas a gemini-embedding-2, debes volver a incorporar todos tus datos existentes.

Además de la incompatibilidad, existen otras diferencias notables entre los dos modelos:

Especificación del tipo de tarea: Con gemini-embedding-001, especificas el tipo de tarea con el parámetro task_type (p.ej., SEMANTIC_SIMILARITY, RETRIEVAL_DOCUMENT). Con gemini-embedding-2, no se admite el parámetro task_type. En su lugar, debes incluir instrucciones de la tarea directamente en la instrucción para las tareas de solo texto. Consulta Tipos de tareas con Embeddings 2 para obtener detalles sobre cómo dar formato a las instrucciones para diferentes casos de uso.
Agregación de embeddings: gemini-embedding-001 genera embeddings individuales para cada cadena en una lista de entradas. En cambio, gemini-embedding-2 produce una sola incorporación agregada cuando se proporcionan varias entradas (como texto e imágenes) directamente en una solicitud. Para generar embeddings independientes para entradas individuales, une cada entrada en un objeto Content o usa la API de Batch. Consulta Agregación de incorporaciones para obtener más información.
Normalización: Si usas output_dimensionality para solicitar incorporaciones con menos de 3,072 dimensiones, gemini-embedding-2 normaliza automáticamente estas incorporaciones truncadas. Con gemini-embedding-001, debes realizar la normalización manual para dimensiones que no sean 3072. Consulta Garantiza la calidad de las dimensiones más pequeñas para obtener más detalles.

Embeddings por lotes

Si la latencia no es un problema, intenta usar los modelos de Gemini Embeddings con la API de Batch. Esto permite una capacidad de procesamiento mucho mayor al 50% del precio predeterminado de Embedding. Encuentra ejemplos para comenzar en la guía de soluciones de la API de Batch.

Aviso de uso responsable

A diferencia de los modelos de IA generativa que crean contenido nuevo, el modelo de embedding de Gemini 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 embeddings 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 usas el modelo de embedding de Gemini, 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 la guía de inicio rápido de embeddings para explorar las capacidades del modelo y aprender a personalizar y visualizar tus embeddings.

Caso de uso	Estructura de una consulta	Estructura del documento
Búsqueda	`task: search result \| query: {content}`	`title: {title} \| text: {content}` Si no hay título, usa `title: none`.
Búsqueda de respuestas	`task: question answering \| query: {content}`	`title: {title} \| text: {content}`
Verificación de datos	`task: fact checking \| query: {content}`	`title: {title} \| text: {content}`
Recuperación de código	`task: code retrieval \| query: {content}`	`title: {title} \| text: {content}`