Go from LLM APIs to Building Production‑Ready AI Products.

By the end of this moduleYou'll understand what generative AI and LLMs actually are, how different AI models and their capabilities compare, and core concepts like tokens, context windows, and inference - the vocabulary and mental model you'll use for the rest of the course.

• What is Generative AI
• Introduction to LLMs
• AI models and their capabilities
• Tokens, context window and inference

By the end of this moduleYou'll be able to write effective prompts using zero-shot, few-shot, and chain-of-thought techniques, and apply prompt engineering best practices to get consistently better outputs from any LLM.

• Zero-shot prompting
• Few-shot prompting
• Chain-of-thought prompting
• Prompt engineering best practices

By the end of this moduleYou'll be able to invoke LLMs programmatically, structure system and user prompts correctly, configure LLM settings, get reliable structured output, and implement your first tool-calling integration - the core building blocks behind every AI application you'll build next.

• Invoking LLMs
• System prompts and message structure
• LLM settings
• Structured output
• Introduction to tool calling
• Implementing a tool

By the end of this moduleYou'll have built a working ChatGPT-style chatbot end to end - UI, server, and integration - with proper prompting, loading states, conversation memory, and safeguards against infinite loops.

• Chatbot UI and server
• Improving the prompt with few-shot examples
• Adding memory to the chatbot
• Preventing infinite loops

By the end of this moduleYou'll understand how retrieval-augmented generation works and how vector embeddings and vector stores let an LLM answer questions using your own data instead of just what it was trained on.

• Introduction to RAG
• Vector embeddings and vector stores

By the end of this moduleYou'll be able to build a complete RAG pipeline from scratch - loading, chunking, and indexing documents into a vector store, then retrieving relevant context to power a company internal chatbot.

• Loading the documents
• Chunking the documents
• Generating embeddings and indexing
• Retrieval and final test

By the end of this moduleYou'll understand what makes an AI system "agentic" and recognize the real-world use cases where agents outperform a simple prompt-response chatbot.

• Agentic AI overview
• Understanding the use cases

By the end of this moduleYou'll understand the agentic framework landscape and know when to reach for LangChain versus LangGraph based on how your agent needs to behave.

• Agentic frameworks overview
• LangChain vs LangGraph
• LangGraph overview

By the end of this moduleYou'll be able to build a ReAct agent from scratch - equip it with built-in and custom tools, visualize its reasoning flow, give it a terminal UI, and add memory so it can hold a real conversation.

• Creating a ReAct agent
• Adding custom tool calling
• ReAct deep dive and visualisation
• Adding memory to a ReAct agent

By the end of this moduleYou'll understand how LangGraph's graph model works and be able to rebuild your ReAct agent on top of a custom graph - with visualization, a terminal UI, and memory - giving you far more control over the agent's execution flow than a prebuilt abstraction.

• Understanding graphs in LangGraph
• Implementing the graph in code
• Rebuilding the ReAct agent on a custom graph
• Adding memory to the agent

By the end of this moduleYou'll have built a real Google Calendar agent end to end - designing its graph, wiring up the Google Developer Console and an Express server, implementing tools to get and create events, adding memory and a terminal UI, and handling real-world details like timezones and secrets management.

• Project architecture
• Designing a custom graph for the project
• Setting up custom tools
• Implementing the graph
• Google Developer Console setup
• Get-event and create-event tools
• Adding memory to the agent
• Handling time zones

By the end of this moduleYou'll be able to trace and debug what your agents are actually doing under the hood using LangSmith and Langfuse - essential for catching failures before your users do.

• Observability overview
• Tracing with LangSmith
• Tracing with Langfuse

By the end of this moduleYou'll understand advanced RAG patterns - agentic RAG, corrective RAG, and self-RAG - that let a system catch and correct its own retrieval mistakes instead of confidently answering with wrong context.

• Agentic RAG
• Corrective RAG
• Self-RAG

