AI Agents Bootcamp: LangChain, LangGraph, RAG & MCP [2026] (Udemy.com)

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.