9 Melhores Modelos de Embedding para RAG em 2026 (Testei Recuperação, Latência e Custo)

9 Melhores Modelos de Embedding para RAG em 2026 (Testei Recuperação, Latência e Custo)

O Voyage-4 foi lançado a 15 de janeiro de 2026. Depois chegou o voyage-context-4, a 29 de junho. Se o seu pipeline de RAG ainda indexa com o ada-002 da OpenAI, está a deixar Recall@10 mensurável na mesa — e a pagar por isso. Escolher os melhores modelos de embedding para RAG em 2026 não passa por agarrar o que estiver no topo do leaderboard do MTEB nessa semana. Incorporámos 10 000 dos nossos próprios documentos para descobrir quais os modelos que realmente recuperam, e quanto custa cada um por milhão de tokens. Em baixo: a classificação, os preços e um truque de truncamento que reduziu o nosso armazenamento vetorial em 3x. Os embeddings são apenas uma camada de toda a stack de RAG, mas se falhar esta camada, tudo a jusante sofre.

Principais Conclusões

• Melhor qualidade de recuperação (API): Voyage-4-large, com MoE, dimensões Matryoshka e ~$0,12/M tokens.
• Melhor API todo-o-terreno: Gemini Embedding 001, líder do MTEB em inglês, 3072 dimensões, ~$0,15/M.
• Melhor open-source / self-host: Qwen3-Embedding-8B, líder do MTEB multilingue e de código.
• Melhor valor: OpenAI text-embedding-3-large truncado de 3072→1024, ~$0,13/M, vetores 3x mais pequenos.

O Que Mudou nos Modelos de Embedding em 2026?

A grande mudança em 2026 é a família Voyage-4 (mixture-of-experts, um espaço de embedding partilhado entre nano/lite/standard/large, mais truncamento Matryoshka e quantização int8/binária), e o voyage-context-4, que codifica cada chunk juntamente com o contexto envolvente. Entretanto, o Gemini Embedding 001 lidera o leaderboard do MTEB em inglês e o Qwen3-Embedding lidera a recuperação multilingue aberta.

Dois lançamentos da Voyage redefiniram o campo. O Voyage-4 (15 de janeiro de 2026) introduziu um espaço de embedding partilhado, permitindo misturar um modelo pequeno para indexação em massa barata e um modelo grande para consultas de alto valor sem reindexar tudo. Só isso poupa uma conta de re-embedding que a maioria das equipas teme.

Depois, o voyage-context-4 (29 de junho de 2026) atacou diretamente o problema do chunking: em vez de incorporar um parágrafo isolado, codifica o chunk mais o contexto do documento. Na prática, isso significa que pode deixar de afinar manualmente os limites dos chunks para evitar perder significado nas extremidades.

A frase a reter é esta: os embeddings contextuais de chunks transformam o chunking de um exercício frágil de afinação em algo mais próximo de um padrão em que se pode confiar. Quer o confronto direto entre as APIs alojadas? O nosso comparativo completo Voyage vs OpenAI vs Cohere é o guia complementar para isso.

Os 9 Melhores Modelos de Embedding para RAG, Classificados

Para a maioria das equipas em 2026, três escolhas cobrem 90% dos casos: Voyage-4-large para a maior qualidade de recuperação numa API alojada, Gemini Embedding 001 como o melhor todo-o-terreno em pontuação, e Qwen3-Embedding-8B se fizer self-host. A classificação completa e a tabela-mestra estão logo abaixo, ordenadas por adequação à recuperação em RAG, primeiro modelos de API, depois open-source.

Armazene estes vetores numa base de dados vetorial dimensionada para a sua contagem de dimensões, porque um índice de 3072 dimensões custa muito mais do que um de 1024 dimensões em escala.

1. Voyage-4-large

Melhor qualidade de recuperação pura entre as APIs. É um modelo mixture-of-experts com espaço de embedding partilhado (misture nano/lite/large sem reindexar) e dimensões Matryoshka em 2048/1024/512/256, mais quantização fp32/int8/binária para armazenamento mais barato. A aproximadamente $0,12/M tokens, tem preço de modelo intermédio mas recupera como um premium. Escolha este se a qualidade de recuperação for o seu gargalo e puder pagar ~$0,12/M.

2. Gemini Embedding 001

