AI Agents Bootcamp: LangChain, LangGraph, RAG & MCP [2026]

This course contains the use of artificial intelligence.

This AI Agents Bootcamp takes you from your first agent loop in plain Python to production AI agents built with LangChain, LangGraph, RAG, MCP and LangSmith, tested with evals and shipped behind FastAPI.

You can call a model. Maybe you have followed a tutorial and watched an agent answer a question, call a tool, and loop. Then you tried to put it in front of real tickets and it invented a policy, looped on a tool call, forgot the thread, or paid a refund nobody approved. That gap between a demo and an agentic AI system your team can ship to production is the whole reason this bootcamp exists.

You will build AI agents the way an engineer builds them: a plain Python loop first, so you know exactly what a framework is doing for you, then LangChain 1.x tools and create_agent, then LangGraph for control, memory, human approval and multi-agent teams, then retrieval, evals, MCP (the Model Context Protocol), security, a chat UI and a FastAPI deployment. Every section is a concept lecture that draws the picture, followed by a lab that types the real file and shows the real output. Nothing on screen is staged.

Build, Evaluate and Ship Production AI Agents with LangChain, LangGraph, RAG and MCP

• Build an agent loop in plain Python and break it three ways before any framework touches it

• Call any LLM from one config file: OpenAI, Anthropic, Google, or a free local model in Ollama

• Write typed LangChain tools and ship the TechCorp IT desk with create_agent and middleware

• Design LangGraph graphs with routing, reducers, a checkpointer, interrupt, streaming and time travel

• Run parallel nodes, map-reduce, subgraphs, deep agents and a supervisor with specialist agents

• Give an agent retrieval as a tool with FAISS and pgvector, then route, grade, rewrite, cite and refuse

• Trace every run in LangSmith, score it against a golden set, and fail regressions in CI

• Block prompt injection, park mutating calls for confirmation, stamp an actor id, strip PII

• Connect tools over MCP with FastMCP, load an Agent Skill folder, and place A2A on the map

• Stream the agent into a chat UI, add an approval inbox, and serve it from FastAPI with Docker

Here is the road, section by section, so you can see the ladder before you climb it.

Sections 1 to 5 are the foundation. You clone the repo, run the tests green without a key, and call one model. You learn what an LLM does at answer time: tokens, cost, structured output, a raw tool call. You build an agent loop in plain Python and break it. You measure context, watch a run die of context rot, and install compaction, notes and a map file. You add thread memory and long-term memory. After this section you can build an agent loop in plain Python, break it three ways, draw the six-box architecture, and say where each framework sits.

Section 6 is LangChain 1.x: models from config, typed tools, structured output, create_agent and middleware, and the TechCorp desk you keep as a portfolio piece. After this section you can call any model from config, write typed tools, get structured output, build the TechCorp desk with create_agent and middleware, and ship it as a tested package.

Sections 7 to 18 are LangGraph, the spine of the course and the part that turns a loop into a production agentic AI workflow. StateGraph and nodes, conditional routing, state and reducers, the checkpointer and the store, human in the loop with interrupt, streaming and time travel, subgraphs and map-reduce, durable execution with retries and caps, multi-agent supervisors, LangSmith Studio and traces, deep agents, and ambient agents that wake on a trigger. After this section you can park a graph with interrupt before a refund, resume with Command to approve or reject, edit state before resuming, and prove a lookup never parks. After this section you can build a supervisor with two specialists, debug a failed handoff, keep writes single-threaded, hand off with Command on one thread, and cap workers.

Sections 19 to 21 are harness engineering: how to diagnose a failed run, install guides, sensors and controls, and turn a miss into a test. After this section you can name the harness around a model, pick one of four cause buckets for a failed DataFlow run, and write it in a failure log.

Sections 22 to 25 are RAG for agents: retrieve as a tool, FAISS and pgvector, agentic RAG with route, retrieve, grade and rewrite, then citations, refusal and RAG evals on the DataFlow knowledge desk. After this section you can cite a real DataFlow file, refuse on empty retrieve, run a RAG eval table, and ship the knowledge desk.

