Plain-Language Reference

Glossary

Every bit of jargon in the course, explained like a colleague would over coffee — no assumed background. When a term trips you up, it's here.

A C E F G H I L M P R S T V

Agent: An LLM that can take actions by calling tools in a loop, deciding its own next step each time — rather than just replying once. Think "assistant that can actually do things," not just talk. e.g. an agent that checks the weather, then books a venue based on it.

API (Application Programming Interface): A way for your code to talk to a service over the internet. The Anthropic API is how your Python scripts send prompts to Claude and get answers back.

API key: A secret password (starts with sk-ant-) that identifies your account and bills you. Kept in .env, never in code.

Adaptive thinking: A setting where the model decides on its own how much internal reasoning to do before answering. You turn it on with thinking:{type:"adaptive"} and don't have to tune a number.

Chunk / chunking: Splitting a document into bite-sized pieces (a few paragraphs each) so retrieval can find and return just the relevant part instead of a whole file. Good chunking is the #1 quality lever in RAG.

Context window: The maximum amount of text (in tokens) a model can consider at once — prompt + answer combined. Exceed it and you must trim or summarize.

Cosine similarity: A math measure of how "close in meaning" two embeddings are, from -1 to 1. Higher = more similar. It's how retrieval ranks chunks against your question.

Compaction: Automatically summarizing older parts of a long conversation so it keeps fitting in the context window. Used in long-running agents.

Embedding: A list of numbers (a vector) that represents the meaning of a piece of text. Similar meanings produce nearby vectors. It's what makes "find related content" possible. "reset password" and "recover my login" land close together even with no shared words.

Effort: A dial (low/medium/high/max) for how hard the model works. Higher = smarter but slower and pricier. Match it to task difficulty.

Eval (evaluation): A repeatable test that scores your system's output quality on a set of examples — the "unit test" of LLM apps. Lets you prove a change helped instead of guessing.

Environment variable: A setting stored outside your code that programs can read (like ANTHROPIC_API_KEY). Keeps secrets out of source files.

Few-shot: Giving the model a handful of example input→output pairs in the prompt so it copies the pattern. "Show, don't tell."

Fine-tuning: Further-training a model on your own data to change its behavior/style. Different from RAG (which supplies facts at query time). You rarely need it to start.

Groundedness: Whether every claim in an answer is actually supported by the retrieved context. High groundedness = not making things up. A key RAG quality metric.

Guardrails: Safety checks you run before the prompt (input) and after the answer (output) — e.g. redacting personal data, blocking unsafe content, verifying the answer is grounded.

Golden set: Your curated list of test questions with known-good answers, used by evals. You grow it from every real mistake the system makes.

Hallucination: When a model states something false with confidence. In RAG, it's usually not the model's fault — the right information was never retrieved and given to it.

Hybrid search: Combining vector search (meaning) with keyword search (exact words like error codes or names) so you catch both. Beats either one alone.

Human-in-the-loop: Requiring a person to approve before the system does something risky or irreversible (send email, delete data, issue a refund).

Inference: The act of running the model to get an output. "An inference call" = one request to the model.

Injection (prompt injection): An attack where malicious text hidden in a document or tool result tries to hijack your model ("ignore previous instructions and…"). Treat all external content as untrusted.

LLM (Large Language Model): The AI that predicts and generates text (Claude, GPT, etc.). The engine everything in this course is built around.

LLM-as-judge: Using a strong model to grade another model's output against a rubric — a scalable way to measure quality when there's no single right answer.

max_tokens: The hard limit on how long the answer can be. Too low = the response gets cut off mid-sentence.

Memory (agent): Keeping information across turns or sessions. Within a chat, "memory" is just resending the history; across sessions, it's writing facts to a file/database.

Model tier: The capability/price class of a model — e.g. Opus (most capable), Sonnet (balanced), Haiku (fast & cheap). Pick per task.

Prompt: The text instructions you send the model. In production it's a versioned artifact you test — not a throwaway string.

Prompt caching: Reusing a large, unchanging part of your prompt so you don't pay full price to re-process it every call. Can cut cost ~90% on the cached part.

Pydantic: A Python library for defining data shapes as classes. We use it to force the model's JSON output into a validated structure.

RAG (Retrieval-Augmented Generation): Fetch relevant snippets of your data, put them in the prompt, and have the model answer from them. How you make an LLM know about your documents.

Recall@k: A retrieval metric: out of your test questions, how often the answer-bearing chunk appears in the top k results. Measures whether retrieval is working.

Re-ranking: Taking a wide set of retrieved candidates and reordering them so the truly-best few rise to the top before generation. Big quality win.

RRF (Reciprocal Rank Fusion): A simple formula for merging two ranked lists (e.g. vector + keyword results) into one combined ranking.

Refusal: When the model declines a request for safety reasons. Shows up as stop_reason: "refusal" — handle it, don't assume there's text to read.

Stateless: The API keeps no memory between calls. Each request must include the full conversation. All "memory" you build is you resending context.

stop_reason: Why the model stopped generating: end_turn, max_tokens, tool_use, refusal, pause_turn. Always check it before using the output.

Streaming: Receiving the answer token-by-token as it's generated (like watching it type) instead of waiting for the whole thing. Better UX; avoids timeouts on long outputs.

Structured output: Making the model return data in a guaranteed shape (usually JSON matching a schema) so your code can use it safely without parsing free text.

System prompt: The instructions that set the model's role and rules, kept separate from the conversation. "You are a support triager who…"

Semantic cache: Caching whole answers keyed by the meaning of the question, so near-duplicate questions skip the model call entirely.

Token: The chunk of text a model processes — roughly ¾ of a word. You're billed per token, input and output separately.

Tool / tool use: A function you describe to the model (name + inputs). When the model wants it, it returns a tool_use request; your code runs the function and returns the result.

Temperature: An older dial for randomness/creativity in output. Newer models steer this through prompting and effort instead; you'll rarely set it directly here.

Vector: A list of numbers. An embedding is a vector representing meaning. Retrieval works by comparing vectors.

Vector database / store: A system that stores embeddings and quickly finds the nearest ones to a query. In the course you build a tiny one yourself, then learn what production ones (pgvector, Pinecone, etc.) add.

Virtual environment (venv): An isolated Python setup for one project so its packages don't clash with the rest of your system. You activate it with source .venv/bin/activate.

Missing a term?If you hit jargon that isn't here, jot it down — it's a great candidate to add as you learn. The best glossary is one you extend yourself.

Educational content, provided as-is and without warranty. Code samples are examples — review, test, and adapt them before using in production. See the Terms of Use & Disclaimer. Use at your own risk.