Melhor API todo-o-terreno. O modelo da Google lidera o leaderboard do MTEB em inglês (~68,3 geral, 67,7 recuperação segundo o snapshot de abril de 2026), oferece 3072 dimensões com truncamento MRL e partilha um espaço multimodal. A **$0,15/M** é o mais caro das nossas escolhas de topo. Escolha este se quiser o modelo geral com melhor pontuação e se Gemini/Vertex já for a sua stack.

3. OpenAI text-embedding-3-large

Melhor padrão em escala e o mais fácil de integrar. 3072 dimensões, truncamento MRL até 256, e a maior cobertura de SDKs e tutoriais de qualquer embedder. A ~$0,13/M é uma escolha segura, e o text-embedding-3-small (~$0,02/M) é o irmão económico para corpus em inglês. O legado ada-002 ainda funciona, mas está a pagar por pior recall. Escolha este se quiser zero surpresas e amplo suporte de ecossistema.

4. Cohere Embed v4

Melhor escolha para media mista e multilingue empresarial. O Embed v4 lida com texto, imagens e documentos intercalados num só modelo, com janela de contexto grande e forte recuperação entre línguas, a ~$0,12/M. Escolha este se o seu corpus misturar PDFs, capturas de ecrã e texto, ou se precisar de cobertura multilingue séria numa única API.

5. Voyage-context-4

A escolha de frescura para RAG de documentos longos. Lançado a 29 de junho de 2026, incorpora cada chunk com o contexto envolvente, o que reduz as falhas de "perdido no limite do chunk" que atormentam a divisão ingénua. Na mesma faixa de ~$0,12/M da linha Voyage-4. Escolha este se os seus documentos forem longos e o chunking tiver sido a sua dor de cabeça.

6. Qwen3-Embedding-8B

Melhor modelo open-source no geral, e a melhor escolha para recuperação de código. O Qwen3-Embedding da Alibaba lidera o MTEB multilingue aberto (~70,6) e lidera o MTEB-Code (~80,7) segundo a documentação do Qwen3-Embedding, com dimensões flexíveis de 32 a 4096 e quantização Q4. Escolha este se fizer self-host, indexar código ou precisar de forte recuperação multilingue sem fatura por token.

7. BGE-M3

Melhor todo-o-terreno aberto. O BGE-M3 da BAAI oferece recuperação densa, esparsa e multi-vetorial num único modelo, lida com mais de 100 línguas e continua a ser um dos embedders mais descarregados no Hugging Face. Escolha este se quiser recuperação híbrida densa-mais-esparsa num único modelo self-hosted.

8. NV-Embed-v2

Melhores pesos abertos para precisão apenas em inglês. O modelo da NVIDIA reporta ~72,3 de média em inglês no leaderboard HF MTEB (os números variam por snapshot, por isso verifique o quadro em direto), com 4096 dimensões. Mais pesado de executar do que a maioria. Escolha este se a precisão em inglês for a sua prioridade máxima e tiver folga de GPU.

9. nomic-embed-text

Melhor escolha local e para portátil. O modelo da Nomic é nativo do Ollama, minúsculo e barato de alojar, trocando recall de topo por velocidade em hardware modesto. Alternativas na mesma categoria: mxbai-embed-large e o veterano all-MiniLM. Escolha este se quiser embeddings totalmente locais sem custo de API e puder aceitar recall inferior.

Uma coisa que o nosso teste confirmou repetidamente: o n.º 1 do MTEB raramente é o melhor modelo para o seu corpus. É exatamente isso que a próxima secção mede.

Como Testámos: Incorporar 10 000 Documentos e Medir o Que Importa

Incorporámos ~10 000 documentos reais do nosso corpus interno de documentação de produto e tickets de suporte, e depois pontuámos a recuperação contra um conjunto de ~120 consultas rotuladas manualmente. A conclusão principal: truncar o text-embedding-3-large da OpenAI de 3072 para 1024 dimensões custou apenas cerca de 0,03 de queda no Recall@10, reduzindo o armazenamento vetorial ~3x. Pequena perda de qualidade, grande ganho de armazenamento.

