The underwriting agent runs on a toy encoder, and the team is ready to replace it. Three proposals arrive in one afternoon. One engineer shares a public leaderboard and suggests the model at the top. Another suggests the largest model that fits, on the theory that more dimensions mean more meaning. A third suggests a hosted embedding API, because it removes a model from the deployment.
Each proposal answers a question nobody asked. The question the insurer needs answered is narrower: for this site's own case UW-R01, does the broker's sentence "roof replaced recently but aerial imagery shows an older roof" still bring back the roof-conflict rule R-ROOF-03? For UW-R04, do SUB-1004's nearest applicants still look like a masonry office with a 20 to 30 year roof in wind zone C? And can the chosen model's vectors legally and safely be computed from precedent text at all?
The previous page showed that a model change silently moves every vector into a new space (case UW-R06). So the choice is expensive to reverse: changing models later means re-embedding every stored row. This page turns the choice into a procedure: rule candidates out with hard constraints, then let the team's own labeled queries decide among what remains.
What this is not. This page does not teach retrieval metrics; recall@k, MRR and nDCG are computed by hand on evaluation. Graders, golden sets and release gates as a discipline belong to eval.sammuthu.com. Nothing here ranks models: no model was benchmarked for this site.
Two kinds of criteria: the ones that rule out, the ones you measure#
Recall what retrieval does on this site. An embedding column holds one vector per row; a vector query compares the query vector with the rows' vectors, ranks the rows by distance and returns the nearest k; the model reads only what retrieval returned. Retrieval is a query. The model reads only what it returns. The embedding model decides where every row lands, so it decides which rows can ever be returned.
The criteria for choosing it fall into two groups, and mixing them is the most common mistake. The first group is constraints. A model's license either permits your use or it does not. Text either may leave your network or it may not. The model either reads your language or it does not. These are yes-or-no questions, answered from documentation, and they remove candidates without any experiment.
The second group is quality: does this model put the right rows near the right queries, for your corpus? That question has no answer in any documentation, because nobody else has your corpus. It is answered by measurement on your own labeled queries. Compute and latency sit between the two: a budget is a constraint, and how much a larger model buys inside that budget is a measurement.
Before AI. Choosing a database index works the same way. Some options are ruled out by facts, such as a column type the index does not support. Among the rest, a team runs EXPLAIN ANALYZE on its own slow queries instead of trusting a vendor's benchmark on someone else's schema.
The constraints, one at a time#
License. The model card states it. As documented on 2026-11-18, all-MiniLM-L6-v2 is Apache-2.0, and bge-small-en-v1.5 is MIT, with the card saying commercial use is allowed free of charge. A model whose license does not cover your use is out, whatever it scores.
Local and private, or an API. A model can run inside your own process or server, or behind a provider's API. Running it yourself is called local embedding here: the text never leaves your machine, and you own the runtime, its version and its capacity. An API removes the runtime and sends every document and every query to the provider. For guidance passages that may be acceptable. For precedents, which carry underwriters' reasoning, or for private notes, it can be the deciding constraint. Both builds on this site embed locally.
In the insurance build. In that build, all-MiniLM-L6-v2 runs in process through ONNX Runtime, a Java library, with no embedding API call. It embeds a banded template for Corpus A, never raw numbers and never personal data.
In Mnemos. In the code read, Mnemos embeds locally with Xenova/bge-small-en-v1.5 by default; an external model, if configured, receives retrieved chunks only.
Language. The model must have been trained on the language of your queries and documents. Both cards read for this site describe English models. If brokers write in two languages, the candidate list is different from the start.
Token limit. A model reads at most so many tokens and ignores the rest: 256 word pieces by default for all-MiniLM-L6-v2, 512 tokens for bge-small-en-v1.5, 8192 tokens for OpenAI's text-embedding-3-small, as each documents. The limit must fit your chunk size, or the end of each chunk is never embedded. The chunking page sizes chunks against it.
Dimension, as a storage limit. A dimension is the vector's length. It costs memory per row and work per comparison, and a store may cap it. pgvector stores vector columns up to 16,000 dimensions but builds HNSW and IVFFlat indexes on vector only up to 2,000, and on halfvec up to 4,000, as documented on 2026-11-18. The next section does the arithmetic.
Dimension and memory, by arithmetic#
A 32-bit float takes 4 bytes. A vector of 384 float32 values therefore takes 384 × 4 = 1,536 bytes of raw numbers. That is computed, not measured. A database adds its own overhead: pgvector documents its vector type as 4 bytes per dimension plus 8, and its half-precision halfvec as 2 bytes per dimension plus 8. The script below prints the numbers; it proves only the arithmetic, not any database's real footprint, which also includes row headers, indexes and free space.
# select_by_eval.py, part 4 (the full file is listed under the decision procedure below)
for d in (384, 768):
print(f" {d} dims x 4 bytes (float32) = {d * 4:,} bytes; pgvector vector({d}) = 4 x {d} + 8 = {4 * d + 8:,};"
f" halfvec({d}) = 2 x {d} + 8 = {2 * d + 8:,}")
print(f" 1,140 rows x 1,536 bytes = {1140 * 1536:,} bytes of raw float32, before any index")
4) memory per vector, computed (not measured):
384 dims x 4 bytes (float32) = 1,536 bytes; pgvector vector(384) = 4 x 384 + 8 = 1,544; halfvec(384) = 2 x 384 + 8 = 776
768 dims x 4 bytes (float32) = 3,072 bytes; pgvector vector(768) = 4 x 768 + 8 = 3,080; halfvec(768) = 2 x 768 + 8 = 1,544
1,140 rows x 1,536 bytes = 1,751,040 bytes of raw float32, before any index
Two things follow. Doubling the dimension doubles the bytes per row and the work per distance computation, for every row, in every query of an exact search. And the insurance build's Corpus A, 1,140 seeded rows at 384 dimensions, holds about 1.75 million bytes of raw vectors: small enough that dimension is not its constraint. At 384 dimensions both real models named on this site fit every limit stated above.
Common confusion. "More dimensions means a better model." Dimension is a length. Two models with 384 dimensions can differ greatly in retrieval quality, and a longer vector can lose to a shorter one on your queries. Dimension tells you the cost per row; only measurement tells you the quality.
Quality versus compute#
A larger model usually means more parameters, more computation per text and more latency per query. The bge-small-en-v1.5 card lists about 33.4 million parameters; the all-MiniLM-L6-v2 card names its base model, a six-layer MiniLM. This site gives no latency numbers for either: timings depend on hardware, batch size and runtime, and none were measured here.
Two moments carry the compute cost, and they are not equal. Documents are embedded once, at write time, and again only when you re-embed. Queries are embedded on every request, in the path a person waits on. A model that is affordable for a nightly backfill can still be too slow for the query side. Measure both with your own hardware, batch sizes and text lengths before the quality comparison, so that the comparison only includes candidates you could run.
Public benchmarks: what MTEB measures, and what it cannot#
A public benchmark runs many models on the same public tasks and reports their scores. A widely cited one for embedding models is MTEB, the Massive Text Embedding Benchmark. As documented on 2026-11-18, MTEB is an Apache-2.0 open-source toolbox for evaluating embedding models and retrieval systems across languages and modalities, with task types including retrieval, reranking, clustering, classification, semantic textual similarity and bitext mining. It runs from Python or a command-line tool, and its papers are MTEB (2022) and MMTEB (2025). Its leaderboard page did not render its table when the source pack fetched it, so this site reports nothing from it, and it never ranks models.
A benchmark like this is useful for one thing: building a shortlist. It shows which models are designed for retrieval at all, which languages they cover, and their sizes. What it cannot tell you is how a model handles your text. The insurer's applicant profiles are banded summaries such as occupancy=office; construction=masonry; area_band=10k-25k. Its rules are named R-ROOF-03 and R-SPRK-01. Its precedents are short rationales written in underwriting language. A public retrieval task built from web questions and encyclopedia passages measures something real, and it is not this.
That is why a benchmark score is evidence about the benchmark first. The decision needs a measurement on your own corpus.
Instruction prefixes: the query side is part of the model#
Some models were trained to see a short instruction in front of queries, and sometimes another in front of documents. That instruction is called an instruction prefix. The bge-small-en-v1.5 card gives the query instruction "Represent this sentence for searching relevant passages: ", says passages never need it, and says v1.5 works without it with only a slight drop, as documented on 2026-11-18. Google's embeddings API expresses the same idea with task types, RETRIEVAL_QUERY and RETRIEVAL_DOCUMENT, covered on Google Cloud choices. all-MiniLM-L6-v2's card mentions no prefix.
The rule is strict in both directions. Use the prefix the model's documentation prescribes, on the side it prescribes, and record that choice as part of the model's identity next to every stored vector. Adding or dropping a prefix later is a pipeline change: queries move to a different place in the space while the stored documents stay where they were.
The example's toy-a@2 shows the effect. It prepends "query: " to queries and stops folding synonyms. Queried against an index built with toy-a@1, it returns a partly overlapping, reordered list, not an error. Part 2 of select_by_eval.py, listed in full in the decision procedure below, runs it for UW-R01; a successful run proves only that a changed query pipeline reorders results over an unchanged index, in this toy.
2) UW-R01 query against the toy-a@1 index:
query toy-a@1: ['GD-NOTE-01', 'GD-2025.4-R-ROOF-03', 'GD-2026.2-R-ROOF-03', 'GD-2025.4-R-ROOF-02', 'GD-2026.2-R-ROOF-02']
query toy-a@2 (prefix 'query: ', no guard): ['GD-2025.4-R-ROOF-01', 'GD-2026.2-R-ROOF-01', 'GD-2025.4-R-ROOF-02', 'GD-2026.2-R-ROOF-02', 'GD-NOTE-01']
R-ROOF-03, the rule the case is about, drops out of the top 5 entirely. This list includes superseded passages because the script filters only on trusted; the lab below shows the 13 current passages.
The lab starts on toy-a@2. Switch the query encoder, watch the two bar strips of the query vector change, compare expected and actual neighbors, and turn on the guard that compares embedding_model. Toy encoders and synthetic passages; it shows the mechanism, not the quality of any model.
The same results without JavaScript, in this example (index toy-a@1, 13 current passages, top 5; R-... means the GD-2026.2-R-... passage):
| Query | Query with toy-a@1 (correct) | Query with toy-a@2 (prefix "query: ") | Query with toy-b@1 |
|---|---|---|---|
| roof replaced recently but aerial imagery shows an older roof | GD-NOTE-01, R-ROOF-03, R-ROOF-02, R-ROOF-01, GD-NOTE-06 | R-ROOF-01, R-ROOF-02, GD-NOTE-01, R-ROOF-03, GD-NOTE-02 (same rows in part, order differs) | R-ROOF-03, GD-NOTE-07, GD-NOTE-04, R-SPRK-01, R-HUMAN-01 (overlap 1 of 5) |
| large warehouse without sprinklers | R-SPRK-01, GD-NOTE-08, GD-NOTE-04, R-ROOF-02, GD-NOTE-06 | R-SPRK-01, R-HUMAN-01, GD-NOTE-04, GD-NOTE-03, R-ROOF-03 | R-ROOF-01, R-ROOF-02, GD-NOTE-01, GD-NOTE-04, R-SPRK-01 |
| who makes the final decision on a submission | R-HUMAN-01, GD-NOTE-03, GD-NOTE-07, R-SPRK-01, R-ROOF-03 | R-SPRK-01, GD-NOTE-08, GD-NOTE-04, R-ROOF-03, R-ROOF-02 | GD-NOTE-05, R-ROOF-02, GD-NOTE-04, GD-NOTE-07, R-ROOF-01 |
With the guard on, every mismatched query is refused before searching.
Plain English. The toy encoders on this page are this site's stand-in for an embedding model: deterministic functions that map words to 16 named concepts and normalize. They are not models, and nothing they score says anything about a real model. They exist so that every result here can be reproduced without a key or a network.
Matryoshka truncation: one model, several lengths#
Some models are trained so that the first part of a vector already carries most of its meaning. You can then keep only the first m numbers, renormalize, and still search reasonably well with less memory. The idea comes from Matryoshka Representation Learning (Kusupati et al., arXiv 2022), which trains embeddings to carry coarse-to-fine information so they can be truncated; such vectors are called Matryoshka embeddings here.
As documented on 2026-11-18, OpenAI's text-embedding-3-small returns 1,536 numbers by default, offers a dimensions parameter that shortens the output, says shortened embeddings keep their concept-representing properties, says its embeddings are normalized to length 1, and advises normalizing again if you cut a vector yourself. In the code read, the Mnemos schema comment names text-embedding-3-small at 384 as an alternative to its default model; by the OpenAI documentation, 384 would be a shortened output of that model.
Truncation is safe only for a model trained and documented for it. Part 3 of the same script cuts a toy vector, which was never trained for truncation, from 16 to its first 8 numbers and renormalizes:
3) truncating a toy vector that was never trained for it, 16 -> 8 dims, renormalized:
16 dims: ['GD-NOTE-01', 'GD-2025.4-R-ROOF-03', 'GD-2026.2-R-ROOF-03', 'GD-2025.4-R-ROOF-02', 'GD-2026.2-R-ROOF-02']
8 dims: ['GD-2025.4-R-ROOF-03', 'GD-2026.2-R-ROOF-03', 'GD-NOTE-01', 'GD-2025.4-R-ROOF-02', 'GD-2026.2-R-ROOF-02']
The order changed. The toy's last eight dimensions include evidence, which the broker's sentence leans on, and truncation threw it away. A model trained for truncation spreads meaning differently, but the lesson holds: a truncated length is its own space. A 384-number truncated vector from one model and a 384-number vector from bge-small-en-v1.5 have the same dimension and different spaces, the UW-R06 situation again. Truncate every stored vector and every query to the same length, store the length in the model identity, and measure the loss on your own queries.
Domain adaptation: when your words are not the model's words#
A general model may place the insurer's vocabulary poorly: band codes, rule ids, terms such as "request info". Training it further on your own pairs of related texts is called domain adaptation, or fine-tuning. The bge-small-en-v1.5 card recommends fine-tuning on your own data with mined hard negatives (texts that look similar and are wrong) to improve retrieval, and suggests a reranker if accuracy is still low, as documented on 2026-11-18.
A fine-tuned model is a new model. Every stored vector must be recomputed with it, and its training pairs must be maintained like code. Before reaching for it, three cheaper levers often address the same complaint. Change what is embedded: the insurance build embeds a fixed banded template instead of raw numbers. Add a lexical signal for ids, the subject of hybrid search. Rerank a broad candidate set, the subject of reranking. Fine-tune when measurement shows those levers are not enough.
Diagram: Changes that look small, and each one puts the stored vectors in a different space
Read left to right. Besides a new model or a new version, an added or dropped instruction prefix, a truncated length or a fine-tune each change what the coordinates mean. All of them lead to the same operation: re-embed every stored row, measured first, and switch queries at the same moment. Rebuilding an index does not help.
- The change
- Instruction prefix: Queries move in the space while stored documents stay where they were.
- Truncated length: A shorter output of the same model is its own space, safe only if documented.
- Fine-tune: Further training on your pairs makes a new model.
- The consequence
- New space: Old vectors and new queries no longer share coordinates.
- The operation
- Re-embed, then switch: Recompute every stored vector, evaluate, and move queries at the same moment.
The diagram collects the three changes this page has met so far, a prefix, a truncated length and a fine-tune, and shows that they end in the same place as a new model. None of them can be repaired by rebuilding an index, because an index only organizes vectors and never changes what their coordinates mean. Each one is a re-embedding, and each one is evaluated before queries switch.
A decision procedure built on evaluation#
The procedure below is the standard this site recommends: decide by measurement on your own labeled queries, and treat every candidate as a full re-embedding of the corpus.
- Write down the constraints: license, data residency, language, token limit, dimension limit of your store, compute budget for documents and for queries.
- Shortlist candidates that pass all of them, using model cards and a public benchmark for orientation only.
- Label queries before you look at any results: real questions, each with the rows that should come back and a grade. This example has 14 labeled guidance queries with grades 2, 1 and 0.
- For each candidate, re-embed the corpus and the queries with that candidate, following its prefix rules.
- Run exact search, compute recall@k, MRR and nDCG overall and per slice (for example id queries, paraphrase queries, each corpus), and measure embedding latency on both sides.
- Choose, then record the full identity: model, revision, pooling, normalization, prefixes, length, metric.
Diagram: Constraints rule candidates out; your labeled queries decide among the rest
Read left to right. Documentation answers the yes-or-no constraints and a public benchmark builds a shortlist. Each surviving candidate then re-embeds the corpus and its own queries, exact search ranks them against labels written in advance, and the chosen model's full identity is recorded. Click a box for the example's numbers.
- Rule out
- Constraints: Yes-or-no facts from documentation remove candidates before any test.
- Shortlist: Public benchmarks show which models target retrieval, their sizes and languages.
- Measure
- Labeled queries: Real questions with graded relevant rows, written before any result is seen.
- Re-embed per candidate: Each candidate embeds the corpus and its own queries, with its own prefix rules.
- Exact search, metrics: Exact search keeps index effects out; metrics are read per slice, next to latency.
- Decide
- Record the identity: Model, revision, pooling, normalization, prefixes, length and metric are stored with every vector.
The diagram's important arrow is the one into step 4: each candidate gets its own space, so a candidate is never compared by querying an index built with another one. Exact search in step 5 matters too: an approximate index would mix index recall into a model comparison, which belongs on ANN.
The script below runs steps 4 and 5 for two candidates, toy-a@1 and toy-a@2, on the example's 14 labeled guidance queries. It is meant to show the shape of the procedure: each candidate re-embeds the corpus and its own queries, then one metric function scores both on the same labels. A successful run proves the procedure is reproducible; it proves nothing about real models, and with 14 synthetic queries it is an observation, not a significance test.
# select_by_eval.py, run from a scratch copy of examples/rag-uw (toy encoders, synthetic labels)
import data
from encoders import TOY_A1, TOY_A2
from metrics import evaluate
from search import VectorTable, exact_topk
from vecmath import normalize
rows = [r for r in data.guidance_passages() if r["trusted"]]
qrels = {q["qid"]: q["rel"] for q in data.GUIDANCE_QRELS}
print("1) each candidate re-embeds the corpus and its queries (14 labeled queries, k = 5):")
for enc in (TOY_A1, TOY_A2):
table = VectorTable.build("guidance", rows, "passage_id", "text", enc)
rk = {q["qid"]: [h["id"] for h in exact_topk(table, enc.encode_query(q["query"]), 50).hits]
for q in data.GUIDANCE_QRELS}
m = evaluate(rk, qrels, 5)
print(f" {enc.name}: " + " ".join(f"{k}={v:.3f}" for k, v in m.items()))
q = data.GUIDANCE_QRELS[0]["query"]
old = VectorTable.build("guidance", rows, "passage_id", "text", TOY_A1)
print("2) UW-R01 query against the toy-a@1 index:")
print(" query toy-a@1:", [h["id"] for h in exact_topk(old, TOY_A1.encode_query(q), 5).hits])
print(" query toy-a@2 (prefix 'query: ', no guard):", [h["id"] for h in exact_topk(old, TOY_A2.encode_query(q), 5).hits])
print("3) truncating a toy vector that was never trained for it, 16 -> 8 dims, renormalized:")
cut = VectorTable("guidance-8", rows, "passage_id", "text", "toy-a@1",
{rid: normalize(v[:8]) for rid, v in old.vectors.items()})
print(" 16 dims:", [h["id"] for h in exact_topk(old, TOY_A1.encode_query(q), 5).hits])
print(" 8 dims:", [h["id"] for h in exact_topk(cut, normalize(TOY_A1.encode_query(q)[:8]), 5).hits])
print("4) memory per vector, computed (not measured):")
for d in (384, 768):
print(f" {d} dims x 4 bytes (float32) = {d * 4:,} bytes; pgvector vector({d}) = 4 x {d} + 8 = {4 * d + 8:,};"
f" halfvec({d}) = 2 x {d} + 8 = {2 * d + 8:,}")
print(f" 1,140 rows x 1,536 bytes = {1140 * 1536:,} bytes of raw float32, before any index")
1) each candidate re-embeds the corpus and its queries (14 labeled queries, k = 5):
toy-a@1: recall@5=0.774 precision@5=0.357 hit_rate@5=0.857 mrr=0.798 ndcg@5=0.691
toy-a@2: recall@5=0.637 precision@5=0.300 hit_rate@5=0.857 mrr=0.697 ndcg@5=0.553
...
The rest of the output is shown in the sections above. In this example, toy-a@1 scores higher on every metric but hit rate, where they tie. The reason is visible in the code: toy-a@2 drops synonym folding, so "aged roofing" no longer lands on old and roof. Notice what kind of evidence this is. It is a comparison on 14 synthetic queries, and it says which toy suits these labels. With real candidates, the same table, sliced by query type and read next to latency, is what a decision rests on.
Production pitfall. A team that switches models by changing a configuration value has changed the query side only. Every stored vector is still from the old model, and every query is now UW-R06. A model switch is a migration: a new column, a backfill, an evaluation, then a cutover of reads, as the operations page plans.
In a coding agent. A team choosing an embedding model for repository search faces the same split. Constraints come first: can source code leave the network for an API, and does the model's token limit fit a function or a file chunk? Then quality, measured on the team's own questions, such as "where do we retry provider calls", labeled with the files that answer them. A public code benchmark can shortlist; it cannot know this repository's naming.
A checklist for Monday#
| Question | Why it matters |
|---|---|
| Are license, residency, language and token limit written down before any test? | They rule candidates out without measurement |
| Is the compute budget split into document side and query side? | Queries are embedded on every request; documents once |
| Are labeled queries written before results are seen? | Labels written after results confirm whatever ranked first |
| Does each candidate re-embed the corpus and its own queries? | Cross-model queries measure UW-R06, not quality |
| Is the comparison run with exact search and sliced by query type? | Index recall and averages hide model differences |
| Does the stored identity include prefixes and any truncated length? | Each is part of the space |
| Is a model change planned as a migration, not a config change? | Old vectors stay in the old space |
An API model has a lifecycle you do not controlPinning, retirement and the forced re-embedding
A hosted embedding model removes a runtime from your deployment and adds a dependency on the provider's lifecycle. The vectors in your table were produced by a specific model at a specific time. If the provider retires that model, every query from then on must use a different one, and the stored vectors must be recomputed before the queries switch, or the system is in the UW-R06 state. The decision to re-embed is then made by the calendar, not by your evaluation.
Three practices reduce the risk. Pin the exact model name the provider exposes, never an alias that may move. Store that name per row, so a partial backfill is visible. Keep the original text of every embedded row, or the template that produced it, because re-embedding needs the input, not the old vector.
A local model has the opposite profile. You control its version indefinitely, and you carry the runtime: packaging, memory, CPU or GPU capacity, and security patches for the runtime library. The insurance build's choice, an ONNX model run in process from Java, puts that responsibility inside the service that already owns the data.
Building labeled queries that can tell models apartSlices, hard cases and label leakage
A labeled query set is only as useful as its hardest queries. If every query is an easy paraphrase, every candidate scores well and the comparison says nothing. Include the situations this site's cases describe: a paraphrase with no shared words (UW-R01), an exact id (UW-R02), a question whose answer differs by policy version (UW-R03), and a profile query whose neighbors must match on bands (UW-R04). Tag each query with its slice, and read results per slice: a model that wins on paraphrases and loses on ids may still be the right choice if hybrid search handles ids.
Write labels before seeing any candidate's results. This example's precedent labels come from row metadata by a rule written before any ranking was seen, and the guidance labels are graded 2, 1 and 0. Labels written while looking at one model's output tend to reward that model.
Keep the set small enough to review by hand and large enough that one query does not decide the outcome. With a few dozen queries, treat a difference of one or two queries as an observation and look at which queries moved, not only at the average. The evaluation page computes each metric by hand.
Three ways to make vectors smaller, and what each changesA smaller model, a truncated length, or lower precision
Memory and work per row grow with dimension, so teams look for smaller vectors. There are three distinct levers, and they change different things.
A smaller model with a shorter output is a different model: new space, full re-embedding, and its quality must be measured like any candidate. A truncated Matryoshka length keeps the model and shortens its output; it is still a new space for the stored vectors, the model's documentation must support it, and the loss must be measured. Lower precision keeps the model and the length and stores each number in fewer bits: pgvector's halfvec uses 2 bytes per dimension plus 8, and its README shows an expression index that casts to halfvec for smaller indexes, as documented on 2026-11-18. Precision changes the stored numbers slightly, not the space, so it is closer to an index decision than to a model decision, and it is measured as index recall against exact search.
Only the first two need a new labeled-query comparison. The third needs the index-recall measurement described on ANN.
In one breath#
Choose an embedding model in two passes. First, constraints answered from documentation rule candidates out: license, whether text may leave your network, language, token limit, dimension limits and a compute budget for both the document side and the query side. Then quality is measured, never assumed: each surviving candidate re-embeds the corpus and its own labeled queries, exact search ranks them, and recall, MRR and nDCG per slice decide. A public benchmark such as MTEB builds the shortlist; instruction prefixes, Matryoshka truncation and fine-tuning are all part of a model's identity, and each one means re-embedding.
The agent now has a chosen model and a recorded identity for it, 384 dimensions in both builds this site describes. What it does not yet have is a place for the vectors: in the same row as the source data, in a table beside it, in a virtual table, or in a separate engine, each with its own answer to what happens when a row is updated or deleted. The next page, storage, lays out those layouts and the row id that joins every match back to its source.