Full Stack Agentic AI Course

Learnkart Technology Pvt. Ltd.

• Full Stack Agentic AI Overview 42:05

  • 1: The Problem with Standard AI Models: Why ChatGPT/Gemini/Claude isn't enough 04:14
  • 2: What is RAG? Understanding Retrieval Augmented Generation 06:09
  • 3: Introduction to MCP and How It Complements RAG 05:13
  • 4: How MCP Works: Tools, APIs, and Real-World Examples 05:10
  • 5: MCP Architecture: Frontend, Backend, LLM and MCP Layer 05:19
  • 6: Checkpoint Quiz 06:00
  • 7: Proficiency Quiz 10:00

• RAG and MCP System Architecture 30:23

  • 8: How MCP Server Actually Works: Architecture Deep Dive 03:57
  • 9: How RAG + MCP Work Together: The Power of Combined Systems 02:00
  • 10: Is RAG Alone Sufficient? Limitations of Simple Retrieval! RAG Only vs RAG + MCP 06:36
  • 11: The Evolution: From Chatbots to Agentic Systems 03:50
  • 12: Checkpoint Quiz 05:00
  • 13: Proficiency Quiz 09:00

• Course Roadmap and Project Overview 17:38

  • 14: What You'll Build in This Course 01:35
  • 15: Career Prep: RAG & Agent Architecture Questions 07:46
  • 16: Agentic AI Full-Stack Project Demo 02:17
  • 17: Proficiency Quiz 06:00

• Environment Setup and RAG Fundamentals 21:14

  • 18: Development Environment - Install Node.js & VS Code Setup 08:53
  • 19: Create Gemini-AI API Key 00:51
  • 20: Create OpenAI (ChatGPT) API Key 04:30
  • 21: Proficiency Quiz 07:00

• RAG Architecture and AI Coding Support 34:04

  • 22: Understanding RAG Architecture 06:54
  • 23: How RAG Actually Works Behind the Scenes 04:27
  • 24: Understanding Embeddings, Retrieval and Augmentation 02:38
  • 25: Installing Gemini Code Assistant and Setting Up AI Coding Support 04:52
  • 26: Getting Gemini API Key and Understanding Free Access Options 04:13
  • 27: Proficiency Quiz 11:00

• Angular Chat App Setup and UI Development 37:52

  • 28: Creating a New Angular Chat Application with Angular CLI 04:16
  • 29: Opening the Angular Project in VS Code and Preparing the Basic Structure 04:20
  • 30: Integrating Tailwind CSS and Bootstrap Icons in Angular 04:23
  • 31: Generating the Chat UI Using Gemini Prompting (Vibe Coding) 05:28
  • 32: Final UI Refinements: Message Interface, Styling, and Responsive Design 06:25
  • 33: Proficiency Quiz 13:00

• Frontend Chat Setup and Messaging Logic 36:52

  • 34: Organizing Frontend Code & Creating Message Interface 04:44
  • 35: Optimizing sendMessage() Logic and Creating askLLM() Function 04:31
  • 36: Creating Angular Chat Service and Implementing HTTP POST API Call 04:50
  • 37: Handling Bot Responses, Error Handling, and UI Testing 05:01
  • 38: Implementing Auto Scroll, Environment Variables, and Final Frontend Setup 05:46
  • 39: Proficiency Quiz 12:00

• Backend Project Initialization and Server Setup 23:36

  • 40: Creating Backend Folder and Initializing Node.js Project 04:12
  • 41: Installing Packages and Creating Basic Express Server 02:56
  • 42: Configuring Environment Variables (.env) and Running Node Server 04:27
  • 43: Using Node Watch Mode and NPM Scripts for Development 04:01
  • 44: Proficiency Quiz 08:00

• Gemini API Integration and Full Chat Testing 42:50

  • 45: Understanding Gemini API Documentation and LLM Integration Basics 04:36
  • 46: Getting Gemini API Key and Configuring .env for Model & API Key 03:40
  • 47: Creating Gemini Provider Class and Implementing generateResponse() 04:08
  • 48: Building Express Chat Router and Connecting Gemini Provider 05:15
  • 49: Testing Gemini API with CURL and Handling Model Responses 06:13
  • 50: Testing NodeJS API in Angular Chat App - Chat with AI 04:58
  • 51: Proficiency Quiz 14:00

