🔥 BLACK FRIDAY SALE1 course ₹199·any 3 courses ₹399 for 3 months·ALL courses + 1 mock interview ₹599 for 6 monthsClaim offer →

Sections · Agentic AI (LangChain and LangGraph)

🕸️

Agentic AI (LangChain and LangGraph)

LIVE

Build reliable AI agents: tools, memory, RAG, multi-agent systems and production deployment.

A complete, hands-on path to building AI agents with LangChain and LangGraph: models, tools and structured output, memory and middleware, retrieval and agentic RAG, MCP, graphs, state and persistence, human-in-the-loop, streaming, multi-agent architectures, Deep Agents, LangSmith observability and evaluation, security and guardrails, deployment, real projects and interview preparation.

Agentic AI (LangChain and LangGraph)
₹500 ₹199

for 3 months · no auto-renewal

Black Friday offer: 1 course ₹199 · any 3 courses ₹399 for 3 months · all courses + 1 mock interview ₹599 for 6 months

Get this section
44in-depth lessons
22+hours of learning
340interview Q&As
4free lessons

What you will be able to do

  • ✓Build tool-using agents with LangChain and understand exactly what they do
  • ✓Add memory, context and structured output you can trust
  • ✓Control agents with middleware: limits, retries, PII handling and human approval
  • ✓Build RAG and agentic RAG systems and connect tools with MCP
  • ✓Model complex workflows as LangGraph graphs with durable state
  • ✓Pause for human approval, replay and fork runs with persistence
  • ✓Design multi-agent systems and use Deep Agents for long tasks
  • ✓Trace, evaluate, secure and deploy agents to production

Who this is for

  • Python developers building AI features
  • Engineers moving from chatbots to agents
  • Teams who need agents that are reliable, observable and safe

What you need first

Working Python (the free Python lessons will get you there). No prior AI experience needed.

Hands-on projects

  • A customer-support agent with approvals
  • A multi-agent research assistant
  • An incident-triage agent for DevOps teams

Full curriculum: what you will learn, topic by topic

44 topics across 6 tracks. Open a track to see every topic and what it teaches.

🧠 Agent Foundations7 topics

What agents are, the LangChain and LangGraph ecosystem, models, messages, tools and your first agent.

1What Is Agentic AI? Agents, Workflows and Chatbots ExplainedUnderstand what an AI agent really is, how it differs from a chatbot or a fixed workflow, the loop that powers every agent, the levels of autonomy, why agents fail in production, and a decision framework for when to build one.Foundation · 24 minFREE2The LangChain and LangGraph Ecosystem Map: Frameworks, Runtimes and HarnessesA guided tour of the LangChain ecosystem. Learn what LangChain, LangGraph, Deep Agents, LangSmith and the Agent Server each do, how the packages fit together, how a request flows through them, and a simple rule for choosing the right layer.Foundation · 22 minFREE3Set Up Your Agent Lab and Make Your First Model Call with LangChainBuild a clean Python environment with uv, manage API keys safely, call a chat model with init_chat_model, and learn invoke, stream, batch, model parameters, token usage, retries, rate limiting and tracing, the foundation for every agent you will build.Foundation · 25 minFREE4LangChain Messages, Prompts and Content Blocks: System, Human, AI and Tool Messages, Multimodal Input and Streaming ChunksUnderstand the data every model call is made of. Learn the four message types and the dictionary format, content as strings versus content blocks, standard block types (text, reasoning, images, files, tool calls), multimodal input, tool_calls and ToolMessage artifacts, usage and response metadata, streaming with AIMessageChunk, prompt design and templates, serialisation safety, and message-history rules that prevent API errors.Intermediate · 26 min🔒 Paid5How Tool Calling Really Works: Messages, JSON Schemas and the Execution LoopLook inside tool calling. Learn the message protocol (AIMessage tool_calls and ToolMessage ids), how a Python function becomes a JSON schema the model sees, parallel calls and tool_choice, writing the loop by hand, and the design rules that make tools reliable, safe and cheap.Intermediate · 32 min🔒 Paid6Inside create_agent: The Agent Graph, State, Context and the Execution ModelOpen the hood of create_agent. Understand the graph it builds (model node, tools node and middleware hooks), the AgentState and its message reducer, runtime context versus state versus config, threads and checkpointers, recursion limits, result shapes and how to read an agent run step by step.Intermediate · 33 min🔒 Paid7Structured Output for Reliable Agents: Pydantic Schemas, Strategies and Error HandlingTurn free-form model text into validated objects. Learn with_structured_output, create_agent response_format, how ToolStrategy and ProviderStrategy work under the hood, schema design with Pydantic, union types, validation retries, refusals and the patterns (extraction, classification, routing) that make agents dependable.Intermediate · 30 min🔒 Paid
⛓️ LangChain Agents in Depth10 topics

