Lección 9 · 10 min · Gratis

Introducción a los embeddings

Copyright 2026 Google LLC.

# @title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Los embeddings son representaciones numéricas que capturan las relaciones entre diferentes entradas. Los embeddings de texto logran esto al convertir el texto en arreglos de números de punto flotante conocidos como vectores. El propósito principal de estos vectores es encapsular el significado semántico del texto. La dimensionalidad del vector, que es la longitud del arreglo de embedding, puede ser bastante grande, con un pasaje de texto a veces representado por un vector con cientos de dimensiones.

La API de Gemini genera embeddings de texto de última generación. Un embedding es una lista de números de punto flotante que representan el significado de una palabra, oración o párrafo. Puedes usar embeddings en muchas aplicaciones posteriores, como la búsqueda de documentos.

Este notebook proporciona ejemplos de código rápidos que te muestran cómo empezar a generar embeddings.

Nota: Este notebook utiliza la API de Interacciones, la forma más reciente de interactuar con los modelos de Gemini. ¿Buscas la versión generateContent? Consulta la rama de archivo.

Tabla de Contenidos

Configuración: Instala el SDK y configura tu clave de API.
Embedir contenido: Genera embeddings de texto para entradas individuales o múltiples.
Embeddings multimodales: Genera embeddings para imágenes, audio, video y PDFs.
Configuración de la dimensionalidad de los embeddings: Explora cómo reducir la dimensionalidad de los embeddings.
Embeddings en la práctica: Análisis de similitud de oraciones usando similitud de coseno y visualización de mapa de calor.
Uso de task_type: Aprende a usar task_type para varias aplicaciones como la Generación Aumentada por Recuperación (RAG).

Configuración

Instalar SDK

Instala el SDK desde PyPI.

%pip install -q -U "google-genai>=2.9.0"  # Minimum version 1.73 for latest embedding behavior # 2.0 is needed to use the interactions API

Configura tu clave de API

Para ejecutar la siguiente celda, tu clave de API debe estar almacenada en un Secreto de Colab llamado GEMINI_API_KEY. Si aún no tienes una clave de API o no estás seguro de cómo crear un Secreto de Colab, consulta Autenticación para ver un tutorial.

from google.colab import userdata

GEMINI_API_KEY = userdata.get('GEMINI_API_KEY')

Inicializar cliente SDK

Con el nuevo SDK, ahora solo necesitas inicializar un cliente con tu clave de API (o OAuth si usas Vertex AI). El modelo ahora se configura en cada llamada.

from google import genai
from google.genai import types

client = genai.Client(api_key=GEMINI_API_KEY)

Elige un modelo

Selecciona el modelo que quieres usar en esta guía.

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

Para una descripción completa de todos los modelos de Gemini, consulta la documentación.

MODEL_ID = "gemini-embedding-2" # @param ["gemini-embedding-2", "gemini-embedding-001"] {"allow-input":true, isTemplate: true}

Embedir contenido

Llama al método embed_content con el modelo para generar embeddings de texto.

text = ["Hello world"]
result = client.models.embed_content(model=MODEL_ID, contents=text)
[embedding] = result.embeddings

# Print just a part of the embedding to keep the output manageable
print(str(embedding.values)[:50], '... TRIMMED]')

[-0.022945018, 0.010467435, 0.036357775, -0.016608 ... TRIMMED]

print(len(embedding.values))  # The embeddings have 3072 dimensions by default

Embeddings multimodales

gemini-embedding-2 soporta los siguientes formatos:

Texto Soporta hasta 8,192 tokens.
Imagen Máximo de 6 imágenes por solicitud. Formatos soportados: PNG, JPEG.
PDF Máximo de 6 páginas.
Audio Duración máxima de 80 segundos. Formatos soportados: MP3, WAV.
Video Duración máxima de 128 segundos. Formatos soportados: MP4, MOV.

El límite máximo total de tokens de entrada es de 8192 tokens.

Embedir imágenes

El siguiente ejemplo muestra cómo embedir una imagen. Las imágenes se pueden proporcionar como datos en línea o como archivos subidos a través de la API de Archivos.

!wget -O jetpack.png https://storage.googleapis.com/generativeai-downloads/data/jetpack.png -q

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

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

print(result.embeddings)

