Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Agentic AI Full‑Stack Masterclass: RAG, MCP & AI Agents

Name: Agentic AI Full‑Stack Masterclass: RAG, MCP & AI Agents
Rating: 4.6 (54 reviews)

Build production-grade Autonomous Agents with MCP, RAG, Gemini, OpenAI and Signals using Angular & Node.js.

Created byNikhil Agarwal

Last updated 6/2026

English

What you'll learn

Architect and build a complete Full-Stack Agentic AI application using Angular, Node.js, and Express.
Implement advanced Retrieval Augmented Generation (RAG) pipelines with embeddings, vector search, and context augmentation.
Master the Model Context Protocol (MCP) by building custom MCP Servers in Node.js to expose real-world tools to LLMs.
Build a production-ready Chat Interface in Angular that handles streaming responses, Markdown rendering, and tool outputs.
Set up and manage Vector Databases (ChromaDB and pgVector) to store high-dimensional embeddings for semantic search.
Create Static RAG Systems using JSON and math-based Cosine Similarity to understand the core algorithms of retrieval.
Implement Native Tool Calling with Gemini and OpenAI to turn natural language into executable code functions.
Connect your RAG Engine as an MCP Tool, creating a modular system where Agents can "choose" to search your database.
Implement MongoDB integration from schema design to optimized query execution within a production-grade Angular and Node.js architecture.

Course content

11 sections • 89 lectures • 15h 19m total length

Course Introduction: Overview of the Full Stack Agentic System1:32
A roadmap of what we will build: A fully autonomous AI Agent using Angular, Node.js, and the Model Context Protocol.
The Problem with Standard AI Models: Why ChatGPT/Gemini/Claude isn't enough4:06
Understanding hallucinations, knowledge cutoffs, and why "out-of-the-box" AI cannot solve complex business problems.
What is RAG? Understanding Retrieval Augmented Generation6:01
A clear explanation of Retrieval Augmented Generation: How to connect your private data to an LLM.
What is MCP? The Model Context Protocol Explained15:17
Introduction to Anthropic's open standard (MCP) that standardizes how AI models connect to data sources.
How MCP Server Actually Works: Architecture Deep Dive3:49
Visualizing the MCP architecture: How the Host, Client, and Server communicate to execute tools.
How RAG + MCP Work Together: The Power of Combined Systems1:52
How to use MCP to "serve" RAG as a tool, allowing the AI to decide when to search your database.
Is RAG Alone Sufficient? Limitations of Simple Retrieval! RAG Only vs RAG + MCP6:28
Why simple search isn't enough for complex reasoning and why we need "Agents" to act on that data.
The Evolution: From Chatbots to Agentic Systems3:42
Moving beyond "Chat" interfaces to autonomous systems that can plan, execute, and verify tasks.
What You'll Build in This Course1:27
A demo of the final project: An Angular Chatbot connected to a Node.js Agent that uses Vector DBs and MCP.
Career Prep: RAG & Agent Architecture Questions7:38
Common interview questions asked by companies hiring for GenAI and Full Stack AI roles.
Agentic AI Full-Stack Project Demo2:09
Resources0:01
Join our Discord and Youtube Community1:00

Development Environment - Install Node.js & VS Code Setup8:44
Setting up the Angular CLI and VS Code extensions for AI development.
Create Gemini-AI API Key0:43
Learn how to generate and manage a Gemini AI API key to start using Google’s AI models in your applications.
Create OpenAI (ChatGPT) API Key4:22
Learn how to create and securely manage an OpenAI API key for integrating AI features into your projects.

Module Introduction0:36
Introduction to the Core Concepts of Retrieval Augmented Generation.
Understanding RAG Architecture6:46
High-level overview of the Retrieval Augmented Generation pipeline.
How RAG Actually Works Behind the Scenes4:19
A technical look at the data flow: from user query to retrieved context.
Understanding Embeddings, Retrieval and Augmentation2:29
How AI converts text into numbers (vectors) to understand semantic meaning. Breaking down the three pillars of RAG: Creating vectors, finding matches, and feeding the LLM.

