Logo

CodeKerdos

OverviewCoursesMasterclassTestimonialsBlogsFAQsContact
Login

Agentic AI & Multi-Agent Systems Bootcamp

Master the architecture, development, and deployment of autonomous AI systems. Learn how to build production-grade Agentic AI applications using LangChain, LangGraph, and advanced LLMs (OpenAI, Claude, Gemini). From foundational RAG pipelines and stateful multi-agent workflows to durable execution and Kubernetes (Minikube) deployment, this bootcamp covers the complete lifecycle of building reliable, scalable, and observable AI agents for real-world enterprise use cases.

Sankalp Saxena

Sankalp Saxena

Advance

AI Engineering
Our Course Benefits
Cup Icon

Understand LLMs, embeddings & retrieval systems

Build complex agents using LangChain & LangGraph

Design multi-agent system communication patterns

Implement evaluated production-grade RAG pipelines

Handle async, streaming & long-running agent tasks

Deploy on Kubernetes (Minikube) with observability

Evaluate agent performance, reliability & safety

Master agentic architectures & framework selection

Career Sectors & Job Roles
Cup Icon

Agentic AI Engineer

Multi-Agent Systems Architect

AI Platform Engineer

Applied AI Engineer

LLM Ops & Backend Engineer

AI Solutions Architect

Forward Deployed Engineer (AI)

AI Infrastructure Engineer

What is a Agentic AI Engineer ?
Book Icon

AI Agents are individual autonomous units that perceive, reason, and act using tools, planning, and memory.

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

In this role, you will orchestrate AI Agents into reliable, production-grade systems, moving beyond simple chains to focus on true autonomy and reasoning.

As enterprises transition to autonomous workflows, mastering Agentic architectures, durable execution, and multi-agent coordination is essential for building the next generation of scalable AI solutions.

Why Choose the Agentic AI & Multi-Agent Systems Bootcamp ?
Book Icon

Unlike basic prompt engineering courses, this program focuses heavily on stateful workflows, multi-agent architectures, and Agentic RAG using LangGraph.

You'll learn to handle the real-world challenges of AI agents, including durable execution, async patterns, human-in-the-loop approvals, and hallucination mitigation.

By the end of the program, you won't just build toy bots; you will deploy a fully observable, production-grade multi-agent system on a local Kubernetes (Minikube) cluster.

What Makes This Program Different?
Book Icon
Standard GenAI CoursesAgentic AI Bootcamp
Prompt engineering & basic API calls
Stateful multi-agent workflows (LangGraph)
Stateless chat applications
Durable execution & memory persistence
Local Jupyter notebook demos
Production Kubernetes (Minikube) deployments
Single model usage (e.g., just OpenAI)
Multi-model orchestration (Claude, Gemini, GPT)
Synchronous, slow execution
Async architecture & parallel tool calling
Black-box outputs
Full observability (Langfuse, Prometheus, Grafana)
Basic autonomous scripts
Human-in-the-loop approval & error handling
Skills You'll Master
Book Icon
Software Engineering & Async

Advanced Python 3.11+

Asyncio & Coroutines

Pydantic

FastAPI

REST APIs & WebSockets

PostgreSQL & pgvector

Redis

AI & LLM Foundations

LLMs (OpenAI, Claude, Gemini)

Prompt Engineering

Function Calling & Tool Use

Embeddings

Vector Databases (ChromaDB, Qdrant)

Semantic Search & Chunking

Structured Outputs

Agentic AI & Frameworks

LangChain & LCEL

LangGraph

Stateful Agent Workflows

ReAct, Plan & Execute

Multi-Agent Orchestration

Agentic RAG & Graph RAG

Model Context Protocol (MCP)

Production AI & Observability

Langfuse

OpenTelemetry

Prometheus & Grafana

RAGAS Framework

Guardrails & Safety

Hallucination Mitigation

Cost Budgeting & Tracking

DevOps & Deployment

Docker & Docker Compose

Kubernetes (Minikube)

GitHub Actions (CI/CD)

Horizontal Pod Autoscaling (HPA)

Helm Charts

Task Queues (Celery/Redis)

Career Transformation Roadmap
Book Icon

