Generative AI & Agentic AI Course in Pune

Python for GenAI

• Installation Process
  • Python Interpreter Installation
  • Python vs Anaconda Python
  • IDE installation
  • Introduction of Jupyter Notebook
• Introduction to Python & Its Objects
  • Python syntax basics
  • Comments in Python
  • Indentation rules
  • Variables in Python
  • Basic data types – int, float, str, list, dict, tuple, set, None, Bool
  • Arithmetic operators
  • Comparison operators
  • Assignment operators
  • Membership and identity operators
  • Data Handling in int, Str
  • Indexing & Slicing in strings
• Operators in Python & User Defined Functions
  • Basic operations on list
  • Basic operations on tuple
  • Basic operations on dict
  • Introduction to Set, None and Bool Objects
  • Introduction to User Defined Functions
  • Defining a Function using def
  • Calling a Function
  • Function Parameters and Arguments
  • Default Parameters
  • Keyword Arguments
  • Return Statement
• Functions in Python
  • Built-in functions in Python
  • input(), len(), type(), abs(), pow(), min(), max(), sum(), range(),
  • enumerate(), zip(), map(), filter(), sorted(), reversed(), all(), any(), id(), help(), dir(), isinstance().
  • str – lower(), upper(), strip(), replace(), split(), join(), find(), startswith(), endswith(), count(), capitalize(), title(), swapcase(), isdigit(), isalpha(), isalnum()
  • list -m append(), extend(), insert(), remove(), pop(), clear(), index(), count(), sort(), reverse()
  • tuple – count(), index()
  • dict – keys(), values(), items(), get()
• Conditonal Statement in Python
  • Introduction to Conditional Statements
  • if Statement
  • if-else Statement
  • if-elif-else Statement
  • Nested if Statements
  • Comparison Operators in Conditions
  • Logical Operators (and, or, not)
  • Practical Examples of Conditional Statements
  • Exception Handling try, except
• Loops in Python – for
  • Introduction to for Loop
  • Syntax of for Loop
  • Flow of Execution in a for Loop
  • Using Conditions in for Loop
  • Using break with for Loop
  • Using continue with for Loop
  • Using pass in for Loop
  • for Loop with else Statement
  • Nested for Loops
• Python Modules
  • Introduction to Python Built-in Modules
  • Importing Modules (import, from, as)
  • Exploring Modules using dir()
  • The datetime Module
  • requests Module
  • Json Module – Introduction to JSON Format, Reading & Writing JSON Data, Converting Python Objects to JSON (dump, dumps), Converting JSON to Python Objects (load, loads)
  • Pip installation
• AI API’s Python
  • Setting up Environment (Python, pip, virtual environment, API keys)
  • Working with ChatGPT API (OpenAI) – basic request & response
  • Gemini API Integration (Google AI) – setup and simple usage
  • Prompt Engineering Basics – writing effective prompts
  • Mini Project (Text summarizer or email generator)
  • Error Handling & API Best Practices (rate limits, cost control)
• Data Handling with Python (pandas)
  • File Handling – Open, Write and Append
  • Introduction to Pandas
  • Installing and Importing Pandas
  • Pandas Series
  • Handling Pandas Series
  • Pandas DataFrame
  • Handling Pandas DataFrane
  • Accessing Dataframes
  • Reading CSV
  • Reading Excel
  • Reading JSON

DS Foundation for GenAI

• AI, Machine Learning & Deep Learning Fundamentals
  • AI, ML and DL Overview: Evolution of AI technologies and difference between Artificial Intelligence, Machine Learning and Deep Learning.
  • Machine Learning Fundamentals: How models learn patterns from historical data and use them for prediction.
  • Types of Machine Learning: Supervised learning, unsupervised learning and reinforcement learning approaches.
  • ML Problem Types: Understanding regression, classification and clustering use cases.
• Machine Learning Workflow, Data Preparation & Feature Engineering
  • ML Lifecycle: Problem definition, data collection, model development, evaluation and deployment process.
  • Data Preprocessing: Handling missing values, duplicate records, incorrect data and preparing clean datasets.
  • Features and Labels: Understanding input variables and target outputs used during model training.
  • Dataset Splitting: Training, validation and testing approaches for reliable model evaluation.
  • Feature Engineering: Creating, transforming and selecting features to improve model performance.
• Machine Learning Algorithms & Model Evaluation
  • Regression: Predicting continuous numerical values using techniques like Linear Regression for real-world prediction problems.
  • Classification: Predicting categories using algorithms such as Logistic Regression, Decision Tree and Random Forest.
  • Clustering: Grouping similar data points using unsupervised learning techniques like K-Means.
  • Model Evaluation: Measuring performance using Accuracy, Precision, Recall, F1 Score, MAE and RMSE.
  • Model Improvement: Understanding overfitting, underfitting and regularization techniques.
• Neural Network Fundamentals
  • Artificial Neuron: Basic unit of neural networks that processes inputs using weights and produces outputs.
  • Perceptron: Simple neural network model used to understand binary classification concepts.
  • Neural Network Architecture: Structure of input layer, hidden layers and output layer.
  • Weights and Bias: Parameters adjusted during training to improve model predictions.
  • Activation Functions: ReLU, Sigmoid and Softmax functions used to introduce non-linearity.
