Python Essentials (Fast Track)

Python environment setup (pyenv, venv, uv)

Data structures for AI workflows (dicts, lists, dataclasses)

Type hints & Pydantic models for structured data

Async/await fundamentals - why it matters for AI apps

asyncio basics: coroutines, tasks, gathering

Hands-on: Async HTTP calls to LLM APIs

Python Ecosystem for AI

Working with APIs: httpx, aiohttp

Environment management: env files, secrets handling

Logging & observability basics

Package management with poetry / uv

Hands-on: Build a reusable async LLM client wrapper

Embeddings & Vector Databases

What are embeddings? From words to vectors

Embedding models: OpenAI, Cohere, open-source (sentence-transformers)

Similarity search: cosine similarity, dot product

Vector databases overview: Pinecone, Weaviate, Qdrant, ChromaDB, pgvector

Indexing strategies: HNSW, IVF, flat

Hands-on: Generate embeddings and store in ChromaDB

Semantic Search & Retrieval

Building a semantic search engine from scratch

Chunking strategies: fixed-size, recursive, semantic

Metadata filtering & hybrid search (keyword + semantic)

Evaluation: precision, recall, MRR for retrieval

Hands-on: Build a document search system over PDF/markdown files

Advanced Prompting Techniques

System prompts, role prompts, structured prompts

Chain-of-thought, tree-of-thought, ReAct prompting

Prompt chaining & decomposition

Output parsing: regex, Pydantic, structured outputs

Guardrails & safety: content filtering, jailbreak prevention

Hands-on: Build a multi-step reasoning pipeline with prompt chaining

Function Calling & Tool Use

Function/tool calling: OpenAI, Anthropic, Gemini patterns

Defining tool schemas (JSON Schema)

Handling tool results and multi-turn tool use

Parallel tool calling

Error handling in tool use flows

Hands-on: Build an LLM that can call weather API, calculator, and web search

LangChain Architecture

LangChain ecosystem overview: Core, Community, LangGraph, Langfuse

Chat models & LLM wrappers

Prompt templates & output parsers

Chains: LLMChain, SequentialChain, RouterChain

LCEL (LangChain Expression Language) - the modern way

Hands-on: Build chains with LCEL (pipe operator, RunnablePassthrough)

Memory & Conversation Management

Conversation memory types: Buffer, Summary, Window, Entity

Custom memory implementations

Message history with different backends (Redis, PostgreSQL)

Streaming responses

Callbacks & tracing with Langfuse

Hands-on: Build a chatbot with persistent memory

RAG Architecture & Implementation

RAG pattern deep dive: Naive RAG vs Advanced RAG

Document loaders: PDF, web, databases, APIs

Text splitters: RecursiveCharacterTextSplitter, semantic chunking

Vector store integrations in LangChain

Retriever types: similarity, MMR, self-query, contextual compression

Hands-on: Build a complete RAG pipeline over company docs

Advanced RAG Techniques

Multi-query retrieval & RAG Fusion

Parent-document retriever & hierarchical retrieval

Hypothetical Document Embeddings (HyDE)

Re-ranking: Cohere Rerank, cross-encoder models

Evaluation: RAGAS framework, faithfulness, relevance

Hands-on: Implement advanced RAG with re-ranking and evaluation

LangGraph Fundamentals

Why LangGraph? Limitations of simple chains

Graph concepts: Nodes, Edges, State, Conditional edges

StateGraph & MessageGraph

Building your first graph: plan -> execute -> reflect

Checkpointing & state persistence

Hands-on: Build a research agent with plan-execute-reflect loop

Advanced LangGraph Patterns

Human-in-the-loop: interrupt, approve, modify

Subgraphs & nested graphs

Parallel node execution

Error handling & retry logic in graphs

Streaming from graphs (events, tokens, state updates)

Hands-on: Build a multi-step document processing pipeline with human review

Multi-Agent Architectures

Agent communication patterns: supervisor, peer-to-peer, hierarchical

Supervisor agent pattern in LangGraph

Agent handoff & delegation

Shared state vs. isolated state

Tool sharing across agents

Hands-on: Build a supervisor + worker agents system

Complex Multi-Agent Workflows

Debate/critique pattern (generator + critic)

Collaborative agents with different specializations

Agent teams for complex tasks

Coordination patterns: sequential, parallel, dynamic routing

Hands-on: Build a AI Software Team (planner, coder, reviewer, tester)

Async LangChain & Performance

Async chains and retrievers

Batch processing with abatch()

Rate limiting & retry strategies

Caching: in-memory, Redis, semantic caching

Token counting & cost optimization

Hands-on: Build a high-throughput async document processing pipeline

Observability & Debugging

Langfuse: tracing, evaluation, datasets

Custom callbacks for monitoring

Debugging agent loops (infinite loops, hallucinations)

A/B testing prompts with Langfuse

Cost tracking & usage analytics

Hands-on: Instrument an agent with full observability

Core Agent Patterns

