AWS AIP-C01 course and practice exam: AI engineering with LLM apps, RAG and agents

This AWS AIP-C01 course has 47 video lessons and 107 graded labs, and its AWS AIP-C01 practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.

Prompts, Retrieval, Tool-Using Agents, MCP & Evals

11 modules, 47 lessons: How LLMs Work; Calling Models From Code; Prompt Engineering; Context Engineering; Embeddings And Vector Search; Retrieval-Augmented Generation; Tools And Agents; Model Context Protocol; Safety And Security; Evaluation And Observability; Beyond Text And The Capstone.

Intermediate · 4 hours · 47 lessons · 211 labs

AWS AIP-C01 exam guide

The AWS AIP-C01 exam (AWS Certified Generative AI Developer – Professional, by Amazon Web Services (AWS)): 180 minutes; questions: 75 total (65 affect score); pass mark: 750 (on a scale of 100–1,000); cost: USD 300.

  • Format: 75 questions (65 scored, 10 unscored pretest); multiple choice or multiple response
  • Duration: 180 minutes
  • Questions: 75 total (65 affect score)
  • Pass mark: 750 (on a scale of 100–1,000)
  • Cost: USD 300
  • Valid for: 3 years
  • Delivery: Pearson VUE testing center or online proctored exam
  • Prerequisites: None required; 2 or more years building production-grade applications on AWS or with open-source technologies, general AI/ML or data engineering experience, and 1 year of hands-on experience implementing GenAI solutions recommended

Exam domains and weights

  • Foundation Model Integration, Data Management, and Compliance: 31%
  • Implementation and Integration: 26%
  • AI Safety, Security, and Governance: 20%
  • Operational Efficiency and Optimization for GenAI Applications: 12%
  • Testing, Validation, and Troubleshooting: 11%

A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

10 AWS AIP-C01 sample questions with answers: free to read, no account needed.

Common questions

How long is the AWS AIP-C01 exam?

The AWS AIP-C01 exam lasts 180 minutes.

How many questions are on the AWS AIP-C01 exam?

75 total (65 affect score).

What is the AWS AIP-C01 passing score?

The pass mark is 750 (on a scale of 100–1,000).

How much does the AWS AIP-C01 exam cost?

USD 300.

Is there a free AWS AIP-C01 practice test?

Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.

Source: AWS Certified Generative AI Developer – Professional exam guide (AIP-C01) (Amazon Web Services (AWS)), checked 2026-10-01.

Who it is for

Intermediate level.

For Python developers who want to build features on large language models: prompts, retrieval, tool-using agents and MCP, with the evals and safeguards that make them fit for production.

What you don't need yet:

What helps:

Before you start:

Take first:

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

Exam objectives this course teaches

AWS Certified Generative AI Developer – Professional

Labs

211 labs, 107 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

How LLMs Work

  1. What An AI Engineer Does (1 lab): You can tell AI-engineering work from ML research, and decide whether a feature needs a model at all.
  2. Tokens And The Context Window (3 labs): You can count the tokens in a request, estimate what it costs, and explain what the context window limits and why the reply needs room in it.
  3. How The Next Token Is Chosen (5 labs): You can explain how logits become a next-token choice, and set temperature, top-k, top-p, penalties, stop sequences and max tokens to suit a task.
  4. Choosing A Model (3 labs): You can choose between closed, open-weight, reasoning and small self-hosted models, or a router, by filtering on licence and data residency and then weighing quality, latency and cost.

Calling Models From Code

  1. The Request And The Response (6 labs): You can build a model request with a system prompt, messages and parameters, read the content, stop reason and usage from the reply, and recognise the Messages, Responses and Chat Completions shapes.
  2. Streaming Responses (6 labs): You can consume a server-sent event stream from a model API, show text as it arrives, reassemble a streamed tool call, and handle a stream that fails part way.
  3. When The Call Fails (4 labs): You can handle rate limits, overloads and timeouts with retries, exponential backoff with jitter, a deadline and a fallback model, and tell which failures must not be retried.
  4. Cost, Latency And Caching (5 labs): You can account for the tokens of each request including cache reads and writes, order a prompt so it caches, decide when to batch, and measure time to first token.

Prompt Engineering

  1. Anatomy Of A Prompt (3 labs): You can write a prompt template with a role, context, instructions, examples and an output format, each in its own fenced section that untrusted input cannot break out of.
  2. Zero-Shot And Few-Shot (4 labs): You can choose and order the examples in a prompt, and measure on labelled data whether they help enough to pay for their tokens.
  3. Reasoning Techniques (3 labs): You can apply chain of thought, self-consistency, step-back and ReAct prompting where a task needs several steps, and recognise when a reasoning model makes them unnecessary.
  4. Structured Output (5 labs): You can get JSON that matches a schema, using a provider's structured-output mode where it exists, and still validate it, repair it with the errors, and refuse to trust a cut-off reply.
  5. Prompts As Code (5 labs): You can keep prompts in the repository with a version that travels with every request, review their changes, and catch regressions with a pytest suite over recorded replies.

Context Engineering

  1. From Prompts To Context (3 labs): You can treat the context window as a budget shared by instructions, tools, retrieved data and history, and assemble each request so the highest-value material fits.
  2. Memory And Compaction (5 labs): You can keep a long conversation within its budget by compacting older turns into a summary that keeps the facts that matter, clearing stale tool results, and storing durable facts in long-term memory.
  3. When Context Fails (5 labs): You can recognise context poisoning, distraction, confusion and clash, read long-context results by length and position, and use an isolated sub-context to keep the main context small.