• Introduction to RAG and Local Knowledge Base 33:22

  • 52: Creating Local Knowledge Base and Understanding Basic RAG Concept 04:21
  • 53: Implementing RAG Service and Preparing Context & Prompt 04:44
  • 54: Integrating RAG with Chat Router and Testing the Q&A Bot 04:21
  • 55: Introduction to RAG for Static Q&A Bot & Overview of Embeddings 04:09
  • 56: Exploring Gemini Embedding API Documentation & Task Types 03:47
  • 57: Proficiency Quiz 12:00

• Implementing Gemini Embeddings and RAG Ranking 33:26

  • 58: Implementing generateEmbedding() in Gemini Provider 04:06
  • 59: Installing Cosine Similarity Package & Preparing Document Loader 04:09
  • 60: Generating Query Vector and FAQ Embeddings for RAG 04:08
  • 61: Ranking Results Using Cosine Similarity and Preparing Context 05:04
  • 62: Testing the RAG Q&A Bot and Improving Prompts for Better Responses 05:59
  • 63: Proficiency Quiz 10:00

• OpenAI Integration and Q&A Testing 40:18

  • 64: Setting Up OpenAI API Key and Selecting the Model 04:28
  • 65: Creating the OpenAI Provider and Installing the SDK 04:07
  • 66: Implementing OpenAI Embeddings Functionality 04:21
  • 67: Integrating OpenAI with the Chat Router and Testing 06:29
  • 68: Testing Q&A Bot with OpenAI for Answers 03:59
  • 69: Interview Prep: RAG & Similarity Questions 05:54
  • 70: Proficiency Quiz 11:00

• MCP Server Setup and Service Implementation 37:49

  • 71: Initializing Node.js TypeScript Project & Installing Dependencies 04:59
  • 72: Configuring TypeScript (tsconfig) and Project Structure 05:40
  • 73: Creating Express Server, Environment Setup & Running the Project 06:09
  • 74: Integrating AI Model (Gemini) in NodeJS 10:01
  • 75: Proficiency Quiz 11:00

• Project Refactoring, API Routes, and Tool Preparation 37:06

  • 76: Project Refactoring: Routes and Controllers Setup 03:51
  • 77: Implementing Chat Controller and Route Integration 03:04
  • 78: Creating Mock Data and Building Customer & Order Controllers 03:57
  • 79: Creating API Routes and Testing Orders & Customers Endpoints 05:15
  • 80: Preparing a Weather API - Real-World Tool 08:07
  • 81: Proficiency Quiz 12:00
  • 82: Summary 00:52

• Refactoring Backend with Services and Controllers 34:28

  • 83: Introduction & Cleaning Mock Data 04:44
  • 84: Why Controllers Should Not Contain Business Logic & Creating Customer Service 05:21
  • 85: Implementing Customer Controller and Query Limit Handling 04:36
  • 86: Creating Order Service and Mapping Orders with Customers 05:18
  • 87: Order Controller Implementation, Gemini Service Optimization & Final Testing 05:29
  • 88: Proficiency Quiz 09:00

• MCP Architecture and Core Components 33:06

  • 89: Introduction to MCP Architecture & Standardization 04:10
  • 90: MCP Server Components: Tools, Resources, and Prompts 04:16
  • 91: Transport Layer, Sessions, and Request Handling 04:24
  • 92: Introduction to MCP Components (Tool vs Resource vs Prompt Analogy) 04:51
  • 93: Understanding MCP Tools (Actions AI Can Perform) 03:25
  • 94: Proficiency Quiz 12:00

• MCP Resources, Prompts, and Transport Layer 31:25

  • 95: Understanding MCP Resources (Read-Only Data Access) 04:36
  • 96: Understanding MCP Prompts (Reusable AI Interaction Templates) 04:09
  • 97: Decision Framework: When to Use Tool, Resource, or Prompt 04:57
  • 98: Understanding Transport Layer in MCP 08:43
  • 99: Proficiency Quiz 09:00

• Introduction to Native Tool Calling and MCP Comparison 20:35

  • 100: AI Tool Integration Challenges & Tool Calling Workflow 05:18
  • 101: MCP Architecture, Advantages & Comparison with Tool Calling 06:32
  • 102: Project Setup for Gemini Tool Calling (Without MCP) 04:43
  • 103: Creating Tool Definitions: Weather and Customer Functions 04:02