AI Agents vs Agentic AI - clarifying the terms

AI Agent: an individual autonomous unit that perceives, reasons, and acts (tool use, planning, memory)

Agentic AI: the system-level design philosophy - building AI systems that are autonomous, adaptive, and can operate with minimal human intervention over extended tasks

How they relate: AI Agents are the building blocks; Agentic AI is the architecture that orchestrates them into reliable, production-grade systems

What makes an Agent vs a Chain? Autonomy & reasoning

ReAct pattern: Reasoning + Acting

Plan-and-Execute agents

Reflexion: self-critique and improvement loops

LATS (Language Agent Tree Search)

Hands-on: Implement ReAct from scratch (no framework)

Tool Design & MCP

Designing effective tools: naming, descriptions, schemas

Tool composition & higher-order tools

Dynamic tool selection & creation

Sandboxing tool execution (Docker, E2B)

MCP (Model Context Protocol) - connecting agents to external systems

Building MCP servers and clients

Hands-on: Build an MCP server and connect it to Claude/your agent

Agentic RAG

From static RAG to Agentic RAG

Self-RAG: retrieve, grade, regenerate

Adaptive retrieval: when to retrieve vs. when to use parametric knowledge

Corrective RAG (CRAG): fact-checking retrieved documents

Multi-source RAG: combining multiple knowledge bases

Hands-on: Build a self-correcting RAG agent with LangGraph

Knowledge Graphs & Structured Retrieval

Knowledge graphs for AI agents (Neo4j, NetworkX)

Graph RAG: combining vector search with graph traversal

Entity extraction & relationship mapping

Structured querying via natural language (Text-to-SQL, Text-to-Cypher)

Hands-on: Build a knowledge graph from documents + query with natural language

Durable Execution & State Management

Challenges of long-running agents (failures, timeouts, costs)

Checkpointing strategies & resumable workflows

Event sourcing for agent state

Temporal.io / Inngest for durable agent workflows

Agent memory: short-term, long-term, episodic

Hands-on: Build a durable research agent that survives crashes

Reliability & Guardrails

Structured outputs & output validation

Retry strategies with exponential backoff

Fallback chains (primary model -> fallback model)

Input/output guardrails: NeMo Guardrails, Guardrails AI

Hallucination detection & mitigation

Cost budgets & token limits for agents

Hands-on: Add comprehensive guardrails to an existing agent

Backend Architecture for Agents

FastAPI for agent APIs (sync & async endpoints)

WebSocket streaming for real-time agent responses

Task queues: Celery, Redis Queue for long-running agents

Database design for agent state (PostgreSQL + pgvector)

Authentication & multi-tenancy

Hands-on: Build a FastAPI service that exposes an agent via REST + WebSocket

Containerization & Local Development

Dockerizing AI applications (multi-stage builds, layer caching)

Docker Compose for local development (app + vector DB + Redis + Postgres)

CI/CD pipelines for AI apps (GitHub Actions)

Environment configuration & secrets management with Kubernetes Secrets

Hands-on: Dockerize the agent service with full local stack

Kubernetes Fundamentals for AI Workloads

Kubernetes concepts: Pods, Deployments, Services, ConfigMaps, Secrets

Minikube setup & local cluster management

Resource management for AI workloads (CPU, memory requests/limits)

Persistent storage for vector databases on K8s (PVCs)

Helm charts for packaging

Hands-on: Deploy the agent service to a Minikube cluster

Production Operations on Minikube

Observability stack: Prometheus + Grafana for metrics

Distributed tracing: OpenTelemetry for agent calls

Log aggregation: structured logging with correlation IDs

Health checks & readiness probes for agent services

Horizontal Pod Autoscaling (HPA) for agent services

Hands-on: Add monitoring, alerting, and auto-scaling to the deployed agent

Multi-agent system with supervisor orchestration

Agentic RAG over uploaded documents + web search

Long-running research tasks with checkpointing

Human-in-the-loop approval for actions

Full observability & cost tracking

Architecture walkthrough & design decisions explained

Code walkthrough: agent core, tools, RAG pipeline

LangGraph orchestration with supervisor pattern

Memory & conversation persistence layer

Live coding: assembling the full system end-to-end

Connecting all components (agents, retrieval, state management)

Running the application locally with Docker Compose

Demonstrating key features: multi-agent collaboration, human-in-the-loop, observability

Q&A: addressing student questions on implementation choices

Containerize the application

Deploy to Minikube cluster (live demo)

Set up monitoring & observability on the cluster

Add guardrails & error handling

End-to-end testing of the deployed system

Load testing & observing scaling behavior

Full live demo of the deployed system on Minikube

Walkthrough of production concerns: scaling, cost, reliability

Discussion: what's next in Agentic AI

OpenAI Swarm, Google ADK, Anthropic Agent SDK

Agent marketplaces & composability

Regulation & responsible AI agents

Career paths in Agentic AI

Certificate ceremony & next steps