Embeddings

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

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

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";
// 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();

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

Tanto gemini-embedding-001 como gemini-embedding-2-preview se entrenan 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, 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 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',
        contents: 'What is the meaning of life?',
        config: { outputDimensionality: 768 },
    });

    const embeddingLength = response.embeddings[0].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

La incorporación de 3,072 dimensiones está normalizada. 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 dimensión más alta.

Dimensión del 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-preview admite entradas multimodales, lo que te permite incorporar contenido de imágenes, videos, audio y documentos junto con texto. Todas las modalidades se asignan al mismo espacio de incorporación, lo que permite la búsqueda y la comparación entre modalidades.

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 80 segundos. Formatos admitidos: MP3 y WAV.
Video La duración máxima es de 120 segundos. Formatos admitidos: 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 forma uniforme hasta 32 fotogramas. Las pistas de audio no se procesan en los archivos de video.
Documentos (PDF) Máximo de 6 páginas.

Cómo incorporar imágenes

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

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'image/png',
                data: imgBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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 la incorporación

Cuando trabajas con contenido multimodal, la forma en que estructures tu entrada afectará el resultado de la incorporación:

  • Entrada de contenido única: Si envías varias partes (por ejemplo, texto y una imagen) en una sola entrada de contenido, se producirá una incorporación agregada para todas las modalidades dentro de esa entrada.
  • Varias entradas: Si envías varias entradas en el array contents, se devuelven incorporaciones separadas para cada entrada.
  • Representación a nivel de la publicación: Para objetos complejos, como las publicaciones en redes sociales con varios elementos multimedia, recomendamos agregar incorporaciones separadas (por ejemplo, promediándolas) para crear una representación coherente a nivel de la publicación.

En el siguiente ejemplo, se muestra cómo crear un embedding agregado para la entrada de texto y la imagen. Usa el campo parts para combinar varias entradas:

Python

from google import genai
from google.genai import types

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

result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents=[
        types.Content(
            parts=[
                types.Part(text="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-preview',
        contents: {
            parts: [
                { text: 'An image of a dog' },
                { inlineData: { mimeType: 'image/png', data: imgBase64 } },
            ],
        },
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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, este ejemplo crea varios embeddings en una sola llamada de embedding:

Python

from google import genai
from google.genai import types

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

result = client.models.embed_content(
    model='gemini-embedding-2-preview',
    contents=[
        "The dog is cute",
        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-preview',
        contents: [
            'The dog is cute',
            {
                inlineData: {
                    mimeType: 'image/png',
                    data: imgBase64,
                },
            },
        ],
    });

    console.log(response.embeddings);
}

main();

REST

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

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

Cómo incorporar audio

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

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'audio/mpeg',
                data: audioBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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}"'"
                }
            }]
        }
    }'

Cómo incorporar un video

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

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'video/mp4',
                data: videoBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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.

Incorporación de 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.

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-preview',
    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-preview',
        contents: [{
            inlineData: {
                mimeType: 'application/pdf',
                data: pdfBase64,
            },
        }],
    });

    console.log(response.embeddings);
}

main();

REST

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

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-2-preview: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

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 Vertex AI 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

Versión preliminar 2 de Gemini Embedding

Propiedad Descripción
Código del modelo

API de Gemini

gemini-embedding-2-preview
Tipos de datos admitidos

Entrada

Texto, imagen, video, audio, PDF

Resultado

Incorporaciones de texto
Límites de tokens[*]

Límite de tokens de entrada

8,192

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.
  • Vista previa: gemini-embedding-2-preview
Última actualización Noviembre de 2025

Gemini Embedding

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 dejaron de estar disponibles, visita la página Bajas.

Migración desde gemini-embedding-001

Los espacios de incorporación entre gemini-embedding-001 y gemini-embedding-2-preview 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-preview, debes volver a incorporar todos tus datos existentes.

Incorporaciones por lotes

Si la latencia no es un problema, intenta usar los modelos de Gemini Embeddings con la API de Batch. Esto permite un rendimiento 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 usas el modelo de Gemini Embedding, confirmas que tienes los derechos necesarios sobre todo el 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.