• Gemini Tool Registration and Testing 28:25

  • 104: Registering Tools in Gemini Configuration 04:34
  • 105: Detecting and Executing Tool Calls from Gemini Response 03:53
  • 106: Sending Tool Results Back to the LLM for Natural Language Response 04:15
  • 107: Testing Tool Calling with Weather and Customer Queries 05:43
  • 108: Proficiency Quiz 10:00

• Limitations of Direct Tool Calling and OpenAI Setup 42:50

  • 109: Limitations of Direct Tool Calling and Why MCP is Better 06:10
  • 110: Creating OpenAI Service and Installing OpenAI SDK 05:33
  • 111: Configuring Environment Variables and Implementing Base OpenAI Functions 05:27
  • 112: Understanding OpenAI Responses API and Tool Calling Workflow 05:42
  • 113: Defining Tools for Weather and Customer Functions 05:58
  • 114: Proficiency Quiz 14:00

• Implementing Native Tool Calling with OpenAI 33:50

  • 115: Implementing Function Call Handling with Loop and Switch Case 04:49
  • 116: Sending Tool Output Back to OpenAI and Generating Final Response 06:21
  • 117: Controller Integration, Instructions Handling, and OpenAI vs Gemini Differences 06:33
  • 118: Testing OpenAI Native Tool Calling in Frontend 05:07
  • 119: Proficiency Quiz 11:00

• MCP Fundamentals and Initial Tool Implementation 39:20

  • 120: Introduction to MCP and Preparing the Agentic Project 03:21
  • 121: Understanding MCP Documentation: Tools, Resources, and Prompts 04:28
  • 122: Creating MCP Folder Structure and MCP Server Setup 03:50
  • 123: Creating Customer Tools File and Registering First MCP Tool 04:41
  • 124: Implementing Input & Output Schema with Zod Validation 04:17
  • 125: Adding Second Customer Tool (Get Customer by ID) 02:43
  • 126: Proficiency Quiz 16:00

• Building MCP Tools and Server Transport Layer 53:46

  • 127: Creating Order Tools and Implementing Multiple MCP Tools 03:58
  • 128: Building Advanced Order Tools (Orders with Customer Details & Order by ID) 04:07
  • 129: Creating Weather Tool and Final MCP Tool Registry Setup 05:24
  • 130: Setting Up MCP Transport Controller & Session Configuration 05:34
  • 131: Creating Transport Logic & Session Management 04:37
  • 132: Implementing POST Request for MCP Client–Server Communication 06:10
  • 133: Handling GET, DELETE Requests & Configuring Express Routes 05:56
  • 134: Proficiency Quiz 18:00

• MCP Client Architecture and LLM Integration 41:52

  • 135: Architecture Deep Dive: The Critical Role of the MCP Client 06:20
  • 136: Introduction & Creating MCP Client Service Structure 04:57
  • 137: Implementing Singleton MCP Client and Client Initialization 06:16
  • 138: Connecting MCP Client to Server Using HTTP Transport 05:12
  • 139: Fetching Available Tools and Implementing Tool Calling Methods 05:07
  • 140: Proficiency Quiz 14:00

• Agent Controller and LLM Integration 43:56

  • 141: Creating Agent Controller and Preparing LLM Request Flow 03:11
  • 142: Integrating MCP Client with Gemini for Tool Calling 06:30
  • 143: Understanding MCP-to-Tool Architecture and Automatic Tool Execution 04:48
  • 144: System Instructions, Prompt Structure, and Temperature Settings 05:13
  • 145: Creating Routes, Running the Application, and Testing MCP Tools 09:14
  • 146: Proficiency Quiz 15:00

• OpenAI MCP Client Integration 48:28

  • 147: Introduction: Implementing MCP with OpenAI 05:24
  • 148: Setting Up OpenAI Service & Installing OpenAI Package 04:18
  • 149: Integrating MCP Client with Agent Controller 04:17
  • 150: Loading MCP Tools and Preparing Tool Context 05:06
  • 151: Writing System Instructions and Response Contract 04:44
  • 152: Preparing Messages Structure and Agentic Loop 06:39
  • 153: Proficiency Quiz 18:00

• MCP Tool Execution and Testing 43:15

  • 154: Creating Zod Schema for Tool Intent Validation 05:08
  • 155: Parsing OpenAI Responses and Executing MCP Tools 05:44
  • 156: Final Output Handling, Loop Completion & Environment Setup 06:59
  • 157: Testing MCP Tool Calling with OpenAI GPT Model 05:34
  • 158: Interview Prep: MCP Architecture Questions 05:50
  • 159: Proficiency Quiz 14:00

