Embedding Models and Providers

One idea, many models

An embedding is just a vector of numbers — but which numbers a text gets depends entirely on the model you embed it with. And there are many. They differ in quality, price, language coverage, vector size, and where they run. Picking one is one of the first real decisions in any semantic search or RAG project.

If you’re completely new here: an embedding is a list of numbers that stands in for the meaning of a text — coordinates on a map of meaning. Similar meanings, similar numbers. Read What Are Embeddings? first if that still feels like magic. It matters here because a bad model puts your texts in the wrong places, and no amount of clever code downstream fixes that.

The main options

Two columns worth decoding:

• Type. “API” means the model runs on the provider’s computers: you send your text over the internet and get numbers back — no setup, but your text leaves your infrastructure, and you pay per use. “Open source, local” means the model runs on your own machine: nothing leaves, no per-use bill, but you provide the hardware.
• Dimensions. The only column that looks scary, and it isn’t: a dimension is just one number in the list. A 1024-dimensional embedding is a list of 1024 numbers describing one text. More numbers means more room for nuance; fewer numbers means less storage and faster search. Nothing else about your code changes — the model, not you, decides what the numbers mean.

A quick tour:

• OpenAI Embeddings API is the default choice for many teams: two lines of code, solid quality, pay per token. The small model is cheap enough that re-embedding an entire knowledge base costs cents.
• Cohere focuses on search and retrieval specifically, with strong multilingual support and dedicated modes for search, classification and reranking (taking a shortlist of candidate results and re-scoring them so the best ones float to the top).
• Gemini Embedding offers top-tier quality with a generous free tier — great for prototypes and side projects.
• Jina is a strong independent option, popular for long documents.
• Sentence Transformers is an open-source Python library. Models run locally — your laptop or your server. No API bills, no data leaving your infrastructure, and for many classic tasks (short-text similarity, clustering) quality is entirely sufficient.

Same meaning, different languages

Here’s the property that makes multilingual embeddings special: the model was trained so that the same meaning lands in the same place, regardless of language. Hover around the map — each cluster holds one concept in four languages, and the query “merci” finds its cluster even though nothing in the data is French:

Try hovering “hello” and then “thank you”: the neighbors stay inside the cluster, in every language at once. That’s the whole feature in one picture.

This means a multilingual model lets you search an English knowledge base with a Russian query — or build one index for users in three countries. That alone is worth checking before anything else if your product is not English-only.

How to actually choose

Don’t overthink it — this is a two-hour decision, not a two-week one:

1. Data sensitivity first. If text cannot leave your infrastructure, you’re already down to Sentence Transformers or a self-hosted model.
2. Then languages. Non-English content? Shortlist Cohere, Gemini, Jina, or a multilingual open model — and test on your real data.
3. Then cost at your scale. Estimate tokens: a 10k-document knowledge base embedded with a cheap API model is a rounding error. Huge corpora tip you toward local models.
4. Then dimensions. Bigger vectors are slightly more expressive but cost more to store and search. For most projects 384–1536 is plenty.
5. Finally, benchmark on your task. Take 20 real queries, embed your docs, eyeball the top results. Ten minutes of this beats any leaderboard.

And remember: the choice is reversible. Since switching models means re-embedding everything, wrap embedding in one function in your codebase — then the model is a config value, not an architectural commitment:

# embed.py — the ONLY place that knows which model you use
MODEL = "text-embedding-3-small"

def embed(texts: list[str]) -> list[list[float]]:
  """Turn texts into vectors. Swap the provider here, nowhere else."""
  response = client.embeddings.create(model=MODEL, input=texts)
  return [item.embedding for item in response.data]

# Switching to a local model? Change the body, keep the signature:
#
# from sentence_transformers import SentenceTransformer
# _m = SentenceTransformer("all-MiniLM-L6-v2")
# def embed(texts): return _m.encode(texts).tolist()

Where the vectors then live — and how you search millions of them — is the next article. And the reason any of this is worth setting up is RAG: handing the right chunks to an LLM at the moment it needs them.