Context, memory, middleware, human approval, streaming, RAG, agentic RAG and MCP.

1Short-Term Memory and Context Management: Checkpointers, Trimming and SummarisationMake agents remember without drowning in tokens. Learn how thread-level memory works with checkpointers, how the context window fills up, how to trim, delete and summarise messages safely (including the tool-call pairing rule), configure SummarizationMiddleware and context editing, and choose a persistent store for production.Intermediate · 32 min🔒 Paid2LangChain Runtime, Context and ToolRuntime: Pass User, Tenant and Services to Tools and Middleware SafelyLearn how an agent run carries dependencies. Understand context versus state versus store, define a context_schema and pass context at invoke time, read it from tools with ToolRuntime and from middleware with Runtime, write dynamic prompts from context, stream custom progress, use execution info, and design secure, testable tools that never trust the model for identity.Advanced · 28 min🔒 Paid3Long-Term Memory for AI Agents with LangGraph Stores: Namespaces, Semantic Search and Production PatternsGive agents memory that outlives a conversation. Learn the store interface (namespaces, keys, put, get, search), how tools read and write memory through the runtime, semantic search with embeddings, memory types (profile, facts, episodes), when to write memories, consolidation and forgetting, Postgres in production, and privacy, safety and evaluation.Advanced · 30 min🔒 Paid4LangChain Agent Middleware Fundamentals: Hooks, Wrap Calls, Custom State and Execution OrderAdd behaviour around every step of an agent without rewriting it. Learn the agent loop, the six middleware hooks (before_agent, before_model, wrap_model_call, wrap_tool_call, after_model, after_agent), decorator versus class style, extending state, jump_to for early exits, request.override, execution order, and build limits, retries, dynamic model choice and logging.Advanced · 30 min🔒 Paid5LangChain Built-in Middleware: Summarization, Retries, Fallbacks, Call Limits, PII and Context EditingUse the ready-made middleware instead of rewriting it. Learn SummarizationMiddleware, ModelRetryMiddleware and ToolRetryMiddleware, ModelFallbackMiddleware, ModelCallLimitMiddleware and ToolCallLimitMiddleware, PIIMiddleware, ContextEditingMiddleware, LLMToolSelectorMiddleware and TodoListMiddleware, with parameters, ordering and a production-ready stack.Advanced · 30 min🔒 Paid6Human-in-the-Loop for AI Agents: Approve, Edit and Reject Tool Calls with Interrupts and CheckpointsPut a person in control of risky actions. Learn how HumanInTheLoopMiddleware pauses a run, what the interrupt contains, the approve, edit, reject and respond decisions, resuming with Command and the same thread, batched versus per-call modes, conditional approvals, building a review UI and API, timeouts and audit logging, and testing approval flows.Advanced · 28 min🔒 Paid7Streaming AI Agents in LangChain: Tokens, Tool Calls, Progress Updates and Custom EventsMake agents feel fast and transparent. Learn why streaming matters, the stream modes (updates, messages, custom), the newer event-streaming API, streaming tokens and partial tool-call arguments, custom progress with the stream writer, combining modes, streaming reasoning tokens, human-in-the-loop streams, serving agent streams over HTTP with server-sent events, and error and cancellation handling.Advanced · 28 min🔒 Paid8RAG from Scratch with LangChain: Loading, Chunking, Embeddings, Vector Stores, Retrieval and Grounded AnswersGround model answers in your own documents. Learn the RAG pipeline end to end: loading, splitting with RecursiveCharacterTextSplitter, embeddings, vector stores and similarity search, building a retrieval tool for an agent and a two-step chain, citations and source metadata, chunking and top-k tuning, indexing in production, security of retrieved text, and evaluating retrieval and answer quality.Advanced · 30 min🔒 Paid9Agentic and Hybrid RAG: Query Planning, Multi-Step Retrieval, Hybrid Search, Re-ranking and Self-CorrectionGo beyond one-shot retrieval. Learn agentic RAG (an agent that decides when and what to retrieve, rewrites queries, uses several tools and checks sufficiency), hybrid search combining keyword and vector scores, query transformation, re-ranking, corrective and self-reflective loops in LangGraph, routing across sources, and how to evaluate, bound and secure these systems.Advanced · 30 min🔒 Paid10MCP Tool Integration for LangChain Agents: Model Context Protocol Servers, Transports, Authentication and SafetyConnect agents to external tools through the Model Context Protocol. Learn what MCP is (servers, clients, tools, resources, prompts), transports (stdio, streamable HTTP, in-memory), loading MCP tools into a LangChain agent, building a small MCP server, multi-server setups, authentication and per-user credentials, trust and security risks (tool poisoning, confused deputy), observability, testing and operations.Advanced · 26 min🔒 Paid
🕸️ LangGraph Fundamentals11 topics

