Reference // 526 terms

Glossary

Every term used in the lessons, in plain English. Each one links to the lesson that explains it best.

A

A/B test: Randomly splitting real users between two versions and comparing a metric to see which performs better.; Lesson 73: Regression evals in CI and A/B testing prompts
A2A (Agent2Agent) protocol: An open protocol for independent agents to discover each other, send tasks and return results without exposing their internals.; Lesson 62: The A2A protocol
A2A task: The unit of work in A2A, with states such as submitted, working, input required and completed, producing artifacts.; Lesson 62: The A2A protocol
Access token: A short-lived credential sent with each request (usually as a Bearer token) that proves the caller is authenticated and what they may access.; Lesson 130: Authentication with JWT and OAuth 2.0
Accuracy: The share of predictions that are correct. Misleading when one class is rare; use precision and recall then.; Lesson 8: Classic machine learning in one lesson
ACID: The guarantees of database transactions, which are Atomicity, Consistency, Isolation and Durability.; Lesson 132: SQL vs NoSQL, indexing and transactions
ACL (access control list): A list attached to a resource saying which users or groups may access it. In RAG, each chunk carries its document's ACL so retrieval can filter by it.; Lesson 100: Access control in RAG
Activation function: A simple non-linear function (ReLU, sigmoid, GELU) applied to a neuron's output. Without it, stacked layers could only model straight lines.; Lesson 3: Neural networks, starting from one neuron
Active parameters: The parameters actually used to process each token in a mixture-of-experts model, as opposed to the total stored.; Lesson 16: Mixture of experts
Adapter: The small set of trained weights produced by LoRA, loaded on top of a base model to change its behaviour.; Lesson 28: Fine-tuning with LoRA and QLoRA
Agent: A system where a model decides, in a loop, which tools to call and what to do next until a task is done.; Lesson 49: The agent loop and the ReAct pattern
Agent Card: A JSON document an A2A agent publishes at /.well-known/agent-card.json describing its skills, endpoint, capabilities and authentication.; Lesson 62: The A2A protocol
Agent evals: Tests that measure whether an agent completes realistic tasks correctly, safely and within budget, judged on final results and on the steps it took.; Lesson 72: Agent evals: tool calls and trajectories
Agent framework: A library that provides the agent loop and common pieces (tools, memory, handoffs, tracing) so you don't write them yourself.; Lesson 58: The OpenAI Agents SDK and other frameworks
Agent harness: Everything around the model in an agent, such as instruction files, tools, context management, permissions, hooks, verification and memory.; Lesson 55: Harness engineering: everything around the model
Agent loop: The cycle at the heart of every agent. The model picks an action, the action runs, the result is added to the context, repeat until a stop condition.; Lesson 49: The agent loop and the ReAct pattern
Agent skill: A folder with a SKILL.md file (name, description, instructions) plus optional scripts and references that an agent loads only when a task needs it.; Lesson 54: Agent skills
Agentic engineering: Using AI agents for production software with engineering discipline, including clear specs, tests, constraints, sandboxes and human review.; Lesson 63: Coding agents and computer-use agents
Agentic RAG: RAG where the model uses retrieval as a tool in a loop, deciding what and how often to search before answering.; Lesson 43: Agentic RAG
AI engineer: An engineer who builds products on top of existing AI models, handling prompting, retrieval, tools, evaluation, cost, security and deployment.; Lesson 11: Where models come from, and what an AI engineer does
Alert: An automatic notification when a monitored condition needs attention, either paging someone urgently or creating a ticket.; Lesson 123: Alerts and dashboards
Amazon S3: Amazon's object storage service; many other stores offer an S3-compatible API.; Lesson 137: File uploads to S3
Annotation guidelines: Written definitions and examples that tell labelers how to judge each case consistently.; Lesson 70: Human labeling and user feedback loops
Answer relevance: Whether an answer actually addresses the question asked, every part of it, without drifting or padding.; Lesson 71: RAG evals: faithfulness, relevance and context precision
API: Application programming interface. A defined way for one program to ask another for something, usually by sending an HTTP request and getting a response.; Lesson 10: Calling an LLM API for the first time
API key: A secret string that identifies you (and who pays) when calling an API. Treat it like a password.; Lesson 10: Calling an LLM API for the first time
Append-only: Storage where new records can be added but existing ones can't be changed or deleted, which keeps audit trails trustworthy.; Lesson 103: Audit logging
Approval flow: The process and UI by which a person reviews a proposed agent action and approves, edits or rejects it.; Lesson 59: Human in the loop
Approval gate: A point where an agent pauses and waits for a person to approve or reject a proposed action before it runs.; Lesson 98: Authorization and human approval for agents
Approximate nearest neighbour (ANN): Search methods that find almost-the-nearest vectors very fast by skipping most comparisons, trading a little recall for speed.; Lesson 36: Vector databases, HNSW and pgvector
Artifact (build): The packaged output of a build, such as a container image, that is tested once and then deployed unchanged to each environment.; Lesson 111: CI/CD pipelines
Artificial intelligence (AI): The broad goal of making computers do tasks that seem to need intelligence, such as understanding language or recognising images. Includes both hand-written rules and learned models.; Lesson 1: What AI, ML, deep learning and generative AI are
Async (asynchronous code): Code that can pause while waiting for slow operations like network calls, letting the program work on other tasks meanwhile. In Python it uses async def and await.; Lesson 128: Async and await
Async job: Work that the API accepts, returns a job ID for, and finishes later in the background; the client polls or gets notified when it's done.; Lesson 85: Batch inference and async job pipelines
At-least-once delivery: A queue guarantee that every message is delivered, but possibly more than once, so handlers must be idempotent.; Lesson 134: Message queues and background jobs
Attack success rate: The share of red-team attacks in a category that achieved their goal, such as leaking a secret. Lower is better; tracked over time.; Lesson 104: Red teaming
Attention head: One independent attention computation. Models run many heads in parallel so each can learn a different kind of relationship.; Lesson 14: Self-attention
Audit log: A complete, tamper-resistant record of security-relevant actions (who did what, on whose behalf, when and with what result), kept for investigations and compliance.; Lesson 103: Audit logging
Authentication: Proving who a user or service is, for example by verifying a password, a token or a signed key.; Lesson 130: Authentication with JWT and OAuth 2.0
Authorization: Deciding whether an authenticated user (or an agent acting for them) is allowed to perform a specific action on a specific resource.; Lesson 98: Authorization and human approval for agents
Autoscaling: Automatically adding or removing copies of a service (or machines) as demand changes, within minimum and maximum limits.; Lesson 119: Autoscaling and load balancing
Axial coding: In error analysis, grouping the individual failure notes into a small number of categories.; Lesson 67: Error analysis

B

Backdoor (model): Hidden behaviour planted in a model through poisoned training data, triggered by a specific input while the model acts normally otherwise.; Lesson 101: Data poisoning and model supply chain
Background job: Work that runs outside the web request, in a worker process, so the API can respond quickly.; Lesson 134: Message queues and background jobs
Backpropagation: The algorithm that efficiently computes the gradient for every weight in a multi-layer network, working backwards from the output.; Lesson 4: Weights, loss and gradient descent
Base model: A model after pretraining only. It continues text rather than following instructions.; Lesson 19: Pretraining and post-training (SFT, RLHF, DPO)
Base64: A way to write binary data (like an image) as plain text characters so it can travel inside JSON. About a third larger than the original.; Lesson 27: Multimodal inputs
Batch API: A way to submit many requests at once for processing within hours, at a large discount (often about 50%).; Lesson 85: Batch inference and async job pipelines
Batch inference: Running a large set of model requests offline, together, for maximum throughput and lower cost, when nobody is waiting for the results right away.; Lesson 85: Batch inference and async job pipelines
Batching: Processing several requests together in one pass through the model, so the weights are read once for many users. It's the main way to raise GPU throughput.; Lesson 80: Serving models with vLLM
Beam search: A decoding method that keeps the few best partial sequences at each step and returns the best complete one.; Lesson 17: Logits, decoding, temperature and top-p
Benchmark: A fixed set of test tasks with a scoring method, used to compare models on a skill.; Lesson 31: Benchmarks and model leaderboards
Bi-encoder: A model that embeds queries and documents separately into vectors, so documents can be indexed ahead of time. Fast, less precise.; Lesson 38: Reranking
Bias (in a neuron): A learned number added to a neuron's weighted sum, shifting how easily it activates. Not the same as unfair bias in data.; Lesson 3: Neural networks, starting from one neuron
Blue-green deployment: Running two identical environments and switching all traffic from the old one to the new one, so switching back is instant.; Lesson 120: Canary, blue-green and feature flags
BM25: The classic keyword-ranking formula. Scores documents by the query words they contain, favouring rare words, with saturation and length normalisation.; Lesson 37: BM25 keyword search and hybrid search
Branch: A separate line of work in Git, so you can make changes without affecting the main code until they are reviewed and merged.; Lesson 107: Git and GitHub for deployment
Browser agent: An agent that operates a web browser, often using the page structure as well as screenshots.; Lesson 63: Coding agents and computer-use agents
Burn rate: How fast the error budget is being used compared with the planned pace; 1x is exactly on budget, 10x would use a month's budget in three days.; Lesson 123: Alerts and dashboards
Byte-pair encoding (BPE): A way to build a tokenizer vocabulary by starting from single bytes or characters and repeatedly merging the most frequent adjacent pairs.; Lesson 12: Tokenization

C

