recallA retrieval
field guide

Modern Embedding Models

Build this skill

Compare open and API embedding models on dimensions, input length, languages, licence and storage.

A crowded shelf of models

When you build semantic search, one of the first decisions is which embedding model to use. There are hundreds to choose from, and new ones appear every few months. The good news is that they fall into a few clear families, and once you know what separates them, the choice becomes much less confusing.

Every embedding model has a short list of properties that matter in practice:

Property What it means Why it matters
Dimensions How many numbers in each embedding More can capture more detail, but take more storage and slower search
Maximum input length How many tokens it reads before cutting off Longer passages need longer limits
Languages Which languages it was trained on Decides whether Hindi or Tamil queries work
Licence Whether you can use it freely, and how Some open models restrict commercial use
Where it runs Your own machine, or a provider's API Affects cost, speed and data privacy

The main families are open models you run yourself and API models you call over the internet.

Open models you can run yourself

Open models can be downloaded and run on your own computer or server, so your documents never leave your control. Several families are widely used.

BGE models come from the Beijing Academy of Artificial Intelligence (BAAI). The best-known for retrieval systems is BGE-M3. The "M3" stands for three strengths: it is multilingual (trained on over 100 languages), multi-granular (it handles inputs from short sentences up to 8,192 tokens), and multi-functional (it can produce ordinary dense embeddings, sparse keyword-style weights and multi-vector representations from the same model). Its dense embeddings have 1,024 dimensions.

Jina embedding models, from Jina AI, also support long inputs of about 8,192 tokens and many languages. Their later versions support task-specific adapters (for example, one for search queries and another for classification) and let you shorten embeddings to save space.

Nomic embedding models, from Nomic AI, are notable for being fully open: the weights, the training code and the training data are published, which makes them easy to study and reproduce. They expect short task prefixes such as "search_query: " and "search_document: ".

There are many more, including the E5 and GTE families and compact models that run comfortably on a laptop. Smaller models produce smaller embeddings (often 384 or 768 numbers) and run faster, at some cost in quality.

API models from providers

API models run on the provider's servers. You send text over the internet and receive embeddings back, paying per token.

OpenAI offers text-embedding-3-small (1,536 dimensions) and text-embedding-3-large (3,072 dimensions). Both let you request shorter embeddings, trading a little quality for less storage. Google's Gemini embedding models are available through its API and cloud platform, with strong multilingual performance. Other providers, such as Cohere and Voyage AI, offer embedding models aimed specifically at search, including models tuned for code, law or finance.

The main attraction of API models is convenience: no servers or GPUs to manage, and good quality out of the box. The main concerns are cost at scale, network latency, and sending your documents to an outside company, which some organisations' data policies do not allow.

Open models (BGE, Jina, Nomic…)Run on your own hardwareDocuments stay in-houseNo per-token feesYou manage servers and updatesCheck each licenceAPI models (OpenAI, Gemini…)Run on the provider's serversText is sent outsidePay per tokenNothing to manageModel can be retired or changed

Neither family is better in general. The right choice depends on privacy rules, volume, budget and the team's skills.

Comparing models fairly: MTEB

With so many models, how do you know which is good? The most widely used comparison is MTEB, the Massive Text Embedding Benchmark, published by researchers at Hugging Face in 2022 and extended since. It tests embedding models on dozens of tasks, including retrieval, classification and clustering, across many languages, and publishes the results as a public leaderboard.

MTEB is a useful starting point, with a few warnings. A model's overall average mixes many tasks, so for search you should look at the retrieval scores specifically. Benchmarks are mostly general web text, not Indian college regulations or your company's contracts. And because the leaderboard is so visible, some models are tuned to do well on it, so small differences in rank rarely mean much. The only fully reliable test is a small evaluation on your own documents and real questions.

Seeing the difference on your own data

The lab below shows what three different models might return for the same student query over the campus pages. The scores and rankings are illustrative, but they mirror patterns you see in practice: a small English model, a large multilingual model, and a large API model.

Storage numbers in the lab come from simple arithmetic: each number in an embedding is usually stored as a 4-byte float, so a 1,024-dimension embedding takes 4,096 bytes. Run the calculation for a whole collection below.

python · runs in your browser

Expected output:

text
small (384 dims)           1.5 GB for 1,000,000 chunks
BGE-M3 (1,024 dims)        4.1 GB for 1,000,000 chunks
large API (3,072 dims)    12.3 GB for 1,000,000 chunks

Each row multiplies passages × numbers per embedding × 4 bytes, then divides by a billion to turn bytes into gigabytes. Change chunks to the size of a collection you have in mind and run it again.

At a million passages, the difference between models is several gigabytes of memory, which affects both the hardware you need and how fast searches run. Model choice is never only about quality.

Follow your curiosity.

↑ ↓ to explore · Enter to open · Escape to close