State, nodes and edges, routing, workflow patterns, persistence, interrupts, time travel and subgraphs.

1LangGraph Fundamentals: State, Nodes, Edges and the Super-Step Execution ModelLearn how LangGraph models an application as a graph over shared state. Build graphs with StateGraph, understand how nodes return updates, how edges and conditional edges route work, how super-steps and reducers execute parallel branches, and when to choose LangGraph over create_agent.Intermediate · 32 min🔒 Paid2LangGraph State Design and Reducers: Schemas, add_messages, Parallel Updates and Input/Output BoundariesDesign the state that every node reads and writes. Learn TypedDict and dataclass schemas, how updates are merged, reducers (operator.add, add_messages and custom), why parallel branches need them, private and input/output schemas, keeping state small and serialisable, versioning state for persisted threads, and testing nodes as pure functions.Advanced · 28 min🔒 Paid3LangGraph Routing: Conditional Edges, Send Fan-Out and Command (update + goto)Control where a graph goes next. Learn static versus conditional edges, routing functions and path maps, LLM-based routing with structured output, Send for runtime fan-out (map-reduce), Command for combining a state update with navigation, navigating from subgraphs to the parent, loops with limits, and how to test and visualise routing.Advanced · 28 min🔒 Paid4LLM Workflow Patterns in LangGraph: Prompt Chaining, Parallelisation and Routing, Workflows versus AgentsLearn the reusable building blocks of LLM applications. Understand workflows versus agents, and implement prompt chaining with gates, parallelisation (sectioning and voting), and routing in LangGraph with complete examples, plus how to choose, test, evaluate and combine patterns, with trade-offs in cost, latency and reliability.Advanced · 28 min🔒 Paid5Orchestrator-Worker and Evaluator-Optimizer Workflows in LangGraph: Plan, Fan Out, Synthesise and RefineBuild two advanced workflow patterns. Orchestrator-worker plans subtasks at run time and fans out workers with Send, then synthesises; evaluator-optimizer generates, critiques and refines in a bounded loop. Includes structured plans and critiques, reducers, limits, stopping criteria, cost control, evaluation and when each pattern earns its complexity.Advanced · 30 min🔒 Paid6Build a ReAct Agent from Scratch in LangGraph: Tool Calling Loop, ToolNode, Limits and Error HandlingRecreate the agent loop by hand to understand what create_agent does. Build the model node, the tools node and the routing edge, manage messages with MessagesState, bind tools, handle tool errors, add step limits and a system prompt, stream and test the loop with a fake model, then compare with the prebuilt agent and know when to customise.Advanced · 28 min🔒 Paid7LangGraph Persistence and Durable Execution: Checkpointers, Threads, State History and Crash RecoveryMake agent runs survive restarts, long pauses and failures. Learn checkpoints and threads, checkpointers (in-memory, SQLite, Postgres), get_state and get_state_history, StateSnapshot fields, update_state, durability modes, idempotent nodes, serialisation and encryption, retention and cleanup, stores versus checkpointers, and operating persistence in production.Advanced · 28 min🔒 Paid8LangGraph Interrupts and Human-in-the-Loop: interrupt(), Command(resume), Review Patterns and Safe ResumptionPause a graph for a person and continue exactly where it stopped. Learn the interrupt function and its requirements, resuming with Command(resume=...), patterns for approve or reject, review and edit, tool-call approval and input validation, multiple parallel interrupts, the rules (node restarts, no broad try/except, stable ordering, idempotency), and building a reviewable workflow service.Advanced · 28 min🔒 Paid9LangGraph Time Travel and Forking: Replay, Branch and Debug Agents from Past CheckpointsRewind and explore agent runs. Learn how checkpoints enable time travel, finding a checkpoint with get_state_history, replaying from it, forking with update_state and as_node, how interrupts and subgraphs behave, what re-executes (and costs money), practical debugging, what-if analysis and test setup workflows, and the caveats that surprise people.Advanced · 24 min🔒 Paid10LangGraph Subgraphs and Modular Design: Reusable Graphs, State Mapping, Checkpointing and NamespacesStructure large agent systems from reusable parts. Learn the two ways to use a subgraph (a node that calls it, or a compiled graph added as a node), mapping between state schemas, checkpointer modes (per-invocation, per-thread, stateless), interrupts and streaming inside subgraphs, namespaces and inspecting subgraph state, design guidelines for team boundaries, testing and versioning.Advanced · 26 min🔒 Paid11LangGraph Streaming Modes and Events: values, updates, messages, custom, checkpoints, tasks and debugChoose the right stream for each job. Learn the stream modes (values, updates, messages, custom, checkpoints, tasks, debug), the unified v2 chunk format, streaming LLM tokens with tag and node filters, custom events with the stream writer, subgraph namespaces, async streaming, event streaming projections, building chat and progress UIs and observability feeds, and common mistakes.Advanced · 24 min🔒 Paid
👥 Multi-Agent Systems5 topics