[ContentEmbedding(
  values=[
    -0.03188358,
    0.0028190175,
    0.01101356,
    0.023310632,
    -0.0031198186,
    <... 3067 more items ...>,
  ]
)]

Agregación de embeddings

Cuando trabajas con contenido multimodal, la forma en que estructuras tu entrada afecta la salida del embedding:

Múltiples partes (agregadas): Agregar múltiples entradas directamente al parámetro contents produce un embedding agregado para todas las entradas.
Múltiples objetos Content (separados): Envolver cada entrada en un objeto Content y pasarlos en el parámetro contents devuelve embeddings separados para cada entrada.
Representación a nivel de publicación: Para objetos complejos como publicaciones de redes sociales con múltiples elementos multimedia, considera agregar embeddings separados (por ejemplo, promediando) para crear una representación coherente a nivel de publicación.

El siguiente ejemplo muestra cómo crear un embedding agregado para entrada de texto e imagen. Simplemente agrega múltiples entradas al parámetro contents:

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

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

[-0.02778835, 0.012552851, 0.0074134488, 0.016986629, 0.004565372, 0.003892788, -0.008809239, 0.011119711, 0.009723783, -0.039775036, -0.029003154, -0.018113032, -0.012267044, -0.014001558, 0.0035700165, -0.0029606563, 0.030061353, -0.0115160765, 0.00014948237, -0.010276958, -0.0009143479, -0.017755022, 0.01311356, 0.017797748, 0.0065239375, 0.004207317, -0.008008417, -0.011630626, 0.01467528, 0.076085314, -0.016140226, -0.00040286762, 0.01713585, -0.0115699135, -0.002077845, 0.0012446983, 0.011202561, 0.025717957, -0.022337716, -0.00024838338, -0.014326085, 0.01896089, 0.010997034, 0.004754592, -0.011108505, 0.038496148, -0.0051699798, 0.0031737643, -0.004062993, 0.015033479, -0.0007253209, 0.018029312, 0.010101663, -0.0032409497, 0.010032238, 0.012775425, -0.021532793, -0.014076273, 0.016891634, 0.00079977687, -0.009644016, 0.016040443, -0.005372171, 0.009447167, 0.00059385103, -0.006214174, 0.0002459909, 0.0043732645, 0.0071064914, -0.009595027, -0.028627764, 0.0068663177, -0.019665072, 0.023707911, 0.0035378037, -0.047712833, -0.05295487, -0.010330729, -0.0034813385, 0.007987745, 0.012439682, 0.0054811323, -0.010801403, -0.02532628, -0.020354321, -0.034843348, 0.0011018439, 0.005206409, 0.029007053, 0.037867375, 0.009539551, 0.007968458, 0.00084738445, -0.0062786858, 0.0046766857, 0.010914774, 0.017554933, 0.0065955017, 0.013148687, -0.015273804, -0.01830454, -0.00033194243, -0.01617461, 0.0010980692, 0.016161203, -0.030305177, 0.011681755, 0.011977882, -0.011198825, -0.008404401, 0.007734854, -0.12926741, -0.01621519, 0.00911485, 0.018415174, 0.1248994, 0.015942974, -0.01014918, 0.0041940813, 0.04272082, -0.020302936, 0.023501312, 0.006301885, 0.011231733, -0.009127419, 0.005810645, 0.009564427, 0.0058093714, -0.019092772, -0.014280515, 0.0010654485, 0.019291723, 0.0038377063, -0.0012526176, 0.00083230215, 0.011623883, 0.004350422, 0.0077868835, 0.029452136, -0.011095386, -0.017374901, -0.012156127, -0.011319708, -0.015120911, -0.0043184357, 0.011864234, 0.012482831, 0.0058199354, -0.010807819, -0.025389554, -0.0063635753, 0.0119141145, -0.007944831, 0.010013601, 0.01434831, -0.025725173, 0.02246274, 0.02602137, -0.008211809, -0.0033362038, -0.011179087, 0.005768078, -0.017304149, -0.009144884, -0.029654313, 0.0135012185, -0.012497788, 0.0082873115, -0.02336313, -0.027214123, 0.010224667, -0.010325975, -0.014214465, 0.0061839367, 0.0049342103, -0.029080488, -0.015055435, -0.01109348, -0.008769813, 0.011201178, 0.026129872, 0.0016085361, -0.028889587, -0.049366232, -0.024407415, -0.02261669, -0.015916303, -0.008063861, 0.009669266, -0.028043697, 0.032092243, 0.0027053761, 0.021146491, 0.009861507, 0.0008628431, -0.014810581, -0.008014855, 0.0008584228, -0.025729645, 0.00034268256, -0.025637362, -0.008086714, -0.014880562, 0.021276845, -0.008933678, 0.008767511, 0.016375381, -0.007772, 0.010856446, 0.00951984, 0.011245429, -0.015104418, 0.0110375825, 0.009971622, 0.01125846, -0.0027548762, 0.013100166, 0.044461627, -0.012143365, 0.005338
… (salida recortada)

Por otro lado, si usas objetos Content dentro del parámetro contents, devuelve embeddings separados.

Este ejemplo crea múltiples embeddings en una sola llamada de embedding:

result = client.models.embed_content(
    model="gemini-embedding-2",
    contents=[
        types.Content(parts=[types.Part.from_text(text="The jetpack is cool")]),
        types.Content(
            parts=[
                types.Part.from_bytes(
                    data=image_bytes,
                    mime_type="image/jpeg",
                ),
            ]
        ),
    ],
)

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

[-0.012537271, 0.011105311, 0.0111775575, 0.0045039845, 0.016670028, 0.008185058, -0.023040224, 0.0212555, 0.035178464, -0.050990116, -0.022403486, -0.008161873, 0.0011535354, 0.016815925, 0.021920172, 0.009631144, 0.03867864, -0.011210484, 0.025030917, -0.006656883, 0.010439161, -0.013888226, 0.019782957, 0.022956759, 0.0024263652, 0.003941284, -0.019987589, 0.007946931, 0.0069078924, 0.12965442, -0.008772056, 0.005368113, 0.022258857, -0.020772723, 0.014085056, -0.00888185, -0.031201258, 0.018691815, -0.020796841, -0.006706359, -0.0039560455, 0.004918334, 0.005459077, 0.005900538, -0.011068883, 0.0033229552, -0.018293332, 0.005533651, -0.008253562, 0.017871954, -0.008394375, 0.021638563, 0.024544567, -0.006286173, 0.017257933, 0.013474631, 0.0036182064, -0.015114975, -0.012351616, 0.025346233, 0.0014939321, 0.011382883, 0.024179881, 0.01987619, 0.008535698, -0.012773408, 0.0054738363, -0.0011921852, 0.007293441, -0.013842952, -0.013377506, -0.013628668, -0.006290459, 0.012558342, -0.0059397435, -0.048737463, -0.011729136, -0.010562439, 0.021188194, 0.0066612507, 0.013711574, 0.0051190993, -0.018294565, -0.015041531, -0.014181303, -0.005262231, -0.0031462947, 0.01478749, 0.011606258, 0.0052610002, -0.023294872, 0.0009616699, 0.00846036, 0.0017626126, 0.0081239045, 0.018726029, -0.009308041, -0.0015126051, 0.029529734, 0.007928983, -0.00500481, 0.022303285, -0.028071746, -0.0053558885, 0.03556608, -0.0021019618, 0.0028194154, 0.007110919, -0.014220911, -0.017373487, 0.0024131765, -0.18439676, 0.0072665242, 0.0074010757, 0.013764999, -0.04889673, 0.011638607, -0.018512107, -0.0030412532, 0.018510686, -0.005991139, 0.011327324, -0.022747641, 0.004093366, 0.004244092, -0.008273078, 0.008451467, 0.019726807, -0.016217029, 0.011642602, -0.00020606478, 0.0073903124, 0.0014453854, -0.006502785, 0.019662157, 0.008364207, -0.00070826674, -0.004499434, 0.018015653, 0.0034871136, -0.00288033, -0.014039816, 0.01499932, -0.0006708965, -0.010164515, 0.04095589, -0.007326831, 0.010022735, 0.0015956409, -0.027611075, -0.011788524, 0.015815636, -0.014882781, 0.011543166, 0.0021114023, -0.0073439544, -0.032825273, 0.0019009865, -0.007026518, -0.014041235, -0.01611181, 0.031630557, -0.015528935, -0.013631811, -0.017265584, 0.019153258, -0.019002898, -0.014057904, -0.00053339254, -0.016771942, 0.0078098816, -0.002946859, 0.020153694, 0.008737279, -0.0045911986, -0.0067482255, 0.00014232736, -0.01310386, 0.0026920547, 0.0019933153, 0.018510876, -0.0037558589, -0.022249565, -0.012461829, 0.010682469, -0.022187952, 0.002300171, -0.017663643, 0.007664655, -0.0071672704, 0.015341395, -0.0043276674, 0.023331577, 0.012886623, -0.007804073, -0.0027048253, 0.008434831, 0.0009269262, 0.013894832, 0.001994782, 0.006816899, 0.005687434, -0.0032428738, 0.017743547, 0.007993045, 0.011497671, -0.0011696594, -0.007219297, 0.011080499, 0.00779504, 0.028609453, -0.011731844, -0.004585539, 0.0014515254, 0.0048651425, -0.0060695047, 0.03666908, 0.034877587, 0.00064925913, 0.00736
… (salida recortada)

Embedir audio

El siguiente ejemplo muestra cómo embedir un archivo de audio. Los archivos de audio se pueden proporcionar como datos en línea o como archivos subidos a través de la API de Archivos.

import urllib.request

URL = "https://www.gstatic.com/aistudio/starter-apps/multimodal-search/audio/trees.wav"
urllib.request.urlretrieve(URL, "trees.wav")
print("Downloaded: trees.wav")

Downloaded: trees.wav

with open('trees.wav', 'rb') as f:
    audio_bytes = f.read()

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

print(result.embeddings[0].values)

[-0.014691585, 0.022381227, -0.013206677, 0.011850665, 0.035578083, 0.0019977319, 0.0061851162, -0.02625317, 0.018176861, -0.0376006, -0.007400012, -0.004811848, 0.0013297366, 0.010735975, 0.009879117, -0.00013183385, 0.008404383, -0.018060809, -0.0026535313, -0.0037703787, -0.033835664, -0.035023443, -0.0032417765, 0.00401048, 0.0048302817, -0.029469417, 0.02552336, -0.009023221, -0.011809175, 0.11926748, -0.03401857, 0.009873673, 0.026386354, 2.164341e-05, 0.0143720135, -0.00943945, 0.001056374, -0.0081864875, 0.022911739, -0.027950134, -0.022190422, 0.007024908, 0.0010172483, -0.03719566, -0.010239827, -0.018494084, -0.019610485, 0.011971436, 0.0013588186, 0.0099576535, 0.038609374, 0.002232686, 0.030444141, -0.0004659526, -0.0124453865, 0.012268184, 0.00824353, -0.0019136879, -0.011247799, -0.004566389, -0.012848222, 0.01516032, 0.0034197615, 0.011052642, -0.014403176, -0.0133214155, 0.004996937, -0.007384965, 0.003393705, 0.0073623694, -0.02919131, -0.012201679, -0.018458609, -0.016050555, -0.020256585, -0.022044053, -0.033897135, 0.004659585, 0.018449754, 0.0038214638, 0.003672345, 0.022083692, -0.016705211, -0.009616214, 0.004820077, 0.0030237827, 0.00906898, 0.020626811, -0.013246924, -0.023521714, -0.035139635, 0.010121011, 0.0034017407, 0.009667699, 0.011062309, 0.010908458, -0.0152256265, 0.01619588, 0.012436912, 0.00942383, -0.0025551848, 0.0070650727, 0.008301209, -0.009983308, 0.0304257, 0.008954758, 0.009830823, -0.0021577224, 0.013484571, -0.008867041, -0.011748532, -0.18719286, 0.00022027633, 0.005787032, -0.016106628, -0.029044516, 0.0077807903, -0.026034478, -0.018864017, 0.014822266, -0.0018417435, -0.0016841241, -0.008262305, -0.01880203, 0.0040691616, -0.005239105, 0.0049488433, -0.021574778, -0.029243035, -0.009432558, 0.00043044856, 0.01224369, 0.009969707, -0.007873241, -0.00016742412, -0.018635888, 0.009311246, 0.0071425075, 0.0033996054, 0.015570762, -0.005943804, -0.008081988, -0.025945934, 0.008979204, -0.0017514909, -0.0008390674, -0.0065548383, -0.0039433646, 0.0042552208, -0.040415958, -0.008293621, -0.0113566285, -0.017294768, 0.0024049266, -0.010308182, -0.0040752636, -0.0044787796, 0.019228503, 0.02793858, 0.008714845, -0.007139691, 0.007401892, -0.021916024, -0.0020478398, -0.012951325, 0.008315473, 0.0055559566, -0.01890427, -0.019276043, -0.009631771, -0.0050742943, 0.010531905, 0.0053190277, -0.008384675, 0.024063103, -0.007175959, -0.028478408, -0.019662227, 0.0056083323, -0.0046664984, 0.0056883018, -0.006598157, 0.0013392204, -0.015224341, 0.016803242, -0.0105889095, 0.0049623097, 0.014885412, 0.028633298, -0.014557888, 0.001682575, -0.025178215, 0.016481396, -0.002667586, 0.020207368, 0.033516236, 0.027215961, -0.008737738, 0.010656108, -0.011343713, -0.0027476796, -0.00040909377, -0.0020231733, 0.010956525, -0.028951183, -0.017835429, -0.0051926556, 0.007711479, -0.007172754, -0.035760768, 0.025603384, -0.009358269, 0.013981581, 0.0035797232, -0.00020145954, 0.015346323, 0.019190395, 0.05149846, -
… (salida recortada)

Embedir video

El siguiente ejemplo muestra cómo embedir un archivo de video. Los archivos de video se pueden proporcionar como datos en línea o como archivos subidos a través de la API de Archivos.

URL = "https://storage.googleapis.com/generativeai-downloads/gemini-cookbook/videos/unicorn.mp4"
!wget -q $URL -O unicorn.wav

with open('unicorn.wav', '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/wav',
      ),
    ]
)

print(result.embeddings[0].values)

None

Embedir PDFs

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

Los PDFs se pueden proporcionar como datos en línea o como archivos subidos a través de la API de Archivos.

!wget -O handwriting_form.pdf https://storage.googleapis.com/generativeai-downloads/data/pdf_structured_outputs/handwriting_form.pdf  -q

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

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

print(result.embeddings)

[ContentEmbedding(
  values=[
    -0.0036888449,
    -0.01085183,
    -0.008020795,
    -0.021453166,
    0.0032369115,
    <... 3067 more items ...>,
  ]
)]

Embedir contenido en lotes

Puedes embedir una lista de múltiples prompts con una sola llamada a la API para mayor eficiencia.

result = client.models.embed_content(
    model=MODEL_ID,
    contents=[
      'What is the meaning of life?',
      'How much wood would a woodchuck chuck?',
      'How does the brain work?'])

for embedding in result.embeddings:
    # Print just a part of the embedding to keep the output manageable
  print(str(embedding)[:50], '... TRIMMED]')

values=[-0.00023927985, 0.011614043, -0.003794512, ... TRIMMED]

Configuración de la dimensionalidad de los embeddings

Los modelos de embedding también soportan dimensiones de embedding más bajas. Especifica output_dimensionality para truncar la salida.

text=["Hello world"]
# Not truncated
result1 = client.models.embed_content(
    model=MODEL_ID,
    contents=text)


# Truncated
from google.genai import types

result2 = client.models.embed_content(
    model=MODEL_ID,
    contents=text,
    config=types.EmbedContentConfig(output_dimensionality=10))

[embedding1] = result1.embeddings
[embedding2] = result2.embeddings


(len(embedding1.values), len(embedding2.values))

Embeddings en la práctica - Análisis de similitud de oraciones

El análisis de similitud de oraciones aprovecha los modelos de embedding para transformar oraciones en vectores numéricos que encapsulan su significado semántico. Esto permite la comparación de oraciones midiendo la distancia o el ángulo entre sus respectivos vectores en un espacio de alta dimensión. De esta manera, los textos con significados similares tendrán vectores más cercanos entre sí.

Para este ejemplo, usarás un dataframe de Pandas para almacenar oraciones y calcular la similitud de una oración externa con ellas.

import pandas as pd

text = [
    "I really enjoyed last night's movie",
    "The film featured a lot of acrobatic scenes yesterday",
    "I had fun writing my first program in Python",
    "a tremendous feeling of relief to finally get my Nodejs scripts to run without errors!",
    "Oh Romeo, Romeo, wherefore art thou Romeo?"
]

df = pd.DataFrame(text, columns=["text"])
df

Ahora crearás una nueva columna de dataframe llamada embeddings para generar los embeddings para cada texto usando el modelo de embedding.

df["embeddings"] = df.apply(lambda x: client.models.embed_content(model=MODEL_ID, contents=(x['text'])).embeddings[0].values, axis=1)
df

Analizando la similitud de ejemplos de texto con similitud de coseno

Al convertir texto en embeddings, puedes calcular puntuaciones de similitud. Hay muchas formas de calcular puntuaciones de similitud, y una técnica común es usar la similitud de coseno.

En el ejemplo anterior, dos de las oraciones en la columna de texto se refieren a disfrutar de una película, y las otras dos se relacionan con disfrutar de la programación. Las puntuaciones de similitud de coseno deberían ser más altas (cercanas a 1.0) al hacer comparaciones por pares entre oraciones semánticamente relacionadas, y las puntuaciones deberían ser más bajas entre oraciones semánticamente diferentes.

La salida del DataFrame a continuación muestra las puntuaciones de similitud de coseno resultantes entre los embeddings:

from sklearn.metrics.pairwise import cosine_similarity

cos_sim_array = cosine_similarity(list(df.embeddings.values))

# display as DataFrame
similarities = pd.DataFrame(cos_sim_array, index=text, columns=text)
similarities

Para que esto sea más fácil de entender, puedes usar un mapa de calor. Naturalmente, el texto es más similar cuando son idénticos (puntuación de 1.0). Las siguientes puntuaciones más altas son cuando las oraciones son semánticamente similares. Las puntuaciones más bajas son cuando las oraciones son bastante diferentes en significado.

import seaborn as sns
import matplotlib.pyplot as plt

plt.figure(figsize=(8, 6))
ax = sns.heatmap(similarities, annot=True, cmap="crest")
ax.xaxis.tick_top()
ax.set_xticklabels(text, rotation=90)
plt.show()

Embeddings.ipynb:cell_45:8: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown

Uso de `task_type` para diferentes escenarios

IMPORTANTE: La siguiente sección se refiere a gemini-embedding-001. Con gemini-embedding-2, el parámetro task_type no es compatible. En su lugar, debes incluir instrucciones de tarea directamente en el prompt para tareas solo de texto. Consulta la documentación de Tipos de tarea con Embeddings 2 para obtener detalles sobre cómo formatear prompts para diferentes casos de uso.

Al generar embeddings, especialmente para sistemas complejos como la Generación Aumentada por Recuperación (RAG), un enfoque único para todos a veces puede llevar a resultados de menor calidad. Por ejemplo, una pregunta como "¿Por qué el cielo es azul?" y su respuesta, "La dispersión de la luz solar causa el color azul", tienen significados distintos como afirmaciones, y un modelo de embedding de propósito general podría no reconocer su fuerte relación. Para resolver esto, puedes especificar un task_type al crear embeddings. Esto instruye al modelo a producir vectores que están específicamente optimizados para tu caso de uso previsto, lo que puede mejorar significativamente el rendimiento y también ahorrar tiempo y costos.

El modelo Gemini Embedding 1 soporta varios tipos de tareas, cada uno adaptado para un objetivo específico. Aquí tienes una descripción general de los tipos disponibles y sus aplicaciones:

SEMANTIC_SIMILARITY: Usa esto cuando tu objetivo sea evaluar cuán semánticamente similares son dos fragmentos de texto.
RETRIEVAL_QUERY y RETRIEVAL_DOCUMENT: Estos son esenciales para las tareas de recuperación de información. Usa RETRIEVAL_QUERY para la consulta de búsqueda del usuario y RETRIEVAL_DOCUMENT para los textos en tu base de datos que quieres buscar. Esta es la base para construir sistemas efectivos de búsqueda semántica y RAG.
CLASSIFICATION: Elige este tipo de tarea cuando tengas la intención de usar los embeddings para entrenar un modelo que clasifique texto en un conjunto de categorías predefinidas.
CLUSTERING: Si tu objetivo es agrupar textos similares para identificar tendencias o temas ocultos sin etiquetas preexistentes, este tipo de tarea generará embeddings optimizados para ese propósito.

Este ejemplo es una intuición de cómo funcionan los sistemas RAG más complejos, como cuando estás construyendo un sistema de preguntas frecuentes. Harás lo siguiente:

definirás alguna información, que representa datos de documentos
usarás el modelo de embedding para generar los embeddings para esa información
buscarás información similar a la pregunta formulada
luego usarás un modelo generativo de Gemini para personalizar una respuesta a la pregunta.

Primero declararás la información que representa los documentos, crearás una estructura que incluya títulos y contenidos de documentos y crearás un dataframe a partir de ella.

contents01 = """
    Operating the Climate Control System Your Googlecar has a climate control system that allows you to adjust the temperature and airflow in the car.
    To operate the climate control system, use the buttons and knobs located on the center console.
    Temperature: The temperature knob controls the temperature inside the car.
    Turn the knob clockwise to increase the temperature or counterclockwise to decrease the temperature.
    Airflow: The airflow knob controls the amount of airflow inside the car.
    Turn the knob clockwise to increase the airflow or counterclockwise to decrease the airflow.
    Fan speed: The fan speed knob controls the speed of the fan.
    Turn the knob clockwise to increase the fan speed or counterclockwise to decrease the fan speed.
    Mode: The mode button allows you to select the desired mode.
    The available modes are: Auto: The car will automatically adjust the temperature and airflow to maintain a comfortable level.
    Cool: The car will blow cool air into the car.
    Heat: The car will blow warm air into the car.
    Defrost: The car will blow warm air onto the windshield to defrost it.
"""

contents02 = """
    Your Googlecar has a large touchscreen display that provides access to a variety of features, including navigation, entertainment, and climate control.
    To use the touchscreen display, simply touch the desired icon.
    For example, you can touch the "Navigation" icon to get directions to your destination or touch the "Music" icon to play your favorite songs.
"""

contents03 = """
    Shifting Gears Your Googlecar has an automatic transmission.
    To shift gears, simply move the shift lever to the desired position.
    Park: This position is used when you are parked. The wheels are locked and the car cannot move.
    Reverse: This position is used to back up.
    Neutral: This position is used when you are stopped at a light or in traffic.
    The car is not in gear and will not move unless you press the gas pedal.
    Drive: This position is used to drive forward.
    Low: This position is used for driving in snow or other slippery conditions.
"""

document01 = {
    "title": "Climate control system",
    "contents": " ".join(contents01.split())
}
document02 = {
    "title": "Touchscreen",
    "contents": " ".join(contents02.split())
}
document03 = {
    "title": "Shifting gears",
    "contents": " ".join(contents03.split())
}

documents = [document01, document02, document03]

docs_df = pd.DataFrame(documents)
docs_df.columns = ['title', 'contents']
docs_df

Ahora crearás los embeddings usando la columna (tipo de tarea RETRIEVAL_DOCUMENT) en el dataframe:

GEMINI_EMBEDDING_1_MODEL_ID = "gemini-embedding-001" #task type param only works with gemini-embedding-001
docs_df["embeddings"] = docs_df.apply(lambda x: client.models.embed_content(model=GEMINI_EMBEDDING_1_MODEL_ID, contents=(x['contents']), config=types.EmbedContentConfig(task_type="RETRIEVAL_DOCUMENT")).embeddings[0].values, axis=1)
docs_df

Ahora crearás una función para hacer la interacción entre preguntas y la búsqueda en el dataframe.

La función find_best_passage, en lugar de buscar palabras clave simples, busca significado.

Aquí tienes un desglose paso a paso de lo que hace cuando haces una pregunta:

Primero, la función toma tu consulta (por ejemplo, "¿cómo cambio de marcha?") y usa el modelo de embedding para convertirla en un embedding usando el tipo de tarea RETRIEVAL_QUERY.
Luego, la función compara los embeddings de tu pregunta con los números de cada documento. Calcula una puntuación de similitud para cada par. Una puntuación más alta significa que los significados están más estrechamente alineados.
Finalmente, la función identifica el documento con la puntuación de similitud más alta y devuelve su texto original como la respuesta más relevante a tu pregunta.

import numpy as np

def find_best_passage(query: str, dataframe: pd.DataFrame, model: str) -> str:

    # 1. Create an embedding for the user's query.
    query_embedding = client.models.embed_content(
            model=model,
            contents=query,
            config=types.EmbedContentConfig(task_type="RETRIEVAL_QUERY")
    )

    # 2. Calculate the dot product to find the similarity between the query and all documents
    dot_products = np.dot(np.stack(dataframe.embeddings), query_embedding.embeddings[0].values)

    # 3. Find the index of the highest score and return the corresponding text.
    best_passage_index = np.argmax(dot_products)

    # 4. return the document contents more relevant to the question
    return dataframe.contents.iloc[best_passage_index]

Por ejemplo, para la pregunta "how to make the fan speed stronger on the car cooling system" tienes el siguiente pasaje como el más cercano:

question = "how to make the fan speed stronger on the car cooling system"

best_passage = find_best_passage(question, docs_df, GEMINI_EMBEDDING_1_MODEL_ID)
best_passage

Ahora puedes hacer una generación aumentada (el último paso del proceso RAG) usando el mejor pasaje encontrado en el primer paso, pero aún teniendo respuestas personalizadas para los usuarios en lugar de simplemente pegar grandes fragmentos de documentos directamente:

from IPython.display import Markdown

final_answer_prompt = f"""
    Your Role: You are a friendly AI assistant. Your purpose is to explain information to users who are not experts.

    Your Task: Use the provided "Source Text" below to answer the user's question.

    Guidelines for your Response:

    Be Clear and Simple: Explain any complicated ideas in easy-to-understand terms. Avoid jargon.
    Be Friendly: Write in a warm, conversational, and approachable tone.
    Be Thorough: Construct a complete and detailed answer in full sentences, using all the relevant information from the source text.
    Stay on Topic: If the source text does not contain the answer, you must state that the information is not available in the provided material. Do not use outside knowledge.

    QUESTION: {question}
    PASSAGE: {best_passage}
"""

MODEL_ID = "gemini-3.7-flash"  # @param ["gemini-3.7-flash", "gemini-2.5-pro", "gemini-3.1-pro-preview"]

final_answer = client.interactions.create(
    model=MODEL_ID,
    input=final_answer_prompt,
)

Markdown(final_answer.steps[-1].content[0].text)

Aprende más

Consulta estos ejemplos en el Cookbook para aprender más sobre lo que puedes hacer con los embeddings:

Reclasificación de búsqueda: Usa embeddings de la API de Gemini para reclasificar los resultados de búsqueda de Wikipedia.
Detección de anomalías con embeddings: Usa embeddings de la API de Gemini para detectar posibles valores atípicos en tu conjunto de datos.
Entrenar un clasificador de texto: Usa embeddings de la API de Gemini para entrenar un modelo que pueda clasificar diferentes tipos de publicaciones de grupos de noticias según el tema.

Los embeddings también tienen muchas aplicaciones en las bases de datos vectoriales. Consulta estos ejemplos:

Con Chroma DB
Con LangChain
Con LlamaIndex
Con Qdrant
Con Weaviate

Puedes aprender más sobre los embeddings en general en ai.google.dev en la guía de embeddings

Lección del curso «Gemini API Cookbook (quickstarts)» de Google, publicado con licencia Apache 2.0. Traducción y adaptación al español de IA con Clase. IA con Clase no está afiliado a Google. Ver el original · Licencia

Esta lección es gratuita. El resto del curso se abre con la Membresía de IA con Clase, que incluye todos los cursos del catálogo. Ver precios

← Anterior Siguiente: Uso de Enums para restringir la salida del modelo →

Introducción a los embeddings

Copyright 2026 Google LLC.

Tabla de Contenidos

Configuración

Instalar SDK

Configura tu clave de API

Inicializar cliente SDK

Elige un modelo

Embedir contenido

Embeddings multimodales

Embedir imágenes

Agregación de embeddings

Embedir audio

Embedir video

Embedir PDFs

Embedir contenido en lotes

Configuración de la dimensionalidad de los embeddings

Embeddings en la práctica - Análisis de similitud de oraciones

Analizando la similitud de ejemplos de texto con similitud de coseno

Uso de task_type para diferentes escenarios

Aprende más

Uso de `task_type` para diferentes escenarios