Opening

A help center had a search box that matched keywords. A customer typed: I can't get into my account. Zero results.

The right article was called: how to reset your password. Not a single word in common. Same topic.

So the team switched the search to embeddings, and that question started finding the right article. Two weeks later, a new bug. People searching cancel subscription got, as the very first result: how to subscribe to the annual plan.

Similar topic, opposite intent. These two cases show exactly what embeddings capture, and where they mislead. And by the end of this lesson, you'll know when to trust them, and when to reach for something else.

The idea

An embedding is a list of numbers, a vector, that represents the meaning of a text. An embedding model was trained so that texts with similar meaning become vectors that sit close together.

Picture a huge map. Every text gets a point on it. Reset password and can't get into my account land on the same street. Delivery times by region lands in another neighborhood entirely.

How it works

You start with two texts. A customer's question and a help article, for example.

The same embedding model processes both.

Each text becomes a vector, with hundreds or thousands of dimensions.

A simple calculation, usually cosine similarity, compares the two vectors.

And the result tells you how close the meanings are. The meanings, not the words.

One rule people learn the hard way. The question and the documents have to go through the same model. Each model draws a different map. Comparing a vector from one model with vectors from another is like comparing a street address with a map of another planet. So if you change the embedding model, you rebuild the whole index.

What it captures

So what does similarity capture well? Synonyms and paraphrases. Get into my account sits close to log in, and to reset password.

Different languages, if the model is multilingual. Reembolso, in Portuguese, sits close to refund.

And the general topic. Texts about the same theme cluster together.

In Brazilian support, this shows up all the time. Pix didn't land, and transfer not credited, share almost no words. They name the same pain. Embeddings catch that. A search that only matches keywords doesn't.

Where it misleads

Now where it misleads. Negation and intent. Cancel subscription and subscribe to a plan share a topic, and the vector sees the topic first.

Numbers and codes. Order forty-five twenty-one and order forty-five twelve end up almost identical. The vector sees: this is an order number. For identifiers, tax IDs and tracking codes, filter in the database. Not by similarity.

Rare terms from your domain. Internal acronyms and product names may be unknown to the model.

And texts that are too long. A twenty page document becomes one single vector, and the meaning of each passage gets diluted. That's why documents are split into chunks before they become embeddings.

That last one is the classic beginner trap. The team embeds a forty page policy as one vector. A question about the return window for electronics hits a blob that mixes vacation, refunds, returns and a code of ethics. The similarity score can even be high. But the useful passage is not isolated. Chunking exists so each vector stands for one topic.

A challenge

Here's one for you. Back to the help center. A customer searches cancel subscription, and the first result is how to subscribe to the annual plan. Is the index broken? What's the right reading of that ranking?

The index is fine. The embedding did its job. It clustered the subscription topic. Intent just came out inverted. To break that tie, you need a signal beyond similarity. Keywords, a filter, reranking, or a classifier.

And swapping for a model that's better in Portuguese won't fix it either. The same thing happens in English, with cancel and subscribe. The model might nudge the order. The intent limit stays.

Where they show up

So where do embeddings show up in practice? Semantic search. Compare the question with chunks of documents, and take the closest.

Retrieval for generation, or RAG. Use that search to choose what goes into the model's context. That's the next lesson.

Clustering. Group similar tickets or feedback, without labeling anything first.

Cheap routing. Compare the message with examples of each route. But watch for ties. A message like I was charged twice for order forty-five twenty-one sits right between billing and orders. Below a threshold, send it to a classifier or a person, instead of forcing first place.

And semantic cache. Reuse the answer to a question that's very close to one you already answered. It inherits the same trap. How do I cancel sits close to how do I subscribe. With a loose threshold, the cache serves the wrong answer. So treat the threshold as part of the contract, and test it with opposite intent cases.

Try it

On the page there's an experiment that runs on your laptop, no API key, with a small open multilingual model. You compare one question against four help articles, and print the scores.

Start with I can't get into my account, and watch reset your password come out on top.

Then change the question to I want to cancel my subscription, and see where the annual plan article lands. Finally, test order forty-five twenty-one against order forty-five twelve. The numbers will show you, on their own, everything this lesson explained.

And one warning. The scores you see belong to this model. Don't copy someone else's threshold from the internet as if it were sacred. Measure your own pairs. The ones that should match, and the ones that must not.

In production

So what changes in your designs? Embedding only search is rarely enough. Combining it with keyword search is a pattern called hybrid search. Remember Pix didn't land? With embeddings alone, the right article sat in fifth place. Turning on keywords pushed it to first, because Pix is a rare, valuable term your domain needs to get right.

Re-sorting the top results with a model is called reranking.

How you cut documents into chunks changes search quality as much as the model does.

And identifiers, dates and amounts get exact filters in the database. Pull the order number out of the question, filter by it, and use similarity only on the free text that's left.

Wrap-up

So here's the idea to take with you. Embeddings put meaning on a map, which is why they find the password article without a single shared word. But a map shows closeness, not direction. Cancel and subscribe are neighbors, and two order numbers look like twins. Use meaning where meaning matters, and exact filters everywhere else.

In the next lesson, we'll put embeddings to work in the pattern that grounds a model in your own documents: retrieval augmented generation. See you there.