Loading...
System Design and AI Engineering, by Roni Das. 980 interactive lessons.
Start LearningAI Engineering · Advanced · LLM and GenAI Ops
A measure of how close two embeddings are, based on the angle between them rather than their length. The standard way to rank how related two pieces of text are in vector search.
In short
Cosine similarity scores how closely two embeddings point in the same direction, ignoring their length. It runs from -1 to 1, and vector search usually ranks documents by it, because the meaning of an embedding lives in its direction.
In short
Cosine similarity scores how closely two embeddings point in the same direction, ignoring their length. It runs from -1 to 1, and vector search usually ranks documents by it, because the meaning of an embedding lives in its direction.
Learn it in the course
This page is the free part.
₹999 in India$49 everywhere elseonce, for the whole course
The AI Engineering course covers Cosine Similarity across a run of lessons, not one page. These 4 alone are about 207 minutes of step-by-step reading, every one with code you run in the browser, all with a quiz.
The same question and the same text scored 0.741 with cosine and 521.380 with a dot product. The difference is the length of the vectors. Ollama's /api/embed returned vectors of length 1 for all 878 lesson texts, where all three measures agree; its older /api/embeddings returned lesson vectors of length 19.0 to 27.4. On those, a raw dot product changed 109 of 300 top-5 places for nomic-embed-text and 51 for bge-m3, while the number of right answers barely moved.
An embedding turns a piece of text into a list of numbers, so that texts with similar meaning get similar numbers. This lesson measures two real embedding models on this laptop. With the English-trained model, sentences with the same meaning scored 0.89 to 0.96 and unrelated ones 0.52 to 0.60. Then the test that matters for a global audience: the same sentence in six other languages. The English-trained model scored five of the six translations below an unrelated English sentence. A multilingual model scored all six 0.92 to 0.98.
Semantic search finds text by meaning instead of by shared words. This lesson builds it over this site's 878 lessons and asks 10 questions in six languages. In English the two models were close: 6 and 4 of 10 in the top 5. Across the five other languages, the multilingual bge-m3 found 21 of 50 and the English-trained nomic-embed-text 5 of 50. Four questions were never found. Rewriting one lesson's short description moved it from rank 34-50 to rank 1 in all six languages.
Keyword search matches words; meaning search matches embeddings. Combining the two rankings (rank fusion) was measured twice. On 470 quiz questions that reuse the lessons' own words, keyword search alone found the right lesson in the top 5 for 453, meaning search with bge-m3 for 439, and both together for 455. On lesson 4's 60 questions written in other words and six languages, keyword search found 5, meaning 27, and both 22. Where keyword search matched no word at all, combining changed nothing; where it matched words in the wrong lessons, it pulled good answers down.
all part of
AI Engineering
210 lessons · about 219 hours · 10 free to read
₹999in India, by UPI
$49everywhere else, by PayPal
pay once,
yours for life
An embedding is a list of numbers, and it helps to picture it as an arrow from a starting point. Cosine similarity measures the angle between two such arrows. If they point the same way, the score is 1. At a right angle, it is 0. In opposite directions, it is -1.
It ignores length on purpose. Take [1, 2] and [2, 4]: the second is the first made twice as long, and their cosine similarity is exactly 1. In an embedding, the meaning lives in the direction, not the length, so a measure that ignores length follows meaning.
That is why cosine similarity is the usual default for text search. A retrieval system embeds the question, scores every stored text by cosine against it, sorts by that score, and shows the top few. The measure you choose there decides, by itself, what the user sees first.
There are three steps. First, multiply the two lists number by number and add the results: that is the dot product. Second, find each arrow's length: square every number, add them up, and take the square root. Third, divide the dot product by the two lengths multiplied together.
Take a question [3, 4, 0] and a document [4, 3, 1]. The dot product is 3x4 + 4x3 + 0x1 = 24. The lengths are 5 and about 5.10. The cosine is 24 / (5 x 5.10), about 0.941. Now stretch the document ten times, to [40, 30, 10], without turning it. The dot product becomes 240 and the straight-line distance between the tips jumps from 1.73 to 46.31, but the cosine stays at 0.941.
When every vector has length exactly 1, which is called normalised, the three measures agree. Cosine and dot product become the same number, and the squared distance equals 2 - 2 x cosine, so a higher cosine always means a smaller distance. From a real run: a cosine of 0.741 gave a distance of 0.719, the square root of 2 - 2 x 0.741. Many systems normalise vectors once when they store them and then use the dot product, which skips the division.
In a measured lab run, one question and one text about rate limiting, embedded with bge-m3, scored a cosine of 0.741 from Ollama's /api/embed endpoint and a dot product of 521.380 from its older /api/embeddings endpoint. Both endpoints gave vectors pointing the same way. The newer one returned vectors of length 1; the older one returned lengths from about 19 to 27. The large number is the same 0.741 multiplied by two lengths of about 26.
On a search over 878 lesson titles and descriptions, with 60 questions per model, a raw dot product on the older endpoint's vectors changed 109 of 300 top-5 places for nomic-embed-text and 51 for bge-m3, compared with cosine. The number of right answers barely moved: 9 against 8 of 60 for nomic-embed-text, 27 against 25 for bge-m3. What changed was which other results the user saw around the right one, for a reason that had nothing to do with meaning.
One search shows how. For "Most of my database traffic is reads. How do I spread that load?", the Read Replicas lesson had cosine 0.6190 and vector length 26.11, and a lesson on distributed transactions had cosine 0.6134 and length 26.85. Cosine ranked Read Replicas higher. The dot product ranked the other lesson higher, 436.9 against 428.9, because its vector was about 2.8 percent longer while it was less than 1 percent further away in angle. The right lesson dropped out of the top 5.
A cosine score is not a percentage. A score of 0.741 does not mean "74 percent similar". Scores from one embedding model are only meaningful next to other scores from the same model. In one run with nomic-embed-text, even unrelated sentences scored 0.52 to 0.60, while pairs with the same meaning scored 0.89 to 0.96.
That makes fixed cut-offs risky. A rule like "keep results above 0.5" would keep an unrelated sentence that scored 0.578 with nomic-embed-text and drop the same sentence with bge-m3, where it scored 0.429. If you need a cut-off, choose it for one model by scoring pairs whose answer you already know, and normalise both the question and the documents, or the numbers stop being cosines.
Watch the sort order and the operator. With cosine and dot product, bigger is closer; with distance, smaller is closer. In pgvector, <=> is cosine distance, which is 1 minus the cosine, so smaller is better, and <#> is the negative dot product. Sorting the wrong way returns the worst matches first and makes a good model look broken.
Run one check: print the length of one vector from your tool. If it is 1, or 0.9999 from rounding, all three measures give the same order, so use whichever your database is fastest at. If it is not 1, or you are not sure, use cosine, or normalise every vector before you store it and every question before you search.
Some models are trained to put information in the length on purpose, and for them a dot product is the intended measure. The model's documentation says which measure it expects. Use the measure the model was trained for, and set the same one in your vector index.
Never mix sources. If documents came from one endpoint and questions from another, cosine still works, because the directions match. But a dot product or a distance would then compare arrows of length 1 with arrows of length about 20 or 26, and length would take over the ranking.
pgvector
The PostgreSQL extension provides the <=> operator for cosine distance and a vector_cosine_ops operator class for its indexes.
scikit-learn
Provides a cosine_similarity function in sklearn.metrics.pairwise that computes the score between rows of two arrays.
FAISS
Meta's vector search library computes inner products; normalising vectors to length 1 first makes that inner product equal to cosine similarity.
Ollama /api/embed
In a measured run on Ollama 0.32.14, this endpoint returned embeddings of length 1, so cosine and dot product gave the same scores.
The dot product grows with both the angle's closeness and the two lengths. Cosine similarity is the dot product divided by both lengths, so it measures only the angle. On vectors of length 1 they are the same number.
Yes. The formula ranges from -1 for opposite directions, through 0 at a right angle, to 1 for the same direction. In practice, sentence embeddings from one model often score well above 0 even when the texts are unrelated.
There is no universal value. With one model, unrelated sentences scored 0.52 to 0.60; with another, around 0.43. Compare scores only within one model, and set any cut-off by testing pairs whose answer you know.
If your vectors have length 1, both give the same order, because squared distance equals 2 minus 2 times the cosine. If they do not, distance mixes length into the ranking, so use cosine or normalise first.
Usually yes, unless the model's documentation says length carries meaning. Normalised vectors make cosine, dot product and distance agree, let you use the cheaper dot product, and keep fixed cut-offs meaningful.
Similarity Search
Finding the most similar items in a dataset, distance metrics, exact vs approximate methods, and real-world applications
What an Embedding Is: Meaning as a List of Numbers
An embedding turns a piece of text into a list of numbers, so that texts with similar meaning get similar numbers. This lesson measures two real embedding models on this laptop. With the English-trained model, sentences with the same meaning scored 0.89 to 0.96 and unrelated ones 0.52 to 0.60. Then the test that matters for a global audience: the same sentence in six other languages. The English-trained model scored five of the six translations below an unrelated English sentence. A multilingual model scored all six 0.92 to 0.98.
Embedding
A list of numbers that represents the meaning of a piece of text, so that similar meanings sit close together in vector space. The same model must embed both the corpus and the query.
ANN (Approximate Nearest Neighbor)
Search that finds vectors close to a query without scanning every item, trading a small chance of missing a true neighbor for a large gain in speed. HNSW and IVF are the common indexes.
Vector Database
A database that stores embeddings, lists of numbers that capture the meaning of text or images, and finds the ones closest to a question's embedding. It powers semantic search and RAG.
RAG (Retrieval-Augmented Generation)
A pattern that retrieves relevant text from an external index and puts it in the model's prompt so the answer is grounded in current, verifiable facts rather than the model's memory.
Agentic RAG
Agentic RAG is RAG where a language model runs the search in a loop. It decides whether to search, what to search for and where. Then it checks if the text it found answers the question.
HNSW
Hierarchical Navigable Small World, a graph-based nearest neighbor index that gives high recall at low latency by navigating layers of links, at the cost of more memory than IVF.
This page explains the idea. The "Cosine, Dot Product or Distance: Which One Compares Embeddings?" lesson builds it up step by step, with diagrams. It is part of the AI Engineering course, which has 210 lessons. 10 of them are free to read. You pay once and keep it for life, with no subscription.
Open the Cosine, Dot Product or Distance: Which One Compares Embeddings? lessoncourse 2
Take models from notebook to production, with labs on real models.