Embeddings And Vector Search

  1. What An Embedding Is (4 labs): You can compare texts with cosine similarity, dot product and Euclidean distance over their embedding vectors, and find a query's nearest neighbours by brute force.
  2. Embedding Models (3 labs): You can choose an embedding model on language, dimensions, input length, cost and licence, and measure what truncating and quantising its vectors cost in recall.
  3. Vector Indexes And Databases (4 labs): You can explain exact and approximate vector search, measure an approximate index's recall and cost against brute force, apply metadata filters without losing results, and choose a vector store.
  4. Keyword And Hybrid Search (5 labs): You can rank passages with BM25, fuse a keyword ranking and a vector ranking with reciprocal rank fusion, and rerank the fused candidates with a cross-encoder.
  5. Measuring Retrieval (5 labs): You can build a labelled query set and report recall at k, mean reciprocal rank and nDCG at k for several retrievers, then turn the numbers into a test that guards against regressions.

Retrieval-Augmented Generation

  1. How RAG Works And When To Use It (4 labs): You can draw the ingest, retrieve and generate pipeline of a RAG system and choose between RAG, long context and fine-tuning for a given knowledge base.
  2. Chunking And Ingestion (6 labs): You can split Markdown documents into chunks along their headings, with overlap and metadata, and give every chunk an id that makes re-ingestion repeatable and incremental.
  3. Retrieval That Finds The Right Thing (6 labs): You can improve retrieval with query rewriting, metadata filters and reranking, and fit the chunks you keep within a token budget.
  4. Grounded Answers With Citations (4 labs): You can make a model answer only from retrieved sources, cite them with search result citations, refuse when they do not answer, and check every answer for all three in code.

Tools And Agents

  1. Function Calling (5 labs): You can define tools with names, descriptions and JSON Schema, run the call, result and answer exchange, and validate every call before your code acts on it.
  2. Designing Tools A Model Can Use (4 labs): You can write tools with clear names, a focused scope, errors that say how to fix the call and compact output, and watch a model recover from a mistake your tool explained.
  3. The Agent Loop (4 labs): You can build a reason, act, observe loop that stops when the model is done, when a step or cost budget runs out, or on an unexpected stop reason, and that reports why it stopped.
  4. Workflows Before Agents (4 labs): You can choose prompt chaining, routing, parallelisation, orchestrator and workers, or evaluator and optimiser before a free-running agent, and build a router and a gated prompt chain.
  5. Planning, Memory And Many Agents (4 labs): You can use planning, ReAct-style loops, self-critique and sub-agents with isolated context, keep a trace of what each agent did, and decide when one agent is enough.
  6. Agent SDKs And Human Approval (6 labs): You can map the OpenAI Agents SDK, the Claude Agent SDK, Google ADK and LangGraph onto the loop you built, and add a human approval step that pauses, saves its state and resumes.

Model Context Protocol

  1. What MCP Is (4 labs): You can explain MCP's hosts, clients and servers, its tools, resources and prompts, and its stdio and Streamable HTTP transports as the stateless 2026-07-28 revision defines them, and check the shape of a JSON-RPC exchange.
  2. Build An MCP Server (6 labs): You can expose the Tasks API as MCP tools over stdio with the standard library, with discovery, input schemas, structured results, per-request version checks and both kinds of error.
  3. Connect An Agent To MCP (4 labs): You can write an MCP client that starts a server over stdio, discovers and lists its tools, and gives them to an agent loop, translating names, schemas, results and errors both ways.
  4. Remote Servers And Trust (7 labs): You can serve MCP over Streamable HTTP, refuse requests without a valid bearer token while pointing clients to the server's OAuth metadata, and decide which servers and tools an agent may trust.

Safety And Security

  1. Threat-Model An LLM App (2 labs): You can map an LLM application's data flows to the OWASP Top 10 for LLM Applications and the Agentic Top 10, rank the risks by what a fooled model could do, and decide what to design out first.
  2. Prompt Injection (5 labs): You can explain direct and indirect prompt injection, mark and isolate untrusted content, and stop an injected tool call with a guard that runs outside the model.
  3. Excessive Agency (3 labs): You can apply least privilege, allowlists, rate limits and human approval to an agent's tools with a policy engine that decides every call before it runs.
  4. Guardrails, Privacy And Governance (4 labs): You can check what goes into and out of a model, redact personal data, render model output safely, and name the duties NIST AI 600-1 and the EU AI Act place on an AI feature.

Evaluation And Observability

  1. Eval-Driven Development (4 labs): You can build a golden dataset with deterministic checks for an assistant, and run it as an eval harness that compares every change against the last version.
  2. Model-Graded Evals (4 labs): You can write a judge rubric for a model grader and measure its agreement with human labels, using Cohen's kappa, before you trust its verdicts.
  3. Evaluating RAG And Agents (4 labs): You can score a RAG answer for faithfulness and its retrieved context for precision and recall, and score recorded agent runs on task success and the tools they used.
  4. Regression Tests In CI (6 labs): You can run evals as pytest tests with thresholds set from measured noise, so a build fails for a real regression and not for a lucky or unlucky sample.
  5. Tracing And Monitoring (4 labs): You can record model calls as spans with the OpenTelemetry GenAI attributes, and turn exported spans and user feedback into a report of latency, cost, errors and satisfaction.

Beyond Text And The Capstone

  1. Images, Audio And Speech (7 labs): You can send images and audio to models, choose between chained and speech to speech audio, and check generated speech by aligning word timings with the script.
  2. Working With AI Coding Assistants (4 labs): You can use coding agents safely: sandbox them, review their output, check the dependencies they add and keep secrets out of what they write.
  3. Capstone: The Tasks Assistant (9 labs): You can combine retrieval, tools served over MCP, an agent loop with approval and an injection guard, and evals with tracing into one tested assistant.