Embeddings and vector search.
Search by meaning, not by matching exact words. Here is the field that makes that possible, in plain language.
An embedding turns a piece of content into a list of numbers, arranged so that things that mean similar things sit close together. Vector search is finding the nearest of those points. We walk it the way the field is built: what it is, why it is hard, how a modern system does it, what it makes possible, and where it is heading. The papers behind each idea are linked, so you can read the source yourself.
- 1“Can we talk about the rate?”
- 2“Let’s discuss the quote.”
- 3“Book the meeting room.”
Meaning, turned into coordinates.
An embedding is a list of numbers that stands in for a piece of content. The arrangement of those numbers is the whole point.
Computers are good with numbers and clumsy with meaning. The word "invoice" and the word "bill" look nothing alike to a plain text search, even though a person reads them as nearly the same thing. So the field found a way to turn meaning into numbers. Each piece of content, a word, a sentence, a document, an image, a snippet of audio, gets converted into a long list of numbers called an embedding, and those numbers are arranged so that similar things sit near each other and different things sit far apart.
Once meaning is a set of coordinates, "find related things" becomes "find nearby points." That is the line that matters: this is search by meaning, not by matching exact words. Picture a search box over your call notes and emails, where "revisit pricing" should find "can we talk about the rate," with no words in common. The rest of this page is about how a machine does that job well, and why doing it well is harder than it sounds.
- Content
A sentence, image, or other supported input.
- Encoder
Convert the input into a fixed-length numeric representation.
- Vector space
Compare it with representations from a compatible model.
Meaning is not in the surface text, and scale fights back.
Good geometry does not arrange itself, the space has strange shape, and a real collection holds millions to billions of points.
Same idea, no shared letters.
"Invoice" and "bill" share no letters but nearly share a meaning. Exact-match and keyword search miss that link entirely, because the connection lives in meaning, not in the spelling.
The numbers have to be earned.
Vectors do not arrange themselves. A model has to be trained so that distance in the space actually tracks similarity in meaning. That is a real, measurable objective, not a given.
Strange geometry up high.
These vectors carry hundreds to thousands of dimensions. Intuition from 2D or 3D breaks down, and naive distance math gets expensive once the count climbs.
Too many points to scan.
A collection can hold millions to billions of vectors. Comparing a query against every one of them, exact and brute force, is accurate but too slow for interactive use.
Fast means not checking everything.
Going fast means not comparing against every point, which means accepting approximate answers. The engineering question is how to keep the approximation close enough while being far quicker.
The space can move under you.
Indexes have to absorb new and changed items. And swapping the embedding model re-maps the whole space, so vectors from two different models are not comparable.
Turn meaning into numbers, measure closeness, search fast.
Map content to vectors, train the space so distance tracks meaning, then find near-neighbors without scanning everything.
| Text | Role |
|---|---|
| Revisit pricing | Query |
| Can we talk about the rate? | Related candidate |
| Discuss the discount | Related candidate |
| Schedule the kickoff | Different topic |
1Embeddings: meaning as coordinates
From words to sentences.
A model maps each item to a fixed-length vector. The early breakthrough was for single words: word2vec (Mikolov et al., 2013) showed that a simple model trained on a large corpus produces word vectors where related words cluster, and where vector arithmetic captures analogies. It made "meaning as geometry" concrete.
Averaging word vectors loses nuance, so the field moved up to whole sentences. Sentence-BERT (Reimers and Gurevych, 2019) adapted a transformer with a siamese setup so a whole sentence maps to one vector that can be compared by cosine similarity in milliseconds. That turns "compare these two sentences for meaning" from hours of pairwise model runs into a fast distance check.
Revisit pricing.
[0.18, -0.62, 0.31, …]Illustrative coordinates. Each position is a learned feature, not a named business field.
2Measuring closeness
Closeness is an angle or a distance.
Similarity is usually cosine similarity, the angle between two vectors, or Euclidean distance, the straight-line gap. Smaller angle, or smaller distance, means more alike. This is the single metric the whole search runs on: every "find related things" question reduces to comparing closeness.
Two passages that mean nearly the same thing point in nearly the same direction, so the angle between them is small. Two unrelated passages point off in different directions, so the angle is wide. That is all "more alike" means here.
- Near directions
- A smaller angle gives a higher cosine similarity.
- Different directions
- A wider angle gives a lower cosine similarity.
3How the space gets trained
Pull related pairs together, push others apart.
Distance only tracks meaning if the space is trained to make it so. A common recipe is contrastive learning: pull related pairs together and push unrelated pairs apart. SimCSE (Gao et al., 2021) showed a strikingly simple version: pass the same sentence through the network twice with different dropout to make a positive pair, treat the other sentences in the batch as negatives, and the resulting space tracks meaning well.
Contrastive training is how modern embedding spaces get their shape. It is the step that earns the geometry the earlier diagrams take for granted.
Schematic two-dimensional projection; actual representations have many more dimensions.
4The scale problem, then the index
Find near-neighbors without scanning everything.
With millions to billions of vectors, scanning all of them per query is too slow. So the field uses approximate nearest neighbor (ANN) search: reach the near-neighbors without examining every point. HNSW (Malkov and Yashunin, 2018) builds a layered graph where each vector links to close neighbors, with sparse long-range links on upper layers for fast hops. A search greedily walks the graph toward the query, reaching the right neighborhood in roughly logarithmic steps instead of a full scan. It is a widely used backbone of vector indexes.
At billion scale, vectors are also compressed, with product quantization, so more fit in memory, and the search is mapped onto parallel hardware. The FAISS work (Johnson et al., 2017) showed billion-scale similarity search running on GPUs, a reference point for how this stays fast at size.
Exact
- Compare all vectors
Compute the query distance to every stored item.
- Select nearest
Return the exact top results for that metric.
Approximate
- Enter the index
Start at an entry point in a neighbor graph.
- Follow promising neighbors
Search a smaller part of the collection.
5Putting it together
The vector search loop.
Embed the query with the same model used for the corpus, search the index for the nearest stored vectors, return those items, and often re-rank the top results for a final order. The query side and the corpus side run through one model on purpose.
Same model on both sides is non-negotiable, since two models produce incomparable spaces. Get that right, and every later step is just measuring closeness in a space where closeness means meaning.
- Index the corpus
Encode documents and store their vectors with source identifiers.
- Encode the query
Use a compatible query encoder.
- Retrieve
Find nearby stored representations.
- Refine
Optionally rerank candidates before presenting passages.
Meaning as geometry is a quiet engine under a lot of software.
At the field level: semantic search, recommendations, deduplication and clustering, the retrieval step under grounded assistants, and matching across languages and formats.
This family of techniques is how the industry lets software search by meaning instead of exact words. Here is what that looks like as an everyday outcome for a seller, stated as outcomes, never as a claim about how any one system is built.
Find the note in plain words.
Ask about an account the way you would say it out loud and surface the right note, even when you do not remember the exact phrase you wrote.
Related context arrives together.
Nearby points are related items, so the surrounding context surfaces in one move instead of forcing ten keyword searches. See Deep context.
"Feels like this one" becomes findable.
Find the past deal that resembles the one in front of you, not just the ones that happen to share a label, because closeness tracks meaning.
The lookup under grounded answers.
Embeddings plus vector search are the engine retrieval-augmented systems use to fetch the passages an answer is built from. See Retrieval-augmented generation.
This explainer covers published research. To see how AI REV Voice helps with sales conversations, explore Prism.
The direction the field is heading.
We describe the direction, not a roadmap of our own.
One space for many formats.
CLIP (Radford et al., 2021) trained images and text into one shared space, so a text query can find a matching image directly. The same idea extends to audio and video, pointing toward search that crosses formats without conversion.
One model, many tasks.
Text embedding models tuned to handle search, clustering, and classification across many domains and tasks at once, instead of one model per job.
Cheaper to store and search.
Methods that shrink or truncate vectors, including adjustable-length embeddings, to cut memory and speed search with little quality loss.
Meaning plus exact match.
Pairing meaning-search with exact-match keyword search, since meaning-search catches paraphrases and exact-match catches codes, SKUs, and IDs. Strong systems run both and merge.
Pushing the trade further.
Continued work on ANN structures and shared benchmarks that push the speed-accuracy trade further at larger scale.
The papers behind this page.
- Mikolov et al. (2013). Efficient Estimation of Word Representations in Vector Space (word2vec). arXiv:1301.3781.
- Reimers and Gurevych (2019). Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks. arXiv:1908.10084.
- Gao et al. (2021). SimCSE: Simple Contrastive Learning of Sentence Embeddings. arXiv:2104.08821.
- Malkov and Yashunin (2018). Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs (HNSW). arXiv:1603.09320.
- Johnson et al. (2017). Billion-scale similarity search with GPUs (FAISS). arXiv:1702.08734.
- Radford et al. (2021). Learning Transferable Visual Models From Natural Language Supervision (CLIP). arXiv:2103.00020.
Keep reading.
Sibling explainers in the Research section.
Talk. Done.
Search by meaning is what lets you ask in plain words and get the right note back. See it on a real call.
No app required. Just your phone number.