• Introduction to Agentic Systems 18:36

  • 160: What is an Agentic System? 01:35
  • 161: The "Why" - Beyond Simple Chatbots (Why Agentic) 01:17
  • 162: The Decision Loop - Why Hard-Coded Logic Fails 05:44
  • 163: Proficiency Quiz 10:00

• Agentic Design Patterns 20:51

  • 164: The Agentic Design Pattern - Passing RAG as a Tool 05:29
  • 165: Architecture Battle: RAG vs. MCP vs. Agents 03:40
  • 166: The Ecosystem: Apps that Support MCP 01:42
  • 167: Proficiency Quiz 10:00

• Vector Database Fundamentals 20:57

  • 168: The Memory Problem: Why AI Needs Vector Databases? 01:37
  • 169: What Vector Databases Do? 00:39
  • 170: What is ChromaDB? 04:28
  • 171: What is pgVector? 02:13
  • 172: Proficiency Quiz 12:00

• Vector Database Setup 27:03

  • 173: ChromaDB vs pgVector - When to Choose? 04:07
  • 174: Preparing File Structure and Data Assets (PDFs/Docs) for RAG 07:47
  • 175: Configuring ChromaDB in Local Environment 07:09
  • 176: Proficiency Quiz 08:00

• Vector Database Integration 39:50

  • 177: ChromaDB Client Configuration & Environment Setup 04:31
  • 178: VectorStoreChroma Class & Upsert Implementation 05:32
  • 179: Search Query Implementation & Vector Store Selection 08:18
  • 180: Introduction to the Data Ingestion Pipeline & Chunking Strategy 05:51
  • 181: Implementing the chunkText() Function for Document Chunking 03:38
  • 182: Proficiency Quiz 12:00

• Data Ingestion and PostgreSQL Configuration 41:32

  • 183: Building the ingestFolder() Function & Reading Files 05:55
  • 184: Generating Embeddings and Storing Chunks in Vector DB 04:47
  • 185: Running the Ingestion Script, CLI Command & Fixing Environment Error 07:09
  • 186: Configuring PostgreSQL & pgVector for MacOS 09:53
  • 187: Configuring PostgreSQL & pgVector for Windows 01:48
  • 188: Proficiency Quiz 12:00

• pgVector Configuration and Queries 42:30

  • 189: Enabling the pgVector Extension for Database Configuration 02:58
  • 190: Connecting NodeJS App to pgVector 02:09
  • 191: Setting Up PostgreSQL & pgvector Connection 04:57
  • 192: Creating the PG Vector Store & Table Schema 03:39
  • 193: Storing Embeddings with SQL Upsert 05:44
  • 194: Building Vector Similarity Search Queries 06:03
  • 195: Proficiency Quiz 17:00

• RAG Engine Development and Query Processing 35:10

  • 196: Testing the Vector Database Integration 04:02
  • 197: Creating the RAG Chunk Interface & RAG Engine Class 03:00
  • 198: Generating Query Embeddings & Validating Dimensions 04:26
  • 199: Searching the Vector Database & Processing Results 04:14
  • 200: Building Context, Prompt Engineering & Final RAG Pipeline 05:28
  • 201: Proficiency Quiz 14:00

• RAG + MCP Integration 52:00

  • 202: Preparing RAG as a Tool and registering in MCP 09:08
  • 203: Preparing the Environment for Agentic App Testing 03:15
  • 204: Testing Tools and Customer–Order Queries 03:39
  • 205: Debugging RAG with PGVector and ChromaDB 03:28
  • 206: Improving Prompt Engineering and Final Application Testing 07:49
  • 207: Model Agnostic - Testing Logic with OpenAI GPT 08:41
  • 208: Proficiency Quiz 16:00

• MongoDB Architecture Setup 38:29

  • 209: MongoDB Architecture Overview and Integration Strategy 00:41
  • 210: Installing and Configuring MongoDB Locally on macOS 09:14
  • 211: Installing and Configuring MongoDB Locally on Windows 06:49
  • 212: MongoDB Environment Setup & Mongoose Installation 04:25
  • 213: Creating MongoDB Connection Config & Server Initialization 06:20
  • 214: Proficiency Quiz 11:00

