Agentic AI Masterclass: Build Autonomous AI Agents with Tool

⚠️ Most AI courses teach how to use LLMs.

This module teaches how LLMs actually work under the hood. I

n Module 2 of the Agentic AI Masterclass, we take a deep dive into the internal mechanics of Large Language Models (LLMs), embeddings, and prompt engineering—the core building blocks behind modern agentic AI systems.

You’ll clearly understand how:

• Tokens, context windows, and attention shape LLM behavior

• Embeddings convert text into semantic vector representations

• Semantic search and retrieval work in AI systems

• Prompt engineering directly influences reasoning, memory, and tool usage

• Agentic workflows rely on embeddings and prompts for accuracy and reliability

• This module forms the technical backbone for building intelligent AI agents, RAG pipelines, and multi-agent systems.   

Chapters:

00:00 – Why Understanding LLM Internals Matters

02:20 – Tokens, Context & Attention Explained

08:40 – How LLMs Generate Responses

14:30 – What Are Embeddings

20:10 – Semantic Search & Vector Similarity

27:50 – Prompt Engineering Fundamentals

34:40 – Prompts for Agentic AI

41:30 – What Comes Next

Module 3: LangChain Components & Agent Loops | Agentic AI Masterclass

Welcome to Day 3 of the PurpleSkill Agentic AI Masterclass!

In today’s session, you will learn the core architecture of Agentic AI: understanding the Agent Loop and mastering LangChain components.

If you want to build AI agents that can think, act, and solve problems autonomously, this module is your essential foundation.

What You Will Learn Today:

•   The Agent Loop Explained What is an agent loop? (Perception → Reasoning → Action → Evaluation) How loops enable autonomous AI decision-making. Real-world examples of multi-step agent workflows.

•   LangChain Fundamentals for Developers Why top developers use LangChain for Agentic systems. Improving LLM apps, RAG pipelines, and complex workflows.

• LangChain Core Components (Deep Dive) We break down the full architecture with practical examples: LLMs & Prompt Templates: The brain and instructions. Chains & Agents: Structuring logic and autonomy. Tools & Memory: Giving your agent capabilities and context. Retrievers & Vector Stores: Connecting to custom data.

•   Building Your First Workflow Step-by-step process to build AI agents using LangChain: Define Task → Template → Model → Tools → AgentExecutor → Loop.

⏱️ Chapters:

0:00 – Introduction to Agentic AI

1:20—What is an Agent Loop? (Perception-Action Cycle)

8:45 – LangChain Basics: Why use it?

15:10 – LangChain Core Components (LLMs, Agents, Tools)

35:20 – LangChain Workflow Breakdown

55:00 – Summary & Day 4 Preview

In this deep-dive session, you learn the "brain" and "hands" of an autonomous agent.

We move beyond simple prompts to master the ReAct Framework (Reasoning + Acting), enabling LLMs to use Tools and retain memory for complex problem-solving.

This is essential knowledge for building agents that can actually do things, not just talk.

What You Will Learn :

•   Tools: The "Hands" of AI What are Tools in LLM agents? API tools vs. Function Calling vs. Custom Tools. How to connect an LLM to the outside world (Search, Calculators, APIs).

•   Memory: The "Context" of AI Short-term vs. Long-term vs. Vector Memory. Why memory is critical for multi-turn conversations. How RAG (Retrieval Augmented Generation) acts as external memory.

•   The ReAct Framework (Reasoning + Acting) Concept: How LLMs alternate between Thought, Action, and Observation. The Loop: Perception → Reasoning → Action → Evaluation. Why "Chain of Thought" isn't enough for autonomous agents.

•   Building the Agent Workflow Step-by-step breakdown of a Tool-using Agent Loop. Real-world architecture using LangChain and Azure AI.

⏱️ Chapters:

0:00 – Introduction: The Brain & Hands of AI

2:15 – What are AI Tools? (Function Calling)

12:30 – AI Memory Explained (Short-term vs Vector)

24:45 – The ReAct Framework Deep Dive

38:00 – How the Agent Loop Works (Step-by-Step)

52:10 – Summary & Next Steps for Day 5

In this advanced session, we move beyond single agents to explore Multi-Agent Systems.

You will learn the 7 critical workflow patterns used to orchestrate autonomous AI agents, from simple sequential chains to complex, self-correcting hierarchies.

These patterns are the building blocks of modern systems like LangGraph, Copilot, and Azure AI Agents.

What You Will Learn Today (7 Core Patterns):

•   Sequential Workflow Step-by-step execution logic (Chain of thought). Best for deterministic, linear pipelines.

•   Hierarchical Workflow (Manager-Worker) Parent–child agent delegation. How a "Manager" agent oversees specialized "Worker" agents.

