Google EmbeddingGemma 2

Google EmbeddingGemma 2

Google DeepMind · Writing · Image · Coding

Google EmbeddingGemma 2 is a 740M-parameter open model that turns text, code, images, audio, and video frames into vectors in one 768-dimension space, running on phones and laptops.

Interface preview of Google EmbeddingGemma 2

About Google EmbeddingGemma 2

What Is Google EmbeddingGemma 2

EmbeddingGemma 2 is an open embedding model from Google DeepMind and the company's first multimodal one, published on October 6, 2026 under the Apache 2.0 license and built on the Gemma 4 architecture. The first version handled text. This one puts five input types into the same vector space: prose, source code, images, video frames, and audio. Every item comes out as 768 numbers, so a screenshot can sit in the same index as the sentence that describes it.

An embedding model doesn't write answers. It converts content into coordinates so a search system can measure how close two things are. That layer sits under semantic search, retrieval for local RAG, deduplication, classification, and routing, and it's the part on-device embeddings replace when you stop calling a cloud service. Running the model on the device means a voice memo or a private repo never leaves the machine, which is the main reason people pick this family over a cloud API.

The tradeoff is that you own the inference. Google doesn't run a hosted endpoint for this model right now. You download the weights from Hugging Face or Kaggle, decide which encoders to load, and wire the model into your own pipeline. Gemini Enterprise Agent Platform Model Garden is listed as coming soon, so teams that want a managed service either wait or use the Gemini Embedding API instead.

Getting Started

  1. Download the weights from Hugging Face or Kaggle. A text-only deployment can skip the vision and audio encoders completely.
  2. Choose a runtime. LiteRT or MediaPipe suits mobile apps, transformers.js and WebGPU suit browsers, and Ollama, vLLM, SGLang, llama.cpp, MLX, or LM Studio work on desktops.
  3. Encode a handful of documents with the query and document prefixes listed on the model card, then check that related items land close together.
  4. Trim the vector length if storage is tight. Cutting 768 dimensions down to 256 removes about two thirds of the index size.
  5. Store the vectors in Qdrant or another vector database, and query with the same encoder you used for indexing.

Product Information

A quick look at Google EmbeddingGemma 2's pricing, supported platforms, and performance.

Free PlanYes
Paid PlansFree to download under Apache 2.0, no paid tiers
PlatformAndroid, iOS, web browsers, macOS, Windows, Linux
DeveloperGoogle DeepMind
CategoryWriting · Image · Coding
Release DateOct 2026
Latest UpdatedNov 2026
Website Visits9.2M
Website Global Rank8.2K
API AvailabilityYes

Best for

The users, tasks, and scenarios where this tool fits best.

Users

  • App developers who need offline search
  • Privacy-focused teams handling sensitive material
  • Engineers indexing a large codebase
  • Researchers comparing how models handle mixed media

Tasks

  • Finding a clip in a long recording
  • Local RAG over office material
  • Semantic code search
  • Clustering and deduplication

Scenarios

  • Field work with no reliable connection
  • A mobile app with a tight memory budget
  • Regulated recordings

Key features

One vector space for five input types

Text, source code, images, video frames, and audio all map into the same 768-dimension space. You can query an audio archive with a written sentence, or find a screenshot using a description of what it showed. Cross-modal comparison works because the vectors share a coordinate system, not because separate models were stitched together afterward. Most multimodal embedding model setups encode each format in its own space and translate between them, which loses detail at the boundary.

Modular encoders you load on demand

The full model is 740M parameters, split into a 270M text and code backbone, a 170M vision encoder, and a 300M audio encoder. Ship the text path alone and the download and memory cost drop sharply. Add vision or audio later, and previously computed text vectors stay valid because the space doesn't change.

Truncatable vectors with Matryoshka embeddings

Matryoshka Representation Learning packs the most useful information into the front of each vector. You can keep all 768 dimensions, or cut the output to 512, 256, or 128 for local storage savings of up to 6x. Lower dimensions cost some retrieval accuracy, and the loss shows up sooner on image and audio than on text, so test your own queries before committing.

An 8K token window across modalities

The context window is four times larger than the first EmbeddingGemma's. That translates to roughly 5.5 minutes of audio, 29 images, or 58 video frames in a single input, including interleaved combinations. A slide deck with narration can be encoded as one item instead of a pile of separate chunks.

Small enough for a phone

With quantization, text-only weights take about 191MB of active RAM on a Pixel 11 Pro. The full multimodal model needs around 567MB. Those numbers make the difference between an app that ships and one that gets rejected for memory use, especially on mid-range Android hardware.

Stronger code retrieval

On MTEB Code, the score moved from 68.76 to 78.68, a 9.92 point gain over the previous version. The model handles local codebase indexing and retrieval for coding agents, where a query often describes intent rather than naming a symbol. Google reports it also beats some specialist models more than twice its size on image, video, document, and audio tasks.

Broad runtime and tooling support

Official and community integrations cover sentence-transformers, transformers, vLLM, SGLang, llama.cpp, Ollama, LM Studio, MLX, transformers.js, and WebGPU. Qdrant published a walkthrough for storing the vectors, and Unsloth documents fine-tuning. You aren't locked into a single inference stack or a Google-only deployment path.

Pairs with Gemma 4 for on-device RAG

EmbeddingGemma 2 shares its text tokenizer and audio encoder with Gemma 4. Running both in one pipeline avoids loading duplicate components, which lowers the combined memory footprint. The retrieval step and the generation step can then happen on the same laptop or phone without a network call.

Pros and cons

Pros

  • Apache 2.0 license allows commercial use without a per-token bill or usage cap.
  • The whole pipeline can run offline, which keeps private audio and code on the device.
  • One index covers text, images, audio, and video, so you skip building separate stores per media type.
  • Tooling support is wide, from mobile runtimes to desktop servers and browser builds.
  • Text-only deployments are small enough for phones, at roughly 191MB of active RAM after quantization.

Cons

  • There's no hosted endpoint from Google yet, so you handle batching, hardware, and uptime yourself.
  • Cutting vectors to 128 dimensions saves storage but costs retrieval quality, and image or audio searches degrade before text does.
  • Full multimodal mode needs about 567MB of RAM, which rules out low-end devices.
  • You still need a vector database and a query strategy, since the model only produces the numbers.

Frequently asked questions

Yes. Google released the weights under Apache 2.0, which permits commercial products, modification, and redistribution. You pay for hardware and engineering time, not for the model itself.