Sections 26 to 32 are how production AI agents win trust, evals, QA and security: LangSmith tracing, datasets and LLM as judge, golden sets and node tests, an eval harness in CI, load tests and Playwright, prompt injection, allowlists, confirm gates, actor ids, PII and a red-team suite. After this section you can write a DataFlow golden set, unit test a node, and fail a fluent wrong answer. After this section you can show a prompt injection that escalates a DataFlow tool, treat a wiki page as data, and block the call at an allowlist.

Sections 33 to 42 are patterns, protocols and the frontier: ReAct, plan and execute, reflection, router, evaluator-optimizer, supervisor and swarm; MCP servers with FastMCP and MCPAdapter; Agent Skills, A2A and AG-UI; streaming into Streamlit or Gradio; approval screens, the agent inbox and voice; Playwright browser agents and computer use; coding agents and sandboxes; and an honest map of CrewAI, Langflow, n8n, AutoGen, the OpenAI Agents SDK and Google ADK, running the same ticket on each. After this section you can write a FastMCP server, bind it with MCPAdapter, choose a transport, and park a mutating MCP tool on interrupt.

Sections 43 to 48 ship it: FastAPI, a Postgres checkpointer, secrets and config, auth, rate limits, Docker, observability and cost, deploy targets, the Monday smoke test and a rollback runbook; a section for PMs and QA on specs, evals and the harness; LangGraph interview questions and your portfolio; then three capstones you build from a starter repo and pass through peer review. After this section you can ship one of three capstone agents from a starter repo, pass peer review, name what to build next, and point at LangGraph, RAG, MCP and FastAPI in your files.

How the course is taught. This is a bootcamp, not a lecture series. Every section opens with a concept lecture that explains what the thing is, why it exists, how it works and how it helps you ship, with the architecture drawn on screen while I talk. Then a lab types the real file in VS Code and runs it against a real model, with the real output captured, including the moment it breaks and the fix. Each concept lecture ends with a knowledge check. Sections carry assessments, and Section 48 has a peer-reviewed capstone.

What you keep. One repo with three portfolio worlds: the TechCorp IT desk, the DataFlow knowledge desk and the TalentFlow document pipeline. Tests that run green without an API key. A config file where the model id lives, so you can point the same agent at OpenAI, Anthropic, Google or a local model in Ollama and nothing else changes. A LangGraph agent that persists a thread, pauses for a human, streams to a screen and serves from FastAPI in Docker. An eval harness that fails a fluent wrong answer in CI. A failure log and a runbook you can bring to work on Monday. In short, a portfolio of AI agents an employer can run.

Who I built this for. The engineer whose company said build an agent for this by next quarter. The developer who finished a LangChain tutorial and does not know what happens when the tool call fails. The QA engineer or product manager who has to specify, test and approve an agent without owning the code. The beginner with basic Python who wants one honest path from the first loop to a deployed service, and does not want to buy four courses to get it.

How this bootcamp is different. Frameworks are not the lesson; the system is. You learn the loop before LangChain, the graph before LangGraph, and the harness before evals, so each tool lands on a picture you already hold. Model names live in a config file, not in lecture titles, because they change every quarter and your agent should not. Every screen you see is a real file and a real run. When a technique is the wrong tool, the lecture says so and shows you the door instead.

Kept current. The curriculum is rebuilt for LangChain 1.x and LangGraph 1.x, and the page shows the last update date at the top. Questions in the Q and A get answered, and the answers feed the next update.

Watch the free preview lectures, then start with Section 1. By the end of the first section you will have the repo running on your own machine, and by the end of the course you will own three agents you can show, explain and defend.

About your instructor. I am Pragati Kunwer. I have spent twenty years building software at companies like IBM and Nike, and I now teach AI agents, LangGraph and RAG full time. More than 30,000 learners have taken my Udemy courses, and this bootcamp has been rebuilt from the ground up on what those learners asked for: fewer slides, more real runs, and one repo they can keep. I teach the way I would explain a system to a colleague at the next desk: plain English, the picture first, then the file, then the run. If you get stuck, ask in the Q and A and I will answer.

Enroll now and start building the AI agent expertise that commands premium salaries and drives business transformation.