The best embedding models FR

#What an embedding model is, and why French makes it more difficult

An embedding model is a neural network that converts text (a sentence, paragraph, or chunk) into a vector of numbers, from 384 to 4,096 dimensions depending on the model. Two texts with similar meanings produce nearby vectors, most often measured using cosine similarity. This is what allows a RAG system to retrieve a passage about a “fixed-term contract” when the user writes “CDD,” with no words in common. The same model must encode the questions and documents, as the Ollama documentation points out; changing models therefore requires reindexing the entire corpus. To choose, three questions are enough: was the model trained on French, does its context cover your chunks, and does its license allow your use?

French adds its own difficulties: accents, elisions (“l'employeur”), legal acronyms, and technical Anglicisms mixed into the text. The gap between models is clear. In the MTEB-French benchmark, the retrieval score ranges from 0.43 for all-MiniLM-L12-v2 to 0.65 for BGE-M3, a 22-point difference on the same question set.

#The five criteria that truly distinguish the models

Training languages

BGE-M3 and Qwen3-Embedding claim more than 100 languages, while multilingual-e5-large supports 94. The model cards for nomic-embed-text-v1.5 and mxbai-embed-large-v1, which are heavily downloaded on Ollama, are labeled English.

Maximum context

512 tokens for multilingual-e5-large, Solon, and mxbai-embed-large; 2 048 for EmbeddingGemma; 8 192 for BGE-M3; 32 000 for Qwen3-Embedding and Granite R2. A longer chunk is truncated, not rejected.

Dimensions and storage

From 384 to 4,096 dimensions, or 4 bytes per dimension and per vector in float32 (calculation below).

License

MIT for BGE-M3, multilingual-e5-large, and Solon; Apache 2.0 for Qwen3-Embedding, Granite R2, nomic, and mxbai; Gemma terms for EmbeddingGemma; CC BY-NC 4.0 (non-commercial) for jina-clip-v2.

Prefixes and instructions

Some models require a prefix before each text ("query:" and "passage:" for E5, even in French). Forgetting it degrades retrieval without producing an error.

#The 2026 ranking for French: nine models compared

This ranking is editorial, not based on in-house testing: it combines French-language coverage, published benchmarks, and local availability. The weights come from the Ollama library when the model is listed there; otherwise, from the float32 estimate in the MTEB-French study.

BGE-M3 remains the best default: its French retrieval has been published, its 8,192-token context avoids most forced chunking, and it also provides the lexical weights useful for hybrid search. Qwen3-Embedding is the candidate when a graphics card is available: its 8B version topped the multilingual MTEB leaderboard when it launched, on June 5, 2025, according to Qwen, but its 4,096 dimensions weigh on storage. EmbeddingGemma targets modest machines.

Solon, often presented as a specialist in French legal and administrative language, does not outperform any of the three retrieval datasets in the MTEB-French study: it matches BGE-M3 on the Syntec collective bargaining agreement and trails it on legal articles (BSARD) and school questions (Alloprof).

#What French benchmarks say—and what they don’t

The published reference is MTEB-French (Ciancone et al., May 2024): 18 datasets, 8 task categories, and 51 models compared. The authors conclude that large multilingual models pretrained on sentence similarity perform exceptionally well. Here is the retrieval (NDCG@10) on three datasets: French legal articles (BSARD), the Syntec collective agreement, and Alloprof school questions.

Three limitations prevent this from being a definitive ranking. The study dates from 2024: it includes neither Qwen3-Embedding (June 2025), nor EmbeddingGemma (September 2025), nor Granite R2, and no comparable French measurements of these models were consulted for this page. The corpora (legal articles, collective bargaining agreements, school questions) may not resemble yours. Finally, the multilingual scores published by vendors are self-reported and combine all languages.

#Which model for which use case: decision table

#Custom enterprise embeddings: open model, fine-tuning, or API

“Custom” does not mean training your own model from scratch. The order that avoids wasting time: a generic open model, careful chunking, hybrid search, and a reranker; then measure recall on your real questions; then, only if failures persist and are tied to business vocabulary (internal references, in-house abbreviations), fine-tune.

In June 2024, Philipp Schmid fine-tuned the bge-base-en-v1.5 model on 6,300 question-passage pairs drawn from financial documents: the retrieval score improved by approximately 7.4% on its test set, with three minutes of training on a consumer graphics card. This is an English case, on a single corpus, with pairs generated by an LLM: an order of magnitude, not a promise. BAAI also documents fine-tuning BGE-M3.

#Multimodal embedding: searching images and document pages

A multimodal embedding model places text and images in the same vector space. You can then retrieve a photo from a sentence, or a scanned PDF page without using OCR. The models from the Ollama library consulted for this page (BGE-M3, Qwen3-Embedding, EmbeddingGemma, nomic-embed-text, mxbai-embed-large) accept text only: the multimodal models below are used through Hugging Face (Sentence-Transformers or Transformers).

A multimodal model is not better for pure text. In the tables published by Qwen, Qwen3-VL-Embedding-2B scores 63.87 on multilingual MTEB, compared with 64.33 for Qwen3-Embedding-0.6B, a text model more than three times smaller. For PDFs whose useful content is text, convert them to clean text (Docling or OCR) and keep a text embedding model. Reserve multimodal models for visual corpora: diagrams, plans, screenshots, and slides.

#Managing your embeddings: prefixes, truncation, storage, and reindexing

A RAG system often degrades more because of these details than because of the model choice. First detail: each model family expects a different input format for queries and documents.

With Ollama, the official mxbai-embed-large example places the prefix directly in the text sent: add it yourself in your code. Qwen indicates that instructions generally provide a 1 to 5% improvement, and recommends writing them in English even for a multilingual corpus.

#The Ollama trap: silent truncation

The /api/embed endpoint of Ollama has a truncate parameter whose default value is true: input that exceeds the model's context window is cut off without an error. With mxbai-embed-large (512 tokens in Ollama), a 700-token chunk is indexed without its ending, and no one notices. The context window of Ollama may also differ from the original specifications: 2K for nomic-embed-text versus the 8,192 claimed by Nomic. Set truncate to false during testing: an error is better than truncated text.

#Dimensions, storage, and indexing limits

Storage is calculated simply: number of chunks × dimensions × 4 bytes in float32, excluding the index. For one million chunks, the vectors alone occupy:

Databases impose limits too. With pgvector, an index supports vectors with at most 2,000 dimensions, or 4,000 in half precision (halfvec): Qwen3-Embedding-8B’s 4,096 dimensions exceed even that limit. The workaround is to truncate the vectors, which models trained with Matryoshka (Qwen3-Embedding, EmbeddingGemma, nomic v1.5) support, and then renormalize them, as Google specifies for EmbeddingGemma. The /api/embed API of Ollama accepts a dimensions parameter, intended for these models.

#Version and reindex

Metadata to retain

Exact model name, revision, dimension, prefix template, chunking parameters, indexing date. Without them, no one knows why retrieval changed.

Model change

Re-encode the entire corpus into a new collection, evaluate it, then switch over. Never mix two models in the same collection.

Normalization

Ollama returns L2-normalized vectors: use the same metric (cosine or dot product) everywhere.

#Use a model in practice and test it on your documents

ollama pull bge-m3

curl http://localhost:11434/api/embed -d '{
  "model": "bge-m3",
  "input": "Le contrat débute le 1er mai."
}'