• Dynamic Decision Making: Condition-based routing (If/Else logic for AI). Real-time task selection based on input complexity.

•   Parallel Processing: Running multiple agents simultaneously (Map-Reduce). Speeding up execution by parallelizing independent tasks.

• Dynamic Handoff Coordination between specialized agents. When and how one agent passes control to another.

•   Self-Correction Loops Agents evaluating their own output (Reflection). Reducing errors through iterative improvement.

• Auction-Based Delegation: Advanced market-based task assignment. Multiple agents "bidding" for a task based on confidence/capability.

  
  

⏱️ Chapters:

0:00 – Introduction to Multi-Agent Systems

2:15 – Pattern 1: Sequential Workflow (Linear Chains)

8:45 – Pattern 2: Hierarchical Workflow (Manager-Worker)

18:30 – Pattern 3: Dynamic Decision Routing

28:15 – Pattern 4: Parallel Processing (Map-Reduce)

36:40 – Pattern 5: Dynamic Handoffs

45:20 – Pattern 6: Self-Correction & Reflection

52:10 – Pattern 7: Auction-Based Delegation

58:00 – Summary & Next Steps

Up until now, your agents were intelligent but isolated. Today, we make them useful.

In this module, we teach you how to bridge the gap between AI and the real world using APIs, webhooks, and external tools.

You will learn how to make your agents fetch live data, trigger real-world actions, and operate like production-grade software.

What You Will Learn Today:

• API Fundamentals for AI: What are REST APIs? (GET, POST, and JSON explained). Why modern AI systems depend on APIs for live data. Using the Python requests library to interact with the web.

•   Advanced Integration Patterns Chain API Calls: Using the output of one API as the input for another. Webhooks vs. Polling: When to listen for events vs. when to ask for updates. Tools vs. Requests: Knowing when to use a defined tool vs. a raw API request.

• Real-World Hands-On Examples: We build live integrations with the GitHub API, automating developer workflows. Weather & Maps: Location-based decision-making. Wikipedia & News: Scraping live information for context.

• Production Best Practices (Critical) Security: Handling API keys, OAuth, and Environment Variables. Reliability: Implementing exponential backoff and retry logic. Mocking: How to test agents without burning API credits.

  
  

⏱️ Chapters:

0:00 – Introduction: Making Agents "Production-Ready"

2:10 – API Fundamentals (REST, JSON, HTTP)

10:45 – Using Python requests (GET/POST)

18:30 – The Chain API Call Pattern (Multi-step Logic)

28:15 – Live Demo: GitHub & Weather API Integration

42:00 – Webhooks vs. Polling Strategies

50:30 – Security: API Keys & Environment Variables

58:15 – Handling Errors: Exponential Backoff & Retries

1:05:00 – Summary & Next Steps

In this critical module, we open the "black box" of AI decision-making.

We move beyond generic chatbots to build Custom Agent Workflows.

You will learn how to architect agents that can Plan, Reason, and Execute complex tasks using enterprise design patterns.

This is the foundation for building agents that are safe, predictable, and production-ready.

What You Will Learn Today:

•   Custom Agent Workflows Why "one-size-fits-all" agents fail in production. Defining structured execution paths for predictable results. The lifecycle: Perception → Reasoning → Planning → Action.

•   Agent Planning Strategies How agents break complex goals into step-by-step plans. Planning before execution vs. Planning during execution. Hybrid Agents: Combining Rule-Based safety with LLM flexibility.

•   Database & Tool Integration Database Access: How agents query SQL databases securely. The Tool Registry: The enterprise pattern for managing 100+ tools. Why a centralized Tool Registry is critical for scalability.

• Enterprise Architecture Designing scalable, debuggable agent systems. Separation of concerns: Execution Layer vs. Reasoning Layer. Answers to common System Design Interview questions.

⏱️ Chapters:

0:00 – Introduction: The "Brain" of the Agent

2:45 – What are Custom Agent Workflows?

12:15 – The Agent Lifecycle (Perception to Action)

24:30 – Hybrid Agents: Rules + LLMs

35:00 – Agent Planning: How Decisions Are Made

48:15 – Connecting Agents to Databases (SQL)

56:40 – The Tool Registry Pattern (Enterprise Standard) 1:08:20 – Summary & Next Steps for RAG

Up until now, your agents were powerful but backend-only.

Today, we give them a face.

In this module, you will learn how to build interactive web UIs for your AI agents using Streamlit—the #1 Python library for AI apps.

You will learn how to turn your Python scripts into production-ready web applications without writing a single line of HTML or CSS.

What You Will Learn Today:

• Why Streamlit for Agentic AI? Why it's better than React/Angular for Python devs. Rapid prototyping for AI demos and internal tools. Understanding Streamlit's unique execution model.

