8-week intensive · Cohort-based · Hands-on

BUILD
AI
Agents.

Go from "I've used ChatGPT" to building production-ready AI agents that think, use tools, remember context, and work in teams — in 8 weeks.

LangChain LangGraph OpenAI Assistants API MCP Tools Agent Memory Agent Skills LangSmith LangFuse Google ADK Streamlit Python
24
Live sessions
48hrs
Total instruction
6+
Working agents built
1
Production capstone
0
Prior AI experience needed
ReAct Agents LangGraph Workflows Agent Memory Tool Calling RAG Pipelines Multi-Agent Systems OpenAI Assistants API Agent Skills Prompt Engineering Chain-of-Thought LangSmith Evals LangFuse Tracing Guardrails & Safety MCP Protocol Google ADK Deployment ReAct Agents LangGraph Workflows Agent Memory Tool Calling RAG Pipelines Multi-Agent Systems OpenAI Assistants API Agent Skills Prompt Engineering Chain-of-Thought LangSmith Evals LangFuse Tracing Guardrails & Safety MCP Protocol Google ADK Deployment

Not another
tutorial series.

Most AI courses teach you to use tools. This course teaches you to build them. Every session has a working output. The course ends with a production-deployed agent in your GitHub portfolio.

Build from day one
Every session ends with working code. No theory-only weeks. By Session 3 you have a multi-agent pipeline. By Session 9 you have a full LangChain research agent.
🎯
Industry-relevant stack
LangChain, LangGraph, OpenAI Assistants API, and MCP are the frameworks hiring managers ask about in 2026. You will use all of them in production context, not toy examples.
🏗️
Real capstone project
The capstone is a production-grade multi-agent system built with the Google Agent Development Kit (ADK) — a coordinator agent delegating to specialised sub-agents, each with its own tools, memory, and MCP connections — then deployed to the Google ecosystem. Ship it to your portfolio, not just your coursework folder.
🧠
Deep, not wide
We go past "call the API and hope." You will understand why the stop token prevents hallucinated observations, how the Google ADK orchestration model compares to LangGraph, and what happens inside a LangGraph StateGraph.
🔌
Tools, MCP & Skills
Model Context Protocol is the open standard for connecting agents to any tool. You will write custom tools, build and deploy your own MCP server, and package reusable capabilities as Agent Skills — a combination almost no freshers have but every AI team needs.
🛡️
Production thinking
Tracing with LangSmith and LangFuse, evaluation datasets, guardrails, prompt injection defences, cost analysis, and Docker deployment. The course doesn't end at "it works." It ends at "it's ready to ship."

24 sessions.
6 phases.

Three sessions per week on alternating days. One hour of focused theory, two hours of hands-on building. Every session produces a working artefact.

Wk 1 · Sessions 1–3 Foundations & Core Concepts
Bots vs Assistants vs Agents Multi-agent architecture LLM internals + Prompt engineering
Wk 2 · Sessions 4–6 Tools, Memory & Planning
Tool calling + parallel calls Custom tools + MCP tool servers Short-term vs long-term memory Agent Skills & reusable capabilities Google ADK ecosystem overview CoT + Tree-of-Thought planning
Wk 3 · Sessions 7–9 LangChain Deep Dive
LCEL + Runnables RAG end-to-end pipeline AgentExecutor + custom tools
Wk 4–5 · Sessions 10–15 LangGraph & Assistants API
StateGraph + nodes + edges HITL + conditional routing Supervisor–worker pattern Threads + Runs + Code Interpreter LangGraph hybrid patterns
Wk 6–7 · Sessions 16–21 Multi-Agent Capstone on Google ADK
Agent topology & delegation design ADK coordinator + sub-agents Session state & long-term memory Tools, MCP servers & Skills Error recovery + observability Peer demo
Wk 8 · Sessions 22–24 Production & Final Demo
LangSmith evaluation & datasets LangFuse tracing & observability Guardrails + prompt injection Deploy to Google ecosystem Agent Engine · Cloud Run · GKE Final presentations

Code that runs.
Agents that work.

Every assignment is a real system, not a textbook exercise. You push to GitHub, you demo it live, you own it.

Week 1–2 Lab
ReAct Agent from scratch
Build the Thought → Action → Observation loop manually in Python — no framework. Understand exactly how the stop token prevents hallucinated observations and why this loop is the foundation of all agent frameworks.
OpenAI API Python JSON Schema
Week 3 Lab
RAG Research Agent
A LangChain agent with three tools: RAG over a custom document set, a Python REPL for live calculation, and Wikipedia search. Produces structured answers with source citations — with every run traced end-to-end in LangSmith and LangFuse so you can see exactly which tool call cost what.
LangChain LCEL Google ADK LangSmith LangFuse
Week 4–5 Lab
Multi-Agent Content Pipeline
A LangGraph pipeline with Researcher, Writer, and Editor agents supervised by an orchestrator. Includes a human-in-the-loop approval gate that pauses execution, waits for review, and resumes — fully checkpointed.
LangGraph StateGraph MemorySaver HITL
MCP Integration
Custom MCP Server
Build and deploy your own Model Context Protocol server in Python — then connect it to a LangGraph agent as a tool node and to a Google ADK agent as an MCP toolset. Write the integration once; use it across every framework.
MCP Protocol stdio transport HTTP+SSE Google ADK
Memory Lab
Agent with persistent memory
Give an agent a memory that survives the session. Implement short-term session state, long-term vector memory with semantic recall, and summarisation to keep context windows under control — then watch the same agent answer a follow-up question three days later.
Session State Vector Memory Embeddings Context Compaction
Skills Lab
Reusable Agent Skills library
Package agent capabilities as self-contained Skills — instructions, tools, and resources bundled together — so a capability you write once can be loaded by any agent in your multi-agent system instead of copy-pasted into every prompt.
Agent Skills Tool Definitions Google ADK

