EmbeddingGemma 2 é o novo modelo de embeddings aberto do Google: roda localmente e converte texto, código, imagens, áudio e vídeo em vetores, sem pagar por token para uma API. Tem 740M de parâmetros, é publicado sob licença Apache 2.0 e seu maior avanço em relação à primeira versão está na busca de código.
O que é EmbeddingGemma 2 e o que são embeddings?
Um embedding é um vetor numérico que representa o significado de um conteúdo: dois textos com sentido parecido produzem vetores próximos, mesmo que não compartilhem palavras. É a peça que faz funcionar a busca semântica, a classificação e qualquer pipeline de RAG (Retrieval-Augmented Generation).
EmbeddingGemma 2 é a segunda geração do modelo de embeddings leve do Google DeepMind, construído sobre a arquitetura do Gemma 4. Gera vetores de 768 dimensões em um único espaço compartilhado para quatro modalidades: texto (incluindo código), imagens, vídeo e áudio. Seus componentes são:
- Modelo de texto: 270M de parâmetros (um backbone de 130M mais um embedder de 140M).
- Encoder de visão: 170M, opcional.
- Encoder de áudio: 300M, opcional.
Você carrega apenas os encoders que precisa, então um pipeline de texto e código nunca paga por visão ou áudio.
A janela de contexto é de 8.192 tokens, quatro vezes a da primeira versão. As entradas multimodais compartilham esse orçamento: cerca de 29 imagens, cerca de 58 fotogramas de vídeo ou aproximadamente cinco minutos e meio de áudio. O Google indica suporte para mais de 100 idiomas.
Segundo o Google, a primeira versão do EmbeddingGemma, lançada no ano passado, superou os 20 milhões de downloads.
EmbeddingGemma 2 é melhor para buscar código?
Sim, e código é o que mais mudou. No MTEB Code, EmbeddingGemma 2 obtém 78,68 contra 68,76 da versão anterior: 9,92 pontos a mais, cerca de 14% relativo.
Em texto multilíngue, por outro lado, as duas versões estão praticamente empatadas (61,36 contra 61,15). Se você já usa EmbeddingGemma 1 para RAG em texto plano, a razão para atualizar é a modalidade múltipla ou código, não a prosa.
Todos esses números vêm do model card do Google e usam o checkpoint em precisão completa. São resultados autorrelatados, e “o melhor de sua classe entre embedders multimodais de menos de 1B” é uma categoria que o próprio Google define. Considere-os como ponto de partida e meça sobre seu próprio repositório.
O Google posiciona a melhoria em código para três usos específicos:
- Indexar um codebase localmente (local codebase indexing)
- Busca semântica de código (semantic code search)
- Recuperação de contexto para agentes de código (code embeddings para coding agents)
Esse é o caso de uso realista para a maioria: dar ao seu agente ou ao seu buscador interno um índice local do seu repositório, sem enviar o código a um terceiro.
Como gerar embeddings localmente com Sentence Transformers?
O caminho mais rápido é Sentence Transformers. Instale-o junto com Transformers:
pip install -U sentence-transformers transformers
Carregue o modelo em modo apenas texto e com um tipo numérico seguro:
import torch
from sentence_transformers import SentenceTransformer
dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float32
model = SentenceTransformer(
"google/embeddinggemma-2",
model_kwargs={"torch_dtype": dtype},
config_kwargs={"vision_config": None, "audio_config": None},
)
As duas entradas de config_kwargs importam. Por padrão, SentenceTransformer carrega os 740M de parâmetros, incluindo visão e áudio. Ao desativar ambos, você fica com o modelo de texto de 270M.
Agora indexe um pouco de código e procure por ele em linguagem natural:
files = {
"auth/session.py": "def refresh_token(user): ...",
"billing/invoice.py": "def generate_invoice(order): ...",
}
doc_embs = model.encode(
[f"title: {name} | text: {code}" for name, code in files.items()]
)
query_emb = model.encode("Onde o token de sessão é renovado?",
prompt_name="CodeRetrieval")
print(model.similarity(query_emb, doc_embs))
Dois detalhes saem direto do model card:
- Prefixos de tarefa: o modelo espera prefixos no texto.
prompt_name="CodeRetrieval"aplicatask: code retrieval | query:à consulta. - Documentos com título: são formatados manualmente como
title: {arquivo} | text: {código}. Incluir o nome do arquivo como título melhora a recuperação.
O model card também lista outros prompts:
SearchQuery/Document: busca geralQuestionAnsweringClassificationClusteringSentenceSimilarity
Como usar EmbeddingGemma 2 com Ollama?
O modelo já está na biblioteca do Ollama, então você pode gerar embeddings com Ollama (ollama embeddings) sem escrever Python:
ollama pull embeddinggemma-2
No momento da publicação desta nota, Ollama listava, entre outros, as tags :270m (378 MB) e :740m (1,3 GB). Os metadados daquele card não coincidiam com o model card do Google na janela de contexto, então considere o model card como referência para os limites.
Se você já executa Gemma 4 localmente com Ollama, o pareamento faz sentido: EmbeddingGemma 2 compartilha com Gemma 4 o tokenizer de texto e o encoder de áudio, e o Google o propõe como a metade de recuperação de um pipeline de RAG no dispositivo. Para escolher a variante do Gemma 4 de acordo com sua memória, consulte Gemma 4 no seu Mac com Ollama: qual variante escolher de acordo com sua RAM.
O Google menciona, além disso, outras formas de executá-lo:
- Bibliotecas: Transformers, transformers.js (navegador), MLX, vLLM, SGLang
- Runtimes locais: llama.cpp (GGUF oficial), LM Studio
- No dispositivo: LiteRT e MediaPipe
Quanta RAM o EmbeddingGemma 2 precisa?
O Google relata cerca de 191 MB de RAM ativa para os pesos apenas de texto e cerca de 567 MB para o modelo multimodal completo. Ambas as cifras foram medidas com quantização em um Pixel 11 Pro, então são o melhor cenário.
Em precisão completa ou bfloat16, em um laptop ou servidor, conte com mais. Os tamanhos de download do Ollama da seção anterior dão uma ideia mais realista do que ocupa em um computador de mesa.
Que erros quebram seus embeddings sem avisar?
Três, e nenhum lança uma exceção.
Não use float16. As ativações do modelo excedem o intervalo de float16. Em float16, ele retorna NaN ou vetores degradados silenciosamente, em vez de falhar. Use bfloat16 onde seu hardware o suporte e, se não, float32, o que inclui a maioria das CPUs.
Renormalize após truncar. EmbeddingGemma 2 usa Matryoshka Representation Learning (matryoshka embeddings), então você pode encurtar os vetores de 768 a 512, 256 ou 128 dimensões. Mas um vetor truncado deixa de ter comprimento unitário. Deixe a biblioteca fazer os dois passos:
emb = model.encode(texts, truncate_dim=256, normalize_embeddings=True)
Além disso, consultas e documentos precisam usar a mesma dimensão.
Não truncue código demais. A própria tabela do Google mostra onde está o custo:
| Dimensões | Armazenamento | MTEB Code |
|---|---|---|
| 768 | 1× | 78,68 |
| 512 | 1,5× menos | 77,24 |
| 256 | 3× menos | 76,18 |
| 128 | 6× menos | 71,41 |
256 é o ponto ótimo: um terço do armazenamento em troca de cerca de 2,5 pontos de precisão em código. Com 128 dimensões, o código cai quase ao nível da versão 1, e o Google avisa que a qualidade multimodal se degrada de forma considerável.
Em qual banco de dados vetorial guardar os embeddings?
Em qualquer banco de dados vetorial que aceite vetores da dimensão que você escolher: EmbeddingGemma 2 apenas gera os vetores, não os armazena. Entre seus parceiros de lançamento, o Google menciona o Qdrant para armazená-los.
O que sim depende do modelo é quanto seu índice ocupa. Escolher a dimensão é a decisão de armazenamento mais importante: guardar em 256 dimensões em vez de 768 reduz o tamanho do índice a um terço, e de acordo com a tabela anterior apenas custa precisão. Decida a dimensão antes de indexar: se guardar vetores truncados e depois quiser mais dimensões, terá que regenerar todos os embeddings do corpus.
EmbeddingGemma 2 é gratuito e onde baixá-lo?
Sim: os pesos são abertos sob Apache 2.0, uma licença que permite uso comercial, então não há custo por token. O que você paga é o processamento de sua própria máquina.
Você pode baixá-lo em:
- Hugging Face:
google/embeddinggemma-2 - Kaggle
- Ollama
No momento da publicação desta nota, o Google indicava a disponibilidade no Model Garden como “em breve”.
O modelo vem com documentação para inferência, embeddings multimodais e fine-tuning, além de um notebook de início rápido de RAG que o combina com Gemma 4.
E você? Qual modelo de embeddings você usa hoje para fazer RAG sobre seu código?
- Com uma API na nuvem
- Com um modelo local (Ollama, llama.cpp…)
- Depende do projeto, uso ambos
- Prefiro outra opção (nos diga qual)
Comente abaixo ou, se este artigo chegou até você por email, responda diretamente ao email: sua resposta é publicada aqui.
Relacionado: Melhorando RAG em espanhol: testando os novos embeddings da Mistral