EmbeddingGemma 2: Embeddings Multimodales Abiertos que Corren en Local

1. Los hechos del lanzamiento

EmbeddingGemma 2 está construido sobre la arquitectura de Gemma 4 y comparte su tokenizer de texto y su encoder de audio. Es modular: el modelo de texto ronda los 270M de parámetros (un transformer de 130M más un embedder de 140M), el encoder de visión suma 170M y el de audio 300M, y de ahí salen los 740M totales. Según el blog de Google, podés cargar solo los encoders que necesitás.

Todo cae en el mismo espacio de 768 dimensiones, y una sola ventana de contexto de 8.192 tokens se comparte entre modalidades. El antecesor, EmbeddingGemma 1 (septiembre de 2025), era un modelo solo de texto de unos 300M de parámetros con 2.048 tokens de contexto.

2. Qué mejoró de verdad frente a EmbeddingGemma 1

Cambiaron tres cosas, y solo una es un benchmark. La versión 1 era solo texto y estaba detrás de los términos Gemma de Google; la versión 2 acepta imágenes, video y audio, cuadruplica la ventana de contexto y, según la card, es Apache 2.0. El único número que Google pone en el titular es la recuperación de código: MTEB (Code, v1) pasa de 68,76 a 78,68, una mejora de 9,92 puntos (reportado por el vendor, model card y blog, 6-oct-2026).

Mirá también la otra fila. En MTEB (Multilingual, v2) la card muestra 61,36 contra 61,15 de la versión 1, o sea que la calidad de texto general es prácticamente igual. Si tu corpus es prosa común, eso solo no alcanza para actualizar. Las razones son el código, los medios y la longitud de contexto.

Los tres cambios reales

3. Los números, con fuentes y salvedades

Cada cifra de abajo sale de la model card de Google (precisión completa, 6-oct-2026) y es reportada por el vendor. Los nombres y versiones de benchmark son los impresos ahí: MTEB multilingual v2, MTEB code v1, MIEB lite, MMEB v2, MSEB retrieval y MAEB. La tabla es la tabla de truncado de la propia card, recortada a seis columnas de score.

Lo que sigue es aritmética mía sobre esos números, nada más. A 256 dimensiones los scores de la card conservan entre 95 y 99% del score de 768 dims en todas las columnas (MMEB v2 es el más bajo, 56,24 contra 59,01). A 128 dimensiones texto y código aguantan (MTEB multilingual 94%, MTEB code 91%) pero los medios no: MMEB v2 cae a 77% (45,65 contra 59,01) y MSEB retrieval a 82%.

4. La licencia: qué gobierna el uso de verdad

A primera vista la card parece inconsistente: dice Apache 2.0 pero enlaza un archivo con nombre de licencia de Gemma 4. En vez de confiar en el nombre del archivo, leí las piezas. Esto encontré el 14 de octubre de 2026.

5. Quickstart: texto, truncado y multimodal

Los snippets de abajo son los que Google imprime en la model card y en la guía para desarrolladores. No los ejecuté. La guía instala con los extras de imagen, audio y video; la línea más corta de la card cubre solo texto.

# solo texto (model card)
pip install -U sentence-transformers transformers

# extras de imagen, audio y video (guía; poné comillas a los extras en zsh)
pip install -U sentence-transformers[image,audio,video] transformers

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("google/embeddinggemma-2")

query = "What causes the northern lights?"
document = "The northern lights are caused by charged particles from the sun."

query_emb = model.encode(query, prompt_name="SearchQuery")
doc_emb = model.encode(document, prompt_name="Document")
print(model.similarity(query_emb, doc_emb))

import torch
from sentence_transformers import SentenceTransformer

# card: bfloat16 si la GPU lo soporta, si no float32 (nunca float16)
dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float32
model = SentenceTransformer("google/embeddinggemma-2", model_kwargs={"torch_dtype": dtype})

query = "What causes the northern lights?"
query_emb = model.encode(
    query,
    prompt_name="SearchQuery",
    truncate_dim=256,          # o 512, 128
    normalize_embeddings=True,
)

