Embeddings and Vector Search

Vector search is the part of this field where the documentation is thickest and the

understanding is thinnest. Every vector database offers a choice of similarity metric, an

index type with three or four tuning parameters, a compression option, and a way to filter by

metadata — and almost none of them tell you what any of it costs, or when a setting that

works quietly stops working.

So the defaults get copied. Cosine similarity because everyone uses it, HNSW because it is

the default, whatever dimension the embedding model happens to produce, and a filter applied

after the search because that is the obvious place to put it. Each of those is right in some

regime and wrong in another, and this book is about knowing which regime you are in.

Books about search benchmark other people's implementations. This one builds them — and that

has a consequence that matters more than any other: **every recall figure in this book is

measured against exhaustive brute-force search over the same vectors.** Not sampled, not

approximated, not taken from a published benchmark. When this book says an index reached

0.9745 recall, that means it returned 9.745 of the true 10 nearest neighbours on average,

where "true" was established by comparing the query against every single vector.

That is possible because vector search is deterministic. There is no training, no random seed

that changes a conclusion, and no behaviour that only appears at scale. This volume needed

cited results less often than any other in the series — three boxes in the whole book.

What gets measured:

- **Why high-dimensional space is strange.** In two dimensions the farthest point in a

collection is 263 times farther away than the nearest. In 1,024 dimensions it is 1.15 times

farther. Every design decision in the rest of the book is a response to that.

- **Why cosine is the default.** Vector norms in a real embedding space span a factor of 15,

and the largest belong to function words — so searching by dot product for *love* returns

*our, my, for, so, thy*, with zero overlap against cosine's results on four of five queries.

After normalisation, cosine, dot product and Euclidean distance rank identically on 300 of

300 queries.

- **What exhaustive search actually costs.** 268 queries per second against 128,000 vectors on

a single core, exactly correct, with nothing to build or tune. It becomes untenable not

because it is slow but because it is unamortisable — which reframes when an index is worth

building at all.

- **What a proximity graph buys.** Recall 0.9745 while examining 590 vectors out of 8,000 —

13.5 times fewer comparisons. And recall 1.0000 while saving only 1.9x, which is the

measurement behind an uncomfortable conclusion: an index tuned for near-perfect recall has

surrendered most of its purpose.

- **What compression costs, and how it is recovered.** Compressing vectors 32-fold dropped

recall to 0.2795. Re-scoring 500 candidates exactly — 2.5% of the collection — brought it

back to 0.9380, with the index unchanged at 8 bytes per vector.

- **When filtering breaks.** Searching first and filtering afterwards held recall 0.9675 at

50% selectivity and collapsed to 0.2000 at 1% — returning fewer results than requested for

**every single query**, silently, with no error raised. At that selectivity, scanning the

matching subset exhaustively is both exact and twenty times cheaper.

What you get:

- 9 chapters covering embeddings, similarity metrics, exhaustive search and its true cost,

dimension, graph indexes, quantisation and re-ranking, filtered search, vector databases in

practice, and a final chapter of limits.

- 48 original practice questions, tagged by certification and by difficulty, where every

option is explained — not just why the right answer is right, but why each wrong answer is

wrong, because on these exams the distractors are where the teaching is.

- A reverse map from each certification to the chapters that serve it, in reading order.

- All the code — every index, every experiment — so each table and figure can be regenerated.

Written to the published objectives of Databricks Certified Generative AI Engineer, NVIDIA

NCA-GENL, NVIDIA NCP-GENL, NVIDIA NCP Agentic AI, and AWS Certified Generative AI Developer –

Professional. Objectives were checked in August 2026; confirm the current blueprint with the

certifying body before you sit.

You need to be able to read Python, and to remember that a dot product multiplies two lists of

numbers pairwise and adds them up. That is the whole prerequisite — and nothing in this volume

assumes you have read any other book.

Every question is original, written from published exam objectives. Nothing is reproduced

from, or based on recollection of, any live examination.

This book was created through a process that combines careful human planning, content direction, and advanced AI technology, followed by thorough refinement and review to ensure a high-quality final work.