Text Embeddings

Text Becomes a Numerical Representation

A text embedding model takes text as input and returns a vector of numbers. The vector is a representation that applications can use for comparison and retrieval.

Document Embeddings vs Query Embeddings

A semantic search system usually embeds two sides: the content you want to search and the user's query. Both need compatible representations so they can be compared.

The search system can rank stored documents according to their similarity to the query vector.

The Text Embedding Pipeline

At query time, the application embeds the user's question, searches the stored vectors, and returns the most relevant text.

Prepare Text Before Embedding

The embedding model can only represent the text you give it. Unnecessary navigation, repeated headers, broken extraction, or irrelevant boilerplate can make retrieval less useful.

HOME | PRODUCTS | LOGIN | SUPPORT

Refund Policy
Refunds may be requested within 30 days...

FOOTER
Copyright 2026...

Refund Policy

Refunds may be requested
within 30 days of purchase.

Why Chunking Matters

Long documents are often divided into smaller chunks before embedding. A query can then retrieve the specific passages that are most relevant.

Very small chunks can lose context, while very large chunks can mix unrelated information and increase retrieval payload.

Similarity Search

After creating a query embedding, the system compares it with stored document embeddings and ranks the closest matches.

Scores here are examples, not universal thresholds. Your model, data, and evaluation method determine what scores are useful.

Python: Create Text Embeddings

An embedding API converts text into a vector that your application can store, compare, or send to a vector database.

from openai import OpenAI

client = OpenAI()

text = "Refunds are available within 30 days."

response = client.embeddings.create(
    model="YOUR_EMBEDDING_MODEL",
    input=text,
)

embedding = response.data[0].embedding

print("Vector length:", len(embedding))
print("First 5 values:", embedding[:5])

Python: Embed Multiple Texts

Embedding multiple inputs is useful when preparing a document collection for search.

from openai import OpenAI

client = OpenAI()

texts = [
    "How do I reset my password?",
    "How can I request a refund?",
    "Where is my order?",
]

response = client.embeddings.create(
    model="YOUR_EMBEDDING_MODEL",
    input=texts,
)

embeddings = [
    item.embedding
    for item in response.data
]

for text, vector in zip(texts, embeddings):
    print(text)
    print("Dimensions:", len(vector))

Python: Calculate Cosine Similarity

Cosine similarity compares the direction of two vectors and is commonly used for semantic similarity.

import numpy as np

def cosine_similarity(a, b):
    a = np.array(a)
    b = np.array(b)

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

score = cosine_similarity(
    query_embedding,
    document_embedding,
)

print("Similarity:", score)

Build a Small Semantic Search

A basic semantic search implementation embeds a query, scores stored vectors, and sorts the results.

documents = [
    {"text": "Reset your password from Account Settings.",
     "embedding": password_vector},
    {"text": "Refunds can be requested within 30 days.",
     "embedding": refund_vector},
    {"text": "Track your order from the Orders page.",
     "embedding": shipping_vector},
]

query_vector = embed("I forgot my password.")

results = []

for document in documents:
    score = cosine_similarity(
        query_vector,
        document["embedding"],
    )
    results.append({
        "text": document["text"],
        "score": score,
    })

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

for result in results:
    print(result)

Embeddings Need Metadata Too

A vector by itself is rarely enough for a useful application. Store metadata that helps you identify, filter, and reconstruct the source of each result.

Metadata can support filters such as product, language, customer type, date, or access permissions.

Normalization and Consistent Comparison

Vector search systems may normalize vectors or use distance measures where normalization is useful. The exact approach depends on the model and database.

Text Embeddings Across Languages

Multilingual applications should evaluate how well the selected embedding model represents the languages used by their users and documents.

Evaluate multilingual retrieval with real examples instead of assuming identical performance across languages.

Common Text Embedding Mistakes