What you'll learn
This curriculum designed by Industry expert for you to become a next industry expert. Here you will not only learn, you will implement your learnings in real time projects.
Code Your Way into Generative AI
3 Weeks
Build the exact Python skills needed for Generative AI development — from environment setup and data structures to APIs, OOP, and interactive Streamlit apps. No prior coding experience required.
Environment & Python Basics:
Set up a professional Python workspace with virtual environments, dependency management, and secure API key handling using .env files.
Python & VSCode Setup
Virtual Environments
Managing Dependencies
Environment Variables & .env
Data Structures for AI:
Master lists, dictionaries, and JSON — the core data formats used in every LLM API response and AI data pipeline.
Lists, Tuples & Sets
Dictionaries & Nested Dicts
JSON Parsing & Navigation
Functions & Control Flow:
Write clean, reusable code using functions, loops, decorators, and generators — essential patterns for LangChain tools and FastAPI endpoints.
Loops & Conditionals
Functions & Lambda
Decorators & Generators
Object-Oriented Programming:
Understand OOP principles to work confidently with LangChain's class-based architecture and build your own custom AI tool classes.
Classes & Objects
Inheritance & Encapsulation
Exception Handling
File Operations
APIs & Streamlit:
Make real API calls, handle async operations, and build interactive chat interfaces using Streamlit — deployable to Streamlit Cloud.
HTTP Requests & REST APIs
Async Programming Basics
Streamlit UI Components
Chat Interfaces & Session State
Build a live weather dashboard using a public API, display data with Streamlit, and practice JSON parsing, API calls, and session state management.
- requests
- JSON Parsing
- Streamlit
- API Keys
- .env Files
A Streamlit app that accepts raw JSON input, validates it, and displays it in a human-readable nested format — perfect for exploring LLM API responses.
- Python Dicts
- JSON
- Streamlit
- Input Validation
By completing this module, you'll write professional Python code ready for GenAI development and build interactive Streamlit apps for rapid AI prototyping.
SQL: Power Your AI with Real Data
1 Week
Learn the SQL skills essential for building AI applications — querying databases, working with joins and aggregations, and connecting Python to SQL backends powering AI agents and LLM dashboards.
SQL Foundations:
Understand relational databases and write SELECT, WHERE, and ORDER BY queries to retrieve and filter data from tables.
SELECT, WHERE, ORDER BY
INSERT, UPDATE, DELETE
SQLite & MySQL Setup
Aggregation & Grouping:
Summarise data with aggregate functions like COUNT and AVG, and group results for reporting and analytics in AI-powered dashboards.
COUNT, SUM, AVG, MIN, MAX
GROUP BY & HAVING
NULL Handling
DISTINCT
Joins & Relationships:
Combine data from multiple tables using INNER and LEFT JOINs, and understand primary/foreign key relationships for relational database design.
INNER JOIN & LEFT JOIN
Primary & Foreign Keys
Multi-Table Queries
Advanced SQL for AI:
Write complex queries using subqueries, CTEs, and CASE statements — the same patterns used inside LangChain SQL agents.
Subqueries & CTEs
CASE Statements
String & Date Functions
Python + SQL Integration:
Connect Python to SQLite and MySQL, execute queries programmatically, and use SQLAlchemy ORM — the foundation of LangChain's SQL agent.
sqlite3 & pymysql
SQLAlchemy ORM Basics
Querying from Python
By completing this module, you'll confidently write SQL queries for AI agents and connect Python to SQL databases — building the foundation for the SQL Agent in Module 6.
Master the Art of Talking to AI
1 Week
Master the art and science of communicating with LLMs to get precise, reliable outputs. Go beyond basic prompting with the same advanced techniques used by AI engineers at OpenAI, Anthropic, and Google.
LLM Fundamentals:
Understand how large language models are trained, how tokens and context windows work, and what controls model output behaviour.
How LLMs Work
Tokens & Context Windows
Temperature & Sampling
Hallucinations & Limitations
Core Prompting Techniques:
Go from basic zero-shot prompts to structured few-shot examples, role prompting, and negative prompts that constrain model behaviour.
Zero-Shot & Few-Shot
System vs User Prompts
Role Prompting
Negative Prompting
Advanced Prompting Frameworks:
Apply Chain-of-Thought, Tree-of-Thought, and ReAct — the frameworks powering modern AI agent reasoning and multi-step problem solving.
Chain-of-Thought (CoT)
Tree-of-Thought (ToT)
ReAct Framework
Meta-Prompting
Structured Output Prompting:
Get LLMs to return JSON and Pydantic-validated data — the foundation for building reliable, production-grade AI pipelines.
JSON Output Prompting
Pydantic Structured Outputs
Tool Descriptions for Agents
Prompt Optimization:
Evaluate, iterate, and improve prompts using LLM-as-judge techniques while reducing costs, hallucinations, and injection vulnerabilities.
LLM-as-Judge Evaluation
Reducing Hallucinations
Prompt Injection Defense
Token Cost Optimization
By completing this module, you'll apply advanced prompting techniques including CoT, ReAct, and structured outputs — and evaluate prompts systematically to build reliable AI systems.
LangChain: Build LLM Apps Like a Pro
3 Weeks
Master LangChain — the most widely used framework for building LLM-powered applications. From your first LLM call to multi-step chains, memory-powered chatbots, and production-ready document processing pipelines.
LLM Providers & Setup:
Connect to OpenAI, Anthropic, Google, and Groq in a unified LangChain interface — and compare models for different use cases.
ChatOpenAI & ChatAnthropic
ChatGoogleGenerativeAI
Groq & Ollama Integration
Prompt Templates & LCEL:
Build reusable prompts and chain components elegantly with LCEL's pipe operator — including parallel and conditional chain routing.
PromptTemplate & ChatPromptTemplate
LCEL Pipe Operator
Parallel & Conditional Chains
Token Streaming
Output Parsers:
Reliably extract strings, JSON, and Pydantic-validated objects from LLM responses — with automatic retry on invalid outputs.
StrOutputParser
JsonOutputParser
PydanticOutputParser
OutputFixingParser
Memory & Conversational State:
Give chatbots a persistent memory using buffer, window, and summary strategies — stored in files, Redis, or databases.
Buffer & Window Memory
Summary Memory
Persistent Chat History
Document Processing:
Load PDFs, CSVs, and web pages, split them into chunks, generate embeddings, and monitor chains end-to-end with LangSmith.
PDF, CSV & Web Loaders
Text Splitters & Chunking
Embeddings & Chroma Basics
LangSmith Tracing
Build a Streamlit chatbot that lets users switch between OpenAI, Claude, and Gemini, with persistent conversation memory across sessions.
- LangChain LCEL
- ChatPromptTemplate
- Memory
- Streamlit
A chain that takes a topic, generates a detailed article, extracts key points as JSON, and formats it as a professional report automatically.
- LCEL Chains
- PromptTemplate
- PydanticOutputParser
- RunnableParallel
By completing this module, you'll build production-quality LLM chains using LCEL, create memory-powered chatbots, and process documents of any type for downstream AI tasks.
Program Fees
8,500
(incl. taxes)
If you will join in a group, complete group will get discount.
You can pay your fee in easy installment's. For more details you can connect with our team.