Supervisors, handoffs, routers, skills and Deep Agents for planning, files and subagents.

1Multi-Agent Architectures with LangChain and LangGraph: Subagents, Handoffs, Skills and Routers ComparedLearn when several agents help and when they only add cost. Compare the four main patterns (subagents, handoffs, skills, router) and custom LangGraph workflows on control, latency, token cost and user experience, with a decision framework, failure modes and a way to evolve from one agent to many safely.Advanced · 28 min🔒 Paid2Supervisor and Subagents in LangChain: Wrap Agents as Tools, Isolate Context and Return Structured ResultsBuild the supervisor pattern step by step. Wrap specialist agents as tools, write routing-friendly names and descriptions, choose isolated or forked context, return results with Command, run background subagents, use a single dispatch tool, and test, trace and budget a delegating system.Advanced · 30 min🔒 Paid3Handoffs in LangChain: State-Driven Multi-Agent Workflows with Command, Middleware and SwarmsBuild handoff-based agents where the active agent changes as the conversation progresses. Learn how a state variable drives the system prompt and tools, how tools return Command to transition, how to guard transitions, design a support triage flow, avoid loops, and extend to swarm-style agent-to-agent transfer.Advanced · 30 min🔒 Paid4Router and Skills Patterns for AI Agents: Fan-Out with LangGraph Send and On-Demand Skill LoadingLearn two lightweight multi-agent patterns. Build a router that classifies a query, fans it out to specialised agents in parallel with LangGraph Send, and synthesises one answer; and build a skills system with progressive disclosure through a load_skill tool and middleware, with the token trade-offs, testing and when to choose each.Advanced · 30 min🔒 Paid5Deep Agents: Planning, a Virtual File System and Subagents for Long-Running TasksLearn what the Deep Agents harness adds on top of LangChain and LangGraph for complex, multi-step work. Understand planning with todos, file-based context offloading, the task tool for subagents, memory with AGENTS.md, summarisation, permissions and approvals, build a research agent with create_deep_agent, and decide when to use it instead of create_agent or a custom graph.Advanced · 30 min🔒 Paid
🚀 Production, Evaluation and Security6 topics

