Generative AI, LLMs & Agentic AI for Modern Applications

Generative AI, LLMs & Agentic AI for Modern Applications
(In Association with iHUB Divyasampark IIT Roorkee)

About the Course:

Course Objectives:

• To introduce participants to core AI concepts, including Natural vs Artificial Intelligence, Machine Learning, Deep Learning, and Generative AI fundamentals.

• To enable learners to do Data Processing for automation, data handling, and API integration (including OpenAI API).

• To introduce participants to Natural Language Processing (NLP) and equip them to build text-processing pipelines including tokenization, sentiment analysis, and custom text classifiers.

• To make learners proficient in working with Large Language Models (LLMs), covering transformer architecture, GPT, BERT, Hugging Face, and LangChain for chatbot development and text generation.

• To equip learners with the knowledge of LangChain framework, LangGraph, and Retrieval Augmented Generation (RAG) for building advanced conversational agents and memory-enabled systems.

• To familiarize learners with Vector Databases (e.g., Pinecone) and their applications in semantic search, recommendation engines, and biomedical research.

• To introduce learners to Speech Recognition and Speech-to-Text systems using traditional ML, Deep Learning, and transformer-based approaches such as Whisper AI.

• To prepare learners for LLM Engineering, including prompt engineering, hosting models vs APIs, cost optimization, scaling strategies, and deploying AI-powered applications with Streamlit.

Prerequisites and eligibility:

Course Overview:

      Module 1: Foundations of Artificial Intelligence & Generative AI

• Building an AI Tool: Overview of the AI application development workflow.
• Artificial Intelligence: Natural vs Artificial Intelligence, brief history and Weak vs Strong AI.
• AI Ecosystem: AI vs Data Science vs Machine Learning vs Deep Learning 
• Data Basics: Data collection, labelled vs unlabelled, structured vs unstructured; metadata
• Machine & Deep Learning: Quick overview of Important Aspects & Applications.
• Natural Language Processing (NLP): Introduction to NLP and its applications 
• Generative AI: Concepts, evolution, applications and introduction to ChatGPT.
• Large Language Models (LLMs): Evolution from N-Grams and RNNs to Transformers; training and inference concepts
• Generative AI Development: Prompt Engineering, Fine-Tuning & RAG-conceptual overview 
• Foundation Models: Open-source vs proprietary models and model selection
• Challenges of Generative AI: Hallucination, inconsistency, bias, data limitations, latency, cost and privacy/security.
• AI Stack: Python, LLM APIs, Hugging Face, LangChain &Vector Databases-an Overview.·

      Module 2: Data Processing for Generative AI

• NumPy Library: Arrays, indexing, slicing, reshaping and vectorized operations.
• Pandas: Series, DataFrames, data types and basic data manipulation. 
• Data Manipulation: Selection, filtering, sorting, indexing (loc/iloc) and groupby operations.
• Data Cleaning & Preprocessing: Missing values, duplicates, data type conversion and basic preprocessing.
• Text Data Processing: String operations, text cleaning and Regular Expressions (Regex).
• File & Data Handling: Reading and writing CSV, JSON and text files.
• Data Exploration: Loading, inspecting, transforming and exporting datasets.

      Module 3: Natural LAnguage Processing (NLP) & Text Analysis

• NLP Fundamentals: Introduction, applications & NLP workflow; supervised vs. unsupervised.
• Text Preprocessing: Text cleaning, normalization, stop-word removal and Regular Expressions.
• Text Representation: Tokenization, stemming, lemmatization and N-grams
• Linguistic Analysis: POS tagging and Named Entity Recognition (NER)
• Text Classification: Sentiment analysis and traditional ML-based text classification
• Numerical Representation: Bag-of-Words, TF-IDF and text feature extraction
• Modern NLP: Introduction to embeddings and pre-trained Transformer-based NLP models
• Hands-on: Build a Text Classification & Sentiment Analysis System using Python and NLP

      Module 4: Large Language Models (LLMs) & Transformer Architecture

• Understanding LLMs: General-purpose & foundation models, applications & limitations
• LLM Training: Pre-training, instruction tuning, fine-tuning and inference
• Transformer Architecture: Input embeddings, positional encoding, self-attention, multi-head attention and feed-forward networks
• Transformer Variants: Encoder, decoder and architectures; masked attention
•  GPT: GPT architecture, autoregressive generation, tokenization & text generation
•  LLM Parameters: Temperature, top-p, maximum tokens & prompt-based customization
•  OpenAI API: API setup, model interaction, text generation and structured responses
•  Hugging Face Transformers: Transformer pipeline, pretrained models & special tokens
•  Encoder-based Models: BERT, RoBERTa & DistilBERT-architecture, applications & comparison
• LLM Applications: Text generation, summarization, question answering and conversational AI
•  Fine-Tuning: Fundamentals, workflow & practical aspects for adapting pretrained models
•  Hands-on: Build a Question-Answering and Text Generation Application using Hugging Face and an LLM API

      Module 5: LangChain & Retrieval-Augmented Generation (RAG)

• Introduction to LangChain: Framework architecture, LLMs, chat models, environment setup & API configuration
• LLM Interaction: System, Human and AI messages; temperature, token limits and streaming
• Prompt Engg. with LangChain: Prompt templates, message templates & few-shot prompting
• Output Parsing: String, structured and list-based output parsers
• LangChain Expression Language (LCEL): Chains, Runnable Sequence, Runnable Passthrough, Runnable Parallel and Runnable Lambda
• Chain Execution: Sequential processing, batching and streaming
• RAG Fundamentals: Architecture, workflow and applications of RAG
• Document Processing: Document loading, text splitting and metadata handling; PDF, DOCX and text documents
• Text Embeddings & Vector Stores: Embeddings, Chroma vector store and document indexing
• Information Retrieval: Similarity search, Maximal Marginal Relevance (MMR) and vector-store retrievers
• RAG Pipeline: Retrieval, context augmentation and response generation
• RAG Optimization: Chunk size, overlap, retrieval parameters and prompt design
• Hands-on: Build a Document Question-Answering (RAG) Chatbot using LangChain, Chroma and an LLM

      Module 6: LangGraph & Agentic AI Flows

