Glossary

Exam terms are added here as modules are published, with the module that introduces each term. Terminology follows the official AWS AIP-C01 blueprint vocabulary.

Amazon Bedrock — AWS’s managed service for integrating foundation models behind one API; it integrates and hosts FMs (you call them), whereas Amazon SageMaker AI builds and trains ML models. (Module 1)

Amazon Comprehend — AWS’s managed NLP service used for entity extraction and PII detection (DetectPiiEntities); it is not a Bedrock foundation model. (Module 6)

Amazon EventBridge — A serverless event bus that decouples publishers from consumers; Relay publishes relay.escalation / relay.approval_required to a custom relay-events bus and stays ignorant of who consumes them. (Module 11)

Amazon Macie — A managed service that scans data at rest in S3 for sensitive data; it classifies, it does not redact text in flight (that is Comprehend’s job). (Module 10)

Amazon Nova — Amazon’s foundation-model family on Bedrock; Relay’s tiers map to Nova Micro (fast), Nova 2 Lite (smart), and Nova Lite (vision) — note Nova Lite ≠ Nova 2 Lite. (Module 1)

Amazon S3 Vectors — A GA, S3-native vector store that idles at ~$0/GB-month, used for Relay’s DIY index and its Knowledge Base index instead of an always-on OpenSearch cluster. (Module 4)

Amazon SQS — A managed queue that lets POST /tickets accept work fast (202) and run the agent asynchronously behind it, decoupling request from processing. (Module 11)

Amazon Textract — A managed document-text-extraction (OCR) service; it reads text from documents but is not image understanding, so it does not “read” a screenshot’s meaning the way a multimodal FM does. (Module 6)

Amazon Transcribe — A managed speech-to-text service; audio goes through Transcribe to text first, then to the FM — it never goes straight to the model. (Module 6)

ApplyGuardrail — The standalone Bedrock API that runs a guardrail over any text with no model call, letting Relay screen input/output independently of Converse. (Module 9)

Asynchronous processing — The serving pattern where the API accepts a request and returns immediately (HTTP 202), completing the work later behind a queue. (Module 11)

Audit trail — The append-only record proving what happened: CloudTrail proves access, while Relay’s structured decision log proves the agent’s decisions. (Module 10)

AWS CDK — Infrastructure-as-code in a real programming language; one CDK stack describes Relay’s whole front door (API, Lambdas, SQS, bus, rules) reproducibly. (Module 11)

Batch inference — Running FM calls asynchronously via CreateModelInvocationJob at roughly −50% cost; the textbook fit is offline work like re-scoring a golden set, never interactive traffic. (Module 12)

Bedrock AgentCore — A managed suite for running agents in production: Runtime hosts the agent, Gateway turns APIs/Lambdas into MCP tools, Memory stores state, and Identity authenticates tool access. (Module 8)

Bedrock AgentCore Memory — AgentCore’s managed store for short-term (session events) and long-term (cross-session records distilled by a strategy) memory; long-term memory is the only idle-billed item, so it is purged at teardown. (Module 8)

Bedrock AgentCore Runtime — The managed runtime that hosts a deployed agent in an isolated microVM with sessions up to 8 hours; idle is free, so you pay only for active consumption. (Module 8)

Bedrock Agents (classic) — AWS’s first-generation managed agent service; treated as exam knowledge, not the build path — don’t pick it by reflex just because it is managed. (Module 7)

Bedrock Data Automation — A managed service for extracting structured data from documents, images, audio, and video; surveyed as the managed alternative to a hand-built intake pipeline. (Module 6)

Bedrock Model Evaluations — Bedrock’s managed evaluation job (including RAG evaluation) that cross-checks your home judge; it bills tokens only, with no job surcharge. (Module 13)

Chunking — Splitting documents into retrieval-sized pieces before embedding; the highest-leverage, least-tuned RAG knob, where hierarchical (heading-aware) chunking beat fixed-size on every test question. (Module 4)

Circuit breaker — A resilience pattern that stops calling a failing dependency after repeated failures and probes it occasionally until it recovers; taught as theory in the FM integration layer. (Module 3)

CloudTrail — AWS’s API-call audit log; it records who called what API, not the prompt or completion content of those calls. (Module 10)