Designing the Chat Interface (Angular UI - via Vibe Coding)33:04
Creating a responsive, modern chat layout using HTML/CSS (Tailwind CSS) and Angular components.
Preparing Frontend for API calling24:13
Setting up Angular Services and HttpClient to communicate with the backend.
Create and Run NodeJS (with ExpressJS) App for Backend15:06
Integrating AI LLM (Gemini) API in NodeJS23:13
Implementing the Google Gemini API in Node.js to generate responses.
Testing NodeJS API in Angular Chat App - Chat with AI4:50
Connecting the Angular frontend to the Node.js backend and verifying the chat flow.
Resources: Source Code Download0:02

Static RAG - Building a Q&A Bot with JSON using Gemini AI13:05
Creating a simple retrieval system using a local JSON file as the "database."
Implementing Text Embeddings, Cosine Similarity and scoring30:28
Hands-on guide to generating embeddings for your text data using OpenAI/Gemini. Understanding how we calculate the "distance" between two vectors to find the best match.
Integrating OpenAI LLM for Answers18:55
Integrating OpenAI LLM for RAG Static Q&A Bot along with Gemini option too. Multi-LLM Modal Options
Testing Q&A Bot with OpenAI for Answers3:51
Testing the RAG App with OpenAI LLM for Accurate Answers
Interview Prep: RAG & Similarity Questions5:46
Interview based questions related to RAG - embeddings, Ranking, Q&A Bot Project
Resources0:03

Module Introduction: The MCP Server Roadmap2:36
Overview of the backend architecture we will build in this section.
Preparing a New NodeJS (TypeScript) Project16:25
Initializing a professional TypeScript project structure for AI development.
Integrating AI Model (Gemini) in NodeJS9:53
How to securely integrate AI models (Gemini / OpenAI) into your backend application.
Prepare Custom APIs15:37
Creating a standard Express API endpoint to expose data to the frontend.
Preparing a Weather API - Real-World Tool7:59
Coding a functional Weather API that fetches real-time data (the "Tool").
Code Optimization & Refactoring24:51
Best practices for structuring Node.js code for scalability and maintenance.
Understanding MCP - Architecture & Functionality12:27
A deep dive into how the Model Context Protocol actually functions. We break down the relationship between the Host (e.g., Claude Desktop/IDE), the Client, and the Server, explaining how they communicate to solve the "context problem" in AI.
Tool vs Resource vs Prompt in MCP21:19
Master the core primitives of MCP. We explain the difference between Resources (reading data like logs/files), Tools (executing actions like API calls), and Prompts (reusable templates), and when to use each in your agentic system.
Understanding Transport Layer in MCP8:35
How does the LLM actually "talk" to your local code? We explore the Transport Layer, comparing STDIO (Standard Input/Output for local processes) vs. SSE (Server-Sent Events for remote connections) and how JSON-RPC 2.0 powers the message exchange.
Architecture Battle: MCP vs. Native Tool Calling11:35
Visual comparison: Why MCP is better than standard API integrations.
Implementating Gemini Native Function Calling (without MCP)32:26
Hands-On: Implementing "Tool Calling" the hard way (Native) using Google Gemini.
Implementating OpenAI Native Function Calling (without MCP)39:36
Hands-On: Implementing "Tool Calling" the hard way (Native) using OpenAI GPT Models.
Testing OpenAI Native Tool Calling in Frontend4:59
Hands-On: Testing "Tool Calling" the hard way (Native) using OpenAI GPT Models.
Preparing the Custom MCP Server & Tool Registry35:47
Writing the core logic to wrap your Weather API as an MCP-compliant tool.
Implementing Transport Layer and Configuring Routes for AI Communication21:46
Setting up the communication channels (Transport) that allow LLMs to "see" your tools.
Architecture Deep Dive: The Critical Role of the MCP Client6:12
Understanding the role of the Client in the MCP Architecture and why it's necessary.
Preparing MCP Client and Test MCP Tool Calling in Gemini54:24
Configuring the MCP Client to allow Gemini to execute your local tools.
OpenAI Integration - Adapting the MCP Client for GPT Models47:12
Configuring the MCP Client to allow OpenAI GPT Model to execute your local tools.
Testing MCP Tool Calling with OpenAI GPT Model5:25
Testing the MCP Client to allow OpenAI GPT Model to execute your local tools.
Interview Prep: MCP Architecture Questions5:42
Advanced technical questions on Protocol design and Tool Calling flow.
Resources: Source Code and PDFs Download0:01