Tools the industry
actually uses.

LangChain
Chains, agents, tools, memory — the backbone of most production agent systems
LangGraph
Stateful agent workflows with conditional routing, loops, and human-in-the-loop
OpenAI Assistants API
Threads, Code Interpreter, File Search — managed execution for complex tasks
MCP Protocol
Anthropic's open standard for connecting agents to any external tool or data source
Google ADK
The capstone framework — build, orchestrate, and deploy multi-agent systems to the Google ecosystem with Gemini
LangSmith & LangFuse
Trace every agent run, score outputs against eval datasets, and track token cost — LangSmith plus the open-source, self-hostable LangFuse
Streamlit
Put a chat front-end on any agent you build during the course — upload, converse, inspect
Guardrails AI
Input/output validation and safety checks for production-ready agent deployment

What you'll be able
to do after.

Build autonomous AI agents that use tools, manage memory, and recover from errors without human prompting at every step
Design and implement multi-agent systems with orchestrator–worker topology, shared state, and parallel execution
Build production RAG pipelines — from document ingestion through chunking, embedding, retrieval, and cited generation
Implement stateful agent workflows in LangGraph with conditional routing, human approval gates, and checkpointed state
Build multi-agent systems on Google ADK — a coordinator agent, specialised sub-agents, shared session state, and delegation between them
Design agent memory — short-term session state, long-term vector memory with semantic recall, and context compaction that keeps token costs sane
Package capabilities as reusable Agent Skills and custom tools that any agent in your system can load, instead of duplicating logic across prompts
Deploy agents to the Google ecosystem — Vertex AI Agent Engine, Cloud Run, or GKE — with a live endpoint, tracing, and a rollback path
Write precise system prompts using the five-component framework — role, goal, knowledge, constraints, and output format
Build and deploy a custom MCP server that exposes any Python tool to any compliant agent framework, including Google ADK
Evaluate, trace, and add guardrails to production agents — full-run observability in LangSmith and LangFuse, eval datasets, prompt injection defences, and per-step cost analysis
Pick the right framework per problem — when LangGraph's explicit state machine beats ADK's delegation model, and when it's the other way round

Built for people
just starting out.

You need Python basics and some curiosity. Everything else — frameworks, APIs, system design — is taught from scratch in context.

🎓
Final year students
  • CS, IT, or related engineering discipline
  • Know Python basics — loops, functions, classes
  • Some exposure to ML concepts or APIs
  • Want a portfolio project that stands out in campus placements
  • Prefer building over passive learning
💻
Recent graduates & freshers
  • 0–2 years experience, looking to specialise in AI
  • Comfortable with Python but new to LLM frameworks
  • Have heard of LangChain but never used it in production
  • Want something concrete to show in interviews
  • Aiming for roles: AI Engineer, ML Engineer, Prompt Engineer
🔄
Developers switching into AI
  • Background in web dev, data engineering, or backend
  • Strong Python — want to apply it to AI systems
  • Already built things but not with LLMs or agents
  • Want structured upskilling, not scattered YouTube tutorials
  • Need a real project to anchor their pivot story

Highly skilled trainers, very knowledgeable and supportive. It was a wonderful learning experience. Would highly recommend for anyone looking for internships or learning opportunities.

Abhishek Abhi

I had a great experience as a Full-Stack Intern, where I gained hands-on experience in full-stack development. I worked on real-time projects that challenged me and helped improve my skills. The teammates were very supportive and always ready to help, making the learning experience even more valuable.

Omprava Prusty

The training program covered a wide range of topics, starting from the basics and gradually progressing to more advanced concepts. I would like to express my gratitude to Raghu sir, who played a pivotal role in my learning journey. consistently demonstrated the qualities of an excellent mentor.

Shantha A H

Structured.
Intensive. Real.

Session structure
Total duration8 weeks
Sessions per week3 sessions
Session daysMon · Wed · Fri
Session duration2 hours
Theory & Hands-on per session1 hour
Hands-on per session1 hour
Total sessions24 sessions
Prerequisites & delivery
Python levelBasics required
ML / AI prior experienceNot required
LangChain prior experienceNot required
Delivery modeIn-person / hybrid
AssignmentsWeekly + capstone
Capstone submissionGitHub + live demo
CertificateYes — on completion

Taught by someone
who builds this.

Raghu Kumar C.K
Raghu Kumar C.K
Course Designer · Practitioner

This course is designed and delivered by an AI engineering practitioner who has built production agent systems — not just demonstrated toy examples. The curriculum is grounded in real-world challenges: what actually breaks in production, what interviewers actually ask, and what architecture decisions actually matter at scale.

Every code example in the course was written and debugged before it was taught. Every concept was chosen because it shows up in real agent engineering work, not because it fills a syllabus slot.

LangChain · LangGraph OpenAI Assistants API Production AI Systems RAG Architecture MCP Protocol Google ADK · Multi-Agent Systems

Your agent
won't build itself.

8 weeks. 24 sessions. One production-ready multi-agent system, deployed to the Google ecosystem, in your portfolio. Applications open for the next cohort.

Apply for next cohort Review curriculum first

SEATS ARE LIMITED PER COHORT · APPLICATIONS REVIEWED WEEKLY