CloudWatch generative AI observability — CloudWatch’s GA capability for tracing and monitoring GenAI workloads (invocations, tokens, agent loops) holistically, beyond raw infrastructure error codes. (Module 14)

CodePipeline — AWS’s managed CI/CD pipeline; Relay’s pipeline runs build → smoke → deploy → rollback, with an eval-gate stage added later so a regression blocks release. (Module 11)

Content blocks — The structured message parts (text, image) of a Converse request; multimodal input is just an image content block alongside text, not a separate API. (Module 6)

Contextual grounding check — A Bedrock Guardrails filter that scores an answer against its retrieved sources and catches hallucinations that content filters cannot. (Module 9)

Converse API — Bedrock’s unified, model-agnostic call path (Converse / ConverseStream); it is the single Bedrock call site in Relay’s code, replacing per-model InvokeModel JSON bodies for generation. (Module 1)

Cosine similarity — The geometric measure used to rank embeddings by semantic closeness; the score Relay uses to compare chunking strategies on retrieval quality. (Module 4)

Cross-Region inference — Routing a Bedrock call across Regions via an inference profile for capacity and resilience; it is the nominal operating mode, not just a disaster-recovery switch. (Module 3)

Data exfiltration — An attack that makes the agent leak what it knows through an output channel; everything the agent reads is treated as untrusted input. (Module 9)

Data sovereignty — The governance constraint that data must stay within a jurisdiction; a residency boundary handled by Region choice and edge services (Outposts, Wavelength), taught as theory. (Module 10)

Dead-letter queue (DLQ) — The queue that captures messages a worker repeatedly fails to process, so failures surface instead of vanishing. (Module 11)

Decision log — Relay’s structured, redacted record of what the agent decided and why; unlike CloudTrail (which proves access), it proves decisions for accountability. (Module 10)

Defense-in-depth — Stacking guardrails so each layer catches what the previous missed; no single layer is enough, and attaching one guardrail to the model call does not solve prompt injection. (Module 9)

Embedding — A vector representation of text where semantic similarity becomes geometric proximity; the same embedder and dimensionality (Titan V2, 1024) must be used for indexing and querying. (Module 4)

Few-shot prompting — Steering a model with worked examples in the prompt; effective but a recurring per-call cost, since the examples are re-sent on every request. (Module 2)

Flex tier — A Bedrock service tier (serviceTier type flex) giving ~−50% cost in exchange for higher, variable latency; selected per call, fit for eval/backfill jobs, never interactive traffic. (Module 12)

FM integration layer — The thin, single-call-site layer (relay/llm.py converse()) that owns model selection, routing, streaming, and resilience, keeping every model ID out of business code. (Module 3)

Foundation model (FM) — A large pre-trained model exposed through Bedrock that you integrate rather than train; the blueprint’s preferred term over “base model” or “LLM-alone.” (Module 1)

Golden dataset — A versioned set of representative cases with expected outputs, re-run on every change to detect regression; a real asset, not a throwaway test file — and a production canary, not just a CI artifact. (Module 13)

Grounding — Ensuring every claim in an answer is supported by retrieved source material; “citations present” is not the same as “grounding verified.” (Module 5)

Guardrails — Programmable Bedrock controls that enforce content, topic, word, PII, and prompt-attack policies on inputs and outputs from outside the model — versioned, and not the model’s own self-policing. (Module 9)

Hallucination — A confident but unsupported model claim; setting temperature to 0 or using a bigger model does not control it — contextual grounding does. (Module 9)

Handoff — Transferring a task plus its context from one agent to a specialist (Relay’s Billing specialist); a handoff routes the work, it does not clone it. (Module 8)

Human-in-the-loop (HITL) — An oversight pattern where a human approval is a blocking step inside the agent’s workflow; it gates the sensitive action (a refund), not every action. (Module 8)

Hybrid search — Combining dense (semantic) and lexical (keyword) retrieval to catch exact tokens like IDs and version strings; it is a property of the vector store, and is unsupported on S3 Vectors (taught as theory). (Module 4)

Idempotency — The property that performing the same operation twice has the same effect as once; load-bearing hardening for retries and duplicate event delivery. (Module 11)

Inference profile — The cross-Region model identifier (us./global. prefix) that every modern Bedrock call must use; a bare regional model ID fails on-demand with “retry with an inference profile” — the canonical M1 trap. (Module 1)