Module Intro: The Shift to Agentic AI1:40
Introduction to the core module: Building autonomous systems that think.
What is an Agentic System?1:27
Defining "Agency": How LLMs plan, execute, and verify tasks autonomously.
The "Why" - Beyond Simple Chatbots (Why Agentic)1:09
Why standard RAG is often not enough for complex business logic.
The Decision Loop - Why Hard-Coded Logic Fails5:36
Analyzing why if/else statements cannot handle dynamic user intent.
The Agentic Design Pattern - Passing RAG as a Tool5:21
The architectural secret: Treating your database search as a "Tool" the Agent can choose.
Architecture Battle: RAG vs. MCP vs. Agents3:32
A clear breakdown of how these three technologies stack together.
The Ecosystem: Apps that Support MCP1:34
A tour of the current landscape of applications supporting this protocol.
Resources: Source Code and PDFs Download0:02

The Memory Problem: Why AI Needs Vector Databases?1:29
Understanding the limitations of Context Windows and why external storage is critical for production apps.
What Vector Databases Do?0:31
How vector databases store data not by keywords, but by "meaning" (Vectors/Embeddings).
What is ChromaDB?4:20
An overview of ChromaDB: The open-source, AI-native database designed for speed and ease of use.
What is pgVector?2:05
An overview of pgVector: How to turn standard PostgreSQL into a powerhouse vector search engine.
ChromaDB vs pgVector - When to Choose?3:59
A strategic comparison to help you decide when to use a specialized DB (Chroma) vs. an existing SQL DB (Postgres).
Resources: Source Codes or PDFs Download0:02

Preparing File Structure and Data Assets (PDFs/Docs) for RAG7:39
Organizing the project assets and creating the directory structure to handle PDF and text document ingestion.
Configuring ChromaDB in Local Environment7:01
Step-by-step guide to installing ChromaDB locally and verifying the server is running for fast vector retrieval.
Integrating ChromaDB in NodeJS - Writing Dynamic Queries18:02
Coding the TypeScript logic to connect to Chroma, insert embeddings, and perform similarity searches.
Data Pipeline - Building the Ingestion Script26:42
Writing the core script that reads documents, splits them into chunks, vectorizes them, and saves them to the DB.
Configuring PostgreSQL & pgVector for MacOS9:45
A dedicated setup guide for Mac users to get PostgreSQL and the pgVector extension running.
Configuring PostgreSQL & pgVector for Windows1:40
A dedicated setup guide for Windows users to ensure PostgreSQL and pgVector are configured correctly.
Enabling the pgVector Extension for Database Configuration2:50
How to run the SQL commands required to enable vector operations inside your standard PostgreSQL database.
Connecting NodeJS App to pgVector2:01
Setting up the database driver in Node.js to establish a secure connection for vector operations.
Writing Vector Search Queries - SQL for AI23:46
Writing the specialized SQL queries needed to perform cosine similarity searches directly inside the database.

The RAG Engine - Coding the Retrieval Logic16:44
Writing the core TypeScript function that accepts a user query, searches the Vector DB (Part 2), and returns the most relevant context.
Preparing RAG as a Tool and registering in MCP9:00
The critical integration step: Wrapping your RAG Engine as an MCP Tool so the AI Agent can "decide" when to look up information.
System Test - Validating the Full Agentic Workflow using Gemini17:44
Running the complete full-stack application: Frontend Chat → Node.js Agent → MCP Tool → Vector DB → Final Answer. (Google Gemini)
Model Agnostic - Testing Logic with OpenAI GPT8:24
Running the complete full-stack application: Frontend Chat → Node.js Agent → MCP Tool → Vector DB → Final Answer. (OpenAI GPT)
Resources: Source Code and PDFs Download0:04

Requirements