• Deep Learning Model Training & Optimization
  • Forward Propagation: Flow of input data through neural network layers to generate predictions.
  • Loss Function: Method to measure difference between actual and predicted results.
  • Backpropagation: Technique used to calculate errors and update network weights.
  • Gradient Descent and Optimizers: Methods used to minimize errors and improve model learning.
  • Training Parameters: Epoch, batch size and learning rate concepts affecting training performance.
  • Regularization: Techniques such as dropout used to reduce overfitting.
• Deep Learning Architectures: CNN and Sequence Models
  • CNN Fundamentals: Neural network architecture used for image processing and feature extraction.
  • Convolution Operation: Using filters to identify patterns such as edges and shapes in images.
  • Feature Extraction: Learning important representations automatically from raw data.
  • Sequence Models: Neural networks designed for ordered data such as text and time series.
  • RNN, LSTM and GRU: Models used for handling sequential information and memory.
• Natural Language Processing Fundamentals
  • NLP Overview: Applications of natural language processing in text analysis and language-based systems.
  • Text Processing: Preparing raw text data before applying machine learning models.
  • Tokenization: Splitting text into smaller units for processing.
  • Text Cleaning: Removing unnecessary words and standardizing text using stop words, stemming and lemmatization.
  • Text Representation: Converting text into numerical format using Bag of Words and TF-IDF.
• Text Representation, Embeddings & Attention Basics
  • Word Embeddings: Representing words as numerical vectors to capture meaning and relationships.
  • Semantic Similarity: Comparing relationships between words and text using vector representations.
  • Attention Mechanism: Concept of focusing on important information while processing sequences.
  • Transformer Basics: Introduction to attention-based architecture including encoder and decoder concepts.
  • NLP Workflow: Complete flow from text preprocessing to representation and prediction.

GenAI & Agentic AI

• Setup & Environment
  • Assumed knowledge: working Python (variables, functions, loops, pandas basics)
  • Install Python and an IDE (VS Code), or use Google Colab
  • Jupyter Notebook basics
  • Create accounts and API keys: OpenAI, Google Gemini (AI Studio), Anthropic Claude
  • Install the provider SDKs and core libraries
  • Managing secrets: .env files and keeping API keys safe
• Generative AI Foundations & Your First API Call
  • Traditional AI vs Generative AI: the paradigm shift
  • How LLMs work (intuition): transformers, attention, next-token prediction
  • Tokens, embeddings and context windows: the engineering implications
  • Decoding controls: temperature, top-p, sampling
  • LLM limitations: hallucination, knowledge cutoff, context degradation
  • Calling the models: OpenAI, Google Gemini and Anthropic Claude SDKs
  • Project: Multi-model playground – one interface that queries OpenAI, Gemini and Claude side by side
• Practical GenAI Use-Cases from Data
  • Turning a business problem into a prompt
  • Text classification and sentiment analysis
  • Tagging, extraction and named-entity recognition
  • Summarization: short, long and structured
  • Translation and tone / style transfer
  • Batch processing over a dataset (pandas + the API)
  • Cost, latency and picking the right model for the job
  • Project: Use-case pack – a reusable notebook of GenAI building blocks run over real data
• Prompt Engineering that Works
  • Zero-shot, few-shot and chain-of-thought (CoT) prompting
  • Self-consistency and tree-of-thought (intro)
  • Role and persona prompting for consistent behaviour
  • Output constraints: format, length, tone
  • Prompt injection: attack vectors and defenses
  • Evaluation-driven iteration: test, measure, improve
  • Prompt versioning and management (intro)
  • Hands-on: provider playgrounds, LangChain PromptTemplate
  • Project: A reusable prompt-pattern library for the rest of the course
• Building a Chatbot from Scratch
  • Anatomy of a chat completion; why LLMs are stateless
  • Conversation memory: how a bot ‘remembers’ a turn
  • Multi-turn dialogue and the chat loop
  • System prompts and grounding the bot’s persona
  • A simple, shareable web UI (Gradio / Streamlit)
  • Hands-on: chat loop class + web interface
  • Project: Resume / Interview Bot that role-plays from your resume, with a web UI
• Structured Output & Guardrails
  • Why structured output is essential for real applications
  • JSON mode and JSON-schema enforcement
  • Typed, validated outputs with Pydantic
  • Designing output schemas for downstream systems
  • Safety guardrails: input / output validation, refusal handling
  • Failure modes, retries and graceful degradation
  • Hands-on: OpenAI JSON mode, Pydantic, Guardrails AI
  • Project: A production-grade classifier with schema-validated output
• Tool Use & Function Calling
  • What tool / function calling is and why agents need it
  • Defining function schemas the model can call
  • Tool orchestration and chaining
  • Connecting tools: web search, image generation, calculators, APIs
  • Handling tool errors and ambiguous calls
  • Hands-on: OpenAI function calling, Anthropic tool use, Gemini
  • Project: Tool-using assistant that searches the web and generates images on demand