Ingestion job — A Knowledge Base’s managed sync that chunks, embeds, and indexes a data source; jobs can fail silently, so their status must be checked, and freshness re-synced. (Module 5)

Intake pipeline — Relay’s upstream stage that validates, normalizes, extracts entities, and reads attachments before any FM call; validation is a quality gate, not security. (Module 6)

InvokeModel — Bedrock’s per-model, JSON-body call path; shown read-only once for comparison (and used only for Titan embeddings), since Converse is the course’s call path for generation. (Module 1)

Jitter — A random factor added to each backoff delay so concurrent clients don’t retry in lockstep; paired with exponential backoff in the retry policy. (Module 3)

Knowledge Base — Bedrock’s managed RAG pipeline (relay-kb) over a data source, exposing Retrieve (control) and RetrieveAndGenerate (turnkey citations); it manages the pipeline, not your judgment. (Module 5)

Least privilege — Granting each component its own IAM role with explicit actions and resource ARNs and zero wildcards; one broad lab role would fail a security review. (Module 10)

Lexical search — Keyword-based ranking (e.g. BM25) that matches exact terms rather than meaning; the remedy, with reranking, for the exact-identifier tokens pure semantic retrieval wobbles on. (Module 4)

LLM-as-a-judge — Using a (stronger) model to score another model’s output against an explicit rubric; the judge must never be the candidate model (self-preference bias). (Module 13)

Loose coupling — An integration style where Relay announces what happened on an event bus and stays ignorant of who cares; coupling goes through EventBridge, not direct calls. (Module 11)

MCP (Model Context Protocol) — The open standard that standardizes how an agent connects to tools and data sources; it is agent↔tools, not an agent-to-agent protocol, and the tool runs in your code, not at the model provider. (Module 7)

Metadata filtering — Filtering retrieval by vector metadata (category, source, tenant); it carries the operational load and is how Relay enforces multi-tenancy. (Module 4)

Model card — A governance document recording a model’s intended use, data, and limitations; it documents, it does not enforce. (Module 10)

Model cascading — Trying a cheap model first and escalating to a stronger one only on failure; distinct from routing, which dispatches by complexity up front. (Module 3)

Model Invocation Logs — Bedrock’s opt-in logs of full request/response content (free on the Bedrock side); distinct from CloudTrail, which logs the API call but not prompt content. (Module 14)

Multimodal FM — A foundation model that accepts more than text (e.g. an image) in its Converse content blocks and reasons over the modalities jointly; Relay uses Nova Lite to read screenshots. (Module 6)

Normalization — Reshaping raw input into a clean, validated form before generation; also a token lever, since cleaner input means fewer tokens. (Module 6)

Observability — Understanding a system’s internal behavior from the telemetry it emits; GenAI failures are silent degradations, not stack traces, so observing invocations and the business matters more than error codes. (Module 14)

On-demand — The default Bedrock pricing mode, billed per token with nothing at idle; contrasted with provisioned throughput. (Module 11)

OpenSearch Serverless — A managed vector store that bills 24/7 (~$174/month) whether or not a query runs; the always-on alternative S3 Vectors is chosen against for its ~$0 idle. (Module 4)

OWASP Top 10 for LLM Applications — The reference catalog of LLM-application risks (prompt injection, data exfiltration, and more) that frames Relay’s safety engineering. (Module 9)

p95 latency — The latency below which 95% of requests finish; the percentile measured before and after every performance optimization, because it reflects the slowest-served users. (Module 12)

PII (personally identifiable information) — Data identifying a person; Relay detects and masks it at the intake edge (before any FM call) so everything downstream inherits the protection. (Module 10)

Prompt caching — Reusing a cached, unchanged prompt prefix (e.g. a system prompt) to cut input cost on repeated calls; distinct from semantic caching and deterministic hashing. (Module 12)

Prompt injection — Content crafted to override an agent’s instructions; direct injection comes from the user, indirect injection hides in content the agent reads, and neither is the same as a jailbreak. (Module 9)

Prompt Management — Bedrock’s service for versioned, approved, audited prompt artifacts; code references a prompt by identifier and version number, never the inline prompt text. (Module 2)

Prompt template — A parameterized, reusable prompt (role + format constraint + allowed values + few-shot examples) that turns ad-hoc text into a governed artifact. (Module 2)

