Mastering Intelligent Agents: A Deep Dive into Building Agentic AI Systems

This module will cover the essentials of Generative AI as a nice recap or refresher for everyone to be on the same foundational level and then we will dive into the essential concepts and components of both RAG & Agentic AI Systems. 

• Whirlwind tour of Generative AI 

• Recap of Prompting LLMs & RAG Systems 

• Basic Intro to LangGraph 

• Hands-on Demo: Building a Consumer Credit Knowledge Assistant with RAG - LangChain & LangGraph 

• Introduction to Agentic AI Systems 

• Key components of Agentic AI Systems - LLM, Tools & Skills, Memory, Prompts, Harness 

• Tool Calling or Function Calling - the workhorse of Agentic AI Systems 

This module builds on the tool-calling aspects from the previous module and teaches you how to build simple tool-use ReAct Agents using LangChain, LangGraph and the ReAct pattern. You will start with the fastest path - a prebuilt agent in a single line - then build the same kind of agent by hand in LangGraph so nothing about it stays hidden. You will also learn about Skills as a way to give an agent durable, curated knowledge that does not belong in a prompt. 

• Hands-on Demo: Build a Credit Card Operations Assistant - Tool-Use ReAct Agent with LangChain 

• Introduction to LangGraph and key components for Agents - State, Nodes, Edges, Reducers, Tool Nodes 

• Introduction to Skills - giving agents curated knowledge that lives in version control, not in prompts 

• Where guardrails belong - asking a model to behave versus making the graph enforce it 

• Hands-on Demo: Build a Banking Text2SQL Data Assistant from scratch using LangGraph + DB Skill 

Design memory-aware agents that hold a conversation. This module covers short-term versus long-term memory, threads and checkpoints, and what to do when a conversation outgrows the context window. You will rebuild the agent from Module 2 by hand in LangGraph - this time with conversational memory, a structural guardrail, and history-aware retrieval & tool calling - so you can see exactly what turns a single-shot agent into one that remembers. 

• Introduction to short-term and long-term memory - and which problem each one actually solves

• Threads, checkpoints and memory stores - how LangGraph persists a conversation between turns

• Managing memory limits and context engineering strategies

• Hands-on Demo: Rebuild the Card Operations Assistant from scratch in LangGraph - Add Conversational Memory and a Structural Guardrail to that agent

This module focuses on the design patterns that separate a working agent from a scalable one. You will see why loading everything an agent might need does not survive contact with a real schema, and build an agent that decides what context to load per request using dynamic skill loading. You will then move from one agent to building multi-agent systems, where each agent has specific role and functions. 

• Key Design Patterns for Architecting Agentic AI Systems - Tool-Use, Planning, Reflection, Multi-Agent Systems 

• Dynamic Context Engineering - why static context does not scale, and progressive disclosure as the fix 

• Hands-on Demo: Build a Dynamic Context Engineering powered Banking Text2SQL Agent - loading only the schema each question needs, with a reflection-powered review loop 

• Understanding Multi-agent design patterns 

• Hands-on Demo: Build a Multi-Agent System for Clinical Utilization Review - specialist agents that assemble evidence for a human reviewer

Combine retrieval with agents so a query reaches the right data, the right tools and the right prompt. You have already learned how to use RAG inside Agents as tools, here you will learn other Agentic RAG patterns and build a customer support system that routes queries to dedicated RAG workflows or straight to a human. You will then move to multimodal agents, reading invoices and receipts as images and PDFs and coordinating specialist agents to extract, validate, store and pay them. 

• Key Design Patterns for Architecting Agentic RAG Systems - RAG as Agent tools, Router RAG, Adaptive RAG, Corrective RAG etc

• Hands-on Demo: Build a Router Agentic RAG System for Customer Support

• Multimodal Agents - how they are different from regular Agents

• Hands-on Demo: Build a Multimodal Multi-Agent System for Invoice Processing - extract, structure and store invoices from mixed images and PDFs

This module takes one of the agents you have already built and ships it - as a web service with a real HTTP interface, a small web UI, and tracing turned on. You will then evaluate it properly, against a dataset with verified ground truth, and see how to build your own evaluation framework for end-to-end Agentic evals. 

• Key workflow for Building → Deploying → Monitoring → Evaluating an end-to-end Agentic AI System 

• Monitoring and tracing with LangSmith - every node, tool call and LLM call 

• Hands-on Demo: Wrap the Banking Text2SQL Agent in a Web Service API using FastAPI - request/response and streaming, plus a simple frontend UI 

• Hands-on Demo (contd.): Deploy the Agentic API in the Cloud from Google Colab 

• Hands-on Demo (contd.): Monitor Agent traces and track latency, errors, costs via LangSmith 

• Why off-the-shelf eval libraries only get you part of the way - and how to build your own Agent evaluation framework 

• Hands-on Demo: Build a Custom Evaluation Framework for the Agent - scoring safety, tool calls, trajectory, context selection, cost, query quality and answer correctness, using deterministic checks, LLM-as-judge, Chain of Thought and Graph-based hybrid approaches 

• Future Scope: Next Steps and Best Practices

Two topics that are not as prevalent when building agents in the industry but are worth your time, and two more notebooks to take home. Long-term memory is what makes an agent remember a user across sessions rather than just across turns. MCP is how an agent gets tools from systems it was never integrated with and enables ease of access and sharing. 

• Short-term versus long-term memory in practice - threads and checkpoints for a conversation, namespaced stores for a user 

• Notebook: Build a Multi-User, Multi-Session Adaptive AI Tutor with LangGraph and LangMem - an agent that remembers preferences, goals and context across sessions, with complete isolation between users 

• Understanding Model Context Protocol - and when do you really need it? 

• Notebook: Build a Multi-Department MCP Architecture for a Cross-Functional Enterprise Agent - Finance and HR servers exposing their own tools, and one agent that discovers all of them at runtime