AI COURSE GUIDE

Agentic AI – Complete Course for Beginners

A chapter-by-chapter readback of the free course by Bappy (Data Science with Bappy) on freeCodeCamp.org.

Length24:15:52
Chapters26
Modules6

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.

Who it's for
Read this guide if
  • 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
Skip ahead if
  • 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
In brief
  • 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

0:00

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.

8:33

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.

41:26

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

1:33:18

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.

2:06:23

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

3:27:08

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.

4:49:37

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

6:30:27

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.

7:44:43

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.

8:29:07

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.

9:19:04

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.

10:15:27

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.

11:06:05

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

11:35:51

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.

12:43:49

Why Persistence Matters

Without persistence, every restart forgets everything. Checkpointing state so conversations survive restarts — and why this is table stakes for anything real.

13:51:00

Streaming Responses

Tokens rendered as they arrive instead of after full generation. Covers the streaming API and the UI implications for any chat product.

14:10:02

Chat Threading

Multiple named conversations per user, each with its own checkpointed state — how ChatGPT-style threading is implemented on top of persistence.

14:42:02

Permanent Memory with a Database

Moving conversation memory from ephemeral checkpoints to a real database so history survives across deployments and devices.

15:16:31

Monitoring with LangSmith

Observability for agents: tracing every node execution, inspecting prompts and outputs, and debugging a graph step by step instead of guessing.

15:40:24

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.

16:54:17

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.

17:50:27

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

18:48:09

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.

19:52:05

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.

20:06:27

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.

22:21:17

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

TimeWhy it matters
41:26Core Characteristics & Components — the agent anatomy
6:30:27LangChain vs LangGraph — the course's pivot
10:15:27Conditional Workflows — where agents become agents
11:35:51First Agentic Chatbot — the spine project starts
17:50:27Human-in-the-Loop — safety in the loop
22:21:17TripMate — the multi-agent capstone

Do this next

  1. Pick one feature chapter (tools, RAG or HITL) and add it to your own mini-chatbot
  2. Work through the TripMate project with the companion repo open
  3. 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