LangSmith observability, evaluation and testing, guardrails, cost and reliability, deployment.

1Observability for AI Agents with LangSmith: Tracing, Metadata, Debugging and Production MonitoringSee what your agents actually do. Learn what a trace contains, how to enable LangSmith tracing for LangChain and LangGraph with environment variables, add the traceable decorator, tags, metadata and run names, debug failures from traces, track cost and latency, build feedback loops, and design a monitoring practice for production agents.Advanced · 28 min🔒 Paid2Evaluating AI Agents: Datasets, Evaluators, LLM Judges, Trajectories and Experiments with LangSmithMeasure agent quality instead of guessing. Learn what to evaluate (outcomes, trajectories, tool use, safety, cost), building representative datasets from real traffic, code evaluators and LLM-as-judge evaluators with rubrics and calibration, trajectory and tool-call checks, running experiments and comparing versions, offline versus online evaluation, statistics and regression gates, and common evaluation mistakes.Advanced · 30 min🔒 Paid3Testing AI Agents: Unit Tests, Fake Models, Recorded Runs, Contract Tests and Safe Integration TestsTest non-deterministic systems deterministically. Learn the agent test pyramid, unit testing tools, prompts and routers, scripted fake chat models and tool doubles, testing middleware and graphs, record-and-replay of model calls, contract and schema tests, property-based and adversarial tests, integration tests with real models under budget, flaky-test strategies and CI organisation.Advanced · 28 min🔒 Paid4Guardrails and Prompt-Injection Defence for AI Agents: Threat Model, Controls and MiddlewareSecure tool-using agents. Learn the threat model (direct and indirect prompt injection, data exfiltration, excessive agency), the lethal trifecta, defence in depth with least privilege, input and output guardrails, PII handling, human approval, sandboxing and allow-lists, how to implement them as LangChain middleware, and how to test your defences.Advanced · 30 min🔒 Paid5Cost, Latency and Reliability for AI Agents: Token Budgets, Caching, Model Routing, Retries, Fallbacks and SLOsRun agents economically and dependably. Learn where cost and latency come from (tokens, calls, tools, context growth), measuring and budgeting, prompt and result caching, smaller models and routing, trimming and summarising context, parallelism and streaming, timeouts, retries with back-off, fallbacks and circuit breakers, rate limits, idempotency, graceful degradation, SLOs and incident handling.Advanced · 28 min🔒 Paid6Deploying AI Agents: Agent Servers, langgraph.json, Docker, Persistence, Scaling, Security and Release PracticeTake an agent from a notebook to a production service. Learn deployment shapes (embedded in your API, a dedicated agent server, a managed platform), the langgraph.json configuration, running locally with the dev server, the threads, runs and assistants model, packaging with Docker, durable checkpointers and stores, background and long-running runs, scaling and concurrency, secrets and configuration, authentication, observability, CI/CD with evaluation gates, and rollout and rollback strategies.Advanced · 28 min🔒 Paid
🛠️ Projects and Interview5 topics

Four end-to-end agent projects and interview scenarios with system design.