Solid understanding of JavaScript & TypeScript: You must be comfortable with Async/Await, Promises, and ES6+ syntax.
Basic Node.js & Express: We build a backend API, so you should know how to set up a server and routes.
Frontend Fundamentals: Experience with Angular is required. We move fast on the UI (using AI-assisted scaffolding)
No AI Experience Needed: I will teach you RAG, Vector DBs, and MCP from the ground up.

Description

Stop building basic chatbots. Start building Enterprise-Grade AI Agents.

Welcome to the Agentic AI Engineering Program for Angular Developers.

Most AI courses focus on Python or React. But enterprise applications run on Angular. In this course, you will architect a complete Full-Stack Agentic AI System using Angular (Latest) and Node.js, built with real production architecture in mind.

This is not a toy project. You will design and deploy a scalable AI platform using Clean Architecture, structured services, and real database persistence.

What You Will Build:

A production-ready AI platform featuring:

Real-time LLM token streaming
Structured Tool Calling
Deterministic RAG pipelines
Custom MCP Servers
Production-grade MongoDB integration

You will replace mock data with a fully integrated MongoDB backend, design optimized schemas, insert data via Custom MCP workflows, and implement performant queries for real-world scalability.

Core Technical Deep Dives

Model Context Protocol (MCP):

Build Custom MCP Servers in Node.js and expose internal databases as tools to Google Gemini and OpenAI GPT models.

Angular Signals & AI Streaming:

Handle high-velocity token streams using Angular Signals and RxJS, ensuring smooth UI updates without performance issues.

Advanced RAG Pipelines:

Implement vector search using ChromaDB and pgVector. Manage embeddings, similarity search, and deterministic context augmentation manually.

Native Tool Calling:

Force LLMs to generate strict structured JSON outputs that directly trigger backend logic — the foundation of reliable agent automation.

Production Database Architecture:

Design scalable MongoDB schemas, migrate from mock data to real persistence, and optimize queries for performance.

Tech Stack

Frontend: Angular (Latest), Signals, TailwindCSS
Backend: Node.js, Express, TypeScript (Strict Mode)
Database: MongoDB
Vector Databases: ChromaDB, pgVector (PostgreSQL)
AI Models: Google Gemini, OpenAI GPT
Protocols: Model Context Protocol (MCP)

If you want to move beyond tutorials and start building scalable, intelligent systems with real enterprise architecture, this course is for you.

Who this course is for:

Full-Stack Developers who want to transition from traditional web apps to building AI-powered Agentic systems.
Solutions Architects & Tech Leads who need to implement the new Model Context Protocol (MCP) standard in enterprise.
AI Enthusiasts looking to master the Model Context Protocol (MCP) and modern Tool Calling standards.
Software Engineers who need to implement RAG and Vector Search without relying on "black box" frameworks like LangChain.
Freelancers & Consultants who want to offer high-value "Custom AI Agent" services to clients.
Developers who want hands-on experience designing MongoDB schemas and integrating real database architecture into AI-powered full-stack systems.

Agentic AI Full‑Stack Masterclass: RAG, MCP & AI Agents

What you'll learn

Explore related topics

Course content

Course Introduction: The Landscape of Agentic AI - RAG, MCP, and the Future13 lectures • 55min

Setting up the Environment3 lectures • 14min

Deep Dive into RAG: Architecture, Embeddings & Vector Search SEO4 lectures • 14min

Build a Modern AI Chatbot: Angular, NodeJS & Gemini API6 lectures • 1hr 40min

Static RAG Q&A Bot - JSON, Embeddings & Cosine Similarity6 lectures • 1hr 12min

Building a Custom MCP Server: Node.js, Weather API & Tool Calling21 lectures • 6hr 25min

Building AI Agentic Systems (Part 1): Architecture & Patterns8 lectures • 20min

Understanding Vector Databases6 lectures • 12min

Building AI Agentic Systems (Part 2) - Vector Database Bootcamp9 lectures • 1hr 39min

Building AI Agentic Systems (Part 3) - MCP + RAG (pgvector & ChromaDB) + AI LLMs5 lectures • 52min

Requirements

Description

Who this course is for: