Your first embedding in 5 minutes

Theory later. Right now the goal is to see actual numbers come out of a real model, because everything after this is easier once you’ve watched it happen once.

Pick whichever route suits you. Both take about the same time.

Free, runs locally

No account, no card, no API key. You download a small model and run it on your own machine. First run pulls about 90 MB and takes a minute; after that it’s instant and offline.

1. Install the library

   pip install sentence-transformers

   It’ll pull in PyTorch, so this is the slow step — a couple of minutes, and a few hundred MB. Go make tea.

2. Write the script

   Save this as first_embedding.py:

   first_embedding.py

   from sentence_transformers import SentenceTransformer
   
   model = SentenceTransformer("all-MiniLM-L6-v2")
   
   text = "The spare set for the front door is in the kitchen drawer."
   vector = model.encode(text)
   
   print(f"Text:       {text}")
   print(f"Dimensions: {len(vector)}")
   print(f"First five: {vector[:5]}")

3. Run it

   python first_embedding.py

You’ll see something along these lines (your exact numbers will differ slightly by version and hardware, which is fine and expected):

Text:       The spare set for the front door is in the kitchen drawer.
Dimensions: 384
First five: [-0.0234  0.0871 -0.0412  0.0159  0.0623]

OpenAI API

Higher quality, nothing to download, but you need an account with a payment method. The good news is embeddings are startlingly cheap — you could embed this entire website many times over for less than a penny.

1. Get an API key

   Create one at platform.openai.com/api-keys. Copy it immediately, it’s only shown once.

2. Set it as an environment variable

   export OPENAI_API_KEY="sk-..."      # macOS / Linux
   setx OPENAI_API_KEY "sk-..."        # Windows PowerShell, then reopen the terminal

   Never paste the key directly into your source file. We’ll say this again on every page, and we’re not sorry.

3. Install the SDK

   pip install openai

4. Write the script

   first_embedding.py

   from openai import OpenAI
   
   client = OpenAI()   # reads OPENAI_API_KEY from the environment
   
   text = "The spare set for the front door is in the kitchen drawer."
   
   response = client.embeddings.create(
       model="text-embedding-3-small",
       input=text,
   )
   vector = response.data[0].embedding
   
   print(f"Text:       {text}")
   print(f"Dimensions: {len(vector)}")
   print(f"First five: {vector[:5]}")
   print(f"Tokens used: {response.usage.total_tokens}")

5. Run it

   python first_embedding.py

Output looks roughly like this:

Text:       The spare set for the front door is in the kitchen drawer.
Dimensions: 1536
First five: [0.0212, -0.0145, 0.0083, -0.0331, 0.0097]
Tokens used: 13

Right. What did we just see?

A number where you expected a sentence. You gave the model twelve words and it handed back a long list of floating-point values. That list is the embedding. There’s no other magic object hiding behind it — this is the thing everybody’s talking about.

A fixed length. 384 numbers from MiniLM, 1,536 from OpenAI’s small model. Notice that the length has nothing to do with how long your text was. Embed a single word or embed three paragraphs; you get the same size list either way. That’s what makes them comparable — you can’t measure the distance between a 5-element list and a 900-element one, so the model always gives you the same shape.

Numbers that mean nothing individually. The first value being 0.0212 tells you precisely nothing. Don’t stare at it. As we said on the previous page, these are only useful in comparison to other embeddings.

Try this — it takes ten seconds

Change the text to something completely different, like "Pizza dough: 500g flour, 300ml water.", and run it again. You’ll get a different list of the same length. Then try a rephrasing of the original, like "I keep the backup front-door keys in a drawer in the kitchen." — the numbers will look broadly similar to the first run.

“Broadly similar” is doing a lot of work in that sentence, and eyeballing it is a terrible way to measure. Putting a proper number on that similarity is exactly what the cosine similarity page is for.

The bit that trips everyone up

You must use the same model for everything you intend to compare. An embedding from MiniLM and an embedding from OpenAI are not comparable, even if you force the dimensions to match. They’re coordinates in two unrelated spaces. Comparing them is like comparing a grid reference in London to one in Tokyo — the numbers are similar-looking and the answer is meaningless.

That includes model versions. If you re-embed your database with a newer model, you have to re-embed all of it, not just the new rows. Mixing generations is one of the most common ways a working search quietly turns to mush, and it produces no error message at all — just steadily worse results that nobody can explain.

Next

You’ve made one embedding. Now make nine and build the actual search:

• Python guide — the full eight-note search, about 40 lines
• .NET / C# guide
• Java guide
• Node / TypeScript guide

Or if you’d rather understand before you build, how text becomes numbers explains what happened inside that encode() call. Wondering which model to use at all? Choosing an embedding model covers the ones people actually pick.

References

• OpenAI — Embeddings guide — models, dimensions, usage
• OpenAI — Embeddings API reference — every parameter, including dimensions and encoding_format
• OpenAI — Pricing — check current embedding costs before you budget
• openai-python on GitHub — SDK source and changelog
• sentence-transformers documentation — the local route, in depth
• all-MiniLM-L6-v2 model card — what the local model is and how it was trained