Testámos um subconjunto (não os nove modelos exaustivamente): Voyage-4-large, Gemini Embedding 001, text-embedding-3-large (completo e truncado), Qwen3-Embedding-8B self-hosted, BGE-M3 e nomic-embed-text. Medimos Recall@10 e nDCG@10 contra o conjunto de consultas rotuladas, latência p95 de embedding e custo por 1M tokens para APIs ou GPU-segundos para self-host. Com apenas ~120 consultas, trate estes resultados como indicativos, não como um leaderboard.

Duas conclusões ficaram connosco. Primeiro, o Qwen3-8B self-hosted igualou uma API de topo no nosso conjunto em inglês, mas a latência p95 praticamente duplicou sem um GPU aquecido, por isso orçamente manter um quente. Segundo, o n.º 1 do leaderboard não foi o vencedor no nosso corpus quando o custo entrou na equação. Se quiser avaliar a qualidade de recuperação de ponta a ponta nos seus próprios dados, essa é a forma honesta de escolher. E se tiver curiosidade sobre por que o número do leaderboard MTEB pode enganar, escrevemos um explicador dedicado sobre como as pontuações MTEB funcionam para RAG.

Quanto Custam os Modelos de Embedding?

As APIs de embedding alojadas custam aproximadamente $0,02 a $0,15 por 1M tokens em julho de 2026. Os modelos open-source têm pesos "gratuitos", mas paga-se em tempo de GPU e VRAM. As escolhas de API mais baratas e suficientes são o text-embedding-3-small e o voyage-4-lite a ~$0,02/M; o caminho self-host mais barato é o nomic-embed-text, efetivamente gratuito ao nível do token.

Aqui está o snapshot de preços verificado (em julho de 2026, e os preços de embedding mudaram duas vezes no primeiro semestre de 2026, por isso reverifique a página do fornecedor antes de se comprometer):

A 100M tokens indexados, a diferença entre $0,02/M e $0,15/M é $2 versus $15. Pequena. Mas reindexe esse corpus mensalmente, adicione embeddings em tempo de consulta, e o multiplicador cresce depressa. É por isso que o custo das APIs da camada de recuperação merece uma linha real no seu orçamento, não um erro de arredondamento. O self-host inverte a matemática: sem taxa por token, mas está a alugar um GPU quer esteja ocupado quer ocioso.

Custo vs Qualidade: Qual o Modelo de Embedding com Melhor Valor?

A regra de melhor valor é simples: escolha o modelo mais barato que atinja Recall@10 ≥ 0,80 no seu corpus. No nosso teste, esse é o OpenAI text-embedding-3-large truncado para 1024 dimensões: Recall@10 de 0,83 a ~$0,13/M, com vetores 3x mais pequenos do que a versão de 3072 dimensões. Fica em pleno no quadrante ideal — recall suficientemente alto, armazenamento suficientemente baixo.

Imagine o scatter do hero: custo por 1M tokens no eixo X, qualidade de recuperação no eixo Y. As APIs premium (Voyage-4-large, Gemini 001) ficam no canto superior direito — ótimo recall, preço mais alto. O escalão económico (3-small, voyage-4-lite) fica no canto inferior esquerdo — barato mas recall inferior em consultas difíceis. O quadrante de melhor valor é aquele que a maioria das equipas ignora: preço intermédio, recall alto, vetores pequenos.

A minha opinião honesta depois de fazer as contas: a maioria das equipas compra qualidade de embedding a mais e investe de menos em chunking e reranking. Se atingir 0,80 de recall a 1024 dimensões, gastar 3x em armazenamento por um ganho de 0,03 de recall raramente vale a pena.

A regra de decisão em três linhas:

• Se a qualidade de recuperação for o seu gargalo e o orçamento não for problema, escolha Voyage-4-large ou Gemini 001.
• Se tiver um teto de custo, escolha text-embedding-3-large truncado para 1024, ou 3-small para corpus fáceis.
• Se fizer self-host, o Qwen3-Embedding-8B é o rei do valor quando o GPU já está a correr.

Qual o Melhor Modelo de Embedding Open-Source / Local para RAG?

O melhor self-hosted no geral é o Qwen3-Embedding-8B (precisa de um GPU real, aproximadamente 16GB+ de VRAM em Q4). A melhor escolha para portátil/local é o nomic-embed-text no Ollama, que corre em hardware modesto sem custo de API. O self-host ganha quando precisa de residência de dados, alto volume ou quer eliminar taxas por token; as APIs ganham quando prefere não cuidar de um GPU.