By the end of this moduleYou'll have built a multi-agent customer support chatbot - routing between a frontdesk agent, marketing support agent, and learning support agent using conditional edges, backed by vector-indexed documents and the corrective/self-RAG patterns from the previous module.

• Understanding the agent graph
• Building the front-desk agent
• Routing with conditional edges
• Marketing support agent
• Vector-indexing internal documents
• Learning support agent
• CRAG and Self-RAG in action
• Adding memory

By the end of this moduleYou'll understand the reflection, reflexion, and plan-and-execute agentic patterns, and put them into practice by building two real projects - a self-critiquing LinkedIn post writer and a Perplexity-style research agent with revision and search.

• The reflection pattern
• LinkedIn post writer: writer and critique nodes
• LinkedIn post writer: conditional edges
• The reflexion pattern
• Research agent: responder, search executor and revisor nodes
• The plan-and-execute pattern

By the end of this moduleYou'll be able to design a multi-agent system with a supervisor agent coordinating specialized sub-agents - the pattern used when a single agent can't reliably handle every task on its own.

• Building sub-agents
• Building the supervisor agent

By the end of this moduleYou'll be able to add human-in-the-loop interrupts to an agent - pausing for explicit approval before it takes a risky or irreversible action, and resuming once a human signs off.

• The human-in-the-loop pattern
• Showing an approval request to the user
• Sending the approval back to the agent
• Human in the loop inside a graph

By the end of this moduleYou'll understand generative UI and have built a complete AI Expense Tracker end to end - an agent with tools to add and query expenses, streaming its responses over Server-Sent Events, and rendering live charts and results directly in a React UI instead of just plain text.

• What is generative UI?
• AI Expense Tracker: designing the graph
• Add-expense and get-expenses tools
• Chart generation tool
• Streaming modes
• Server-Sent Events (SSE), server and client
• Streaming custom events from the server
• Rendering tool results and charts in the UI

By the end of this moduleYou'll understand the Model Context Protocol (MCP) architecture and be able to build both an MCP server (with tools, prompt templates, and resources) and an MCP client that can connect to local and remote servers - the emerging standard for connecting AI models to real tools and data.

• MCP concepts and architecture
• Local MCP server: tools
• Local MCP server: prompt templates
• Local MCP server: resources
• Building a remote MCP server
• Debugging remote MCP servers
• Building an MCP client
• Connecting the client to a remote server

By the end of this moduleYou'll have built a full AI-powered image editor - from image upload and AI-driven generation to a canvas-based masking system with brush, eraser, and rectangle tools, undo/redo history, and AI remix/filter/expansion features - the kind of production-grade creative tool most AI courses never actually teach you to build.

• Product architecture
• Image generation and LLM setup
• History with undo and redo
• AI image remixing
• AI image filters
• AI image expansion
• Masking for image editing
• Brush, eraser and rectangle tools
• Sending the image and mask to the LLM

By the end of this moduleYou'll have built a real-time voice AI language tutor - handling live audio streaming, processing raw PCM audio data, playing back AI responses with interrupt support, transcripts, and secure ephemeral tokens - the real-time audio plumbing most AI tutorials skip entirely.

• Architecture
• Audio streams and permissions
• Audio session connectivity
• Audio processing and 16-bit PCM data
• Playing the AI's audio response
• Interrupting the conversation mid-reply
• Live audio transcripts
• Customising the conversation
• Ephemeral tokens

By the end of this moduleYou'll have built a complete, production-grade fullstack AI SaaS from scratch - authentication (email, Google, GitHub), a multi-model streaming chatbot with persistent threads and memory, tool calling, and a full subscription and credit-based billing system with a real payment gateway - tying together everything from the entire course into one deployable product.

• Product architecture
• Postgres in Docker
• Auth with Better Auth: sign-up, Google and GitHub
• Protected routes
• Multi-model support
• Streaming messages from the backend
• Message threads
• Persistent short-term memory
• Tool calling with results rendered in the UI
• Payment gateway and subscriptions
• Credit-based usage with Polar
• Restricting paid models
• Long-term memory