Google DeepMind's EmbeddingGemma 2 Searches Text, Video, and Audio in One 740M Model

Google DeepMind has released the weights and technical report for EmbeddingGemma 2, an open model that encodes text, code, images, video, and audio into a shared vector space. Across Google’s benchmark suite, it outperformed several specialist systems and multimodal models with two to 12 times as many parameters. Google describes the result as a new Pareto frontier: within its comparison set, no model delivered higher aggregate quality at the same or a smaller size.

Embedding models convert content into numerical vectors whose distances represent semantic similarity. Placing multiple media types in the same coordinate system enables a text query to retrieve matching images, recordings, videos, code, or mixed-media documents through nearest-neighbor search.

Many multimodal retrieval-augmented generation pipelines first caption images and transcribe audio, then pass that derived text to another embedding model. A native multimodal encoder removes those intermediate services, reduces indexing complexity, and preserves visual or acoustic signals that captions and transcripts can omit.

One space for text and media

EmbeddingGemma 2 produces 768-dimensional vectors for individual inputs or interleaved combinations of text, code, images, video, and audio. A text query such as waterproof shoes for trail running can therefore be scored directly against a product record containing descriptions, photographs, and a demonstration video.

The complete model contains 740 million parameters: a 270M text path, a 170M vision encoder, and a 300M audio encoder. The text path consists of a 130M transformer backbone and a 140M embedding component.

One checkpoint, four footprints

Independent vision and audio modules can be omitted when the model loads, giving developers four deployment configurations from the same checkpoint.

Each configuration projects into the same 768-dimensional geometry. Teams can use a smaller text-only instance for document indexing and a larger multimodal instance for queries without rebuilding the text index, provided preprocessing and instruction formats remain consistent.

The text-only configuration can be loaded through sentence-transformers by disabling both optional encoders:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer(
    "google/embeddinggemma-2",
    config_kwargs={
        "vision_config": None,
        "audio_config": None,
    },
)  # text-only, 270M parameters

Internally, the Gemma 4-derived backbone uses 24 layers with a model width of 512 and a hidden dimension of 2,048. Attention combines grouped-query and multi-query variants to reduce cache costs, with a 5:1 ratio of local to global attention and a 1,024-token sliding window for local layers. The tokenizer has a 262,144-entry vocabulary. Mean pooling condenses the sequence representation, and a 512-to-768 projection produces the final embedding. The model accepts an 8,192-token context shared by text and media.

Smaller vectors, lower storage costs

Matryoshka Representation Learning concentrates useful information toward the beginning of each vector, allowing the 768-dimensional output to be truncated to 512, 256, or 128 dimensions without retraining. Google reports near-lossless quality at 256 dimensions, which cuts vector storage by roughly threefold. The 128-dimensional option is intended for text-only use because multimodal retrieval quality declines more sharply at that size.

With 4-bit integer weight quantization, Google reports about 567MB of active memory for the full model. Total application memory will be higher because runtimes, activations, input buffers, and vector indexes add overhead. Actual mobile viability will depend on the target chipset, runtime, sequence length, and media mix.

Benchmarks at a glance

Higher values indicate better performance, but scores should be compared only within the same benchmark and metric. Hit@1 measures whether the correct result ranks first, MRR@10 rewards higher placement of the first relevant result within the top 10, and NDCG rewards useful ranking across multiple relevant results. These figures come from Google’s evaluation, so production teams should reproduce the relevant tests on their own corpora and query distributions.

Google reports an approximately 14% relative improvement over the previous model on code tasks. That gain targets natural-language code search, repository navigation, duplicate detection, and retrieval for coding assistants.

A staged multimodal curriculum

Shared embedding spaces can become skewed when one modality dominates training. The report attributes EmbeddingGemma 2’s balance to simplified per-layer embeddings and a curriculum that introduces modalities and objectives in stages. This progression covers unimodal retrieval, cross-modal matching, and mixed-modal inputs while preserving useful representations from multiple network depths.

Pretraining data included web documents in more than 140 languages, code, images, video, audio, and paired examples spanning multiple modalities. The reported data cutoff is January 2025.

Mixed media in one call

EmbeddingGemma 2 can encode interleaved media as one input and return a single vector for the complete sequence. Placeholder tokens specify each media item’s position, and their order must correspond to the supplied image, video, or audio values.

embedding = model.encode({
    "text": (
        "Waterproof running shoes. <|image|> "
        "Mesh upper. <|image|> "
        "Wet rock grip test: <|video|>"
    ),
    "image": ["shoe.jpg", "mesh.jpg"],
    "video": "demo.mp4",
})

Those maxima assume the context contains little or no text, other media, or formatting overhead. A configurable vision budget can reduce the tokens assigned to each image or frame, raising capacity to roughly 114 visual items per context at the cost of detail and retrieval quality.

Deployment targets and sharp edges

• Private or edge RAG: Index and query local content without sending raw user data to a hosted embedding API.
• Cross-modal retrieval: Search audio with spoken or written queries, retrieve product text from images, or match video against descriptions.
• Code search: Retrieve functions, files, or repositories from natural-language queries.
• Content organization: Classify, cluster, and detect near-duplicates across mixed media.

Weights, mobile builds, and evaluation

Google hosts the weights on Hugging Face under the Apache 2.0 license. A LiteRT build targets mobile deployment, while the technical report documents the architecture, training curriculum, comparisons, and ablation studies.

Teams evaluating the model should test representative queries against their own corpus, then measure retrieval quality, latency, peak memory, vector storage, language coverage, and the effects of dimension truncation and quantization. Those measurements will determine whether the 270M text configuration, a partial multimodal build, or the full 740M model offers the best deployment tradeoff.