Python / Backend Developer

LLM API Integration

Semantic Search & RAG Engineer

Stateful AI Developer

Multi-Agent Systems Architect

Agentic AI Engineer

What to expect from this course ?
Book Icon

The Agentic AI & AI Agents Bootcamp is designed to transform developers into experts capable of building autonomous, production-ready AI systems. Unlike basic prompt engineering courses, this program covers the complete lifecycle of designing, building, orchestrating, and deploying Stateful Agent Workflows.

You'll begin with Phase 1: AI & LLM Foundations, getting hands-on with Python 3.11+, async programming, embedding models, vector stores, and advanced prompting techniques like ReAct and function calling across OpenAI, Claude, and Gemini.

In Phase 2: LangChain & LangGraph Core, you'll master modern RAG pipelines, LCEL, and stateful graphs. You will learn to orchestrate multi-agent architectures using supervisor patterns, peer-to-peer delegation, and human-in-the-loop workflows.

Moving to Phase 3: Agentic AI Deep Dive, you will implement advanced paradigms such as Agentic RAG (Self-RAG, Corrective RAG), Knowledge Graphs, and Model Context Protocol (MCP). You'll also solve real-world problems like durable execution for long-running agents, handling timeouts, and implementing guardrails.

Finally, in Phase 4 & Phase 5: Production & Deployment, you'll productionize your multi-agent systems. You will build a FastAPI backend with WebSockets, containerize the stack with Docker, and deploy it onto a Kubernetes (Minikube) cluster complete with Prometheus/Grafana monitoring, Langfuse tracing, and autoscaling.

By the end of the 16 weeks, you will have engineered a massive Enterprise AI Research Assistant Capstone from scratch and will possess the exact architectural knowledge and DevOps skills required to lead AI initiatives in the industry.

Learning Journey
Book Icon

LLM & Async Python Foundations

Vector DBs & Semantic Retrieval

Advanced Prompting & Tool Calling

LangChain & RAG Pipelines

Stateful LangGraph Workflows

Multi-Agent Architecture Design

Production DevOps & Minikube Deployment

The Curriculum
Book Icon

  • AI Landscape & Core Concepts
  • What is AI, ML, DL - the hierarchy
  • Supervised, Unsupervised, Reinforcement Learning (conceptual)
  • Neural Networks intuition (no math deep-dive, just mental models)
  • The Transformer architecture - why it changed everything
  • Attention mechanism explained simply
  • Hands-on: Run your first LLM inference via API (OpenAI / Anthropic)
  • LLMs Deep Dive
  • How LLMs are trained: pre-training, fine-tuning, RLHF
  • Tokens, context windows, temperature, top-p, top-k
  • Prompt engineering fundamentals
  • Zero-shot, few-shot, chain-of-thought prompting
  • Hands-on: Systematic prompt engineering exercises with Claude/GPT APIs

  • 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
  • Lab: Create a multi-model comparison tool (call Claude + GPT + Gemini in parallel)

  • 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
  • Lab: Semantic search over a codebase

  • 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
  • Lab: Create a personal assistant that routes to different tools based on user intent

  • 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
  • Lab: Multi-user conversation system with isolated histories

  • 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
  • Lab: Build a RAG system with citation tracking

  • 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
  • Lab: Content moderation agent with escalation flow

  • 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)
  • Lab: Multi-agent research system (searcher, summarizer, fact-checker)

  • 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
  • Lab: Build an eval harness that auto-scores agent responses

  • 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
  • Lab: Create an agent that writes and executes code safely

  • 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
  • Lab: Hybrid RAG system (vector + graph + SQL)

  • 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
  • Lab: Build an agent with budget constraints and automatic fallbacks

  • 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
  • Lab: Set up CI pipeline with linting, testing, and Docker build

  • 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
  • Lab: Load test the agent service and observe scaling behavior

  • Project: Enterprise AI Research Assistant
  • 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
AI Tools & Frameworks You'll Master
Book Icon
LLMs & AI APIs

OpenAI

Anthropic (Claude)

Google (Gemini)

Cohere

AI Frameworks

LangChain

LangGraph

Sentence-Transformers

Vector DBs & Databases

ChromaDB