• MongoDB Models, Schemas, and Service Migration 55:32

  • 215: Creating Customer Schema & Interface with Mongoose 04:28
  • 216: Building the Customer Model & Understanding Mongoose Models 03:25
  • 217: Creating Order Schema & Preparing Database Insertion Service 03:42
  • 218: Creating MCP Tool for Customer Insertion & Testing in Chat App 07:51
  • 219: Migrating Customer Services from Mock Data to MongoDB 05:14
  • 220: Refactoring Order Services & Understanding Schema + Populate 05:46
  • 221: Creating Orders Tool & Testing via Chat Application 10:06
  • 222: Proficiency Quiz 15:00

• Schema Optimization and Advanced MongoDB Handling 52:38

  • 223: Understanding MongoDB _id Issue & Need for Schema Optimization 05:37
  • 224: Creating Global Schema Options for Cleaner MongoDB Responses 04:26
  • 225: Applying Schema Options to Customer Model & Transforming Fields 05:39
  • 226: Implementing Getters & Date Transformations in Customer Schema 05:26
  • 227: Designing Order Schema with References and Populate 05:05
  • 228: Fixing Query Output Types & Optimizing Tool Responses 08:39
  • 229: Proficiency Quiz 17:00
  • 230: Course Summary 00:46

You'll begin this Agentic AI course by building a complete full-stack RAG chatbot from the ground up, using Angular for the frontend and Node.js for the backend, while integrating both OpenAI and Gemini APIs.

Along the way, you'll learn the core mechanics behind retrieval-augmented generation, including embeddings, similarity search, and ranking, so your AI produces smarter, context-aware answers instead of generic ones. You'll also get your first introduction to tool-calling and MCP concepts, giving you a working system that can act, not just respond.

Then the course goes from AI to architecting agents. You will learn how to architect real MCP servers, designing tools, resources, and prompts so an agent can reliably call APIs and run workflows, not just generate text.

You’ll go deeper into tool calling with Gemini and OpenAI, creating agents that invoke backend actions and make multi-step decisions with little human input. You’ll also bring in vector databases like ChromaDB and pgVector to power fast, context-aware retrieval pipelines.

From there, you'll focus on making everything production-ready. You'll build a production-grade RAG engine using PostgreSQL and pgVector, complete with optimized similarity search and query pipelines. You'll design MCP-integrated workflows around realistic scenarios like customer records and order processing, refine your prompt engineering and context construction for more grounded, accurate outputs, and architect scalable MongoDB systems, covering schema design, service migration, and query optimization.

Applied Learning Throughout

This course is built around hands-on projects that mirror real agentic AI development, not hypothetical exercises:

• Building a full-stack RAG chatbot with Angular and Node.js

• Integrating LLMs like ChatGPT and Gemini for advanced language capabilities

• Designing an MCP server that lets AI agents call APIs and manage workflows autonomously

• Using vector databases (ChromaDB, pgVector) and embeddings for semantic search

• Working through realistic customer and order-processing scenarios
• Architecting scalable MongoDB and PostgreSQL systems for production use

This Agentic AI certification course is designed for anyone who wants to move beyond basic AI API usage and build real, production-ready intelligent systems. It's suited for:

• Software Developers looking to add AI agent development to their skill set

• AI/ML Engineers who want to specialize in agentic systems, RAG, and MCP architecture

• Backend Developers aiming to work with vector databases, MongoDB, and scalable data systems

• Full-Stack Developers wanting to build complete AI products from frontend to backend

• Students and Career Changers entering the AI engineering field with little to no prior experience

• Product Managers and Technical Leads who want a hands-on understanding of how agentic AI systems are architected

• Freelancers and Consultants looking to offer AI agent development services to clients
• AI Enthusiasts who've used tools like ChatGPT or Gemini and want to learn how to build with them, not just prompt them

• No prior AI experience needed

• Basic programming knowledge (JavaScript/Node.js/Angular) is preferred but not mandatory

This Full Stack Agentic AI course equips you with the skills to pursue high-demand roles such as:

• AI Engineer: Build production-grade agentic AI systems

• Agentic AI Developer: Build autonomous agents using MCP & tool-calling

• Backend Developer: Architect scalable AI data systems

• AI Solutions Architect: Design end-to-end RAG and agent architectures

There are currently no Q&As for this course. Be the first to ask a question.