🏫 Programming & Software Development

Generative AI

Mastering Transformer Architectures, RAG Systems, Fine-Tuning & Multi-Agent Orchestration

Duration

12 Weeks

Weekly Hours

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

Component	Percentage
Quizzes	20%
Class Participation / Attendance	15%
Projects	25%
Final Projects	40%
Total	100%

Ready to Register in This Course?

Join thousands of students who have transformed their careers. Start your journey today!