Cache: A fast store of results that were expensive to compute or fetch, reused for repeated requests until they expire.; Lesson 133: Caching with Redis
Cache hit: A request that finds what it needs already stored in a cache, so the expensive work is skipped.; Lesson 25: Prompt caching and token pricing
Cache invalidation: Removing or bypassing cached entries when the underlying data changes, so users don't get stale results.; Lesson 133: Caching with Redis
Cache-aside: The common caching pattern where the app checks the cache first, and on a miss computes the result, stores it with a TTL and returns it.; Lesson 133: Caching with Redis
Canary release: Sending a small share of users to a new version first and comparing its metrics with the stable version before rolling out to everyone.; Lesson 120: Canary, blue-green and feature flags
Canary token: A unique random string planted in hidden content (like a system prompt); if it ever shows up in an output or request, you know that content leaked.; Lesson 96: PII redaction and data leakage
Causal mask: A rule in attention that lets each token look only at itself and earlier tokens, matching left-to-right generation.; Lesson 14: Self-attention
Chain of thought: Having a model write out intermediate reasoning steps before its final answer, which helps on multi-step problems.; Lesson 21: Few-shot prompting and chain of thought
Checkpoint: A saved snapshot of an agent's state after a step, so it can pause, resume, recover from crashes or be inspected.; Lesson 57: LangGraph, state and checkpoints
Chunk: A small piece of a document (often a few hundred tokens) that is embedded, stored and retrieved as one unit.; Lesson 35: Chunking strategies
Chunk overlap: Repeating a little text from the end of one chunk at the start of the next, so ideas near a boundary aren't lost.; Lesson 35: Chunking strategies
CI/CD: Continuous integration and continuous delivery. Automatically building, testing and deploying every change through a pipeline.; Lesson 111: CI/CD pipelines
Circuit breaker: A pattern that stops calling a failing service for a while after repeated errors, sending traffic to a fallback instead, then tests it again later.; Lesson 82: Model routing, fallbacks and LLM gateways
Citation: A reference in an answer that points to the exact source passage supporting a claim.; Lesson 41: Citations
Classification: A machine learning task that predicts a category from a fixed set, such as spam or not spam.; Lesson 8: Classic machine learning in one lesson
Classifier: A model that sorts inputs into categories, such as spam or not spam, or benign, injection or jailbreak. Small classifiers are fast and cheap enough to run on every request.; Lesson 8: Classic machine learning in one lesson
Closed model: A model you can only use through its maker's API; the weights are not released.; Lesson 30: Open vs closed models, small vs large
Clustering: Grouping similar examples together without any labels, for example finding customer segments.; Lesson 8: Classic machine learning in one lesson
Code autocomplete: Inline suggestions that complete code as a developer types, served by a small fast model within a few hundred milliseconds.; Lesson 92: Case study: an AI coding assistant
Code context: The parts of a codebase given to a coding model, such as the code around the cursor, open files, related symbols, search results and project rules.; Lesson 92: Case study: an AI coding assistant
Coding agent: An agent that reads, edits and runs code in a repository using file, search and shell tools, verifying its work with tests.; Lesson 63: Coding agents and computer-use agents
Cohen's kappa: A measure of agreement between two raters that corrects for agreement expected by chance; 1 is perfect.; Lesson 69: LLM as a judge, pairwise comparison and rubrics
Cold start: The extra delay when a platform must start a fresh instance (and load code or models) before it can handle a request.; Lesson 115: Serverless functions and the easy hosting route
Commit: A saved snapshot of changes in Git, with a message and a unique ID (SHA).; Lesson 107: Git and GitHub for deployment
Community summary: In GraphRAG, an LLM-written summary of a cluster of closely connected entities, used for big-picture questions.; Lesson 42: GraphRAG
Computer-use agent: An agent that operates a computer's graphical interface by looking at screenshots and choosing clicks, typing and scrolling.; Lesson 63: Coding agents and computer-use agents
Concurrency: Making progress on several tasks in overlapping time periods, such as many LLM calls waiting on the network at once.; Lesson 128: Async and await
Conditional edge: A connection in a graph that chooses the next step based on the current state, creating branches and loops.; Lesson 57: LangGraph, state and checkpoints
Confidence interval: A range that likely contains the true value of a measured score. Small test sets give wide intervals, so small gaps may be noise.; Lesson 31: Benchmarks and model leaderboards
Confusion matrix: A table counting true positives, false positives, false negatives and true negatives for a classifier.; Lesson 68: Precision, recall and F1
Constrained decoding: Restricting which tokens a model may generate at each step so the output always fits a grammar or schema.; Lesson 23: Structured outputs
Container: A lightweight, isolated package of an app and everything it needs to run, sharing the host's kernel. Docker is the most common tool. Also used as a sandbox.; Lesson 109: Docker
Container image: A read-only package of an app plus its runtime, libraries and files, built from a Dockerfile and run as containers.; Lesson 109: Docker
Container registry: A server that stores and serves container images by name and tag, such as GitHub Container Registry, Docker Hub or a cloud registry.; Lesson 109: Docker
Content hash: A short fingerprint computed from a document's content. If it changes, the document changed and needs re-indexing.; Lesson 34: Document parsing and ingestion pipelines
Content moderation: Checking text or images for harmful content (harassment, hate, self-harm, violence and so on), usually with a classifier that scores each category against thresholds you choose.; Lesson 95: Input guardrails, output validation and moderation
Content-Type: The header that says what kind of data a body contains, such as application/json, application/pdf or text/event-stream.; Lesson 137: File uploads to S3
Context compaction: Replacing a long conversation history with a faithful summary plus recent turns, so a long-running agent stays within its context window.; Lesson 52: Context engineering and compaction
Context engineering: Deciding exactly what goes into the model's context at each step (instructions, tools, knowledge, memory, history, results) within a budget.; Lesson 52: Context engineering and compaction
Context precision: How much of the retrieved context is relevant, and whether the relevant chunks are ranked near the top.; Lesson 71: RAG evals: faithfulness, relevance and context precision
Context recall: Whether the retrieved context contains everything needed to answer the question.; Lesson 71: RAG evals: faithfulness, relevance and context precision
Context window: The maximum number of tokens a model can consider in one request, counting both the input and the generated output.; Lesson 18: Context windows and the KV cache
Contextual retrieval: Adding an LLM-written sentence of context to each chunk (which document, entity, period) before embedding and keyword indexing.; Lesson 40: Contextual retrieval
Continuous batching: A batching method where new requests join the running batch as soon as others finish, step by step, instead of waiting for the whole batch to end. Keeps GPUs busy with mixed-length replies.; Lesson 80: Serving models with vLLM
Continuous delivery (CD): Keeping every change that passes the pipeline ready to release. Continuous deployment goes further and releases it automatically.; Lesson 111: CI/CD pipelines
Continuous integration (CI): Automatically testing and checking every change when it is pushed or proposed, so problems are found within minutes.; Lesson 111: CI/CD pipelines
Coroutine: A function defined with async def; calling it creates an object that runs when awaited and can pause at each await.; Lesson 128: Async and await
CORS (cross-origin resource sharing): The browser mechanism that lets a page from one origin read responses from another origin only if that server allows it with special headers.; Lesson 131: CORS
Cosine similarity: A score from -1 to 1 for how closely two vectors point in the same direction, ignoring their length. The standard way to compare embeddings.; Lesson 33: Embeddings and cosine similarity
Cost per request: The total cost of one user request, adding up every model call, tool and service it triggered.; Lesson 76: P95 latency and cost per request
Cross-encoder: A model that reads a query and a document together and outputs a relevance score. Precise but too slow to run on a whole corpus.; Lesson 38: Reranking
CRUD: Create, Read, Update and Delete, the four basic operations on stored data, usually mapped to POST, GET, PUT or PATCH, and DELETE.; Lesson 126: REST APIs with FastAPI
Cursor pagination: Paging by continuing after the last item seen, using a cursor the server returns. Fast at any depth and stable while data changes.; Lesson 138: Pagination

D

Dashboard: A page of charts showing a system's key metrics, such as traffic, errors, latency, cost and quality, at a glance.; Lesson 123: Alerts and dashboards
Data contamination: When test questions appeared in a model's training data, making its benchmark score look better than its real ability.; Lesson 31: Benchmarks and model leaderboards
Data leakage: Private or confidential information escaping to people or systems that shouldn't have it, through answers, logs, caches, prompts or training data.; Lesson 96: PII redaction and data leakage
Data leakage (ML): When information from the test set, or from the future, sneaks into training and makes scores look better than they really are.; Lesson 5: Overfitting and train, validation and test splits
Data poisoning: Planting manipulated examples in data a model learns from or retrieves (training, fine-tuning, feedback, RAG, memory) to change how it behaves.; Lesson 101: Data poisoning and model supply chain
Database index: An extra sorted structure on one or more columns that lets the database find matching rows without scanning the whole table.; Lesson 132: SQL vs NoSQL, indexing and transactions
DataFrame: A pandas table with rows and named columns, like a spreadsheet controlled by code.; Lesson 9: Python for AI engineers
Dead-letter queue (DLQ): A separate queue for jobs that keep failing after their retries, so they can be inspected instead of blocking others or retrying forever.; Lesson 134: Message queues and background jobs
Decision tree: A model that learns a flowchart of yes/no questions about the features, ending in a prediction. Easy to explain; ensembles of trees are strong on tables.; Lesson 8: Classic machine learning in one lesson
Decode phase: The phase of generation where tokens are produced one at a time, each reusing the KV cache. Limited by memory bandwidth.; Lesson 18: Context windows and the KV cache
Decoder-only model: A transformer that uses causal attention and generates text left to right. GPT, Claude, Gemini and Llama are decoder-only.; Lesson 15: The transformer architecture
Deep learning: Machine learning with neural networks that have many layers. Works especially well on messy data like images, sound and text.; Lesson 1: What AI, ML, deep learning and generative AI are
Defence in depth: Using several independent layers of protection so that if one check fails, another can still stop the problem.; Lesson 88: Where guardrails sit in the architecture
Delimiter: Markers such as XML tags or triple quotes that clearly separate pasted data from instructions in a prompt.; Lesson 20: Prompt engineering basics and system prompts
Denial of wallet: An attack or accident that makes a system spend large amounts of money (for example on model calls) instead of making it unavailable.; Lesson 105: Denial of wallet and cost abuse
Dependency injection: Passing a component's dependencies (database, LLM client) in from outside instead of creating them inside, so they can be swapped, for example for fakes in tests.; Lesson 140: Testing APIs with pytest
Deployment: Putting a specific version of your app onto servers with the right configuration, sending traffic to it once healthy, and watching it.; Lesson 108: What deploying means, and environment configs
Deployment (Kubernetes): A Kubernetes object that keeps a set number of identical pods running from a template and handles rolling updates and rollbacks.; Lesson 118: Kubernetes basics
Dimension: The number of values in a vector. An embedding with dimension 1,536 is a list of 1,536 numbers.; Lesson 6: Vectors and matrices, just enough for AI
Distillation: Training a small student model to imitate a large teacher model's outputs, keeping much of its quality at lower cost.; Lesson 29: Quantization and distillation
Docker: A tool that packages an app with everything it needs into an image and runs it as a container, the same way on any machine.; Lesson 109: Docker
Docker Compose: A tool that starts several containers together from one compose.yaml file, with their ports, settings, volumes, health checks and network.; Lesson 110: Docker Compose
Dockerfile: A text file of instructions (FROM, COPY, RUN, CMD...) that Docker follows to build an image. Each instruction makes a cached layer.; Lesson 109: Docker
Document parsing: Turning PDFs, web pages, scans and office files into clean, structured text (headings, tables, page numbers) ready for chunking.; Lesson 34: Document parsing and ingestion pipelines
Dot product: Multiply two vectors position by position and add up the results. Large when the vectors point in similar directions.; Lesson 6: Vectors and matrices, just enough for AI
DPO: Direct preference optimisation. Trains a model directly on pairs of preferred and rejected answers, without a separate reward model or RL loop.; Lesson 19: Pretraining and post-training (SFT, RLHF, DPO)
Draft model: The small, fast model (or other guesser) that proposes tokens in speculative decoding for the large model to verify.; Lesson 81: Speculative decoding and prefix caching
Drift: When real infrastructure no longer matches its code, usually because someone changed it by hand.; Lesson 114: Infrastructure as code

