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:
- No API key or paid model account: labs replay real replies
- No machine learning background: you use models, not train them
- You don't need to know any agent framework yet
What helps:
- Working Python: functions, classes, modules and virtual environments
- HTTP APIs: requests, JSON bodies and status codes
Before you start:
- Working Python: functions, classes, modules and virtual environments (the Python course covers all of it)
- HTTP APIs: requests, JSON bodies and status codes (the APIs course covers all of it)
Take first:
- Hands-on Python: Complete Video Course & Book — Beginner
- Modern API Architecture: REST, GraphQL & gRPC — Intermediate
- Automated Testing, TDD & Quality Engineering — Beginner
Take next:
- Full-Stack Observability: Metrics, Tracing & Logging — Advanced
- Application Security & Threat Modeling for Engineers — Advanced
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
- Foundation Model Integration, Data Management, and Compliance (31% of the exam): Analyze requirements and design GenAI solutions; Select and configure FMs; Implement data validation and processing pipelines for FM consumption; Design and implement vector store solutions; Design retrieval mechanisms for FM augmentation; Implement prompt engineering strategies and governance for FM interactions
- Implementation and Integration (26% of the exam): Implement agentic AI solutions and tool integrations; Implement model deployment strategies; Design and implement enterprise integration architectures; Implement FM API integrations; Implement application integration patterns and development tools
- AI Safety, Security, and Governance (20% of the exam): Implement input and output safety controls; Implement data security and privacy controls; Implement AI governance and compliance mechanisms; Implement responsible AI principles
- Operational Efficiency and Optimization for GenAI Applications (12% of the exam): Implement cost optimization and resource efficiency strategies; Optimize application performance; Implement monitoring systems for GenAI applications
- Testing, Validation, and Troubleshooting (11% of the exam): Implement evaluation systems for GenAI; Troubleshoot GenAI applications
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.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
How LLMs Work
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- 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.