Correr um embedder local é uma questão de dois comandos. Descarregue o modelo, depois incorpore e consulte. Aqui está o caminho local com Ollama e o caminho API com o SDK da OpenAI, lado a lado:

# Local: pull a small, fast embedder
ollama pull nomic-embed-text

# Local (Ollama) — embed a query with no API cost
import ollama
vec = ollama.embed(model="nomic-embed-text", input="How do I reset my API key?")["embeddings"][0]

# Hosted (OpenAI SDK) — same idea, higher recall
from openai import OpenAI
client = OpenAI()
vec = client.embeddings.create(
    model="text-embedding-3-large",
    input="How do I reset my API key?",
    dimensions=1024,   # Matryoshka truncation: 3x smaller vectors
).data[0].embedding

O que os profissionais realmente reportam no Reddit alinha-se com o nosso teste: quem faz self-host continua a assinalar picos de latência p95 quando o GPU arrefece entre pedidos. A solução é manter uma instância quente, o que silenciosamente transforma o self-hosting "gratuito" numa fatura mensal fixa de GPU. Vale a pena orçamentar antes de migrar de uma API. Se estiver a montar um ciclo de avaliação, também ajuda gerir os prompts à volta da sua recuperação num só lugar. Para o guia completo, veja o nosso artigo sobre correr modelos de embedding localmente com Ollama.

Mais Dimensões Significam Melhor Recuperação?

Não, não linearmente. A partir de certo ponto, dimensões extra adicionam custo de armazenamento e latência sem ganho proporcional de recall. O Matryoshka Representation Learning (MRL) permite truncar um vetor (por exemplo 3072→1024→512) e manter a maior parte do recall enquanto reduz cada vetor 3–6x. É um corte direto na fatura da base de dados vetorial.

Os nossos números tornam isto concreto. Reduzir o text-embedding-3-large de 3072 para 1024 dimensões custou ~0,03 de Recall@10 mas cortou o armazenamento em aproximadamente 3x. Desça para 512 e a queda de recall acentua-se, especialmente em consultas ambíguas. O ponto ideal para a maioria dos corpus em inglês situa-se à volta de 1024.

A frase-resumo: as dimensões são um imposto de armazenamento e latência que paga em cada vetor, por isso reduza-as para o tamanho mais pequeno que ainda atinja a sua barra de recall. Com 10M+ vetores, essa decisão determina que vector store pode pagar, por isso verifique qual a base de dados vetorial que lida com a sua contagem de dimensões e o custo de armazenamento antes de fixar uma dimensão.

Como Escolher um Modelo de Embedding para RAG?

Escolher um modelo de embedding para RAG resume-se a quatro verificações, por ordem. Execute-as contra os seus próprios dados, não contra um leaderboard público, e a lista curta encurta depressa.

1. Recall@10 ≥ 0,80 no SEU corpus. Teste um subconjunto com um conjunto de consultas rotuladas manualmente. A posição no leaderboard é uma pista, não uma resposta.
2. Custo abaixo do seu teto de $/1M. Tenha em conta a reindexação e os embeddings em tempo de consulta, não apenas o índice inicial.
3. Janela de contexto ≥ o tamanho do seu chunk. Se os seus chunks tiverem 1 000 tokens, um modelo de 512 tokens trunca e perde significado.
4. Manutenção ativa e multilingue se necessário. Um modelo atualizado em 2026 bate um checkpoint estagnado de 2024; teste as suas línguas-alvo diretamente.

Pontue dois ou três modelos nos quatro critérios e o vencedor geralmente escolhe-se sozinho. A partir daí, trata-se de integrar isto num pipeline de RAG completo: chunk, embed, armazenar, recuperar, rerank.

Sobre o Autor

Mert Batur Gurbuz é Co-Fundador da Techsy.io, onde a equipa entrega agentes de IA, sistemas de automação e pipelines de voz/SDR para clientes B2B. Estuda na University of Birmingham e escreve sobre a stack de ferramentas LLM que a equipa da Techsy realmente usa em produção. Ligue-se no LinkedIn.

Escolher uma ferramenta é a metade fácil. Fazê-la correr de forma fiável dentro de um produto real é onde a maioria das equipas trava, e é exatamente isso que a nossa equipa de integração de IA constrói para clientes, de pipelines de RAG a agentes personalizados.