1Project: Build a Customer Support Agent with LangChain and LangGraph (RAG, Handoffs, Approvals, Evaluation)Build a complete support agent end to end. Combine a retrieval tool over policy documents, per-customer order tools, handoff-style steps, human approval for refunds, structured outputs, a persistent checkpointer, tracing and an evaluation suite, then review security and cost. A capstone for the agent track with a clear architecture and tests.Advanced · 45 min🔒 Paid2Project: Build a Research Assistant Agent with Planning, Parallel Subagents, Citations and EvaluationBuild a research assistant that plans a task, searches several sources in parallel with subagents, keeps notes in files instead of the prompt, verifies claims against sources, and writes a cited report. Covers architecture, the plan-and-execute graph, source tools with budgets, citation tracking, claim verification, human review, evaluation with a rubric, cost control and safety against injected web content.Advanced · 45 min🔒 Paid3Project: Build a Safe SQL Data Analyst Agent with Schema Retrieval, Query Validation and Read-Only GuardrailsBuild a natural-language data analyst for a SQL database. Covers architecture, schema discovery and retrieval for large schemas, generating queries with a validator loop, a read-only and row-limited execution layer, SQL parsing and allow-listing, handling errors and ambiguity, result summarisation and charts, row-level permissions, prompt-injection and data-exfiltration defences, evaluation with execution accuracy, and operations.Advanced · 45 min🔒 Paid4Project: DevOps Incident Triage Agent with Alert Context, Runbooks, Read-Only Diagnostics and Human ApprovalBuild an on-call assistant that receives an alert, gathers context (metrics, logs, deploys, runbooks, past incidents), forms ranked hypotheses with evidence, proposes next steps and drafts updates, while only taking read-only actions automatically and requiring human approval for any change. Covers architecture, tool design, triage graph, evidence handling, safety tiers, evaluation with replayed incidents, integration with paging and chat, and operational guardrails.Advanced · 45 min🔒 Paid5Agentic AI Interview Scenarios: Questions, System Design Cases and Model Answers for Agent EngineersPrepare for agent engineering interviews. Covers fundamentals (agents versus workflows, tool calling, memory), LangChain and LangGraph specifics, RAG, evaluation, security and reliability questions with model answers, eight system-design scenarios with structured approaches and trade-offs, whiteboard exercises, red flags interviewers look for, and a self-assessment checklist.Advanced · 36 minFREE
Start here · no payment needed

Start free with Agentic AI (LangChain and LangGraph)

Learn what agents really are, how the LangChain and LangGraph ecosystem fits together, and build your first agent.

  1. 1What Is Agentic AI? Agents, Workflows and Chatbots ExplainedUnderstand what an AI agent really is, how it differs from a chatbot or a fixed workflow, the loop that powers every agent, the levels of autonomy, why agents fail in production, and a decision framework for when to build one. · 24 min
  2. 2The LangChain and LangGraph Ecosystem Map: Frameworks, Runtimes and HarnessesA guided tour of the LangChain ecosystem. Learn what LangChain, LangGraph, Deep Agents, LangSmith and the Agent Server each do, how the packages fit together, how a request flows through them, and a simple rule for choosing the right layer. · 22 min
  3. 3Set Up Your Agent Lab and Make Your First Model Call with LangChainBuild a clean Python environment with uv, manage API keys safely, call a chat model with init_chat_model, and learn invoke, stream, batch, model parameters, token usage, retries, rate limiting and tracing, the foundation for every agent you will build. · 25 min
  4. 4Agentic AI Interview Scenarios: Questions, System Design Cases and Model Answers for Agent EngineersPrepare for agent engineering interviews. Covers fundamentals (agents versus workflows, tool calling, memory), LangChain and LangGraph specifics, RAG, evaluation, security and reliability questions with model answers, eight system-design scenarios with structured approaches and trade-offs, whiteboard exercises, red flags interviewers look for, and a self-assessment checklist. · 36 min
Create a free account to track progress

Learn it. Practise it. Prove it.

Questions, answered

Which models does it use?

Any. LangChain gives one interface, so examples work with Anthropic, OpenAI, Google and local models.

Is the content current?

Yes. It follows the current LangChain and LangGraph documentation, including create_agent and middleware.

Is it only theory?

No. Every lesson has runnable code and a lab, and the course ends with full projects.

Also available