Embeddings: The Foundation of AI Search

Before you can build semantic search, a retrieval-augmented generation system, or a recommendation engine, you need to understand embeddings. They are the numerical foundation that makes all of these features possible.

This post explains what embeddings are, how similarity search works, and how to put them to use in a Node.js application.

What Is an Embedding?

An embedding is a fixed-length array of floating-point numbers that represents the meaning of a piece of text. Two pieces of text with similar meanings produce vectors that are close to each other in high-dimensional space; unrelated texts produce vectors that are far apart.

This is fundamentally different from keyword matching. The phrase "automobile accident" and "car crash" use no common words, but their embeddings will be close because they describe the same concept.

Embedding models are trained to capture this semantic proximity. You pass them a string and receive a vector, typically several hundred to a few thousand dimensions long. You never inspect the individual numbers — you only compute distances between vectors.

Generating Embeddings

Anthropic's API does not currently expose a dedicated embeddings endpoint, so in practice you pair Claude with a separate embeddings model. A common choice for Node.js projects is the text-embedding-3-small model from OpenAI or the open-weight nomic-embed-text model served locally. What matters architecturally is that:

• You use the same model at index time and at query time. Vectors from different models are not comparable.
• You chunk long documents before embedding — embedding a 50-page document as one vector loses resolution.

Here is a minimal embeddings utility that works with any REST-compatible endpoint:

ts
async function embed(text: string): Promise<number[]> {
  const res = await fetch("https://api.openai.com/v1/embeddings", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "text-embedding-3-small",
      input: text,
    }),
  });
  const data = await res.json();
  return data.data[0].embedding as number[];
}

Store these vectors alongside your documents in a vector database or in a column that supports vector search.

Similarity Search: The Core Operation

Given a query embedding and a collection of stored embeddings, similarity search returns the stored vectors that are closest to the query vector. Two distance metrics dominate:

Cosine Similarity

Measures the angle between two vectors. Values range from -1 (opposite directions) to 1 (identical direction). For normalised vectors, cosine similarity is equivalent to dot-product similarity and is the most common choice for semantic search:

ts
function cosineSimilarity(a: number[], b: number[]): number {
  const dot = a.reduce((sum, ai, i) => sum + ai * b[i], 0);
  const magA = Math.sqrt(a.reduce((s, v) => s + v * v, 0));
  const magB = Math.sqrt(b.reduce((s, v) => s + v * v, 0));
  return dot / (magA * magB);
}

Euclidean Distance

The straight-line distance between two points. Useful when magnitude matters, but for most NLP tasks cosine similarity performs better because text embeddings are typically high-dimensional and unit-normalised.

Approximate Nearest Neighbour (ANN) Search

Brute-force cosine similarity over millions of vectors is too slow for production. Vector databases solve this with Approximate Nearest Neighbour (ANN) algorithms like HNSW and IVF, which trade a small amount of recall for orders-of-magnitude faster query times.

Popular vector stores:

• Pinecone — fully managed, scales without ops burden.
• Weaviate — open-source, self-hostable, with hybrid search built in.
• pgvector — a PostgreSQL extension; good if you already run Postgres.
• Chroma — lightweight, easy to run locally during development.

For a deeper comparison of these options, see Vector Databases and How Semantic Search Works.

Chunking Strategy

The quality of search results depends heavily on how you split documents:

• Too large: Each chunk covers many topics; the resulting embedding is a blend that matches nothing precisely.
• Too small: Each chunk lacks enough context to be meaningful on its own.

A practical starting point is 300-500 token chunks with 50-100 token overlap between adjacent chunks. The overlap ensures that sentences near chunk boundaries appear in at least one full chunk.

ts
function chunkText(text: string, chunkSize = 400, overlap = 80): string[] {
  const words = text.split(/\s+/);
  const chunks: string[] = [];
  let i = 0;
  while (i < words.length) {
    chunks.push(words.slice(i, i + chunkSize).join(" "));
    i += chunkSize - overlap;
  }
  return chunks;
}

After chunking, embed each chunk individually and store it with metadata pointing back to the source document.

Using Embeddings in a RAG Pipeline

Embeddings are the retrieval layer in RAG. The pipeline is:

1. Embed the user's query.
2. Retrieve the top-k most similar document chunks from the vector store.
3. Inject those chunks into the prompt as context.
4. Ask the LLM to answer using only the provided context.

This keeps the LLM grounded and is one of the most effective ways to reduce hallucinations. The full pattern is covered in Retrieval-Augmented Generation (RAG), Explained.

Beyond Search: Clustering and Recommendations

Embeddings are not only for search. Other common applications:

• Clustering: Group similar documents together using k-means or DBSCAN on their embedding vectors — useful for auto-tagging or topic discovery.
• Recommendations: "More like this" features work by embedding the item a user is viewing and returning the nearest neighbours.
• Duplicate detection: Two texts that are near-duplicates produce very similar embeddings, even if they use slightly different wording.

For a full end-to-end implementation of blog search using embeddings, see Adding AI-Powered Search to Your Blog with Embeddings.

Practical Notes

• Embed at write time, not query time. Pre-computing and storing embeddings during ingestion keeps query latency low.
• Re-embed when the model changes. A model upgrade invalidates all stored vectors — plan for re-indexing.
• Cache embedding API calls for frequently repeated texts to reduce cost. Caching Strategies: CDN, ISR, Redis covers caching patterns applicable here.

You can see embedding-based features in action on the /projects page.

Conclusion

Embeddings convert text into a form where mathematical distance equals semantic similarity. Everything that makes modern AI search feel intelligent — the ability to match intent rather than keywords, to find related content, to power RAG — traces back to this idea. Understanding embeddings is not optional if you are building AI features; it is the bedrock concept everything else builds on.