• Core UI Components (Hands-On) Widgets: Text inputs, sliders, dropdowns, and buttons. Data Display: Rendering JSON, Markdown, and DataFrames. Visuals: Displaying charts and large datasets interactively.

•   State Management (Crucial for AI) Session: How to keep your AI agent "alive" between interactions. Context: Storing conversation history and variables and avoiding costly model re-initialization.

• Building Interactive Apps: Multi-Page Apps: Creating navigation and dashboards. Dynamic Filtering: Sidebars and real-time data updates. External Data: Fetching APIs and loading CSVs directly in the UI.

• Agent Integration Preview: Connecting your UI inputs to AI logic. Handling spinners and progress bars while the agent "thinks." Displaying streaming responses in real-time.

⏱️ Chapters:

0:00 – Introduction: Giving Your Agent a Face

3:15 – Recap: The Agent Journey So Far

8:40 – Why Streamlit? (Python-Native UI)

15:30 – Installing & Running Your First App

22:10 – Core Widgets: Inputs, Buttons & Sliders

34:45 – Displaying Data: Tables, JSON & Charts

46:00 – Session State: Managing AI Context (Critical)

58:20 – Multi-Page Applications & Navigation

1:08:15 – Connecting UI to Agent Logic

1:15:30 – Summary & Next Steps

In Module 8, we gave our agents a face. Today, we give them a brain.

In this advanced module, you will explore how to integrate ChromaDB with Streamlit to build RAG-powered agents that can remember conversations and answer questions from your own data.

We are moving from basic chatbots to intelligent, memory-aware systems.

What You Will Learn Today:

• Advanced Streamlit Integration: Moving beyond simple chat interfaces. Callback Handlers: Visualizing agent "thought processes" live in the UI. Managing complex agent state across long conversations.

• Mastering ChromaDB (Vector Database): What is a vector database, and why do agents need it? ChromaDB vs. FAISS: When to use which for enterprise apps. Understanding Embeddings, Collections, and Semantic Search.

•   Building RAG Pipelines (Hands On) Ingestion: Loading PDFs, web pages, and text files. Retrieval: Finding the right context for the LLM. Generation: Producing accurate, grounded answers in the UI.

• SQL Agents & Real-World Data: Connecting Streamlit to SQL Databases for structured data queries. End-to-End Workflow: User UI - Agent - Vector Store - LLM - Answer.

⏱️ Chapters:

0:00 – Introduction: Adding Memory to Agents

3:10 – Advanced Streamlit: Callbacks & State

12:45 – Visualizing Agent Reasoning Live

20:30 – SQL Agent Integration (Structured Data)

32:15 – Introduction to ChromaDB & Vector Stores

45:00 – ChromaDB vs. FAISS: The Critical Differences

54:20 – Building the RAG Pipeline (Ingest & Retrieve)

1:08:45 – Connecting Web Content to Agent Memory

1:18:30 – Final Demo: End-to-End RAG Agent 1:25:00 – Summary & Next Steps

We started with simple LLM scripts, moved to Agents, added Tools, Memory (RAG), and UI.

Now, in this final module, we explore the Model Context Protocol (MCP)—the industry standard for building scalable, production-ready AI systems.

If you want to move from "building toy agents" to "architecting enterprise AI platforms," this is the most important lesson of the entire course.

? What You Will Learn Today:

• The Scalability Problem: Why traditional tool integration breaks at scale. The "Adapter Hell" problem in Enterprise AI. How MCP acts as the "Universal USB Port" for AI Agents.

• Model Context Protocol (MCP) Explained: Understanding the MCP Architecture: Clients, Servers, and Hosts. JSON-RPC: The language-agnostic protocol that powers agents. Why top AI labs are adopting MCP as the standard.

• Hands-On: Building MCP Servers: Creating a robust MCP Server in Python. The Bridge Pattern: Wrapping existing REST APIs and Databases into MCP. Connecting your agents to the file system and external tools securely.

• Enterprise Architecture & Security Governance: Centralized control over what tools agents can access. Modularity: Swapping tools without breaking your agent code. Future-Proofing: Designing agents that are ready for GPT-5 and beyond.

⏱️ Chapters:

0:00 – Finale Introduction: The "Universal Standard"

4:15 – Why Agents Need a Protocol (The Scaling Problem)

12:30 – What is Model Context Protocol (MCP)?

21:45 – Architecture: Clients, Servers & Transports

34:00 – Hands-On: Building Your First MCP Server

48:15 – The "Bridge Server" Pattern (Crucial for Devs)

59:30 – Connecting Agents to External Tools via MCP

1:12:00 – Security, Governance & Enterprise Scale 1:25:40 – MASTERCLASS GRADUATION & SUMMARY ?