Agentic AI – Complete Course for Beginners
A chapter-by-chapter readback of the free course by Bappy (Data Science with Bappy) on freeCodeCamp.org.
- Foundations: From LLMs to Agents
- Engineering Prerequisites
- Building with LangChain
- LangGraph Workflows
- The Agentic Chatbot, Feature by Feature
- 11:35:51 · First Agentic Chatbot with LangGraph
- 12:43:49 · Why Persistence Matters
- 13:51:00 · Streaming Responses
- 14:10:02 · Chat Threading
- 14:42:02 · Permanent Memory with a Database
- 15:16:31 · Monitoring with LangSmith
- 15:40:24 · Integrating Tools
- 16:54:17 · RAG in the Agentic Chatbot
- 17:50:27 · Human-in-the-Loop
- Deployment & Capstone Projects
At 24 hours this is less a video than a curriculum — but it is structured like one: every chapter is a working agent you build and run, and the second half is a single chatbot that gains persistence, tools, RAG and human oversight chapter by chapter. You leave with projects, not just concepts.
- You know basic Python and want to move from calling LLM APIs to building agents
- You want one continuous course instead of a dozen disconnected LangChain tutorials
- You learn by building the same project bigger, chapter after chapter
- You have never written Python — finish a Python course first
- You want theory about agent architectures — this is a build-along
- 24 hours is too long right now — read our chapter guide and jump to what you need
- 24h 16m total, 26 chapters, average chapter ~56 minutes
- Instructor: Bappy; stack: LangChain, LangGraph, Pydantic, LangSmith, FastAPI, ChromaDB
- Second half builds one agentic chatbot, adding a feature per chapter
- Two capstone projects: a custom ChatGPT agent and TripMate, a multi-agent travel planner
- Companion GitHub repo is linked in the video description
The walkthrough
Each chapter below is our original written explanation of what happens at that moment in the video — a paraphrase, not a transcript. Click any timestamp to jump the player.
Foundations: From LLMs to Agents
Introduction & Planning
The instructor maps the full 24-hour journey: what you will build, the projects waiting at the end, and the skills assumed (basic Python). A sensible first watch to calibrate whether this course is your level.
Evolution from LLMs to Agentic AI
Why plain LLM calls stop being enough: no memory, no tools, no goal-directed loops. The chapter defines what makes a system 'agentic' — planning, tool use, and acting on feedback — with the vocabulary used for the rest of the course.
Agentic AI Core Characteristics & Components
A deeper pass on agent anatomy: reasoning loops, planning, memory types, and tool interfaces. The component diagrams here are the mental model every later chapter assumes.
Engineering Prerequisites
Asynchronous Programming for AI Agents
Agents make many overlapping network calls, so async/await is a prerequisite, not a nice-to-have. The chapter covers coroutines, awaiting multiple LLM calls, and the patterns LangChain itself relies on.
Pydantic Data Validation for AI Agents
Structured output is what turns an LLM's prose into usable program data. Pydantic models define the shapes agents must return, and validation catches malformed outputs before they crash a workflow.
Building with LangChain
Single AI Agent System with LangChain
The first end-to-end agent: an LLM wired to tools with a reasoning loop, built and run live. Seeing a single agent plan, call a tool and answer in one script is the course's first real payoff.
Multi-Agent AI System with LangChain
Multiple specialized agents handing work to each other — a researcher, a writer, a checker pattern. The chapter covers when multi-agent beats one big prompt and the orchestration overhead it adds.
LangGraph Workflows
LangChain vs LangGraph & Why Graphs
The pivot of the course: chains run straight through, graphs can loop, branch and pause. He shows where LangChain alone breaks down — multi-step stateful flows — and why LangGraph's state machine model exists.
LangGraph Core Components
Nodes, edges, and State: the three building blocks. The chapter walks the graph API with a minimal working graph so the next four workflow chapters read as variations, not new material.
Sequential Workflows
The simplest graph shape: nodes run in order, each receiving the state the previous one left. Presented as the backbone most real pipelines use.
Parallel Workflows
Branches that run at once and merge — useful when several independent analyses feed one final answer. Also covers the merge logic and its failure modes.
Conditional Workflows
Edges that choose the next node based on state — the feature that makes agents agentic. A routing example shows the graph deciding between tool calls and final answers.
Iterative Workflows
Loops with exit conditions: the classic agent cycle of act, observe, decide. Understanding when the loop stops is framed as the difference between a demo and a reliable system.
The Agentic Chatbot, Feature by Feature
First Agentic Chatbot with LangGraph
The course's spine project starts: a minimal chatbot as a LangGraph. From here to the end, every chapter adds one capability to this same application.
Why Persistence Matters
Without persistence, every restart forgets everything. Checkpointing state so conversations survive restarts — and why this is table stakes for anything real.
Streaming Responses
Tokens rendered as they arrive instead of after full generation. Covers the streaming API and the UI implications for any chat product.
Chat Threading
Multiple named conversations per user, each with its own checkpointed state — how ChatGPT-style threading is implemented on top of persistence.
Permanent Memory with a Database
Moving conversation memory from ephemeral checkpoints to a real database so history survives across deployments and devices.
Monitoring with LangSmith
Observability for agents: tracing every node execution, inspecting prompts and outputs, and debugging a graph step by step instead of guessing.
Integrating Tools
The chatbot gains the ability to call external tools — search, calculators, APIs — with tool schemas and the routing logic that decides when to call them.
RAG in the Agentic Chatbot
Retrieval-augmented generation joins the graph: documents are embedded into ChromaDB, retrieved per question, and injected as context. The chapter connects classic RAG pipelines to the agent loop.
Human-in-the-Loop
Pausing the graph to ask a human before irreversible or sensitive actions — approval gates inside the workflow. Framed as essential for anything that spends money or sends messages.
Deployment & Capstone Projects
CI/CD Deployment on AWS
Dockerizing the chatbot and shipping it with GitHub Actions: container builds, registry pushes and deployment to AWS, so the project leaves localhost.
Deploying on Render for Free
The zero-cost path: the same Docker image deployed to Render's free tier, useful for portfolios and prototypes without an AWS bill.
Project: Build Your Own ChatGPT Agent
The first capstone assembles nearly everything: an LLM agent with LangGraph orchestration, FastAPI serving, SQLAlchemy persistence, ChromaDB retrieval and LangSmith monitoring — a production-shaped codebase to study.
Project: TripMate AI Travel Planner
The final project: a multi-agent travel planner where specialized agents divide research, planning and formatting. It is the multi-agent chapter scaled into something you could genuinely extend and show to an employer.
Moment by moment
| Time | Why it matters |
|---|---|
| 41:26 | Core Characteristics & Components — the agent anatomy |
| 6:30:27 | LangChain vs LangGraph — the course's pivot |
| 10:15:27 | Conditional Workflows — where agents become agents |
| 11:35:51 | First Agentic Chatbot — the spine project starts |
| 17:50:27 | Human-in-the-Loop — safety in the loop |
| 22:21:17 | TripMate — the multi-agent capstone |
Do this next
- Pick one feature chapter (tools, RAG or HITL) and add it to your own mini-chatbot
- Work through the TripMate project with the companion repo open
- After finishing: read our guide on evaluating agent reliability — the next skill after building one
Common questions
Do I need to know LangChain before this course?
No — LangChain is taught from within the course. You do need intermediate Python: async/await is taught, but object-oriented comfort is assumed.
Is 24 hours really necessary?
Not all of it for everyone. The Foundations and LangGraph modules are the core; the chatbot feature chapters can be sampled based on what your project needs. Use the chapter guide to jump.
Does it cover frameworks other than LangChain/LangGraph?
No — the stack is LangChain, LangGraph, FastAPI, ChromaDB, LangSmith. Concepts transfer to CrewAI or OpenAI's Agents SDK, but the code does not.
Is there a certificate?
No certificate for the YouTube course itself. The companion GitHub repo plus the two capstone projects are the portfolio evidence.
Spot a mistake?
Every summary on this page was written by a person watching the course, and we still miss things. If a chapter summary gets a concept wrong or a timestamp drifts, tell us at support@readcast.dev and we will check the video and fix it — usually within a day.
More course guides
- SQL Tutorial – Full Database Course for BeginnersfreeCodeCamp.org · 4:20:36
- Learn Python – Full Course for BeginnersfreeCodeCamp.org · 4:27:21