• Enterprise RAG & Retrieval Foundations
  • Why RAG: knowledge-freshness, grounding and the enterprise knowledge problem
  • Embeddings: what they are and how to choose an embedding model
  • Vector databases and similarity search: FAISS / ChromaDB, and enterprise stores (pgvector, Pinecone, Weaviate)
  • Chunking strategies: fixed, recursive, semantic, document-aware
  • The end-to-end RAG pipeline: ingest, embed, retrieve, generate
  • Hands-on: LangChain, embeddings, a vector database
  • Project: Multi-document RAG chatbot – chat with your own PDFs
• Graph Databases & Semantic Search Optimization
  • Semantic search optimization: keyword vs semantic vs hybrid search (BM25 + vectors)
  • Two-stage retrieval: retrieve-then-rerank with cross-encoders
  • Query optimization: rewriting, expansion and metadata filtering
  • Knowledge graphs and graph databases (Neo4j): modeling entities and relationships
  • GraphRAG: graph-based vs vector-only retrieval, and when relationships matter
  • Hands-on: hybrid search, a reranker, and Neo4j / GraphRAG
  • Project: Enterprise knowledge-base chatbot combining vector and graph retrieval
• Building Your First AI Agent
  • What an agent really is: goals, tools, memory, autonomy
  • The ReAct pattern: reasoning and acting in a loop
  • Agent design patterns: researcher, planner, writer
  • Short-term memory and structured context passing
  • Building agents with LangGraph
  • Hands-on: LangGraph, a tool-using agent
  • Project: Research Agent that plans, searches and writes up findings autonomously
• Advanced Agents: Token Management, State Persistence & Long-Term Memory Architectures
  • Token and context-window management: budgeting, summarization, context compaction
  • State persistence: checkpointing and durable state across runs (LangGraph persistence)
  • Long-term memory architectures: vector, episodic and semantic memory (Mem0)
  • Human-in-the-loop: approvals, interrupts and steering
  • Reliability and safe autonomy: retries, fallbacks, idempotency, scoping
  • Hands-on: context budgeting + a memory store + an interrupt / approval step
  • Project: Agentic app with long-term memory, persistent state and a human-in-the-loop checkpoint
• Multi-Agent Systems
  • Multi-agent architectures: sequential, parallel, hierarchical
  • Role-based agents: specialist vs generalist
  • Coordinator-dispatcher and delegation patterns
  • Passing context and outputs across agent boundaries
  • Frameworks: CrewAI and Google ADK
  • Hands-on: CrewAI, Google ADK, LangGraph multi-agent
  • Project: Multi-agent research crew (fetcher, analyzer, writer)
• MCP: The Model Context Protocol
  • What MCP is and why modern agents use it
  • MCP architecture: client, server, transport
  • Registering tools, resources and capabilities via MCP servers
  • Connecting agents to databases, APIs and internal systems
  • MCP vs traditional tool-calling: when and why
  • Hands-on: the MCP SDK
  • Project: Build an MCP server and connect it to an AI assistant
• Agentic Automation with n8n
  • No-code / low-code automation for AI workflows
  • n8n core concepts: nodes, workflows, triggers, credentials
  • Event-driven automation: webhooks, schedules and app triggers
  • Putting an LLM / agent in the loop of a business workflow
  • Connecting apps: email, Google Sheets, Slack, CRMs, databases
  • AI agent nodes and chaining tools inside n8n
  • When to use no-code automation vs a coded agent
  • Project: An automated, AI-powered workflow (inbound lead, enrich, summarize, route)
• The Agentic Developer Workflow
  • Coding with AI agents: the agentic SDLC
  • Spec / intent-driven development and ‘loop engineering’
  • Using coding agents (e.g. Claude Code) to build, test and refactor
  • Running open models locally (Ollama) and when it makes sense
  • From idea to shipped app, the agentic way
  • Hands-on: build a feature end-to-end with a coding agent
  • Project: Build and ship a working app end-to-end with an AI coding agent
• Multimodal & Voice Agents
  • Beyond text: vision, audio and document understanding
  • Multimodal prompting (Gemini / GPT vision)
  • Voice agent architecture: speech-to-text, LLM, action, text-to-speech
  • Streaming and latency for real-time voice
  • Hands-on: Gemini multimodal, speech-to-text / TTS
  • Project: Voice assistant or PodcastGPT – turn content into an AI-generated podcast
• LLMOps: Automated Evals, Routing and Fallbacks
  • LLMOps: automated evaluation with Ragas and TruLens; evals in CI and regression testing
  • Evaluating agentic systems: task completion, tool-use accuracy, quality; tracing and debugging
  • Gateway routing: LLM gateways and cost / latency-based model routing
  • Graceful fallbacks: provider failover, retries and degraded modes
  • Deployment and Responsible AI: APIs (FastAPI), secrets, cost control, going to production
  • Capstone Project: Portfolio-grade, end-to-end agentic application (RAG + graph + agents + multi-agent + MCP)