Semantic Similarity

What Is Semantic Similarity?

Semantic similarity measures how closely two pieces of content are related in meaning. The wording does not have to be identical. Two sentences can use different vocabulary while expressing nearly the same idea.

Keyword Matching vs Semantic Similarity

Traditional keyword search can be excellent when users know the exact terms. Semantic similarity becomes useful when the query and the stored content use different words for the same or related idea.

How Embeddings Enable Semantic Similarity

An embedding model converts text into a numerical vector. Once two texts have vectors, a similarity or distance function can compare those vectors.

The embedding model and similarity metric work together. A similarity score is only meaningful in the context of the model, metric, data, and task being used.

A Simple Semantic Similarity Example

Consider these three pairs. The first pair expresses almost the same request. The second pair is related but not identical. The third pair is unrelated.

Similarity Scores

A similarity function produces a numerical signal that can be used to rank candidate texts. With cosine similarity, for example, vectors with more aligned directions receive higher cosine values.

The numbers above are illustrative. Do not copy a score such as 0.80 as a universal definition of “similar.” Different embedding models and systems can produce different score distributions.

Cosine Similarity and Semantic Similarity

A common approach is to represent each text as an embedding and calculate cosine similarity between the two vectors.

For embedding-based semantic comparison, cosine similarity is widely used, but it is not the only possible metric. The correct choice depends on the embedding system and application.

Python: Compare Two Simple Vectors

Before using a real embedding model, it helps to understand the comparison step with small vectors.

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (
        np.linalg.norm(a) * np.linalg.norm(b)
    )

a = np.array([0.8, 0.2, 0.1])
b = np.array([0.7, 0.3, 0.1])

score = cosine_similarity(a, b)

print("Similarity:", score)

Python: Compare Multiple Text Candidates

A semantic search workflow usually compares one query against many candidate vectors and then ranks the candidates by similarity.

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (
        np.linalg.norm(a) * np.linalg.norm(b)
    )

query = np.array([0.8, 0.2, 0.1])

documents = {
    "password reset": np.array([0.78, 0.24, 0.12]),
    "account login": np.array([0.70, 0.30, 0.15]),
    "weather forecast": np.array([0.05, 0.90, 0.20]),
}

results = []

for name, vector in documents.items():
    score = cosine_similarity(query, vector)
    results.append((name, score))

results.sort(key=lambda item: item[1], reverse=True)

for name, score in results:
    print(f"{name}: {score:.3f}")

In production, the document vectors would normally be generated by an embedding model and stored in an appropriate vector index or database.

Similarity Is Not the Same as Correctness

A high similarity score means that the vectors are close according to the selected comparison method. It does not prove that the retrieved text is the correct answer.

Choosing a Similarity Threshold

Sometimes an application needs a decision rather than a ranking: “Is this FAQ close enough to answer the user's question?” A threshold can help, but it must be selected from evaluation data rather than guessed.

For example, you might test thresholds such as 0.70, 0.75, 0.80, and 0.85 on a labeled set of real queries. Measure how many relevant results are retrieved and how many irrelevant results are incorrectly accepted.

Semantic Similarity in Semantic Search

Semantic search is one of the most common applications. The system embeds a user query, compares it with stored document embeddings, and returns the strongest candidates.

Semantic Similarity in RAG

In Retrieval-Augmented Generation, semantic similarity helps retrieve chunks that are relevant to a user's question before the language model generates an answer.

Retrieval quality also depends on chunk size, metadata, query formulation, embedding model, indexing strategy, reranking, and evaluation. Similarity is an important component, not the entire RAG system.

Real-World Applications

Common Mistakes