Rather than a new toy example per topic, the programme builds a single system that deepens each day: an AI agent that answers from your own documents through RAG, checks live system state through tools, decides, acts — then is evaluated, guarded and traced until it is fit to put in front of people. The domain is set to yours during scoping.
What Each Engineer Can Do Afterwards
Not “has been introduced to” — can do, unaided, on your own systems
- Write a tool-using AI agent from first principles, and say what a framework adds.
- Build a RAG pipeline and state its retrieval score against a golden set.
- Get typed, validated structured output from an LLM, and handle it when it fails.
- Model an agent as a state graph with branching, persistence and human-in-the-loop approval gates.
- Run an eval suite in CI that fails the build on a quality regression.
- Trace a run, attribute token cost, and cut latency with evidence.
- Find and close a prompt-injection path in their own build.
- Expose an internal system to any agent as an MCP server.
Curriculum — Day by Day
Timed to an eight-hour day with 90 minutes of breaks — 390 minutes of instruction per day, roughly 75% hands-on. Compresses to four days where scheduling requires it.
Foundations — the LLM as a component
75 + 120 + 120 + 75 = 390 minHow a large language model behaves
Context windows, token budgets, temperature and non-determinism — shown by running things, not by slides.
Structured output
Typed, validated objects instead of prose: JSON schemas, structured output modes, and recovery when parsing fails.
Tool calling (function calling)
How an LLM selects a tool, how arguments arrive, and why tool-schema design is really API design.
Consolidation and supported build
Open working time with the instructor circulating, so everyone ends Day 1 on the same working baseline.
AI agents — the agent loop, built by hand
135 + 105 + 105 + 45 = 390 minBuilding the agent loop
Reason, call, observe, repeat — written from first principles with no framework, so every later abstraction has something concrete beneath it.
Termination, iteration limits and errors
Stop conditions, iteration caps, and how errors travel through a loop that calls an LLM that calls a tool.
Extending the agent
More tools, harder questions, and the point where a single prompt stops being enough.
Review and shared baseline
Comparing implementations across the room — engineers solve the agent loop differently, and the comparison teaches more than the build did.
RAG — Retrieval-Augmented Generation that works
75 + 105 + 135 + 75 = 390 minA naive RAG pipeline, deliberately mediocre
Load, chunk, embed, store in a vector database, retrieve, generate — built fast and imperfectly on purpose, so the rest of the day has something real to fix.
Chunking, embeddings and representation
Fixed, recursive, semantic and structure-aware chunking; chunk size and overlap; embedding choice; why tables and scanned pages break retrieval.
Measuring retrieval quality
Golden sets, hit rate, recall@k and mean reciprocal rank. Hybrid search, reranking and metadata filters — each kept only if the number moves.
Grounding, citation and refusal
Prompting for citations, forcing an honest “not in the sources”, and wiring RAG into the Day 2 agent as a tool.
Agent frameworks — state, control, coordination
105 + 90 + 105 + 90 = 390 minPort the hand-rolled loop onto the framework
The same agent rebuilt as a state graph. Because the loop was written by hand, every abstraction is recognisable rather than magic.
Branching, routing and recovery
Conditional paths on state, fallbacks, bounded retries and cycles that terminate.
Persistence and human-in-the-loop (HITL)
Durable state across turns, resuming an interrupted run, and approval gates before anything destructive.
Multi-agent systems, and MCP
Supervisor, router and plan-and-execute patterns, plus exposing an internal service as an MCP (Model Context Protocol) tool.
Production — evals, guardrails, LLMOps
105 + 90 + 90 + 105 = 390 minLLM evaluations and the regression suite
Assertion-based checks against LLM-as-a-judge. Evaluating retrieval and generation separately. Running evals in CI.
Guardrails, verifiers and blast radius
Output validation, verifier patterns, prompt injection arriving through retrieved documents and tool results, and allowlists.
Observability, cost and latency
Tracing, token accounting per request and per feature, semantic caching, model routing, streaming and timeouts.
Deployment, failure modes, your own system
Packaging, concurrency, rollout, and model-version changes that shift behaviour underneath you. Closes on a live architecture review of each team’s own system.
Choice of Stack
Days 1, 2, 3 and 5 are stack-neutral. Day 4 is where the stack matters — one is selected at booking, and the outcomes are identical either way.
LangGraph + LangChain
- Graph nodes with a typed state schema
- Conditional edges, cycles and bounded retries
- Checkpointers with interrupt and resume
- Supervisor, router and plan-and-execute patterns
- LangSmith tracing and evals
AWS Bedrock
- Amazon Bedrock Agents and AgentCore with session state
- Action groups backed by AWS Lambda
- Bedrock Knowledge Bases alongside the Day 3 RAG pipeline
- Step Functions for multi-agent orchestration
- CloudWatch and Bedrock Guardrails
Outcomes, Audience and Technologies
Each participant leaves with
- A working AI agent written without a framework, plus the LangGraph or AWS Bedrock version beside it
- A RAG pipeline with a measured retrieval score and the golden set behind it
- An eval suite wired into a build that catches a regression
- A course manual and reference implementation to rebuild everything independently
The organisation gains
- Capability that stays — engineers who build and maintain agentic AI systems unaided
- A shared vocabulary across engineering, architecture and security for reviewing AI work
- The ability to evaluate AI quality with numbers, which makes it reviewable and fundable
- A team that can tell a workable AI proposal from an unworkable one
Who this is for
Working software engineers who write code day to day — backend, full-stack, platform or data. Python is the working language; engineers from Java, C#/.NET or similar backgrounds are well served, with a short primer provided in advance so everyone starts level.
Architects and technical leads take the same programme and gain the review vocabulary with it.
Technologies and topics covered
RAG (Retrieval-Augmented Generation) · AI agents · agentic AI · LangGraph · LangChain · AWS Bedrock · Amazon Bedrock AgentCore · Bedrock Knowledge Bases · MCP (Model Context Protocol) · LLMs (large language models) · vector databases · embeddings · semantic search · hybrid search · reranking · chunking strategies · golden sets · recall@k · MRR · tool calling / function calling · structured output · prompt engineering · context engineering · multi-agent systems · supervisor and router patterns · plan-and-execute · human-in-the-loop (HITL) · checkpointing and persistence · LLM evaluations (evals) · LLM-as-a-judge · guardrails · prompt injection defence · observability and tracing · token cost optimisation · semantic caching · LLMOps · Python · FastAPI · CI/CD for AI
Delivery
On-Site Corporate
- Five consecutive days at your offices
- Hands-on groups of five to six
- A second facilitator for larger cohorts
- Worldwide — Asia-Pacific, the Middle East, Europe and the Americas
Live Online
- Ten half-days across three to four weeks
- Same content and same labs, with better attendance and retention
- Breakout rooms for every lab
- Any time zone
Practicalities
- Compresses to four days where scheduling requires
- Delivered in English, paced for cohorts working in a second language
- Labs run on your own documents and systems where access allows
- A short technical readiness call and setup checklist before delivery
Frequently Asked Questions
How many days is the RAG and agentic AI engineering training?
Five days, timed to an eight-hour day with 90 minutes of breaks - 390 minutes of instruction per day, roughly 75% of it hands-on. It compresses to four days where scheduling requires, by tightening the consolidation and supported-build sessions.
Is this delivered on LangGraph or AWS Bedrock?
Either. Days 1, 2, 3 and 5 are stack-neutral. Day 4 is delivered on LangGraph and LangChain by default, or on AWS Bedrock - Bedrock Agents and AgentCore, action groups on Lambda, Bedrock Knowledge Bases and Step Functions - for AWS-native teams. The stack is chosen at booking and the outcomes are the same.
How much of the training covers RAG?
A full day. Day 3 is entirely retrieval-augmented generation: chunking, embeddings, vector search, hybrid search, reranking, and measuring retrieval quality against a golden set. RAG then continues into Day 4 as an agent tool and Day 5 as both an injection surface and an eval target.
Who should attend?
Working software engineers who write code day to day. Python is the working language; engineers from Java, C#/.NET or similar backgrounds are well served, with a short primer provided in advance. Architects and technical leads take the same programme.
Can it be delivered remotely?
Yes. Remote delivery runs as ten half-days across three to four weeks rather than five consecutive full days - the same content and labs, with materially better attendance and retention.
What does each engineer leave with?
A working AI agent written without a framework plus the framework version beside it, a RAG pipeline with a measured retrieval score and the golden set behind it, an eval suite wired into a build, and a course manual with a reference implementation.
Can the training be run on our own data and systems?
Yes, and it is better that way. Labs run on your own documents and non-production systems wherever access allows. Sample corpora are provided as a fallback.
Related
Low-Code AI Automation with n8n (3 Days) →
The non-technical counterpart: AI agents, RAG and automation with n8n and NotebookLM, no coding required.
All Training Programmes →
The full catalogue of AI and technical training, formats and how to book.
RAG Training →
Focused RAG track — chunking, embeddings, pgvector, hybrid search, grounded answers and evals.
LangGraph Training →
Focused LangGraph track — state, edges, cycles, persistence, human-in-the-loop, multi-agent.