• Introduction to LangGraph: Architecture, use cases and relationship with LangChain
• Graph Fundamentals: State, nodes, edges and message-based workflows
• Building Workflows: Creating nodes, defining state & constructing the first LangGraph application
• Conditional Workflows: Routing functions, conditional edges and dynamic execution
• State Management: State, MessagesState, reducers, Annotated and message management
• Memory & Persistence: Threads, Checkpointers and state persistence
• Short-Term Memory: InMemorySaver and conversational state management
• Long-Term Memory: Persistent storage using SQLite
• State Inspection: StateSnapshot and monitoring workflow execution
• Agentic Workflows: Multi-step reasoning, tool-based workflows and basic agent architecture
• Error Handling & Workflow Control: Managing execution flow and maintaining reliable state
• Hands-on: Build a Stateful AI Agent with LangGraph featuring conditional routing, conversation memory and persistent state

      Module 7: Vector Databases & Semantic Search

• Introduction: Need for vector databases; SQL vs NoSQL vs Vector Databases
• Vector Fundamentals: Vector space, embeddings, similarity concepts and distance metrics -Cosine Similarity, Euclidean Distance and Dot Product
• Vector Database Architecture: Collections/indexes, vectors, metadata, namespaces and similarity search
• Vector Database Platforms: Overview and comparison of Pinecone, Chroma, FAISS and other popular vector databases
• Pinecone: Account setup, API configuration, creating indexes & managing vector collections
• Pinecone with Python: Connecting to Pinecone, generating embeddings, upserting vectors and metadata, querying and retrieving results
• Advanced Retrieval: Metadata filtering, top-K search, similarity thresholds & hybrid search
• Vector Database Applications: Semantic search, recommendation systems, document retrieval, question answering and AI-powered applications
• Integration with GenAI Applications: Connecting vector databases with LLMs, RAG pipelines
• Hands-on Project: Build a Semantic Search & Recommendation System using Python, embeddings and Pinecone

      Module 8: Speech Recognition & Speech AI

• Introduction to Speech AI: Evolution of speech recognition, applications & end-to-end speech processing pipeline
• Speech & Audio Basics: Sound waves, frequency, harmonics, formants and phonemes
• Digital Audio Processing: Sampling rate, bit depth, bit rate, audio formats and importing/processing audio using Python
• Audio Signal Processing: Time-domain, frequency-domain and time-frequency representations; Fourier Transform and spectrograms
• Audio Preprocessing & Feature Extraction: Noise reduction, normalization and extraction of relevant audio features for machine learning
• Traditional Speech Recognition: Acoustic and language models, Hidden Markov Models (HMMs) and their evolution
• Deep Learning for Speech Recognition: CNNs, RNNs and LSTMs for speech processing
• Transformer-based Speech Recognition: Attention mechanisms, Transformers and modern end-to-end speech recognition systems
• Speech-to-Text APIs & Models: Google Web Speech API and OpenAI Whisper; model-based vs API-based approaches
• Whisper AI: Transformer-based speech recognition, audio transcription, multilingual transcription and batch processing of multiple audio files
• Speech Recognition Evaluation: Word Error Rate (WER), Character Error Rate (CER) and practical evaluation of transcription quality
• Text-to-Speech (TTS): Basics of speech synthesis and AI-powered text-to-speech systems
• Hands-on Project: Build an AI-powered Speech Transcription & Text-to-Speech Application using Python, Whisper and a TTS service

      Module 9: LLM Engineering & Production AI Applications

• LLM Application Architecture: LLM APIs vs self-hosted models; open-source vs proprietary models; selecting models based on performance, cost, latency and use case
• Tokens & LLM Economics: Tokenization, context windows, input/output tokens, API pricing and estimating application costs
• Prompt Engineering for Applications: Prompt structure, system instructions, role-based prompting, prompt templates & prompt optimization across software development lifecycle
• LLM Parameters & Output Control: Temperature, Top-P, maximum tokens and parameter selection for different use cases
• LLM Application Design: Requirement analysis, application workflow, database/schema design and activity diagrams for AI-powered applications
• OpenAI Playground & API Development: Model experimentation, API configuration, client initialization and structured interaction with LLMs
• Building LLM Applications with Streamlit: Application structure, UI components, text and chat elements, forms and session-state management
• Conversational AI Development: Chat functionality, conversation history, session management, feedback collection and user interaction
• Reliability & Safety: Hallucination mitigation, prompt injection, input validation, output control and responsible application design
• Cost Optimization & Performance: Token optimization, prompt optimization, model selection, caching, latency reduction and efficient API usage
• Deployment & Scaling: Application deployment, configuration management, monitoring, scalability and production considerations
• Hands-on Capstone Project: Develop and deploy a Production-Ready LLM Chat Application using an LLM API and Streamlit, incorporating conversation memory, feedback, cost optimization and basic security controls

Contact Person: Dr. Subrat Kotoky

Email: [email protected] / [email protected]

Phone: 9085317465 / 8473874389

Expert Profile: Mr. Shreyas Shukla

       


Register Now