Provisioned throughput — Reserved Bedrock capacity for guaranteed throughput, billed idle by the hour; it is not “the production default” — on-demand is. (Module 11)

Query decomposition — Breaking a complex query into sub-queries the retriever answers separately before generation; a Knowledge Base query-transformation lever. (Module 5)

RAG (retrieval-augmented generation) — Retrieving relevant external content at query time and injecting it into the prompt before generation; it beats fine-tuning for documents that change. (Module 4)

ReAct loop — The agent pattern that interleaves reasoning and tool actions until done; every iteration of the loop is a billed model call, which is why stop conditions and timeouts matter. (Module 7)

Regression gate — An automated pass/fail check (e.g. grounding < 0.8 or a >5-point drop vs baseline) that blocks a release; evals without a baseline and a gate protect nothing. (Module 13)

Reranker — A cross-encoder that re-scores a candidate list for precision after retrieval; it buys precision, never recall, and is Relay’s measured precision lever on S3 Vectors. (Module 5)

Retrieval drift — Retrieval quality silently degrading over time (stale or corrupted index) while infra reports no errors; a GenAI silent degradation caught by monitoring, not stack traces. (Module 14)

Retry with exponential backoff — Retrying a throttled or 5xx call after a delay that doubles each attempt, capped, with jitter — never an immediate loop. (Module 3)

Routing — Dispatching each request to a model tier by complexity (fast vs smart) before the call; it captures ~80% of the savings and is distinct from cascading. (Module 3)

Runbook — The versioned document that turns an alert into action, working in order: symptom → signal → diagnosis → remedy → verify; a dashboard without alarms and a runbook is a poster. (Module 14)

Semantic caching — Returning a cached answer when a new request is similar enough to a past one (by embedding similarity above a threshold); it needs a threshold and an invalidation story, and differs from prompt caching and deterministic hashing. (Module 12)

Service tier — The Bedrock serviceTier knob (priority / default / flex / reserved) selecting cost-vs-latency per call; the course’s “standard” maps to the API’s default. (Module 12)

Specialist agent — A focused agent with its own system prompt for one job (Relay’s Billing specialist), added only when the specialization is genuinely justified — more agents is not automatically better. (Module 8)

Stop conditions — Hard limits (max iterations, timeouts, budget) that end an agent loop; not a luxury, since each loop iteration is a billed model call. (Module 7)

Strands Agents — The open-source framework that defines the agent’s reasoning loop, tools, and handoffs; it composes with AgentCore (the runtime) rather than competing with it. (Module 7)

Streaming — Pushing tokens to the client incrementally via ConverseStream over a held-open channel; stream for humans, not for parsers, and serverless can stream too. (Module 3)

Structured output — Constraining a model to a validated schema (e.g. Pydantic-checked JSON); temperature 0 does not guarantee format, so only programmatic validation does — and unvalidated JSON is a deferred incident. (Module 2)

Supervisor — A coordinating agent that routes work to specialists and collects results; the multi-agent topology Relay uses over a leaderless swarm. (Module 8)

Temperature — The inference parameter controlling output randomness; Relay’s triage runs at temperature 0 because creativity in a classifier is a bug, not a feature — but 0 is not determinism and does not replace validation. (Module 2)

Tier (fast / smart) — Relay’s two production model tiers — fast (Nova Micro) for triage and simple work, smart (Nova 2 Lite) for complex answers — selected by the complexity router. (Module 3)

Titan Text Embeddings V2 — Amazon’s embedding model (amazon.titan-embed-text-v2:0), pinned at 1024 dimensions as Relay’s sole InvokeModel call and the fixed vector contract across all indexes. (Module 4)

Tool calling — The mechanism by which the model emits a structured request for a function and your code executes it; the agent decides, your tools act — the tool does not run at the model provider. (Module 7)

Vector store — A store that indexes embeddings for fast approximate similarity search; Relay uses S3 Vectors (idle ~$0) over an always-on cluster. (Module 4)

Verbosity bias — A judge scoring longer answers higher at equal content; a known LLM-as-a-judge bias to mitigate with rubric design. (Module 13)

X-Ray — AWS’s distributed tracing service; Relay traces the API → SQS → agent path with X-Ray alongside Strands OTel/ADOT traces to see one request end to end. (Module 14)