import numpy as np
import ollama

textes = [
    "Le contrat débute le 1er mai.",
    "Date de début : 01/05.",
    "La voiture est rouge.",
]
vecteurs = np.array(ollama.embed(model="bge-m3", input=textes)["embeddings"])

# Les vecteurs d'Ollama sont normalisés : le produit scalaire vaut le cosinus
print(vecteurs[0] @ vecteurs[1])
print(vecteurs[0] @ vecteurs[2])

Keep only the ordering of the two scores in mind: the first must clearly exceed the second. To seriously compare two or three candidates, the following procedure supersedes all published rankings.

1. 01
   Build a real-world test set

   Collect 50 to 100 questions asked by real users (support, tickets, frequently asked questions) and note for each the chunk containing the answer. Questions invented by an LLM make the results look better than they are.
2. 02
   Encode with each candidate model

   Encode the chunks and then the questions according to the prefix table, using the same chunk length and storage dimension for all candidates.
3. 03
   Measure recall@5

   For each question, check whether the correct chunk appears among the top five results. The script below performs this calculation.
4. 04
   Decide based on cost

   Keep the smallest model whose recall@5 remains within one or two points of the best: a model eight times larger costs more in storage and time on every reindexing.

import numpy as np
from sentence_transformers import SentenceTransformer

modele = SentenceTransformer("BAAI/bge-m3")

chunks = [...]      # vos chunks (liste de textes)
questions = [...]   # 50 à 100 vraies questions
cible = [...]       # pour chaque question, l'index du bon chunk

C = modele.encode(chunks, normalize_embeddings=True)
Q = modele.encode(questions, normalize_embeddings=True)

top5 = np.argsort(-(Q @ C.T), axis=1)[:, :5]
recall5 = np.mean([cible[i] in top5[i] for i in range(len(questions))])
print(f"recall@5 = {recall5:.0%}")

• Sentence Transformers: local embeddings
• Chunking strategies: chunk size versus the model’s context
• Hybrid BM25 + vector search
• Add a reranker before fine-tuning
• pgvector: dimension limits and indexes
• Ragas: evaluate your RAG with numbers

• Source: official BGE-M3 specification sheet (BAAI)
• Source: MTEB-French, study by Ciancone et al. (2024)
• Source: Ollama embedding documentation
• Source: Qwen3-Embedding specifications
• Source: EmbeddingGemma fact sheet (Google)