main abstraction

Giving a language model your documents to answer from. The standard way to make AI useful on your company’s knowledge.

Retrieval breaks before the model does. The failure that decides the design is narrower than it sounds: search for a name that appears twice in a corpus and embeddings can miss it inside the top eight, while keyword search puts it first. Embeddings smear a rare token toward its neighbourhood, and names are what people actually search for. That single query class is why hybrid retrieval earns its complexity. The rest is chunking that follows document structure, fusion, a reranker over the final candidates, and a groundedness test that checks every answer against the sources.

Merging two ranked lists into one using only the positions, so scores from a keyword index and a vector index never have to be made comparable.

The formula carries a constant, and almost every implementation sets it to 60. That number comes from a 2009 paper that fused search runs over thousands of documents. The constant decides how much a rank difference is worth, so over a candidate pool of a few dozen it swamps the ranks and fusion collapses into a vote: anything both retrievers return beats anything one returns, however confident either was. LangChain exposes it defaulted to 60. LlamaIndex hardcodes it. We derive it from the pool size and write the arithmetic down.

Software that runs a language model in a loop: reason about the goal, call a tool, observe the result, repeat until done. The model decides at runtime which tool to reach for.

Demos skip the two hard parts: stopping and state. A production agent carries a hard iteration cap and a written definition of done, or it loops until the invoice arrives. Tools connect through open standards like MCP: one integration serves every agent. Every step lands in a trace, so when the agent does something strange at 2 a.m., you can read what it saw and what it chose.

A scored test for a non-deterministic system: real cases with known good answers, run against every change.

Teams without one review quality from memory: the demo looked fine, someone rewrote a prompt on Thursday, nobody can say whether Friday’s answers got better or worse. The harder part is knowing when a number moved. A four-point gap on a hundred cases sits inside the noise, so we decide with a paired bootstrap on data the system was never tuned against and release when the interval excludes zero. A suite that passes everything has stopped measuring: we quote scores as the range three identical runs actually produced, and leave the known failures in it.

A check around a probabilistic system: on the way in (injected instructions, personal data) and on the way out (schema, policy, facts).

For agents, put the check on the action: inspect the tool call before it runs. Anything irreversible (send, delete, pay) passes an allowlist or waits for a person. Checks belong in code, after generation, and should report rather than rewrite, because the reader needs to know which sentence to distrust instead of a smoother paragraph. Run more than one: on the same answers, a groundedness judge caught an unsupported claim unanimously while a per-claim audit reported nothing wrong. Two checks, one answer, different verdicts.

Data moving from where it is created to where it is needed, on schedule, without a person in the middle.

A model answers from whatever the pipeline fed it that morning. Stale loads, silent failures, and duplicated rows all surface the same way: users tell you the AI is wrong. Production pipelines run idempotent, monitored, and re-runnable from any point in history, so the day the source API dies twice costs you one re-run.