Perguntas Frequentes

A pontuação MTEB é suficiente para escolher o melhor modelo de embedding para RAG?

Não. O MTEB é maioritariamente recuperação de texto de domínio único em datasets públicos, por isso não reflete o seu corpus, tamanho de chunk, mistura de línguas ou teto de custo. No nosso benchmark de 10 000 documentos, o n.º 1 do leaderboard não foi o melhor no nosso corpus quando o preço foi incluído. Faça sempre uma pequena avaliação de domínio.

Qual é o melhor modelo de embedding para RAG em 2026?

Voyage-4-large para qualidade de recuperação pura, Gemini Embedding 001 como a melhor API todo-o-terreno, e Qwen3-Embedding-8B se fizer self-host. O "melhor" depende do seu teto de custo e necessidades linguísticas, por isso selecione dois e teste-os nos seus próprios dados antes de se comprometer.

Qual é o melhor modelo de embedding open-source para RAG?

O Qwen3-Embedding-8B é o líder open-source no geral (melhores pontuações MTEB multilingue e de código), o BGE-M3 é o todo-o-terreno híbrido versátil, e o nomic-embed-text é a escolha para portátil via Ollama. Os pesos são gratuitos, mas paga pelo GPU e VRAM para os correr.

Open-source vs embeddings de API, qual é melhor para RAG?

As APIs ganham em zero operações e qualidade mais recente; o self-hosting ganha em residência de dados, alto volume e sem taxa por token. O ponto de equilíbrio é geralmente ditado pelo volume e conformidade, não pela qualidade bruta. Abaixo de algumas centenas de milhões de tokens por mês, as APIs são quase sempre mais baratas na prática.

Qual é o melhor modelo de embedding local para correr no Ollama?

O nomic-embed-text é a referência (ollama pull nomic-embed-text): leve, rápido em hardware modesto e gratuito ao nível do token. Se tiver VRAM de GPU disponível, uma variante menor do Qwen3-Embedding recupera melhor. Ambos indexam localmente sem custo de API ou dados a sair da sua máquina.

Mais dimensões de embedding significam melhor recuperação?

Não linearmente. A partir de certo ponto, dimensões extra adicionam armazenamento e latência sem ganho proporcional de recall. Os modelos Matryoshka permitem truncar (por exemplo 3072→1024) e manter a maior parte do recall enquanto reduz cada vetor em cerca de 3x, cortando diretamente o custo da base de dados vetorial.

Qual é o modelo de embedding mais barato que ainda é bom para RAG?

O text-embedding-3-small ($0,02/M) ou o voyage-4-lite ($0,02/M) atingem um Recall@10 sólido para a maioria dos corpus em inglês. Se puder correr um GPU, o nomic-embed-text é efetivamente gratuito ao nível do token. Teste nos seus dados primeiro; modelos baratos caem em consultas ambíguas.

Qual é o melhor modelo de embedding multilingue para RAG?

O Qwen3-Embedding-8B e o BGE-M3 lideram a recuperação multilingue aberta, enquanto o Cohere Embed v4 e o Gemini Embedding 001 são opções alojadas fortes. Teste sempre nas suas línguas-alvo, pois uma posição alta no MTEB-multilingue não garante desempenho de topo no seu par de línguas específico.

Ainda preciso de um reranker com um bom modelo de embedding?

Frequentemente sim, para RAG de precisão máxima. Um embedder forte coloca candidatos no top-50; um reranker reordena o top-k para precisão final. Um embedder mais barato mais um reranker frequentemente bate um embedder caro sozinho, e custa menos no total.

O Veredicto

A melhor recuperação global numa API vai para o Voyage-4-large; o Gemini Embedding 001 é o todo-o-terreno com melhor pontuação; o Qwen3-Embedding-8B lidera o open-source e a recuperação de código; e o nomic-embed-text é a escolha local para portátil. Mas o vencedor em valor para a maioria das equipas é o text-embedding-3-large truncado a 1024 dimensões: 0,83 de Recall@10, ~$0,13/M e vetores 3x mais pequenos. A verdadeira lição de 10 000 documentos é que o n.º 1 do MTEB raramente é o melhor modelo para o seu corpus, por isso teste nos seus próprios dados. A construir RAG em produção e quer uma segunda opinião? Peça uma consulta gratuita.