Generative AI
Mastering Transformer Architectures, RAG Systems, Fine-Tuning & Multi-Agent Orchestration
5 Months
4 Hours
Course Incharge
Muzammil Bilwani
📋 Prerequisites
✓ Python programming experience required. Essentials for AI & Prompt Mastery recommended as prior course for students new to AI concepts.
📖 Course Description
A comprehensive, builder-focused course for students who want to move beyond using AI tools to actually building with them. Covers how large language models and transformers work under the hood, developer-level prompt engineering, retrieval-augmented generation (RAG), fine-tuning, vector databases, multi-agent systems, evaluation, and production deployment — culminating in a fully deployed, AI-powered application.
What You Will Learn
Understand transformer architecture and how LLMs are trained
Use LLM APIs (OpenAI, Claude, open-source models) programmatically
Apply developer-level prompt engineering techniques
Build Retrieval-Augmented Generation (RAG) systems with vector databases
Understand fine-tuning vs. prompting vs. RAG trade-offs
Design and build multi-agent AI systems with tool use
Evaluate LLM application quality and reliability
Deploy AI applications to production with monitoring
Build and deploy a complete, production-ready AI-powered application
Course Outline
Foundations of Generative AI
- →How LLMs work — transformers, attention, tokens explained
- →The evolution from GPT-1 to modern LLMs
- →Overview of the generative AI ecosystem and use cases
- →Hands-on: Explore and compare outputs from multiple LLM providers
Working with LLM APIs
- →Setting up and using the OpenAI/Claude API in Python
- →Understanding tokens, context windows, and pricing
- →Handling API responses, streaming, and errors
- →Hands-on: Build a simple Python script that calls an LLM API
Developer-Level Prompt Engineering
- →System prompts, few-shot examples, and chain-of-thought prompting
- →Structuring outputs with JSON mode
- →Prompt templates and reusable prompt design
- →Hands-on: Build a prompt-driven mini application (e.g. content generator)
Function Calling and Tool Use
- →Introduction to function calling / tool use in LLM APIs
- →Designing tools/functions for an LLM to call
- →Handling tool call responses in an application
- →Hands-on: Build an LLM app that calls a custom function/tool
Introduction to Embeddings
- →What are embeddings? Vector representations of text
- →Generating embeddings with an API
- →Measuring similarity (cosine similarity) between texts
- →Hands-on: Build a simple semantic search script using embeddings
Vector Databases
- →Introduction to vector databases (Pinecone, Chroma, or similar)
- →Storing and querying embeddings at scale
- →Indexing strategies for semantic search
- →Hands-on: Set up a vector database and perform semantic search on a document set
Building RAG Systems — Part 1
- →RAG architecture — retrieval + generation explained
- →Document chunking and preprocessing strategies
- →Building the retrieval component of a RAG pipeline
- →Hands-on: Build the retrieval half of a RAG system on custom documents
Building RAG Systems — Part 2
- →Combining retrieval with generation for grounded answers
- →Handling context injection and prompt construction
- →Evaluating and improving RAG answer quality
- →Hands-on: Complete a working RAG chatbot over a custom knowledge base
Advanced RAG Techniques
- →Re-ranking, hybrid search, and query rewriting
- →Handling multi-document and long-context retrieval
- →Common RAG failure modes and how to fix them
- →Hands-on: Improve your RAG system with an advanced retrieval technique
Introduction to Fine-Tuning
- →Fine-tuning basics — when and why to fine-tune
- →Fine-tuning vs. prompting vs. RAG — decision framework
- →Preparing a dataset for fine-tuning
- →Hands-on: Prepare a fine-tuning dataset for a specific task
Fine-Tuning in Practice
- →Fine-tuning a model using a hosted API or lightweight open-source approach
- →Evaluating fine-tuned model performance
- →Cost and infrastructure considerations
- →Hands-on: Fine-tune or adapt a model and compare it to the base model
Introduction to AI Agents
- →What are AI agents? Agent loops and reasoning patterns (ReAct)
- →Giving agents tools and memory
- →Single-agent architecture design
- →Hands-on: Build a simple single-agent system that uses tools
Multi-Agent Systems
- →Multi-agent orchestration patterns — roles, delegation, communication
- →Agent frameworks overview (LangChain/LangGraph or similar)
- →Designing workflows with multiple specialized agents
- →Hands-on: Build a multi-agent workflow for a defined task
Evaluating LLM Applications
- →Why evaluation matters — hallucination, reliability, consistency
- →Building evaluation datasets and test cases
- →Automated and human evaluation approaches
- →Hands-on: Build an evaluation suite for your RAG or agent system
Safety, Guardrails, and Responsible AI
- →Prompt injection and jailbreak risks
- →Content filtering and guardrail techniques
- →Responsible AI design principles for applications
- →Hands-on: Add basic guardrails to your AI application
Deploying AI Applications
- →Packaging an AI application (API, simple frontend)
- →Deployment basics and environment configuration
- →Monitoring cost, latency, and usage in production
- →Hands-on: Deploy your AI application to a live environment
Capstone Project — Build
- →Planning a complete AI-powered application (RAG chatbot, agent workflow, or custom AI tool)
- →Building the core system — retrieval, agents, or fine-tuned components
- →Integrating evaluation and guardrails
- →Hands-on: Build the majority of the capstone application
Capstone Project — Deployment and Presentation
- →Final testing, evaluation, and deployment
- →Preparing a technical demo and documentation
- →Capstone: Present and demo a complete, deployed AI-powered application
- →Course wrap-up and next steps
Grading Criteria
Ready to Register in This Course?
Join thousands of students who have transformed their careers. Start your journey today!