# una consulta de texto contra una foto y una grabación de sonido
image_emb = model.encode({"image": "sunset_beach.jpg"})
audio_emb = model.encode({"audio": "ocean_waves.wav"})
query_emb = model.encode("ocean waves at sunset", prompt_name="SearchQuery")

print(model.similarity(query_emb, image_emb))
print(model.similarity(query_emb, audio_emb))

# intercalado: un embedding para texto + fotos + video
listing_emb = model.encode({
    "text": "Waterproof running shoes. <|image|> Featuring a breathable mesh upper. <|image|> Grip test on wet rock: <|video|>",
    "image": ["shoe.jpg", "mesh.jpg"],
    "video": "demo.mp4",
})

Si preferís no correr Python, Google lista Ollama (ollama pull embeddinggemma-2), un build GGUF de llama.cpp, MLX, vLLM, SGLang, LM Studio, LiteRT, MediaPipe y transformers.js con una demo WebGPU. La página de Ollama que leí lista solo tags de texto y de texto más imagen e imprime un contexto de 256K que contradice los 8.192 tokens de la card, así que para audio o video usá la ruta de Python y confiá en la card.

6. Cuentas de almacenamiento: 768 vs 128 dimensiones

El tamaño del embedding es la parte del modelo que controlás vos, así que hacé la aritmética antes de elegir dimensión. Un vector cuesta dimensiones por bytes por número. El blog de Google anuncia hasta 6x menos almacenamiento a 128 dimensiones; acá está de dónde sale.

768 dims x 2 bytes (bf16) = 1.536 bytes por vector
1.000.000 x 1.536 B       = 1,536 GB   (guía: "roughly 1.5 GB")

128 dims x 2 bytes        =   256 bytes por vector
1.000.000 x 256 B         = 256 MB     (guía: "roughly 250 MB")

768 / 128 = 6x    768 / 256 = 3x    768 / 512 = 1,5x

float32 duplica cada línea: 768 x 4 B = 3.072 B -> 3,07 GB por 1M de vectores
pgvector vector  = 4 x dims + 8 bytes -> 3.080 B a 768 dims, 520 B a 128 dims
pgvector halfvec = 2 x dims + 8 bytes -> 1.544 B a 768 dims, 264 B a 128 dims

Dos advertencias. Son bytes crudos de vector: arriba se suman el índice HNSW, la metadata y las réplicas. Y el ahorro no es gratis: a 128 dims el score MMEB v2 de la card cae de 59,01 a 45,65, y la propia guía de Google dice que valides 128d con tus datos antes de usarlo en consultas multimodales.

7. ¿Elegirlo o quedarte en una API hosteada?

Las APIs de embeddings hosteadas siguen siendo el camino más corto para muchos equipos, incluido el Gemini Embedding 2 de la propia Google. La pregunta es qué restricción tenés de verdad.

Mi post anterior cubre la ruta hosteada (Vertex AI, 3.072 dimensiones por defecto al momento de ese post): Gemini Embedding 2: los embeddings multimodales de Google

8. Límites honestos

Todo lo bueno de este release está en la página de Google. Esto es lo que dicen las mismas fuentes, y el sentido común, para tener presente.

9. Qué hacer esta semana

No decidas con la tabla del vendor. Una evaluación de un día con tus propios datos responde la pregunta, y los pasos son baratos.

Veredicto

EmbeddingGemma 2 es un release abierto sólido con un titular honesto, la recuperación de código, y un cambio estructural realmente útil: un modelo chico y modular que puede indexar texto, código, imágenes, video y audio en local. En el benchmark multilingüe de la propia Google la mejora de texto sobre v1 es nula, y toda cifra es reportada por el vendor.

Vale una evaluación de un día si hacés búsqueda de código o de medios o necesitás que los datos queden en local. Salteá la migración si embebés prosa común y un modelo hosteado ya cumple tu recall. En cualquier caso, decidí con tu propio recall@k, empezando en 256 dimensiones.