Qdrant

pgvector

PostgreSQL

Redis

Observability & Evaluation

Langfuse

OpenTelemetry

Prometheus

Grafana

RAGAS

Containerization & Orchestration

Docker

Docker Compose

Kubernetes (Minikube)

Helm

Certificate of Completion
Certificate Icon
Certficiate of Completion
Shardul Naik

Shardul Naik

AI Engineer @ American Express

Student

+103%

Salary Hike

Trainee AI Engineer

"The 'Agentic AI & AI Agents Bootcamp' was an excellent platform for enhancing my skills. The program was instrumental in my career growth, helping me secure a role as an AI Engineer at American Express."

Enterprise AI Capstone Project

Design, build, and deploy a production-grade multi-agent system from scratch, solving real business problems at an enterprise scale.

Enterprise AI Research Assistant

Build a production-grade multi-agent system featuring supervisor orchestration, Agentic RAG over uploaded documents, and web search. It includes long-running research tasks with checkpointing, human-in-the-loop approvals, and full observability.

View More
Frequently Asked Questions
Book Icon

An AI Agent is an individual autonomous unit that perceives, reasons, and acts (using tools, planning, and memory). Agentic AI refers to the system-level design architecture that orchestrates these individual agents into reliable, production-grade systems.

Basic programming experience (preferably in Python) and a conceptual understanding of REST APIs are recommended. You will also need a computer with at least 16GB RAM to run local Minikube clusters.

You'll work with Python 3.11+, LangChain, LangGraph, FastAPI, PostgreSQL (pgvector), ChromaDB, Docker, Kubernetes (Minikube), and LLMs from OpenAI, Anthropic (Claude), and Google (Gemini).

This is an advanced engineering bootcamp. Instead of just writing prompts, you will learn to build autonomous systems, handle state and memory, orchestrate multiple agents to collaborate, and deploy the entire backend architecture on Kubernetes.

Yes! Throughout the 16 weeks, you will complete multiple hands-on labs, culminating in a massive Capstone Project: an Enterprise AI Research Assistant deployed on Minikube with full observability and human-in-the-loop approvals.

Graduates can target high-demand roles such as AI Agent Engineer, Applied AI Engineer, Enterprise AI Engineer, AI Architect, and Forward Deployed Engineer (FDE).

Who Should NOT Join This Program?
Book Icon

This program may not be the right fit if:

You're looking for a basic 'How to use ChatGPT' tutorial without writing code.

You have zero programming experience and do not want to learn Python.

You only want to write prompts and want to avoid backend engineering or databases.

You are not interested in complex architectures like LangGraph, multi-agent state, or Kubernetes.

You cannot commit to building, debugging, and deploying hands-on, enterprise-scale projects.

Get the complete course details in our brochure.

Discover all the essential information about our courses in our detailed brochure. Get insights on curriculum, schedules, and enrollment options to help you make the best choice for your education.

Ready to Master Agentic AI & AI Agents?

Master the complete lifecycle of autonomous AI systems—from LLM foundations and LangGraph orchestration to Docker containerization, Kubernetes deployment, and system observability. Build production-grade multi-agent applications, solve complex asynchronous workflows, and gain the hands-on experience required to deploy reliable, safe, and scalable Agentic AI solutions in modern enterprises.

Monthly EMI options upto (24) Months
Monthly EMI options upto (24) Months

Flexible monthly EMI plans available for up to 24 months.

Modes of Payment ( UPI, Cards, Wallet, Net Banking)
Modes of Payment ( UPI, Cards, Wallet, Net Banking)

Explore the various modes of payment available today: UPI for instant transfers, cards for secure transactions, wallets for convenience, and net banking for easy online management. Each option offers unique benefits to suit your needs.

Course Fees

₹69,999

Final pricing refers to the last and definitive cost of a product or service, including all applicable fees and discounts.

Includes:

  • Live Interactive Classes
  • Lifetime Recorded Sessions
  • Study Material & PDFs
  • Enterprise Assignments
  • Production AI Projects
  • 1:1 Mentorship Sessions
  • Mock Interviews
  • Resume Reviews
  • Portfolio Building
  • Industry Certification
  • Placement Assistance