EmbeddingGemma 2: Open Multimodal Embeddings That Run Locally

1. The launch facts

EmbeddingGemma 2 is built on the Gemma 4 architecture and shares Gemma 4’s text tokenizer and audio encoder. It is modular: the text model is about 270M parameters (a 130M transformer plus a 140M embedder), the vision encoder adds 170M and the audio encoder 300M, which is where the 740M total comes from. Per Google’s blog, you can load only the encoders you need.

Everything lands in the same 768-dimensional space, and one 8,192-token context window is shared across modalities. The predecessor, EmbeddingGemma 1 (September 2025), was a text-only model of roughly 300M parameters with a 2,048-token context.

2. What actually improved vs EmbeddingGemma 1

Three things changed, and only one of them is a benchmark. Version 1 was text-only and gated behind Google’s Gemma terms; version 2 takes images, video and audio, quadruples the context window and, per the card, is Apache 2.0. The one number Google puts in the headline is code retrieval: MTEB (Code, v1) goes from 68.76 to 78.68, a gain of 9.92 points (vendor-reported, model card and blog, Oct 6, 2026).

Read the other row too. On MTEB (Multilingual, v2) the card shows 61.36 against 61.15 for version 1, so general text quality is essentially flat. If your corpus is plain prose, that is not a reason to upgrade by itself. The reasons are code, media and context length.

The three real changes

3. The numbers, with sources and caveats

Every figure below comes from Google’s model card (full precision, Oct 6, 2026) and is vendor-reported. Benchmark names and versions are as printed there: MTEB multilingual v2, MTEB code v1, MIEB lite, MMEB v2, MSEB retrieval and MAEB. The table is the card’s own truncation table, trimmed to six score columns.

What follows is my arithmetic on those numbers, nothing more. At 256 dimensions the card’s scores keep 95 to 99% of the 768-dim score on every column (MMEB v2 is the lowest, 56.24 against 59.01). At 128 dimensions text and code hold up (MTEB multilingual 94%, MTEB code 91%) but media does not: MMEB v2 falls to 77% (45.65 against 59.01) and MSEB retrieval to 82%.

4. The license: what actually governs use

At first glance the card looks inconsistent: it says Apache 2.0 but links a file named after Gemma 4’s license. I read the pieces instead of trusting the filename. Here is what I found on October 14, 2026.

5. Quickstart: text, truncation and multimodal

The snippets below are the ones Google prints in the model card and the developer guide. I have not executed them. The developer guide installs with the image, audio and video extras; the card’s shorter line covers text only.

# text only (model card)
pip install -U sentence-transformers transformers

# image, audio and video extras (developer guide; quote the extras in 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 when the GPU supports it, otherwise float32 (never 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,          # or 512, 128
    normalize_embeddings=True,
)

# one text query against a photo and a sound recording
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))

# interleaved: one embedding for text + photos + 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",
})

If you would rather not run Python, Google lists Ollama (ollama pull embeddinggemma-2), a llama.cpp GGUF build, MLX, vLLM, SGLang, LM Studio, LiteRT, MediaPipe and transformers.js with a WebGPU demo. The Ollama page I read lists text and text-plus-image tags only and prints a 256K context figure that contradicts the card’s 8,192 tokens, so for audio or video use the Python route and trust the card.

6. Storage math: 768 vs 128 dimensions

Embedding size is the part of this model you control, so do the arithmetic before choosing a dimension. A vector costs dimensions times bytes per number. Google’s blog advertises up to 6x storage reduction at 128 dimensions; here is where that comes from.

768 dims x 2 bytes (bf16) = 1,536 bytes per vector
1,000,000 x 1,536 B       = 1.536 GB   (guide: "roughly 1.5 GB")

128 dims x 2 bytes        =   256 bytes per vector
1,000,000 x 256 B         = 256 MB     (guide: "roughly 250 MB")

768 / 128 = 6x    768 / 256 = 3x    768 / 512 = 1.5x

float32 doubles every line: 768 x 4 B = 3,072 B -> 3.07 GB per 1M vectors
pgvector vector  = 4 x dims + 8 bytes -> 3,080 B at 768 dims, 520 B at 128 dims
pgvector halfvec = 2 x dims + 8 bytes -> 1,544 B at 768 dims, 264 B at 128 dims

Two cautions. These are raw vector bytes: an HNSW index, metadata and replicas sit on top. And the saving is not free: at 128 dims the card’s MMEB v2 score falls from 59.01 to 45.65, and Google’s own guide says to validate 128d on your data before using it for multimodal queries.

7. Pick it, or stay on a hosted API?

Hosted embedding APIs are still the shortest path for many teams, including Google’s own Gemini Embedding 2. The question is which constraint you actually have.

My earlier post covers the hosted route (Vertex AI, 3,072 dimensions by default as of that post): Gemini Embedding 2: Google’s multimodal embeddings

8. Honest limits

Everything good about this release is on Google’s page. Here is what the same sources, and common sense, say to keep in mind.

9. What to do this week

Do not decide from the vendor table. A one-day evaluation on your own data answers the question, and the steps are cheap.

Verdict

EmbeddingGemma 2 is a solid open release with one honest headline, code retrieval, and one genuinely useful structural change: a small, modular model that can index text, code, images, video and audio locally. On Google’s own multilingual benchmark the text gain over v1 is flat, and every figure is vendor-reported.

Worth a one-day evaluation if you do code or media search or need data to stay local. Skip the migration if you embed plain prose and a hosted model already meets your recall target. Either way, decide with your own recall@k, starting at 256 dimensions.