E

Effort (reasoning effort): A request setting that controls how much a model thinks before answering, trading cost and latency for depth.; Lesson 22: Reasoning models
Embedding: A vector of numbers that represents the meaning of a piece of text (or an image), so that similar meanings get similar vectors.; Lesson 33: Embeddings and cosine similarity
Embedding model: A model that turns a text (or image) into a fixed-length vector so that similar meanings get similar vectors.; Lesson 33: Embeddings and cosine similarity
Embedding table: A learned matrix inside a model with one vector per vocabulary token. Looking up a token ID returns its vector.; Lesson 13: Embeddings and positional encoding
Endpoint: One URL and method in an API that does a specific job, such as POST /ask.; Lesson 126: REST APIs with FastAPI
Entity: A specific thing named in text, such as a person, company, product or place.; Lesson 42: GraphRAG
Environment (dev, staging, prod): A separate place where the app runs with its own config, data and keys, such as development, staging for testing, and production for real users.; Lesson 108: What deploying means, and environment configs
Environment variable: A named value set outside your code (in the shell, a .env file or a server's settings), used for secrets and config.; Lesson 10: Calling an LLM API for the first time
Epoch: One full pass of training over the whole training dataset.; Lesson 4: Weights, loss and gradient descent
Error analysis: Reading real failures, noting what went wrong in each, grouping them into failure modes and counting them to decide what to fix first.; Lesson 67: Error analysis
Error budget: The amount of failure an SLO allows, such as 0.5% of requests for a 99.5% target.; Lesson 123: Alerts and dashboards
EU AI Act: The European Union's AI law, which sets obligations by risk level, from banned practices to strict rules for high-risk uses like hiring and credit, plus duties for general-purpose models.; Lesson 106: Responsible AI basics
Eval: A repeatable test of an AI system's quality on a set of examples with a scoring method.; Lesson 65: Why evals matter
Eval gate: A pipeline step that runs evals on a change and blocks the merge or release if quality falls below thresholds or regresses versus main.; Lesson 113: Eval gates in CI
Eval-driven development: Writing the eval for a desired behaviour first, then changing the AI system until it passes, and keeping the cases forever.; Lesson 65: Why evals matter
Event loop: The scheduler at the heart of async Python that runs whichever task is ready while others wait for I/O.; Lesson 128: Async and await
Event stream (text/event-stream): The content type used by server-sent events, where each message is sent as data lines followed by a blank line.; Lesson 129: Streaming with SSE, and WebSockets
Excessive agency: When an AI system has more tools, permissions or autonomy than its job needs, so a mistake or attack can do real damage. LLM03 in the OWASP 2026 list.; Lesson 97: Least-privilege tools and sandboxing
Expert (MoE): One of the many small feed-forward networks inside a mixture-of-experts layer.; Lesson 16: Mixture of experts
Exponential backoff: Retrying a failed request after waits that double each time (1s, 2s, 4s…), usually with random jitter, so a struggling service can recover.; Lesson 136: Retries with backoff and idempotency keys

F

F1 score: The harmonic mean of precision and recall; high only when both are high.; Lesson 68: Precision, recall and F1
Failure mode: A recurring kind of mistake a system makes, such as wrong retrieval, stale documents or invented numbers.; Lesson 67: Error analysis
Fairness (AI): Whether an AI system treats people and groups equitably, measured with outcome and error rates per group and judged in the context of the use case.; Lesson 106: Responsible AI basics
Faithfulness: How well every claim in an answer is supported by the provided sources. Unsupported claims are hallucinations.; Lesson 71: RAG evals: faithfulness, relevance and context precision
False negative: Missing something that really was positive.; Lesson 68: Precision, recall and F1
False positive: Flagging something as positive when it isn't (a false alarm).; Lesson 68: Precision, recall and F1
FastAPI: A popular Python web framework for building APIs, using type hints and Pydantic for validation and automatic docs.; Lesson 126: REST APIs with FastAPI
Feature: One piece of input information the model uses to make a prediction, such as a flat's size or the words in an email.; Lesson 2: How a computer learns from examples
Feature flag: A setting checked at runtime that turns a feature on or off for chosen users without a new deploy.; Lesson 120: Canary, blue-green and feature flags
Feed-forward network (MLP): The part of each transformer block that processes every token's vector on its own; holds most of the model's parameters.; Lesson 15: The transformer architecture
Few-shot prompting: Including a few worked examples (input and ideal output) in the prompt so the model copies the pattern.; Lesson 21: Few-shot prompting and chain of thought
Fine-tuning: Further training an existing model on your own examples to change its behaviour, style or narrow skills.; Lesson 28: Fine-tuning with LoRA and QLoRA
Fixed window (rate limiting): Counting requests per calendar interval, such as per minute. Simple, but allows bursts at the edges between windows.; Lesson 135: Rate limiting
Flow engineering: Designing the steps, checks and retries around model calls, instead of relying on one big prompt to do everything.; Lesson 47: Workflows vs agents
Foundation model: A large model pretrained on broad data that can be adapted to many tasks, such as GPT, Claude, Gemini or Llama.; Lesson 11: Where models come from, and what an AI engineer does

G

GenAI semantic conventions: OpenTelemetry's standard attribute names for model calls, such as gen_ai.request.model and gen_ai.usage.input_tokens.; Lesson 74: Tracing and OpenTelemetry for LLMs
Generalisation: How well a model performs on new data it never saw in training. The thing you actually care about.; Lesson 5: Overfitting and train, validation and test splits
Generative AI: Models that create new content (text, images, audio, code) instead of only choosing from fixed labels.; Lesson 1: What AI, ML, deep learning and generative AI are
GGUF: A file format for quantized models used by llama.cpp, Ollama and LM Studio.; Lesson 29: Quantization and distillation
Git: A version control system that records every change to your files as commits, so you can see history, work on branches and go back to any earlier version.; Lesson 107: Git and GitHub for deployment
GitHub: A website that hosts Git repositories and adds pull requests, code review, issues and automation (GitHub Actions).; Lesson 107: Git and GitHub for deployment
GitHub Actions: GitHub's built-in automation that runs workflows (tests, builds, deployments) on fresh machines when something happens in a repository, such as a push or pull request.; Lesson 112: GitHub Actions
Golden dataset: A trusted, versioned set of test inputs with expected outputs or labels, used to measure an AI system repeatably.; Lesson 66: Golden datasets and synthetic test data
GPU (graphics processing unit): A chip with thousands of small cores that do many multiplications at once, which is why it runs neural networks far faster than a CPU. Its memory (VRAM) decides which models fit.; Lesson 78: GPUs, memory and GPU vs API cost
GPU instance: A cloud virtual machine with one or more GPUs attached, rented by the hour to run or fine-tune models.; Lesson 117: GPU instances
GPU utilisation: The share of time (or compute) a GPU is doing useful work. Idle or half-busy GPUs are expensive, so serving systems batch requests to keep utilisation high.; Lesson 78: GPUs, memory and GPU vs API cost
Gradient: For each weight, the direction and steepness in which the loss increases. Training steps the opposite way.; Lesson 4: Weights, loss and gradient descent
Gradient descent: The training method that repeatedly moves every weight a small step against its gradient so the loss goes down.; Lesson 4: Weights, loss and gradient descent
Graph state: The shared, typed data that every step of a graph reads and updates.; Lesson 57: LangGraph, state and checkpoints
GraphRAG: RAG over a knowledge graph of entities and relationships extracted from documents, for multi-hop and corpus-wide questions.; Lesson 42: GraphRAG
Greedy decoding: Always choosing the single most likely next token. Deterministic but repetitive.; Lesson 17: Logits, decoding, temperature and top-p
Grounding: Giving the model trusted source material and instructing it to answer only from it, so answers are based on facts rather than guesses.; Lesson 26: Hallucinations
Guardrail: A check on an AI system's input or output (rules, classifiers or a model call) that can block, modify or flag content.; Lesson 95: Input guardrails, output validation and moderation

H

Hallucination: A confident model output that is false, made up or not supported by the given sources.; Lesson 26: Hallucinations
Handoff: One agent transferring control of a conversation to another, more specialised agent.; Lesson 56: Multi-agent handoffs and orchestrator-worker
Harness engineering: Designing the system around a model that makes it a reliable agent, including instructions, tools, context, permissions, hooks, verification, state and tracing.; Lesson 55: Harness engineering: everything around the model
Hash chain: A sequence of records where each includes the hash of the previous one, so changing any record breaks every later link and is easy to detect.; Lesson 103: Audit logging
Health check: A small endpoint (like /health or /ready) that the platform calls to decide whether an instance is alive and should get traffic.; Lesson 122: Health checks and rollbacks
HNSW: Hierarchical navigable small world. A popular ANN index that links vectors into a layered graph and searches it greedily.; Lesson 36: Vector databases, HNSW and pgvector
Hook: Code a harness runs automatically at a fixed point (before a tool call, after an edit, before finishing) to block, fix, verify or log.; Lesson 55: Harness engineering: everything around the model
Horizontal Pod Autoscaler (HPA): The Kubernetes component that changes the number of pod replicas based on a metric such as CPU or queue length.; Lesson 119: Autoscaling and load balancing
HTTP: The request-and-response protocol of the web. A client sends a method, path, headers and optional body; the server replies with a status code, headers and a body.; Lesson 125: HTTP and status codes
HTTP header: A name and value sent with a request or response to carry metadata, such as Authorization, Content-Type or Retry-After.; Lesson 125: HTTP and status codes
HTTP method: The verb of a request, such as GET (read), POST (create or run), PUT (replace), PATCH (update) or DELETE (remove).; Lesson 125: HTTP and status codes
Hugging Face: A platform hosting open models, datasets and demo apps (Spaces), plus popular libraries like Transformers.; Lesson 11: Where models come from, and what an AI engineer does
Hugging Face Spaces: Hugging Face's hosting for ML demos and apps (Gradio, Streamlit or Docker) deployed from a git repository.; Lesson 115: Serverless functions and the easy hosting route
Human in the loop: Designing an AI system to pause for a person to approve, edit, reject or add information at important moments.; Lesson 59: Human in the loop
Human labeling: People judging or annotating AI outputs, following written guidelines, to create trusted ground truth.; Lesson 70: Human labeling and user feedback loops
Human oversight: Keeping a responsible person able to monitor, review, override and stop an AI system, especially for high-stakes decisions.; Lesson 106: Responsible AI basics
Hybrid search: Running keyword search and vector search together and merging their results, to catch both exact terms and meaning.; Lesson 37: BM25 keyword search and hybrid search
HyDE: Hypothetical document embeddings. Searching with the embedding of a model-written hypothetical answer instead of the question.; Lesson 39: Query rewriting, HyDE and query routing

I

Idempotency: The property that doing the same operation twice has the same effect as doing it once, which makes retries safe (no double charges or duplicate emails).; Lesson 136: Retries with backoff and idempotency keys
Idempotency key: A unique ID a client sends with a request so the server can recognise repeats and return the original result instead of doing the work again.; Lesson 136: Retries with backoff and idempotency keys
Image tokens: The vectors an image is turned into (one per patch) so a transformer can process it with text. Billed like tokens.; Lesson 27: Multimodal inputs
Immutable version: A version that can never be edited after it is created; changes always produce a new version.; Lesson 121: Prompt versioning, model versioning and registries
Indirect prompt injection: Prompt injection hidden in content the model reads rather than typed by the user, such as a web page, email, document, code comment or tool result.; Lesson 93: Prompt injection, indirect injection and jailbreaks
Inference: Using a trained model to produce an output for a new input. Every call to an LLM API is inference.; Lesson 2: How a computer learns from examples
Inference server: Software that loads a model onto hardware and answers requests over an API, handling batching, memory and streaming. Examples include vLLM, SGLang, TGI and Ollama.; Lesson 80: Serving models with vLLM
Infrastructure as code (IaC): Describing cloud resources (servers, databases, networks, permissions) in version-controlled files that a tool turns into real infrastructure.; Lesson 114: Infrastructure as code
Ingestion pipeline: The repeatable process that loads, parses, chunks, embeds and stores documents, and keeps the index in sync as they change.; Lesson 34: Document parsing and ingestion pipelines
Input guardrail: A check on a request before (or while) the model sees it, such as detecting prompt injection, removing personal data or keeping the request on topic.; Lesson 88: Where guardrails sit in the architecture
Input tokens: All tokens you send in a request (system prompt, history, documents, tools), billed at the input price.; Lesson 25: Prompt caching and token pricing
Instruction file (AGENTS.md): A file in a repository, such as AGENTS.md or CLAUDE.md, with project rules and commands that coding agents read every session.; Lesson 55: Harness engineering: everything around the model
Inter-annotator agreement: How often different labelers give the same label to the same item; low agreement means unclear guidelines.; Lesson 70: Human labeling and user feedback loops
Interrupt: Pausing an agent run at a specific step, saving its state, until a person or system provides input to resume it.; Lesson 59: Human in the loop

J

Jailbreak: A prompt crafted to get a model past its safety training, for example through role-play, fictional framing, encodings or many-turn manipulation.; Lesson 93: Prompt injection, indirect injection and jailbreaks
Jitter: Random variation added to retry delays so many clients don't all retry at the same moment.; Lesson 136: Retries with backoff and idempotency keys
Job (CI): A group of steps in a CI workflow that runs on one machine. Jobs run in parallel unless one needs another to finish first.; Lesson 112: GitHub Actions
JSON: A simple text format for structured data (objects, lists, strings, numbers), used by almost every web API and by LLM structured outputs.; Lesson 125: HTTP and status codes
JSON Schema: A standard way to describe the shape of JSON data (fields, types, allowed values), used for structured outputs and tool arguments.; Lesson 23: Structured outputs
Jupyter notebook: A document that mixes runnable code cells with their outputs (tables, charts, text). Great for exploring, fragile for production.; Lesson 9: Python for AI engineers
JWT (JSON Web Token): A compact signed token carrying claims such as user ID, scopes and expiry, which servers can verify without a database lookup. Signed, but not encrypted.; Lesson 130: Authentication with JWT and OAuth 2.0

K

Key rotation: Replacing a key with a new one on a schedule or after a leak, usually with a short overlap so services can switch without downtime, then revoking the old key.; Lesson 99: Secrets management and API key rotation
Keyset pagination: The database technique behind cursor pagination, filtering with WHERE on the sort key (for example id less than the last id) instead of OFFSET.; Lesson 138: Pagination
Keyword search: Search that matches the exact words of the query against an inverted index, ranked with formulas such as BM25.; Lesson 37: BM25 keyword search and hybrid search
Kill switch: A feature flag used to turn a risky feature off instantly during an incident.; Lesson 120: Canary, blue-green and feature flags
Knowledge graph: A network of entities (people, products, teams) connected by labelled relationships.; Lesson 42: GraphRAG
Kubernetes: A system that runs containers across a cluster of machines, keeping the desired number of healthy copies running, updating them gradually and rolling back.; Lesson 118: Kubernetes basics
KV cache: Stored keys and values of already-processed tokens, so each new token can be generated without recomputing everything before it.; Lesson 18: Context windows and the KV cache

L

Label: The correct answer attached to a training example, the thing the model should learn to predict (a price, "spam", "cat").; Lesson 2: How a computer learns from examples
Langfuse: An open-source LLM engineering platform for tracing, evals, prompt management, datasets and dashboards; cloud or self-hosted.; Lesson 75: Langfuse and observability dashboards
LangGraph: A library for building agents and workflows as graphs of nodes and edges with shared state and durable checkpoints.; Lesson 57: LangGraph, state and checkpoints
Large language model (LLM): A very large neural network trained on huge amounts of text to predict the next token. That one skill lets it answer questions, write, summarise and follow instructions.; Lesson 1: What AI, ML, deep learning and generative AI are
Latency: How long one request takes. For LLMs it splits into time to first token and the time per output token after that.; Lesson 79: Streaming, time to first token and throughput
Layer: A group of neurons that all read the same inputs. Networks stack layers so later ones build on what earlier ones found.; Lesson 3: Neural networks, starting from one neuron
Layer normalisation: Rescaling each token's vector to a standard range inside the model, which keeps training stable. RMSNorm is a common variant.; Lesson 15: The transformer architecture
Leaderboard: A ranking of models by benchmark scores or by human preference votes.; Lesson 31: Benchmarks and model leaderboards
Learning rate: How big each gradient-descent step is. Too big and training blows up; too small and it crawls.; Lesson 4: Weights, loss and gradient descent
Least connections: A load-balancing method that sends each new request to the replica with the fewest requests in progress; good when request lengths vary a lot.; Lesson 119: Autoscaling and load balancing
Least privilege: Giving each user, service, tool or agent only the permissions it needs for its job, and nothing more, so mistakes and attacks can do little damage.; Lesson 97: Least-privilege tools and sandboxing
Liveness probe: A check of whether the process is still alive; if it keeps failing, the platform restarts the container.; Lesson 122: Health checks and rollbacks
LLM as a judge: Using a model, with a grading prompt and criteria, to score another model's outputs at scale.; Lesson 69: LLM as a judge, pairwise comparison and rubrics
LLM gateway: A service between your app and model providers that handles routing, fallbacks, retries, keys, rate limits, caching and cost tracking in one place. LiteLLM is a common open-source example.; Lesson 82: Model routing, fallbacks and LLM gateways
Load balancer: A component that receives requests at one address and spreads them across healthy replicas.; Lesson 119: Autoscaling and load balancing
Local model: A model running on your own computer or server (for example with Ollama) instead of a provider's API. Private and free per token, but often less capable.; Lesson 116: Ollama for local models
Log level: The severity of a log message, such as DEBUG, INFO, WARNING, ERROR or CRITICAL, used to filter what gets recorded and shown.; Lesson 139: Logging and monitoring
Logits: The raw scores a model outputs for every possible next token, before softmax turns them into probabilities.; Lesson 17: Logits, decoding, temperature and top-p
Long-term memory: Information an agent saves outside the model (facts, preferences, past events) and retrieves in later sessions.; Lesson 51: Short-term and long-term memory
Loop detection: Spotting that an agent is stuck, for example repeating the same action or making no progress, and stopping it.; Lesson 60: Stop conditions, errors and cost control
Loop engineering: Designing automated loops around agents (triggers, verifiers, stop conditions, budgets, human gates) so they do repeated work without step-by-step prompting.; Lesson 61: Loop engineering: agents that run on repeat
LoRA: Low-rank adaptation. Fine-tuning that freezes the original weights and trains small add-on matrices, usually under 1% of the parameters.; Lesson 28: Fine-tuning with LoRA and QLoRA
Loss: One number measuring how wrong a model's predictions are on a batch of examples. Training tries to make it small.; Lesson 4: Weights, loss and gradient descent
Lost in the middle: The tendency of models to use information at the start and end of a long context better than information in the middle.; Lesson 18: Context windows and the KV cache

M

Machine learning (ML): Getting a computer to find patterns in examples, instead of a person writing the rules, so it can make predictions on new inputs.; Lesson 1: What AI, ML, deep learning and generative AI are
Maker-checker loop: One agent produces work and an independent checker (tests, linters, evals or another agent) verifies it, repeating until it passes or a limit is hit.; Lesson 61: Loop engineering: agents that run on repeat
Managed platform: A hosting service that runs your app or container for you, handling servers, HTTPS, scaling and logs.; Lesson 115: Serverless functions and the easy hosting route
Matrix: A table of numbers with rows and columns. Multiplying a matrix by a vector does many dot products at once; neural network layers are matrix multiplications.; Lesson 6: Vectors and matrices, just enough for AI
max_tokens: A request setting that caps how many tokens the model may generate in its reply.; Lesson 18: Context windows and the KV cache
MCP (Model Context Protocol): An open standard for connecting AI applications to tools, data and prompts through servers that any compatible client can use.; Lesson 53: MCP: servers and clients
MCP client: The connector inside an AI app that talks to one MCP server, discovering and calling what it offers.; Lesson 53: MCP: servers and clients
MCP host: The AI application (such as a desktop assistant, IDE or your own agent) that runs the model and manages MCP client connections.; Lesson 53: MCP: servers and clients
MCP server: A program that exposes tools, resources and prompts over the Model Context Protocol.; Lesson 53: MCP: servers and clients
Memory bandwidth: How many bytes per second a GPU can read from its memory. Generating each token means reading the model's weights, so bandwidth often limits tokens per second more than raw compute.; Lesson 78: GPUs, memory and GPU vs API cost
Memory tool: A tool an agent can call to save or look up memories itself, with the app deciding where they are stored.; Lesson 51: Short-term and long-term memory
Message queue: A buffer where producers put tasks and workers take them off one by one, so work can be spread out, retried and processed at a safe pace. Examples include SQS, RabbitMQ and Redis streams.; Lesson 134: Message queues and background jobs
Metadata: Extra information stored with each chunk, such as source, page, date, owner and access permissions, used for citations and filters.; Lesson 34: Document parsing and ingestion pipelines
Metadata filter: A condition on stored fields (tenant, ACL, date, source) applied during a vector or keyword search so only matching chunks are considered.; Lesson 100: Access control in RAG
Metadata filtering: Restricting search results by fields stored with each chunk, such as tenant, date, language or access group.; Lesson 36: Vector databases, HNSW and pgvector
Metrics: Numbers measured over time, such as request rate, error rate, latency percentiles or cost per hour, used for dashboards and alerts.; Lesson 139: Logging and monitoring
Mixture of experts (MoE): A model design where each layer has many expert networks and a router sends each token to only a few of them, so total capacity is large but per-token compute is small.; Lesson 16: Mixture of experts
MLOps: The practices and tools for reliably training, versioning, evaluating, deploying and monitoring machine learning models.; Lesson 121: Prompt versioning, model versioning and registries
Mock (fake): A stand-in object used in tests that imitates a real dependency, returning controlled results and recording how it was called.; Lesson 140: Testing APIs with pytest
Model: The thing you keep after training. A function, stored as numbers, that turns an input (an email, a prompt) into an output (a label, a reply).; Lesson 1: What AI, ML, deep learning and generative AI are
Model card: A short document describing a model's intended use, training data, evaluation results, limitations and risks. A system card does the same for a whole AI product.; Lesson 106: Responsible AI basics
Model fallback: Automatically sending a request to a backup model or provider when the first one fails, times out or is rate limited.; Lesson 82: Model routing, fallbacks and LLM gateways
Model licence: The legal terms for using a model's weights, from permissive (Apache 2.0, MIT) to custom licences with conditions.; Lesson 30: Open vs closed models, small vs large
Model provider: A company that offers access to models, through its own API (OpenAI, Anthropic, Google) or by hosting others' models (AWS Bedrock, Vertex AI, Azure).; Lesson 11: Where models come from, and what an AI engineer does
Model registry: A store of model versions with their metadata, metrics and lineage, plus labels showing which version runs in which environment.; Lesson 121: Prompt versioning, model versioning and registries
Model routing: Sending each request to the most suitable model, typically cheap models for easy requests and strong models for hard ones.; Lesson 82: Model routing, fallbacks and LLM gateways
Model versioning: Pinning and recording exact model versions (provider snapshots or your own trained weights) so behaviour is reproducible and changes are deliberate.; Lesson 121: Prompt versioning, model versioning and registries
MRR (mean reciprocal rank): The average over test questions of 1 divided by the position of the first relevant result.; Lesson 45: Measuring retrieval: Recall@k, MRR and nDCG
MTTR (mean time to recovery): The average time from a problem starting to service being restored. Health checks and fast rollbacks shorten it.; Lesson 122: Health checks and rollbacks
Multi-agent system: An application where several agents with different roles, instructions or tools cooperate on a task.; Lesson 56: Multi-agent handoffs and orchestrator-worker
Multi-hop question: A question whose answer needs several facts chained together, often from different documents.; Lesson 42: GraphRAG
Multi-query retrieval: Generating several phrasings of a question, retrieving for each, and merging the results to improve recall.; Lesson 39: Query rewriting, HyDE and query routing
Multi-tenancy: One system serving many customers (tenants) on shared infrastructure, while keeping their data, usage and costs separate.; Lesson 86: Provider rate limits and multi-tenant design
Multimodal: Able to take (or produce) more than one kind of data, such as text plus images, PDFs or audio.; Lesson 27: Multimodal inputs
Multimodal RAG: RAG that also retrieves images, charts, tables and scanned pages, using text stand-ins or multimodal embeddings.; Lesson 44: Multimodal RAG: images, tables and PDFs
Multipart upload: Uploading a large file in parts that can be sent in parallel and retried individually, then combined into one object.; Lesson 137: File uploads to S3

N

nDCG: Normalised discounted cumulative gain. Scores a whole ranking, rewarding relevant results more the higher they appear.; Lesson 45: Measuring retrieval: Recall@k, MRR and nDCG
Neural network: A model made of layers of neurons connected by weights. Can learn very complex patterns from data.; Lesson 3: Neural networks, starting from one neuron
Neuron: The basic unit of a neural network. Multiplies its inputs by weights, adds them plus a bias, and passes the total through an activation function.; Lesson 3: Neural networks, starting from one neuron
Node (graph): One step in a LangGraph-style graph, such as a function, LLM call or tool call, that reads the state and returns updates.; Lesson 57: LangGraph, state and checkpoints
Noisy neighbour: A tenant whose heavy usage slows down or breaks service for other tenants sharing the same capacity.; Lesson 86: Provider rate limits and multi-tenant design
NoSQL: Databases that don't use the relational table model, such as key-value, document, wide-column and graph stores, often chosen for a specific access pattern or scale.; Lesson 132: SQL vs NoSQL, indexing and transactions
numpy: The Python library for fast maths on arrays of numbers (vectors and matrices).; Lesson 9: Python for AI engineers

O

OAuth: A standard for granting an app limited, revocable access to an account or API through tokens with scopes, without sharing passwords. OAuth 2.1 is used for remote MCP servers.; Lesson 130: Authentication with JWT and OAuth 2.0
Object storage: Cheap, durable storage for files of any size, organised as objects in buckets, such as Amazon S3, Google Cloud Storage or Azure Blob Storage.; Lesson 137: File uploads to S3
Observability: Being able to understand what a system is doing from its outputs (logs, metrics and traces), so you can find out why a request was slow, wrong or expensive.; Lesson 74: Tracing and OpenTelemetry for LLMs
Observability dashboard: Charts of the key health numbers of a system (traffic, errors, latency, cost, quality) built from traces, metrics and logs.; Lesson 75: Langfuse and observability dashboards
Observation: The result of an agent's action (a tool result) fed back into the model's context for its next decision.; Lesson 49: The agent loop and the ReAct pattern
OCR: Optical character recognition. Reading text from images of pages, such as scanned PDFs or photos.; Lesson 34: Document parsing and ingestion pipelines
Offline eval: An evaluation run before release on a fixed, versioned test set, used to compare versions and catch regressions.; Lesson 65: Why evals matter
Offset pagination: Paging by skipping a number of rows (LIMIT and OFFSET). Simple, but slow for deep pages and unstable when rows are added.; Lesson 138: Pagination
Ollama: A free tool that downloads open-weights models and runs them on your own computer, with a simple API.; Lesson 116: Ollama for local models
On behalf of (delegation): An agent or service acting with a user's identity and permissions, so it can never do more than that user could do themselves.; Lesson 98: Authorization and human approval for agents
On-call: A rota of engineers who respond to urgent alerts outside normal hours.; Lesson 123: Alerts and dashboards
Online eval: Measuring quality on live production traffic, through sampled judge scores, user feedback and business metrics.; Lesson 65: Why evals matter
Open coding: In error analysis, writing a short free-text note describing what went wrong in each failure.; Lesson 67: Error analysis
Open weights: A model whose trained parameters can be downloaded and run on your own hardware. The licence may still limit use.; Lesson 30: Open vs closed models, small vs large
OpenAI Agents SDK: OpenAI's Python library for agents, with agents, tools, handoffs, guardrails, sessions and built-in tracing.; Lesson 58: The OpenAI Agents SDK and other frameworks
OpenAPI: A standard, machine-readable description of an HTTP API's endpoints, inputs and outputs, used to generate docs, clients and tests. FastAPI produces it automatically.; Lesson 126: REST APIs with FastAPI
OpenTelemetry (OTel): An open, vendor-neutral standard and toolkit for producing and exporting traces, metrics and logs.; Lesson 74: Tracing and OpenTelemetry for LLMs
OpenTofu: An open-source infrastructure-as-code tool (a fork of Terraform) that creates, changes and deletes resources from configuration files.; Lesson 114: Infrastructure as code
Orchestrator-worker pattern: A lead agent splits a job into sub-tasks, worker agents do them (often in parallel), and the lead combines the results.; Lesson 56: Multi-agent handoffs and orchestrator-worker
Origin: The combination of scheme, host and port of a web page or API, such as https://app.example.com. Different ports mean different origins.; Lesson 131: CORS
Output guardrail: A check on the model's answer before it reaches the user or a tool, such as masking personal data, checking policy or validating the format.; Lesson 88: Where guardrails sit in the architecture
Output tokens: Tokens the model generates, including hidden reasoning tokens, billed at the (higher) output price.; Lesson 25: Prompt caching and token pricing
Output validation: Checking a model's output (types, values, business rules, safety) before using it or showing it to users.; Lesson 95: Input guardrails, output validation and moderation
Overfitting: When a model memorises its training examples, including their noise, so it does well on them but badly on new data.; Lesson 5: Overfitting and train, validation and test splits
OWASP: The Open Worldwide Application Security Project, a non-profit community that publishes free security guides, including Top 10 lists of risks for web apps and for LLM applications.; Lesson 94: The OWASP Top 10 for LLM apps

P

P95 latency: The response time that 95% of requests are faster than; describes what the slowest common requests feel like.; Lesson 76: P95 latency and cost per request
Page size: How many items one page returns. APIs set a default and a maximum.; Lesson 138: Pagination
PagedAttention: vLLM's technique of storing the KV cache in small fixed-size blocks (like pages in an operating system), so memory isn't wasted and many more requests fit on a GPU.; Lesson 80: Serving models with vLLM
Pagination: Returning a long list one page at a time instead of all at once.; Lesson 138: Pagination
Pairwise comparison: Judging which of two outputs for the same input is better, usually run twice with the order swapped.; Lesson 69: LLM as a judge, pairwise comparison and rubrics
pandas: The Python library for working with tables of data (DataFrames), for loading, filtering, grouping and summarising.; Lesson 9: Python for AI engineers
Parallel tool calls: Several tool calls requested in one model turn. Run them (concurrently if safe) and return all results together.; Lesson 48: Tool calling
Parameter: Any number a model learns during training (all its weights and biases). Model size is usually quoted in parameters, e.g. 8B = 8 billion.; Lesson 3: Neural networks, starting from one neuron
Parent-child chunking: Searching small child chunks for precise matches, then giving the model the larger parent section they belong to.; Lesson 35: Chunking strategies
Percentile: The value below which a given share of measurements fall. p95 latency means 95% of requests were faster.; Lesson 76: P95 latency and cost per request
pgvector: A Postgres extension that adds a vector column type, distance operators and HNSW/IVF indexes, so Postgres can do similarity search.; Lesson 36: Vector databases, HNSW and pgvector
Pickle: Python's built-in format for saving objects. Loading a pickle file can run arbitrary code, so pickled model files from untrusted sources are dangerous.; Lesson 101: Data poisoning and model supply chain
PII (personally identifiable information): Data that can identify a person, such as names, emails, phone numbers, addresses, ID and card numbers. It must be protected and often masked.; Lesson 96: PII redaction and data leakage
pip: Python's standard package installer, e.g. pip install numpy.; Lesson 9: Python for AI engineers
Pipeline (CI/CD): An automated sequence of steps (checks, tests, evals, build, deploy) that runs on every change; a failure stops the steps after it.; Lesson 111: CI/CD pipelines
Plan (Terraform / OpenTofu): A preview of exactly what an infrastructure tool will create, change, replace or destroy before anything is applied.; Lesson 114: Infrastructure as code
Planning (agents): The agent writing down the steps of a task before acting, and updating that plan as it learns.; Lesson 50: Planning and reflection
Pod: The smallest unit Kubernetes runs, made of one or more containers that share a network address and are scheduled together.; Lesson 118: Kubernetes basics
Position bias: A judge's tendency to prefer the first (or second) of two options regardless of quality.; Lesson 69: LLM as a judge, pairwise comparison and rubrics
Positional encoding: Information added to token vectors so a transformer knows word order. Variants include sinusoidal, learned and rotary (RoPE).; Lesson 13: Embeddings and positional encoding
Post-training: Training after pretraining (SFT, preference training, RL, safety) that turns a base model into a helpful assistant.; Lesson 19: Pretraining and post-training (SFT, RLHF, DPO)
Precision: Of the items a system flagged or returned, the share that were actually correct or relevant. TP / (TP + FP).; Lesson 68: Precision, recall and F1
Precision@k: The share of the top k search results that are relevant.; Lesson 45: Measuring retrieval: Recall@k, MRR and nDCG
Prefill: The first phase of generation, where the whole prompt is processed in parallel and the KV cache is filled. Drives time to first token.; Lesson 18: Context windows and the KV cache
Prefix caching: Reusing the stored KV cache for a prompt beginning that was already processed (like a shared system prompt), so only the new part needs computing. Cuts time to first token and cost.; Lesson 81: Speculative decoding and prefix caching
Preflight request: An OPTIONS request a browser sends before certain cross-origin requests to ask the server whether the real request is allowed.; Lesson 131: CORS
Presigned URL: A short-lived URL signed by your server that allows one specific upload or download from object storage without sharing credentials.; Lesson 137: File uploads to S3
Pretraining: The first, most expensive training stage, where a model learns by predicting the next token on huge amounts of raw text.; Lesson 19: Pretraining and post-training (SFT, RLHF, DPO)
Probability: A number from 0 (never) to 1 (certain) saying how likely something is.; Lesson 7: Probability, just enough for AI
Probability distribution: A list of every possible outcome with its probability, all adding up to 1. An LLM produces one over its whole vocabulary for every next token.; Lesson 7: Probability, just enough for AI
Production: The environment real users use. Changes reach it only after passing tests, evals and staging.; Lesson 108: What deploying means, and environment configs
Progressive disclosure: Loading information in stages, only as needed. For skills, short metadata first, full instructions on use, extra files only when required.; Lesson 54: Agent skills
Prompt: The input you give a language model, including instructions, context and the question.; Lesson 20: Prompt engineering basics and system prompts
Prompt caching: A provider feature that reuses the processed beginning of a prompt when it repeats exactly, making those tokens much cheaper and faster.; Lesson 25: Prompt caching and token pricing
Prompt engineering: Writing and testing the instructions, context, examples and format you give a model so it behaves reliably.; Lesson 20: Prompt engineering basics and system prompts
Prompt injection: An attack where text in the input (typed by a user or hidden in a document, web page or tool result) tries to override the system's instructions.; Lesson 93: Prompt injection, indirect injection and jailbreaks
Prompt template: A fixed prompt with named slots (like a question or a customer tier) that code fills in for each request.; Lesson 20: Prompt engineering basics and system prompts
Prompt versioning: Storing every prompt change as a numbered version, so you can review, test, deploy and roll back prompts like code.; Lesson 121: Prompt versioning, model versioning and registries
Provenance: A record of where data or a model came from, who changed it and when, so you can trust, trace and roll it back.; Lesson 101: Data poisoning and model supply chain
Pseudonymisation: Replacing personal details with placeholders or codes (like EMAIL_1) while keeping a separate, protected mapping so the real values can be restored when allowed.; Lesson 96: PII redaction and data leakage
Pull request (PR): A request to merge one branch into another, where teammates review the changes and automated checks run before merging.; Lesson 107: Git and GitHub for deployment
Pydantic: A Python library for defining data shapes as classes and validating data against them. Widely used for LLM outputs and APIs.; Lesson 127: Input validation with Pydantic, and config
Pydantic Settings: A Pydantic add-on that loads typed, validated configuration from environment variables and .env files.; Lesson 127: Input validation with Pydantic, and config
pytest: Python's most popular testing framework, with plain assert statements, fixtures and parametrised tests.; Lesson 140: Testing APIs with pytest

Q

QLoRA: LoRA fine-tuning on top of a base model loaded in 4-bit precision, so large models can be tuned on a single GPU.; Lesson 28: Fine-tuning with LoRA and QLoRA
QPS (queries per second): How many requests a system receives each second. Daily volume divided by 86,400 gives the average; peaks are usually a few times higher.; Lesson 90: Case study: a chatbot for 1 million users
Quantization: Storing a model's numbers with fewer bits (e.g. 4-bit instead of 16-bit) to save memory and speed it up, with a small quality loss.; Lesson 29: Quantization and distillation
Query rewriting: Turning a user's message (often a vague follow-up) into a clear, standalone search query before retrieval.; Lesson 39: Query rewriting, HyDE and query routing
Query routing: Deciding which index, database or tool should handle a question before retrieving.; Lesson 39: Query rewriting, HyDE and query routing
Query, key and value: The three vectors each token makes in attention. Queries are compared with keys to get weights; the output is a weighted mix of values.; Lesson 14: Self-attention

R

RAG (retrieval-augmented generation): Fetching relevant documents for a question and adding them to the prompt, so the model answers from your data.; Lesson 32: What RAG is: the whole pipeline
RAG access control: Filtering retrieval by the asking user's permissions (using access lists stored with each chunk), so restricted documents never reach the model or the answer.; Lesson 100: Access control in RAG
Rank (LoRA): The size of LoRA's bottleneck (e.g. 8 or 16). Higher rank means more capacity and more trainable parameters.; Lesson 28: Fine-tuning with LoRA and QLoRA
Rate limit: A cap on how many requests or tokens a client may send in a period. Providers return HTTP 429 when you exceed theirs.; Lesson 86: Provider rate limits and multi-tenant design
ReAct pattern: Reasoning and Acting. The model alternates a written thought, a tool action and the observed result until it can answer.; Lesson 49: The agent loop and the ReAct pattern
Readiness probe: A check of whether an instance can serve traffic right now; if it fails, the load balancer stops sending it requests.; Lesson 122: Health checks and rollbacks
Reasoning model: An LLM trained to think internally before answering, which improves maths, code and multi-step tasks at the cost of more tokens and time.; Lesson 22: Reasoning models
Reasoning tokens: Tokens a reasoning model generates while thinking before its answer. Usually hidden, but billed as output tokens.; Lesson 22: Reasoning models
Recall: The share of the truly relevant items that a search (or classifier) actually finds.; Lesson 68: Precision, recall and F1
Recall@k: The share of relevant items that appear in the top k search results, averaged over test questions.; Lesson 45: Measuring retrieval: Recall@k, MRR and nDCG
Reciprocal rank fusion (RRF): Merging ranked lists by giving each item 1 / (k + rank) points from every list it appears in. Needs no score calibration.; Lesson 37: BM25 keyword search and hybrid search
Red teaming: Authorised, adversarial testing where people (and tools) attack your own system like real attackers would, to find weaknesses before others do.; Lesson 104: Red teaming
Redaction: Removing or masking sensitive details such as personal data or secrets before text is sent, stored or shown.; Lesson 96: PII redaction and data leakage
Redis: A very fast in-memory data store used for caching, rate-limit counters, sessions, queues and locks.; Lesson 133: Caching with Redis
Reflection (agents): Checking a draft against criteria (with tests, rules or a judge) and revising it before finishing.; Lesson 50: Planning and reflection
Regression: A machine learning task that predicts a number, such as a price or a delivery time.; Lesson 8: Classic machine learning in one lesson
Regression eval: Running an eval suite on every change and failing it if quality drops below the previous baseline.; Lesson 73: Regression evals in CI and A/B testing prompts
Replica: One running copy of a service. Several replicas behind a load balancer share traffic and survive individual failures.; Lesson 119: Autoscaling and load balancing
Request ID: A unique ID assigned to each incoming request and included in every related log line, call and trace.; Lesson 139: Logging and monitoring
Reranker: A model that re-scores a short list of retrieved candidates more carefully, so the most relevant ones end up first.; Lesson 38: Reranking
Residual connection: Adding a layer's input to its output, so information and gradients flow easily through very deep networks.; Lesson 15: The transformer architecture
REST API: An API that exposes resources at URLs and uses standard HTTP methods and status codes to work with them.; Lesson 126: REST APIs with FastAPI
Retention period: How long data such as logs or conversations is kept before it is deleted, set by policy and law.; Lesson 103: Audit logging
Retrieval: Finding the pieces of stored information most relevant to a question, for example by keyword or vector search.; Lesson 32: What RAG is: the whole pipeline
Retry: Repeating a failed request, which helps only for temporary errors and should use backoff and a limit.; Lesson 136: Retries with backoff and idempotency keys
Retry-After: An HTTP response header telling the client how many seconds to wait before trying again, sent with 429 and 503 responses.; Lesson 135: Rate limiting
Reward model: A model trained to predict how much humans would prefer an answer; used to guide reinforcement learning.; Lesson 19: Pretraining and post-training (SFT, RLHF, DPO)
RLHF: Reinforcement learning from human feedback. Humans rank answers, a reward model learns their preferences, and RL pushes the model towards preferred answers.; Lesson 19: Pretraining and post-training (SFT, RLHF, DPO)
Rollback: Returning to the previous known-good version of code, config, prompt or model after a bad release.; Lesson 122: Health checks and rollbacks
Rolling update: Replacing old copies of an app with new ones a few at a time, keeping enough healthy copies serving throughout.; Lesson 118: Kubernetes basics
Router (MoE): The small learned layer that scores the experts for each token and picks which ones run.; Lesson 16: Mixture of experts
Rubric: A list of specific criteria (ideally pass/fail) that define a good output, used by human or LLM graders.; Lesson 69: LLM as a judge, pairwise comparison and rubrics
Rug pull (MCP): A tool provider changing its tool definitions or behaviour after you reviewed and approved it.; Lesson 102: MCP server trust
Runner: The machine that executes a CI job. GitHub provides fresh virtual machines (like ubuntu-latest) for each job, or you can host your own.; Lesson 112: GitHub Actions

S

Safetensors: A file format for model weights that stores only tensor data and metadata, with no executable code, making it safe to load from others.; Lesson 101: Data poisoning and model supply chain
Same-origin policy: The browser rule that pages can freely read responses only from their own origin; CORS relaxes it in a controlled way.; Lesson 131: CORS
Sampling: Picking the next token at random, following the model's probabilities, instead of always taking the most likely one.; Lesson 17: Logits, decoding, temperature and top-p
Sandbox: An isolated environment (container, VM, restricted process) where code or agents run with limited access, so mistakes and attacks stay contained.; Lesson 97: Least-privilege tools and sandboxing
Scale to zero: Running no instances when there is no traffic, so you pay nothing while idle, at the cost of a cold start on the next request.; Lesson 119: Autoscaling and load balancing
Scheduled agent run: An agent task started automatically by a schedule (like nightly) or an event (like a failed build), rather than by a person.; Lesson 61: Loop engineering: agents that run on repeat
Schema: A precise description of what valid data looks like (fields, types, limits), such as a Pydantic model or a JSON Schema.; Lesson 127: Input validation with Pydantic, and config
scikit-learn: The standard Python library for classic machine learning, with the same fit / predict / score pattern for every model.; Lesson 8: Classic machine learning in one lesson
Scope: A named permission attached to a token, such as chat:read or calendar.readonly, limiting what the token can be used for.; Lesson 130: Authentication with JWT and OAuth 2.0
Scoped credentials: Keys or tokens limited to specific actions and resources (for example read-only access to one table), ideally short-lived.; Lesson 97: Least-privilege tools and sandboxing
Secret: Any credential that grants access, such as an API key, password, token or private key. It must never appear in code, prompts, logs or images.; Lesson 99: Secrets management and API key rotation
Secret scanning: Automatically searching code, commits, logs or prompts for strings that look like keys or passwords, and blocking or alerting when one is found.; Lesson 99: Secrets management and API key rotation
Secrets manager: A service that stores secrets encrypted, controls and logs who can read them, and delivers them to apps at runtime. Examples include cloud secret stores and HashiCorp Vault.; Lesson 99: Secrets management and API key rotation
Self-attention: The transformer operation where each token compares itself with other tokens and takes in information from the most relevant ones.; Lesson 14: Self-attention
Semantic cache: A cache that returns a stored answer when a new question is close in meaning (by embedding similarity) to one already answered, skipping the model call.; Lesson 83: Semantic caching
Semantic chunking: Splitting text where its meaning changes, detected by comparing embeddings of neighbouring sentences.; Lesson 35: Chunking strategies
Semantic search: Search by meaning rather than exact words, usually by comparing embeddings.; Lesson 33: Embeddings and cosine similarity
Semaphore: A counter that limits how many tasks can do something at the same time, for example at most 5 concurrent LLM calls.; Lesson 128: Async and await
Server-sent events (SSE): A simple HTTP standard for a server to push a stream of text events to the browser over one long-lived response. Most LLM APIs stream tokens this way.; Lesson 129: Streaming with SSE, and WebSockets
Serverless function: Code that the platform runs only when a request or event arrives, scaling automatically and billing per use, with no servers for you to manage.; Lesson 115: Serverless functions and the easy hosting route
Service (Compose): One named container definition in a compose.yaml file, such as app, db or ollama. Other services reach it by that name.; Lesson 110: Docker Compose
Service (Kubernetes): A stable name and address in Kubernetes that load-balances traffic across the ready pods matching a label.; Lesson 118: Kubernetes basics
Short-term memory: What an agent keeps in its context window during one conversation or task, trimmed or summarised to fit.; Lesson 51: Short-term and long-term memory
Sliding window (rate limiting): Counting requests over the trailing time period, such as the last 60 seconds, which smooths out boundary bursts.; Lesson 135: Rate limiting
SLO (service level objective): A target for a user-facing metric over a period, such as 99.5% of requests succeeding over 30 days.; Lesson 123: Alerts and dashboards
Small language model: A model with relatively few parameters (roughly 1 to 15 billion) or a provider's cheapest tier. Fast and cheap, good at narrow tasks.; Lesson 30: Open vs closed models, small vs large
Softmax: A function that turns a list of raw scores into positive probabilities that add up to 1, giving bigger scores bigger shares.; Lesson 7: Probability, just enough for AI
Span: One timed step inside a trace (such as a retrieval or a model call), with a parent, a status and attributes.; Lesson 74: Tracing and OpenTelemetry for LLMs
Speculative decoding: Speeding up generation by letting a cheap method guess several next tokens and having the big model check them all in one pass; accepted guesses save time, and the output is unchanged.; Lesson 81: Speculative decoding and prefix caching
Spending alert: An automatic warning when costs for a key, feature or account go above a set level or rise unusually fast.; Lesson 105: Denial of wallet and cost abuse
Spot instance: Spare cloud capacity sold at a large discount that the provider can take back at short notice; good for interruptible jobs.; Lesson 117: GPU instances
SQL database: A relational database that stores data in tables with columns, relations and constraints, queried with SQL. Postgres, MySQL and SQLite are examples.; Lesson 132: SQL vs NoSQL, indexing and transactions
Staging: A production-like environment where a release is tested with real infrastructure but no real users before it goes to production.; Lesson 108: What deploying means, and environment configs
State file: The record an infrastructure tool keeps of which real resources it manages, used to work out the changes needed next time. Must be stored safely.; Lesson 114: Infrastructure as code
Statistical significance: Evidence that a measured difference is unlikely to be due to random chance, often judged by a p-value below 0.05.; Lesson 73: Regression evals in CI and A/B testing prompts
Status code: The three-digit number in an HTTP response saying how it went, such as 200 OK, 404 Not Found, 429 Too Many Requests or 500 Internal Server Error.; Lesson 125: HTTP and status codes
Stop condition: A rule that ends an agent loop, such as a final answer, a maximum number of steps, a token or time budget, or an error.; Lesson 60: Stop conditions, errors and cost control
Streaming (responses): Sending the model's reply token by token as it is generated, so the user starts reading within a second instead of waiting for the whole answer.; Lesson 79: Streaming, time to first token and throughput
Strict mode (tools): A setting that forces a model's tool arguments to match the JSON Schema exactly (types, required fields, no extras).; Lesson 48: Tool calling
Structured logging: Writing logs as machine-readable records (usually JSON) with named fields, so they can be searched, filtered and charted.; Lesson 139: Logging and monitoring
Structured outputs: An API feature that forces a model's reply to match a JSON Schema you provide, so code can parse it reliably.; Lesson 23: Structured outputs
Subagent: An agent started by another agent for a scoped task, with its own context window, that returns a short result.; Lesson 56: Multi-agent handoffs and orchestrator-worker
Supervised fine-tuning (SFT): Training a model on examples of prompts paired with ideal responses, so it learns to follow instructions in a given style.; Lesson 19: Pretraining and post-training (SFT, RLHF, DPO)
Supervised learning: Learning from examples that come with the right answers (labels). Unsupervised learning has no labels; self-supervised learning makes labels from the data itself.; Lesson 2: How a computer learns from examples
Supply chain (AI): Everything your AI system is built from that others made, such as pre-trained models, datasets, packages, plugins and MCP servers, each of which can be a way in for attackers.; Lesson 101: Data poisoning and model supply chain
Synthetic test data: Test cases generated by an LLM (variations, edge cases, rare situations) to extend a golden dataset. Needs human review.; Lesson 66: Golden datasets and synthetic test data
System prompt: Standing instructions set by the app (role, rules, tone, format) that frame a whole conversation and take priority over user messages.; Lesson 20: Prompt engineering basics and system prompts

T

Tag (release): A fixed name attached to a specific commit, such as v1.2.0, used to mark releases.; Lesson 107: Git and GitHub for deployment
Tail latency: The slowest part of the latency distribution (p95, p99 and above), often caused by retries, long outputs or slow steps.; Lesson 76: P95 latency and cost per request
Teacher and student models: In distillation, the large model that produces answers (teacher) and the smaller model trained to copy them (student).; Lesson 29: Quantization and distillation
Temperature: A setting that divides the logits before softmax. Low values make output focused and predictable, high values make it varied and riskier.; Lesson 17: Logits, decoding, temperature and top-p
Tenant isolation: Keeping each customer's data, caches, memory and limits separate so one tenant can never see or affect another's.; Lesson 86: Provider rate limits and multi-tenant design
Test fixture: Reusable setup (and cleanup) for tests, such as a test client or a fake LLM, provided to tests that ask for it.; Lesson 140: Testing APIs with pytest
Test set: Held-out data used once, at the end, to estimate how the model will do on real new data.; Lesson 5: Overfitting and train, validation and test splits
Threat model: A structured look at what you're protecting, who might attack it, how, and which controls stop each attack. Done before building and revisited as the system changes.; Lesson 94: The OWASP Top 10 for LLM apps
Threshold: A fixed limit a metric must meet, such as recall@3 of at least 0.90, used by gates and alerts.; Lesson 113: Eval gates in CI
Throughput: How much work a system finishes per second, e.g. requests per second or tokens per second across all users. Batching raises throughput, sometimes at the cost of per-request latency.; Lesson 80: Serving models with vLLM
Time to first token (TTFT): How long it takes from sending a request until the first token of the reply arrives. Key for perceived speed in chat.; Lesson 79: Streaming, time to first token and throughput
Time to first token (TTFT): How long a user waits from sending a request until the first token of the reply arrives. Mostly set by queueing and prompt processing (prefill); it's the latency users feel most.; Lesson 79: Streaming, time to first token and throughput
Timeout: The longest a request or function may run before it is stopped. LLM calls and serverless functions both need sensible timeouts.; Lesson 115: Serverless functions and the easy hosting route
To-do list (agent): A plan stored as a checklist the agent updates as it works, often visible to the user.; Lesson 50: Planning and reflection
Token: A small chunk of text (a word, part of a word or a symbol) that a language model reads and writes one at a time. Usage and prices are counted in tokens.; Lesson 12: Tokenization
Token bucket: A rate-limiting algorithm where a bucket refills at a steady rate and each request takes some units out; when it's empty, requests wait or are rejected. Allows short bursts.; Lesson 135: Rate limiting
Token budget: A limit on how many tokens a request, step or whole task may use, to control cost, latency and context size.; Lesson 84: Token budgets and context window management
Token ID: The integer that stands for one token in a model's vocabulary. The number itself carries no meaning.; Lesson 12: Tokenization
Token pricing: Charging for model use per million input tokens and per million output tokens, with output usually costing more.; Lesson 25: Prompt caching and token pricing
Tokenizer: The component that splits text into tokens and maps them to integer IDs (and back). Each model family has its own.; Lesson 12: Tokenization
Tokens per minute (TPM): A provider rate limit on how many input or output tokens an account can use each minute; with long prompts it is often reached before the request limit.; Lesson 86: Provider rate limits and multi-tenant design
Tool call accuracy: How often an agent calls the right tools with the right arguments, compared with the expected calls.; Lesson 72: Agent evals: tool calls and trajectories
Tool calling (function calling): A model replying with a request to run one of your functions, with arguments; your app runs it and sends the result back.; Lesson 48: Tool calling
Tool poisoning: Hiding instructions inside a tool's name or description (for example in an MCP server) so the model, which reads the description, is steered into harmful actions.; Lesson 102: MCP server trust
Tool result: The output of a tool your app ran, sent back to the model linked to the call's ID so it can continue.; Lesson 24: Function and tool calling basics
Tool schema: The definition of a tool given to a model, with a name, a description and a JSON Schema for its arguments.; Lesson 24: Function and tool calling basics
Top-k sampling: Sampling the next token from only the k most likely tokens.; Lesson 17: Logits, decoding, temperature and top-p
Top-p (nucleus) sampling: Sampling from the smallest set of most likely tokens whose probabilities add up to p, such as 0.9.; Lesson 17: Logits, decoding, temperature and top-p
Trace: The full record of one request or task, made of nested timed spans for every step it took.; Lesson 74: Tracing and OpenTelemetry for LLMs
Tracing: Recording every step of a request (model calls, tool calls, retrieval) with timing, inputs and outputs, so you can debug and measure it.; Lesson 74: Tracing and OpenTelemetry for LLMs
Training: The phase where a model's internal numbers are adjusted, using examples, until its outputs match the right answers as closely as possible.; Lesson 2: How a computer learns from examples
Training data: The examples a model learns from. For supervised learning, each example has features and a label.; Lesson 2: How a computer learns from examples
Training set: The part of the data the model learns from.; Lesson 5: Overfitting and train, validation and test splits
Trajectory eval: Evaluating an agent's whole sequence of steps for order, efficiency, recovery from errors and safety, not just its final answer.; Lesson 72: Agent evals: tool calls and trajectories
Transaction: A group of database changes that are applied together or not at all.; Lesson 132: SQL vs NoSQL, indexing and transactions
Transformer: The neural network architecture behind modern LLMs, built from stacked blocks of attention and feed-forward layers.; Lesson 15: The transformer architecture
Transformer block: One repeated unit of a transformer, containing attention and a feed-forward network, each wrapped with normalisation and a residual connection.; Lesson 15: The transformer architecture
Transparency: Being open about AI use, such as telling people when they deal with AI, labelling generated content, and documenting how a system works and its limits.; Lesson 106: Responsible AI basics
TTL (time to live): How long a cached entry stays valid before it expires and must be fetched or computed again.; Lesson 83: Semantic caching
Twelve-factor app: A widely used set of principles for web services; one of them is keeping configuration in the environment, separate from the code.; Lesson 108: What deploying means, and environment configs

U

Unbounded consumption: An AI system using resources or money without limits, through floods of requests, huge prompts, long outputs or runaway agents. LLM06 in the OWASP 2026 list.; Lesson 105: Denial of wallet and cost abuse
Underfitting: When a model is too simple or under-trained to capture the pattern, so it does badly even on its training data.; Lesson 5: Overfitting and train, validation and test splits
Unit economics: The cost and revenue of one unit of the product, such as one request, one task or one user per month. AI features must cost less to serve than they earn.; Lesson 89: Cost optimization
Unit test: A fast, automated test of one small piece of code in isolation, with external services replaced by fakes.; Lesson 140: Testing APIs with pytest
User feedback loop: Collecting user signals (thumbs, edits, retries, complaints), finding the causes and feeding fixes and new test cases back into the system.; Lesson 70: Human labeling and user feedback loops
uv: A very fast Python package and project manager that creates environments, installs packages and locks versions.; Lesson 9: Python for AI engineers

V

Validation: Checking that data has the right shape, types and values before using it, and rejecting it with a clear error if not.; Lesson 127: Input validation with Pydantic, and config
Validation set: Held-out data used to compare models and settings during development, without touching the test set.; Lesson 5: Overfitting and train, validation and test splits
Vector: An ordered list of numbers, such as [0.9, 0.8, 0.0]. AI represents words, documents and images as vectors so it can compare and compute with them.; Lesson 6: Vectors and matrices, just enough for AI
Vector database: A database that stores embeddings with their text and metadata and quickly finds the ones nearest to a query vector.; Lesson 36: Vector databases, HNSW and pgvector
Vibe check: Judging an AI change by trying a few examples and going with how it feels, instead of measuring on a test set.; Lesson 65: Why evals matter
Vibe coding: Building software by accepting AI-written code without really reading or testing it. Fine for throwaway prototypes, risky in production.; Lesson 63: Coding agents and computer-use agents
Virtual environment: A private folder of Python packages for one project, so projects don't break each other's versions.; Lesson 9: Python for AI engineers
Vision-language model: A model that understands images together with text, for example answering questions about a screenshot.; Lesson 27: Multimodal inputs
vLLM: A popular open-source engine for serving LLMs on GPUs fast, using PagedAttention, continuous batching and prefix caching, with an OpenAI-compatible API.; Lesson 80: Serving models with vLLM
Vocabulary: The fixed list of all tokens a tokenizer and model know, often 100,000 to 250,000 entries.; Lesson 12: Tokenization
Volume: Storage managed by Docker that lives outside a container, so data such as databases or downloaded models survives when the container is replaced.; Lesson 110: Docker Compose
VRAM: The memory on a GPU. Model weights, the KV cache and activations must fit in it, so it usually limits which models a GPU can run.; Lesson 78: GPUs, memory and GPU vs API cost

W

WebSocket: A long-lived, two-way connection between browser and server where either side can send messages at any time.; Lesson 129: Streaming with SSE, and WebSockets
Weight: A learned number that says how much one input matters to a neuron and in which direction. Training is mostly the search for good weights.; Lesson 3: Neural networks, starting from one neuron
Worker: A process that takes jobs from a queue and does them, separately from the web servers.; Lesson 134: Message queues and background jobs
Workflow (LLM): A fixed sequence of steps controlled by code, where LLM calls fill in specific blanks such as classifying or drafting.; Lesson 47: Workflows vs agents

Z

Zero-shot prompting: Asking a model to do a task with instructions only, without any worked examples.; Lesson 21: Few-shot prompting and chain of thought