// TRACK
AI & ML Engineering
Python and statistics through to RAG, agents and MLOps.
32 pages in this track
Completed0/32(0%)
Foundation
4Foundation — part of the ai-ml-engineering track.
Stats eda
2Stats eda — part of the ai-ml-engineering track.
Classical ml
4Classical ml — part of the ai-ml-engineering track.
Llm apis
4Llm apis — part of the ai-ml-engineering track.
Rag
4Rag — part of the ai-ml-engineering track.
Agents
4Agents — part of the ai-ml-engineering track.
Production
5Production — part of the ai-ml-engineering track.
Specialisation
4Specialisation — part of the ai-ml-engineering track.
Portfolio
1Portfolio — part of the ai-ml-engineering track.
🤖 AI & Machine Learning
Complete Learning Roadmap
From Zero to Production-Ready AI Professional — Revised & Expanded Edition
9 Parts28+ Modules15+ Projects
100+ Free Resources36 Weeks Full Stack
Data AnalystData Scientist
ML EngineerAI/GenAI Engineer
Portfolio & Job-Readiness Checklist
0%
0 of 17 items completed
🗺️ Learning Path Overview
P0
How to Use
P1
Foundation
P4
LLM APIs
P5
RAG
P6
Agents
P7
Production
P8
Specialize
P9
Portfolio
P2
Stats & EDA
P3
Classical ML
AI / GenAI Engineer path
ML / Data Science branch (optional)
Interchange — both paths stop here
🧭
Choose Your Learning Path
Data Analyst
Data Scientist
ML Engineer
AI/GenAI Engineer
Full Stack AI/ML
Duration
~14 weeks
Outcome
SQL, Pandas, EDA, Visualization
P0 How to UseP1 Foundation
P2 Stats & EDAP3 Classical ML (optional)
Duration
~24 weeks
Outcome
Full ML competency, model building & evaluation
P0P1 Foundation
P2 Stats & EDAP3 Classical ML
P7 Production (optional)
Duration
~28 weeks
Outcome
Build and deploy production ML models
P0P1 Foundation
P2 Stats & EDAP3 Classical ML
P7 Production + MLOps
Duration
~26 weeks
Outcome
LLMs, RAG, Agents, Production AI systems
P0P1 Foundation
P2 Stats (optional)P3 Classical ML (optional)
P4 LLM APIsP5 RAG
P6 Agents & EvalsP7 Production
P8 Specialization
Duration
~36 weeks
Outcome
The most versatile, future-ready AI/ML profile
All 9 Parts
🤖 AI / GenAI Engineer Path
P0 → P1 Foundation → P4 LLM APIs → P5 RAG → P6 Agents → P7 Production → P8 Specialization
📊 Data Scientist / ML Engineer Path
P0 → P1 Foundation → P2 Stats & EDA → P3 Classical ML → P7 Production (MLOps) → P8 Specialization
⚡ Parallel Branch: Parts 2 & 3 (Stats/EDA and Classical ML) are a separate parallel branch for AI Engineers — labelled OPTIONAL. Not required to build LLM systems, but strongly recommended for data intuition and broader employability.
Part 0 — How to Use This Roadmap
Reading Guide & Time Commitment
Icons • SKIP IF System • 1–2 hrs/day
+
- Complete Beginner: Follow every Part sequentially. Spend extra time on Python basics before rushing to ML.
- Beginner with C/C++/Java background: Use the ⚡ SKIP IF boxes. Skim modules where your existing knowledge applies directly.
- Time commitment: 1–2 hours/day = ~10 hours/week. Each week is calibrated for this pace.
- Projects: Never skip projects. They are your portfolio. Every completed project goes on GitHub.
- Resources: All resources listed are free.
Role Comparison & Salary Guide
4 Roles • India & US Salaries • Best Parts per Role
+
| Role | Key Skills | India | US | Best Parts |
|---|---|---|---|---|
| Data Analyst | SQL, Python, Pandas, Visualization, Stats | 8–18 LPA | $65–90K | P0, P1, P2 |
| Data Scientist | ML algorithms, Stats, EDA, Model building | 12–25 LPA | $90–130K | P0–P3 |
| ML Engineer | ML + Software Eng., MLOps, Deployment, APIs | 15–30 LPA | $110–160K | P0–P3, P7 |
| AI/GenAI Eng. | LLMs, RAG, Prompt Eng., Agents, Vector DBs | 18–40 LPA | $120–180K | P0,P1,P4–P8 |
Math & Statistics Prerequisites
Linear Algebra • Calculus • Probability & Stats
+
📌 You do NOT need to master all math before starting. Study alongside Parts 1–2. If you did B.Tech/engineering, you already know most of this — focus only on the statistics section.
- Linear Algebra: vectors, matrices, dot product, matrix multiplication, eigenvalues
- Calculus: derivatives, partial derivatives, chain rule, maxima/minima for gradient descent
- Probability & Statistics: distributions, Bayes theorem, hypothesis testing, correlation
Free Math Resources
| Type | Resource | Category |
|---|---|---|
| Course | Khan Academy — Linear Algebra | Linear Algebra |
| Course | Khan Academy — Statistics & Probability | Statistics |
| Video | 3Blue1Brown — Essence of Linear Algebra (YouTube) | Visual Linear Algebra |
| Video | 3Blue1Brown — Essence of Calculus (YouTube) | Calculus Visually |
| Book | Mathematics for Machine Learning (Free PDF — Cambridge) | Comprehensive Math for ML |
| Video | StatQuest with Josh Starmer (YouTube) | Stats & ML Concepts |
Part 1 — Universal Foundation
Module 1: Python Programming Fundamentals
3 Weeks • Beginner • Python 3, VS Code / Jupyter
+
⚡ SKIP IF: You already program in C/C++/Java — Python syntax for variables, loops, conditionals, functions, and basic OOP will feel very familiar. Spend 2–3 days scanning syntax differences.
What You Will Learn
- Core Python syntax: variables, data types, type casting, string operations, f-strings
- Data structures: lists, tuples, dictionaries, sets
- Flow control: if/elif/else, for/while loops, break/continue
- Functions: parameters, return values, *args/**kwargs, lambda, list comprehensions
- File I/O: reading and writing text and CSV files
- Error handling: try/except/finally for robust code
- Intro to OOP: classes, objects, __init__, methods
- Virtual environments (venv), pip, requirements.txt
Week-by-Week Plan
| Week | Topics Covered | Daily Task / Mini-Project |
|---|---|---|
| W1 | Install Python 3 & VS Code. Variables, data types, type casting, string methods, lists, tuples | Unit converter (km↔miles). String palindrome checker. Shopping list app. |
| W2 | Dictionaries, sets, if/elif/else, for/while loops, break/continue/pass | Phone book using dicts. Number guessing game. Grade classifier. |
| W3 | Functions, *args/**kwargs, file I/O with CSV, try/except/finally, intro to OOP | Student Grade Calculator (file-based). CSV reader/writer. Bank Account OOP class. |
Free Resources
| Type | Resource | Category |
|---|---|---|
| Course | CS50P: Introduction to Programming with Python (Harvard, free) | Best free Python course |
| Video | Python for Beginners (freeCodeCamp, YouTube) | 4.5hr complete intro |
| Course | Python for Everybody (Coursera, free to audit) | Best for absolute beginners |
| Docs | Official Python Tutorial | Official reference |
| Course | Kaggle Python Course (Free, Interactive) | Hands-on exercises |
| Book | Automate the Boring Stuff with Python (Free) | Project-oriented Python |
| Video | Corey Schafer Python OOP Tutorials (YouTube Playlist) | OOP deep dive |
| Tool | Google Colab — free cloud Jupyter notebooks | Zero setup environment |
🛠PROJECT: CLI Student Grade Management System[Beginner] 3–4 days
Build a CLI app that: reads/writes student data from CSV, calculates grades/GPA/class rank, filters and sorts by subject scores, handles invalid input with try/except.
Skills: File I/O, dictionaries, functions, error handling, CSV parsing
Module 2: NumPy & Pandas Data Toolkit
3 Weeks • Beginner–Intermediate • Jupyter/Colab, NumPy, Pandas
+
⚡ SKIP IF: You know Java/C++ arrays — NumPy arrays are similar but with vectorized operations. Pandas DataFrame is like a database table. Skim NumPy basics and focus on Pandas.
What You Will Learn
- NumPy: ndarray, indexing, slicing, broadcasting, vectorized operations, math functions
- Pandas Series and DataFrame — core data structures for all ML work
- Reading data: pd.read_csv(), pd.read_excel(), pd.read_json()
- Data inspection: .head(), .info(), .describe(), .shape, .dtypes
- Data cleaning: NaN handling, duplicates, type conversion
- Data manipulation: filtering, sorting, groupby, pivot tables, merge/join
- String operations and datetime handling
Week-by-Week Plan
| Week | Topics Covered | Daily Task / Mini-Project |
|---|---|---|
| W4 | NumPy arrays, indexing, slicing, boolean masking, broadcasting, np.mean/std/sum/dot/reshape | Compute stats without loops. Matrix multiplication with np.dot. Reshape 1D sensor data. |
| W5 | Pandas Series vs DataFrame, read_csv, .head/.info, .loc/.iloc, NaN handling, drop_duplicates | Load dataset, write data health report. Handle missing values in COVID dataset. |
| W6 | groupby(), .agg()/.transform(), merge/join/concat, pivot_table, string ops, datetime | Top 5 countries by COVID cases. Merge two datasets. Extract month/year from date column. |
Free Resources
| Type | Resource | Category |
|---|---|---|
| Course | Kaggle Pandas Course (Free, Interactive) | Best hands-on Pandas |
| Video | NumPy for Beginners (freeCodeCamp, YouTube) | NumPy complete |
| Docs | Pandas Official Documentation User Guide | Official reference |
| Video | Corey Schafer Pandas Tutorials (YouTube Playlist) | Deep Pandas tutorials |
| Cheatsheet | Pandas Cheat Sheet — DataCamp (Free PDF) | Quick reference |
🛠PROJECT: COVID-19 Global Data Analysis[Beginner] 4–5 days
Load and clean COVID-19 data, compute rolling 7-day average, find top 10 countries by deaths-per-million, identify months with highest surges, export cleaned summary CSV.
Skills: NumPy, Pandas cleaning, groupby, datetime, merge, export
Module 3: Developer Essentials — Git, CLI, APIs & Async
2 Weeks • Beginner • Terminal, Git, Python requests/httpx
+
⚡ SKIP IF: You already use Git and understand HTTP — focus only on async/await in Python and JSON handling, which are essential for LLM API work later.
- Git: init, add, commit, push, pull, branching, merging, .gitignore, GitHub repos
- CLI/Terminal: cd, ls, pwd, mkdir, rm, cat, grep, environment variables, PATH
- HTTP fundamentals: GET/POST requests, status codes (200/400/401/404/500), headers
- JSON: reading and writing, parsing API responses in Python
- Python requests library: calling any web API from Python
- Async/await: what async def and await do — critical for streaming LLMs later
🛠PROJECT: Public API Script[Beginner] 1–2 days
Write a Python script that calls Open-Meteo weather API (no API key needed), formats the result as clean JSON, and saves it to a file. Push to GitHub with a proper README.
Skills: requests library, JSON, HTTP, Git, GitHub
Module 4: SQL Basics & FastAPI
2 Weeks • Beginner • SQLite, FastAPI, Uvicorn
+
⚡ SKIP IF: You know SQL from databases — focus only on the FastAPI tutorial. If you know Spring Boot or Express.js, FastAPI will feel immediately familiar.
- SQL: SELECT, WHERE, GROUP BY, JOIN, ORDER BY, basic aggregations
- FastAPI: GET/POST endpoints, path and query parameters, request bodies with Pydantic
- Running uvicorn dev server, using FastAPI /docs interface to test without writing a client
- Pydantic: data validation and schema definition
🏁 Part 1 Milestone — You Are Ready When...
- Write Python programs that read/write files, call APIs, and handle errors cleanly
- Version your code with Git and push projects to GitHub confidently
- Navigate the terminal without hesitation
- Understand what an HTTP request is and make one in Python with requests
- Query a SQLite database with basic SQL
- Build and run a simple FastAPI app locally and test it via the /docs interface
Part 2 — Statistics, EDA & ML Workflow
⚡ AI ENGINEER SHORTCUT: Required for: Data Analyst, Data Scientist, ML Engineer. OPTIONAL but recommended for AI/GenAI Engineer — gives you the data intuition that makes AI engineers more versatile. On a fast track? Skip to Part 4 now and return here later.
Module 5: Statistical Thinking & Data Visualization
2 Weeks • Intermediate • Matplotlib, Seaborn, SciPy
+
⚡ SKIP IF: You know engineering math — mean, std, correlation are likely familiar. Focus on: visual interpretation (box plots, histograms) and understanding WHY we do train-test split.
- Descriptive statistics: mean, median, mode, variance, std dev, skewness, kurtosis
- Normal distribution, outlier detection via IQR method and Z-score
- Correlation matrix: df.corr() and heatmap, Pearson vs Spearman
- Matplotlib: figures, axes, subplots, styling, labels, titles, legends
- Seaborn: histplot, boxplot, violin, pairplot, heatmap, regplot, categorical plots
| Week | Topics Covered | Daily Task / Mini-Project |
|---|---|---|
| W7 | Descriptive stats, normal distribution, skewness/kurtosis, correlation matrix, outlier detection, Matplotlib | Plot house price distribution. Compute Titanic correlation matrix. Find outliers in salary dataset. |
| W8 | Seaborn histplot/boxplot/violin/pairplot, bar charts, scatter plots with regression line, heatmaps | Full EDA report with 6+ visualizations. Pairplot for Titanic survival. Monthly sales trend chart. |
Free Resources
| Type | Resource | Category |
|---|---|---|
| Video | StatQuest — Statistics for Machine Learning (YouTube) | Best stats intuition |
| Course | Kaggle Data Visualization Course (Free) | Seaborn & Matplotlib |
| Course | Kaggle Feature Engineering Course (Free) | Feature engineering |
| Docs | Scikit-learn Preprocessing Guide | Scaling & encoding |
| Book | Hands-On ML with Scikit-Learn (Free Chapter 2) | End-to-end ML project |
Module 6: ML Workflow & Feature Engineering
2 Weeks • Intermediate • Scikit-learn, Pandas
+
- Label encoding vs One-hot encoding (pd.get_dummies)
- Feature binning (pd.cut/qcut), log transformation for skewed features, polynomial features
- Scaling: StandardScaler, MinMaxScaler, RobustScaler — when to use which
- Train-test split (stratified), K-Fold cross-validation with cross_val_score()
- Scikit-learn Pipeline: combine preprocessing + model in one object
- CRITICAL: Data leakage — ALWAYS split before any scaling or encoding
| Week | Topics Covered | Daily Task / Mini-Project |
|---|---|---|
| W9 | Label/one-hot encoding, feature binning, log transform, polynomial features, feature selection | Transform Titanic dataset. Apply log transform to skewed price column. One-hot encode city column. |
| W10 | StandardScaler/MinMaxScaler, train_test_split (stratified), K-Fold CV, sklearn Pipeline, leakage demo | Build full preprocessing Pipeline. Demonstrate data leakage. Compare scores with/without CV. |
🛠PROJECT: End-to-End EDA & Feature Engineering Report[Intermediate] 5–6 days
Professional EDA report: statistical summary, 8+ visualizations, outlier analysis, feature engineering (encode, scale, create 2 new features), correlation insights, train-test split, save processed dataset.
Skills: Statistics, Matplotlib, Seaborn, Pandas, Scikit-learn preprocessing, Pipeline
🏁 Part 2 Milestone
- Perform complete EDA on any dataset: distributions, correlations, outliers, missing values
- Build 8+ publication-quality visualizations using Matplotlib and Seaborn
- Apply feature engineering: encoding, scaling, log transforms, new feature creation
- Build a full sklearn Pipeline combining preprocessing + model
- Understand and prevent data leakage (always scale AFTER splitting, never before)
Part 3 — Classical ML [Parallel Branch]
🔀 PARALLEL PATH: This Part runs in parallel with Parts 4–6 for AI Engineers. Not required to build LLM systems, but strongly recommended to deepen data intuition and broaden employability. Data Scientists and ML Engineers follow this sequentially after Part 2.
Module 7: Supervised Learning — Regression
2 Weeks • Intermediate • Scikit-learn
+
- Linear, Multiple, Polynomial Regression
- Metrics: MAE, MSE, RMSE, R² — interpretation and selection
- Ridge (L2) and Lasso (L1) Regression — regularization to control overfitting
- When to use Ridge vs Lasso, residual plotting to check model assumptions
| Week | Topics Covered | Daily Task / Mini-Project |
|---|---|---|
| W11 | Linear Regression, sklearn fit/predict API, MAE/MSE/RMSE/R², Multiple & Polynomial Regression | Predict house prices with linear regression. Compare MAE vs RMSE. Plot residuals. |
| W12 | Ridge (L2) and Lasso (L1), Logistic Regression for binary classification, decision boundary | Apply Ridge vs Lasso — compare feature coefficients. Build spam classifier. |
Free Resources
| Type | Resource | Category |
|---|---|---|
| Course | Kaggle Intro to Machine Learning (Free) | Best beginner ML |
| Course | Andrew Ng — ML Specialization (Coursera, Audit Free) | Gold standard ML course |
| Video | StatQuest — Logistic Regression, Decision Trees, Random Forest (YouTube) | Intuition-first |
| Docs | Scikit-learn User Guide: Supervised Learning | Complete reference |
Module 8–9: Classification & Ensemble Methods
5 Weeks • Intermediate • Scikit-learn, XGBoost, LightGBM, Optuna, SHAP
+
- Decision Trees, KNN, Naive Bayes, Logistic Regression
- Metrics: Accuracy, Precision, Recall, F1, ROC-AUC, Confusion Matrix
- Bias-Variance tradeoff, learning curves, SMOTE for class imbalance
- Random Forest (bagging), Gradient Boosting, XGBoost, LightGBM (boosting)
- Stacking and Voting classifiers, Optuna for automatic hyperparameter tuning
- Model explainability: SHAP values for feature importance
- GridSearchCV, RandomizedSearchCV, saving models with joblib
Free Resources
| Type | Resource | Category |
|---|---|---|
| Video | StatQuest — Random Forest, Gradient Boosting (YouTube) | Best visual explanation |
| Docs | XGBoost Documentation (Official) | XGBoost reference |
| Course | Kaggle ML Explainability Course (Free, SHAP) | Model interpretation |
| Course | Kaggle Intermediate ML: Pipelines, XGBoost (Free) | XGBoost practice |
🛠PROJECT: Customer Segmentation + Churn Prediction[Intermediate] 6–7 days
Part A: K-Means + PCA to segment customers, visualize with t-SNE. Part B: XGBoost churn classifier, SMOTE for class imbalance, Optuna tuning, SHAP analysis.
Skills: K-Means, PCA, t-SNE, XGBoost, SMOTE, Optuna, SHAP, joblib
Module 10: Unsupervised Learning
2 Weeks • Intermediate–Advanced • Scikit-learn
+
- K-Means: algorithm, elbow method for choosing K, inertia
- DBSCAN: density-based clustering, handles arbitrary shapes
- Hierarchical clustering: dendrograms, Ward linkage
- PCA: dimensionality reduction, explained variance ratio
- t-SNE: visualizing high-dimensional data in 2D
- Anomaly detection: Isolation Forest, One-Class SVM
🏁 Part 3 Milestone
- Build end-to-end regression and classification pipelines with proper evaluation
- Apply ensemble methods (Random Forest, XGBoost, LightGBM, Stacking) and know when each helps
- Tune hyperparameters automatically using Optuna
- Cluster data with K-Means and DBSCAN, reduce dimensions with PCA and t-SNE
- Explain model predictions to stakeholders using SHAP values
Part 4 — LLM API Mastery
Module 11: Prompting Fundamentals
1 Week • Beginner–Intermediate • OpenAI API, Anthropic API
+
- System vs user messages — what each controls and why the distinction matters
- Zero-shot, one-shot, few-shot prompting with examples
- Chain-of-thought (CoT) prompting — “think step by step”
- Role prompting, persona assignment, XML tag structuring for reliable output control
- How small wording changes dramatically shift output quality
Resources
| Type | Resource | Category |
|---|---|---|
| Tutorial | Anthropic Interactive Prompt Engineering Tutorial | Best hands-on prompting — 9 chapters |
| Docs | Anthropic Prompt Engineering Docs | Official reference |
| Docs | OpenAI Prompt Engineering Guide | OpenAI official guide |
| Guide | promptingguide.ai — basic to advanced strategies | Comprehensive guide |
Module 12: Structured Outputs & Tool Calling
1 Week • Intermediate • Pydantic, Instructor, OpenAI/Anthropic SDK
+
- Structured outputs: forcing the model to match a JSON schema you define
- Defining Pydantic models, passing schemas to the API, Instructor library for 15+ providers
- Tool calling: the model does NOT execute your functions — it returns a structured call
- The 5-step flow: define tools → call model → parse tool call → execute function → feed result back
- Parallel tool calls, tool_choice: “auto”, handling no-tool-call responses
- Writing tool descriptions that get selected correctly and reliably
🛠PROJECT: Invoice Parser + 3-Tool Assistant[Intermediate] 3–4 days
Part A: Invoice parser returning structured Python object (invoice_number, amount, items, due_date). Part B: Assistant with 3 tools: get_weather(city), calculate(expression), search_notes(query).
Skills: Pydantic, Instructor, OpenAI/Anthropic SDK, tool calling loop, JSON schemas
Module 13: Streaming & Conversation State
1 Week • Intermediate • FastAPI StreamingResponse, httpx
+
- Streaming: showing model output word-by-word — makes apps feel dramatically faster
- Setting stream=True, iterating over delta chunks, assembling full response from parts
- Wiring streaming into a FastAPI endpoint using StreamingResponse
- Server-Sent Events (SSE) — what is happening at the HTTP level
- LLMs are stateless — you manage conversation history. The model has no memory between calls.
- The messages array structure — why you append both user and assistant messages
- Context window limits, what happens when exceeded, basic truncation strategies
🛠PROJECT: Multi-Turn Streaming Chatbot[Intermediate] 2–3 days
Multi-turn chatbot in the terminal with streaming output. Each turn appends to messages list. /reset command clears history. Print token count after each exchange. Wire same logic into a FastAPI StreamingResponse endpoint.
Skills: Streaming, conversation state, messages array, token counting, FastAPI
Module 14: Reliability, Cost & Security
1 Week • Intermediate • Tenacity, tiktoken, OWASP LLM Top 10
+
- Token basics: ~4 chars per token, input vs output tokens priced differently
- tiktoken: count tokens before sending. Don’t use GPT-4/Opus for everything.
- LLM APIs fail: 429 rate limits, timeouts, malformed JSON. Handle gracefully.
- Tenacity library: retry logic with exponential backoff in one decorator
- Fallback strategies: retry with different model, return cached response
- Prompt injection: the #1 security risk in LLM apps
- Direct injection (jailbreaking) vs indirect injection via external content (docs, websites)
- OWASP Top 10 for LLM Apps — LLM01: Prompt Injection. Principle of least privilege.
⚠️ CRITICAL: Prompt injection is when untrusted user input overrides your system instructions. Never trust unvalidated LLM output to make consequential decisions automatically.
Additional Free Tools — LLM APIs
| Type | Resource | Category |
|---|---|---|
| Course | DeepLearning.AI: Prompt Engineering for Developers | Prompt engineering course |
| Tool | Groq API — Free Fast LLM Inference (Llama, Mistral) | Free OpenAI alternative |
| Tool | Google Gemini API — Free Tier Available | Free LLM API |
🏁 Part 4 Milestone
- Write prompts that produce consistent, reliable outputs for a given task
- Get structured JSON data out of any model using Pydantic + Instructor
- Wire up tool calling so a model can call your Python functions
- Stream responses in real time through a FastAPI endpoint
- Manage multi-turn conversation history with proper truncation strategies
- Estimate token cost before sending requests using tiktoken
- Handle API errors, timeouts, and bad outputs without crashing using Tenacity
- Explain prompt injection and apply basic defences
Part 5 — RAG Systems
RAG is the most in-demand practical skill in AI engineering right now. Almost every real enterprise AI use case — customer support bots, internal knowledge bases, document Q&A — is built on it. Understanding it deeply is what separates good engineers from great ones.
Module 15: Embeddings & Vector Databases
1 Week • Intermediate • OpenAI embeddings, sentence-transformers, ChromaDB
+
- A text embedding is text projected into high-dimensional vector space — similar text ends up close together
- Cosine similarity: how we measure distance between vectors in embedding space
- Embedding models: OpenAI text-embedding-3-small/large vs HuggingFace sentence-transformers
- Vector DB options: Chroma (local dev) → Pinecone (managed) → Qdrant (open-source prod) → pgvector (if on Postgres) → FAISS
- Creating collections, inserting embeddings with metadata, querying by similarity with top_k
- Filtering by metadata at query time: source, date, category, document type
| Type | Resource | Category |
|---|---|---|
| Article | Stack Overflow Blog: Intuitive Introduction to Text Embeddings | Best beginner explanation |
| Guide | HuggingFace: Getting Started With Embeddings | Hands-on embeddings |
| Docs | OpenAI Embeddings Guide | OpenAI embedding models |
| Docs | Chroma Official Docs — in-memory, no infrastructure | Best for prototyping |
| Docs | Qdrant Documentation — best open-source vector DB for production | Production vector DB |
| Repo | pgvector — vector search inside PostgreSQL | If already on Postgres |
Module 16: Chunking & Document Ingestion
1 Week • Intermediate • LangChain Text Splitters, LlamaIndex
+
- Documents too large to embed whole — chunking breaks them into embeddable pieces
- Baseline: RecursiveCharacterTextSplitter with chunk_size=500, chunk_overlap=50
- Fixed-size, recursive, and semantic chunking — when to use each
- Core tradeoff: chunks too large = poor retrieval precision; too small = lost context
- Good starting point: ~250 tokens with 10–20% overlap to avoid losing context at boundaries
- Tag every chunk with metadata at ingestion: filename, page, section, date, category
| Type | Resource | Category |
|---|---|---|
| Guide | Weaviate: Chunking Strategies for RAG | Most practical guide |
| Docs | LangChain Text Splitters Docs | Code reference |
| Article | Unstructured: Chunking for RAG Best Practices | Technical deep-dive |
Module 17: Retrieval Quality — Filtering, Reranking & Failure Modes
1 Week • Intermediate–Advanced • Cohere Reranker, LangChain
+
- Metadata filtering: constrain retrieval by date, source, user, category before similarity search
- Two-stage pattern: embed and search (fast, approximate) → rerank top-k (slower, more accurate)
- Cohere reranker: re-scores results based on true contextual relevance, not just vector proximity
- Bi-encoder (first-stage embedding search) vs cross-encoder (reranking)
- Most RAG failures are retrieval failures, not model failures
- Failure modes: semantic drift → query rewriting; chunk boundary → increase overlap; missing metadata → filter; top-k too small → increase then rerank
- HyDE (Hypothetical Document Embeddings): generate a hypothetical answer, embed it, search — improves retrieval
| Type | Resource | Category |
|---|---|---|
| Docs | Cohere Reranking Docs — single line of code | Best place to start reranking |
| Docs | LangChain: Query Transformations | Query rewriting, HyDE, step-back prompting |
| Guide | Pinecone: Improving Retrieval Quality | Common failure modes with fixes |
Module 18: RAG Pipelines, Grounding & Hallucination Reduction
1 Week • Advanced • LlamaIndex, LangChain, OpenAI/Anthropic
+
- LlamaIndex for RAG-first: 5 stages — load → index → store → query → evaluate
- LangChain for orchestration when you need multi-agent workflows or conditional chains
- Rule: use LlamaIndex for Part 5 RAG work. Move to LangChain for Part 6 agents.
- Grounding: prompt model to answer only from provided context, say “I don’t know” otherwise
- Citations: pass chunk metadata (source, page, URL) into prompt and surface in response
- Hallucination reduction: RAG + chain-of-thought + guardrails together beat any single approach
- Confidence thresholds: validating retrieval quality before surfacing responses
| Type | Resource | Category |
|---|---|---|
| Docs | LlamaIndex: Introduction to RAG | Official RAG guide |
| Docs | LangChain: Build a RAG Agent | From minimal to full pipeline with reranking |
| Docs | Anthropic: Giving Claude Sources | Citation prompting |
| Course | DeepLearning.AI: LangChain for LLM App Dev (Free) | LangChain fundamentals |
| Course | DeepLearning.AI: Building Advanced RAG (Free) | Advanced RAG course |
🛠PROJECT: 'Chat With Your Docs' RAG App[Advanced] 5–7 days
Ingest 10–20 PDF/text files. FastAPI endpoint accepts a question, retrieves top 5 chunks with Cohere reranking, returns a cited answer from Claude or OpenAI. Include: chunking with metadata, Chroma or Qdrant, source attribution. Deploy so others can try it.
Deep Dive Module →Skills: LlamaIndex or LangChain, ChromaDB/Qdrant, Cohere reranking, FastAPI, OpenAI/Anthropic, citations, deployment
🏁 Part 5 Milestone
- Explain what an embedding is and why similar text produces similar vectors
- Chunk any document intelligently using the right strategy for the content type
- Store and query embeddings in a vector database with metadata filtering
- Add a reranking step using the two-stage retrieve-then-rerank pattern
- Debug common retrieval failures systematically (semantic drift, chunk boundaries, metadata issues)
- Build a complete end-to-end RAG pipeline that returns grounded, cited answers
Part 6 — Agents, Workflows & Evaluation
Module 19: Agent Loops & LangGraph
1.5 Weeks • Advanced • LangGraph, OpenAI/Anthropic API
+
- An agent is a while loop with an LLM making the branching decisions — not magic
- The perceive → plan → act → observe cycle and how it terminates
- Build from scratch first (no framework) — gives you the foundation to understand what frameworks abstract
- LangGraph: state as a shared memory object flowing through the graph
- State schemas with TypedDict, reducers for merging parallel updates
- In-memory state vs persisted checkpointing
- Human-in-the-loop: inspect and modify state mid-execution
- Conditional edges: how the graph branches based on state values
⚡ Practice first: Build an agent from scratch — just the OpenAI or Anthropic API directly. Give it 3 tools, a goal, and a while loop. This is the most valuable thing you can do to understand what frameworks are abstracting.
| Type | Resource | Category |
|---|---|---|
| Article | Anthropic: Building Effective Agents | Read this FIRST before writing any agent code |
| OpenAI: A Practical Guide to Building Agents | Agent patterns and guardrails | |
| Course | LangChain Academy: Introduction to LangGraph (Free) | Official free LangGraph course |
| Docs | LangGraph State Management | State schemas reference |
Module 20: Tool Design, Workflow Patterns & When NOT to Use Agents
1 Week • Advanced
+
- Tool names: self-explanatory verbs. Descriptions: explain WHEN to call, not just what it does.
- Test every tool: “If I had only this JSON schema, would I know exactly when and how to call this?”
- Decision framework: single LLM call → workflow → agent. Reserve agents for genuinely open-ended tasks.
- A chain of 3 fixed LLM calls is always faster, cheaper, and more debuggable than an agent that could make 3 calls
- Workflow patterns: prompt chaining, routing, parallelization, orchestrator-subagent
- Anthropic: “find the simplest solution possible and only increase complexity when needed”
🛠PROJECT: 3-Step Content Pipeline (No Agent Required)[Intermediate] 2–3 days
Step 1: LLM extracts key facts from an article. Step 2: Another LLM call generates tweet, LinkedIn post, and summary in PARALLEL. Step 3: Final LLM call scores all three and picks the best. Demonstrates that most ‘agent’ use cases are better served by explicit workflows.
Deep Dive Module →Skills: Parallelization pattern, orchestrator pattern, OpenAI/Anthropic API
Module 21: Failure Handling in Agents
0.5 Weeks • Advanced
+
- Agents fail differently: bad tool calls can corrupt state or cause infinite loops
- Always set maximum iteration limits — without them, a buggy tool causes an infinite loop
- Per-tool retry with exponential backoff, catch exceptions at tool execution layer
- When to surface failure to user vs retry silently
- Guardrails as layered defense: LLM-based checks + rules-based filters + moderation APIs
Module 22: Evaluation Harnesses & Task Success Metrics
1 Week • Advanced • DeepEval, Ragas, LangSmith, Promptfoo
+
⚠️ CRITICAL: Evals are not optional polish. Every prompt change, model swap, or retrieval tweak without running evals is a gamble. Engineers who ship reliable AI products run evals constantly.
- Build a golden test set of 20–50 representative inputs with expected outputs or rubrics
- Deterministic eval functions: string match, JSON schema validation
- LLM-as-judge: use a model to score outputs that resist exact matching
- Process metrics (did the agent call the right tool?) vs outcome metrics (did the task succeed?)
- DeepEval: pytest-inspired framework, 50+ built-in metrics including hallucination and answer relevancy
- Ragas: RAG-specific — faithfulness, answer relevancy, context precision, context recall
- Promptfoo: CLI for testing prompts across models, CI/CD integration, red teaming
- LangSmith: tracing, debugging, and evaluation for LangChain/LangGraph
🛠PROJECT: Eval Harness for Your RAG Pipeline[Advanced] 3–4 days
Create 30 question-answer pairs from your docs. Run through your pipeline. Score for relevance, faithfulness, and completeness using DeepEval and Ragas. Change one thing (chunk size, model, top-k) and re-run to measure the improvement.
Deep Dive Module →Skills: DeepEval, Ragas, LangSmith tracing, golden test set, LLM-as-judge
🏁 Part 6 Milestone
- Explain what an agent loop is and implement one from scratch without a framework
- Write tool descriptions that get selected correctly across a wide range of inputs
- Manage agent state properly using LangGraph (schemas, reducers, checkpointing)
- Handle failures inside agent loops without crashing (iteration limits, per-tool retry, guardrails)
- Decide confidently whether a task needs an agent, a workflow, or a single prompt
- Build multi-step workflows that chain, route, and parallelize LLM calls
- Write automated evals that catch regressions when you change prompts or models
- Define and measure task success metrics for any AI system you build
Part 7 — Production & Deployment
This is where most AI engineers stall. They can build a great demo but cannot ship a product that survives contact with the real world. The skills here are what companies actually pay for: reliability, security, cost control, and the ability to keep things running.
Module 23: FastAPI Production Patterns
0.5 Weeks • Intermediate • FastAPI, Gunicorn, Uvicorn
+
- Single uvicorn with --reload is fine for dev. In production it becomes the bottleneck immediately.
- Gunicorn with Uvicorn workers for multi-worker ASGI configuration
- Proper error handling middleware, health check endpoints (/health), CORS policies
- Async database pooling, Redis caching, background tasks
| Type | Resource | Category |
|---|---|---|
| Docs | FastAPI Deployment Docs | Start here |
Module 24: Docker & Background Jobs
1 Week • Intermediate • Docker, Docker Compose, Celery, Redis
+
⚡ SKIP IF: You know DevOps and CI/CD — Docker and containerization will be very familiar. Focus your time on background job patterns for LLM apps, which are ML-specific.
- Docker: stop saying ‘it works on my machine’. Solve dependency conflicts, consistent environments.
- Dockerfile for Python/FastAPI, multi-stage builds to keep images small, .dockerignore
- Docker Compose for multi-service setups: app + vector DB + Redis
- LLM calls are slow — background jobs let you accept immediately and process async
- FastAPI BackgroundTasks for simple fire-and-forget; Celery + Redis for heavier tasks
🛠PROJECT: Dockerized RAG App[Intermediate] 3–4 days
Containerize your RAG app with docker-compose.yml running: FastAPI app + vector database (Chroma or Qdrant) + Redis for caching. Add /health endpoint. Deploy so ‘docker compose up’ starts everything.
Deep Dive Module →Skills: Docker, Docker Compose, FastAPI, Qdrant or Chroma, Redis, health checks
Module 25: Auth, Logging & Observability
1 Week • Intermediate–Advanced • Langfuse, LangSmith, Structlog
+
- Without authentication, anyone can burn through your LLM credits — you will wake up to a large bill
- JWT tokens for user auth, API key management for service-to-service communication
- Rate limiting per user/key. Never store secrets in code — environment variables only.
- LLM-specific challenge: a 200 status code can still be a useless or hallucinated answer
- Langfuse: traces every request — prompt, response, tokens, latency, tool calls, cost per request
- Structlog: structured JSON logging that is searchable and parseable in production
- Dashboard metrics: request volume, error rates, cost per day, latency percentiles
| Type | Resource | Category |
|---|---|---|
| Docs | FastAPI Security Docs — OAuth2, JWT tokens, API keys | Auth reference |
| Guide | OWASP API Security Top 10 | Broken auth, injection, mass assignment |
| Tool | Langfuse — open-source LLM observability. Free tier. | Best LLM observability |
| Tool | LangSmith — tracing for LangChain/LangGraph | LangChain tracing |
| Library | Structlog — structured JSON logging for Python | Production logging |
Module 26: Prompt Versioning, Cost Monitoring & Caching
1 Week • Intermediate • Langfuse, Helicone, LiteLLM, Redis, GPTCache
+
- In production, your prompts are code — version control, testing, and rollback are required
- Store prompts outside application code. Version every change. A/B test variants in production.
- A traffic spike or prompt bug can burn hundreds of dollars in minutes without spending limits
- Helicone: proxy-based cost tracking, one line of code — just change your base URL
- LiteLLM: unified interface for 100+ providers with budget management and rate limiting
- If 20% of users ask similar questions, you are paying for the same LLM call 20 times — cache it
- GPTCache: semantic caching using embedding similarity for similar (not just identical) queries
| Type | Resource | Category |
|---|---|---|
| Tool | Langfuse Prompt Management — versioning with rollback | Best prompt versioning |
| Tool | Helicone — proxy-based cost tracking, one line of code | Easiest cost monitoring |
| Library | LiteLLM — unified interface + budget management | Multi-provider management |
| Library | GPTCache — semantic caching | Semantic caching |
Module 27: MLOps Foundations
1.5 Weeks (Required for ML Engineer) • MLflow, Evidently AI, GitHub Actions
+
⚡ SKIP IF: You know DevOps and CI/CD — GitHub Actions and Docker will be familiar. Focus on MLflow for experiment tracking and Evidently AI for model drift monitoring, which are ML-specific.
- Model serialization: joblib, pickle, ONNX for cross-platform serving
- MLflow: experiment tracking, model registry — log_param(), log_metric(), log_model()
- Evidently AI: data drift and model drift detection as open-source reports
- GitHub Actions: CI/CD workflow that tests code on every push
- Model monitoring: prediction distributions over time, alerting on drift
| Type | Resource | Category |
|---|---|---|
| Course | Made With ML — best free MLOps curriculum | Best free MLOps course |
| Docs | MLflow Documentation (Official) | Experiment tracking |
| Tool | Evidently AI — open-source model monitoring and drift | Data drift detection |
| Tool | Render.com — Free Docker App Hosting | Free deployment platform |
| Tool | HuggingFace Spaces — Free Hosting for ML Demos | Free ML demo hosting |
🏁 Part 7 Milestone
- Deploy a FastAPI + LLM app in Docker with proper production configuration (Gunicorn + Uvicorn workers)
- Handle long-running LLM tasks with background jobs and queues (Celery + Redis)
- Secure your API with auth, rate limits, and API key management (never secrets in code)
- Trace and debug every LLM call using Langfuse or LangSmith
- Manage prompts with version control, A/B testing, and rollback capability
- Monitor costs in real time and set hard spending limits (Helicone or LiteLLM)
- Cache LLM responses (exact-match Redis, semantic GPTCache) to reduce latency and cost
Part 8 — Specialization & Launch
This is the final phase. Choose the track that matches your career direction. You only need to complete ONE track — but you can explore all four. Each ends with a capstone project.
🚀 Track A — AI Product Engineer
Best for startup jobs, shipping AI products that real users interact with
Vercel AI SDK • Streamlit • Gradio • Product UX for AI • Ship 2–3 complete products
🔬 Track B — Applied ML / LLM Engineer
Best for deeper technical roles, understanding what’s under the hood
Fine-tuning • LoRA/QLoRA • Open-source models • vLLM • Inference optimization
⚙️ Track C — AI Automation Engineer
Best for building for businesses immediately, automating real workflows
n8n • Temporal • Business process automation • CRM/email/support automation
📊 Track D — Data Scientist / Analyst
Best for data-focused roles, combining statistical rigour with AI
Capstone projects • Kaggle competition strategy • Dashboard & reporting tools
Track A — AI Product Engineer
Vercel AI SDK • Streamlit • Gradio • Google PAIR • Nielsen Norman AI UX
+
- Vercel AI SDK: fastest way to build AI UIs with streaming. React, Next.js, Vue integrations.
- Streamlit: AI demos in pure Python. Ideal for internal tools and MVPs.
- Gradio: quick ML/AI interfaces, especially good for demoing on HuggingFace Spaces.
- AI UX: how to handle loading states, wrong answers, user feedback, probabilistic output
- Design for trust: users need to know when the AI is confident vs uncertain
| Type | Resource | Category |
|---|---|---|
| Docs | Vercel AI SDK — AI-powered UIs with built-in streaming | Fastest AI UI framework |
| Docs | Streamlit — AI demos in pure Python | Best for MVPs and demos |
| Docs | Gradio — quick model interfaces, HuggingFace Spaces deploy | Quick prototyping |
| Guide | Google: People + AI Guidebook | Best AI UX resource |
| Guide | Nielsen Norman Group: AI UX Guidelines | Research-backed AI interface guidelines |
🛠PROJECT: CAPSTONE: Build & Ship 2–3 AI Products[Advanced] 3–4 weeks
Build complete shippable products: (1) ‘Chat with your docs’ app with full RAG, (2) AI-powered internal tool automating a real workflow, (3) Agent with human-in-the-loop approval. Ship them. Deploy them somewhere people can try them.
Skills: Vercel AI SDK or Streamlit, LangChain/LlamaIndex, FastAPI, Docker, LLM APIs, Langfuse
Track B — Applied ML / LLM Engineer
Fine-tuning • LoRA/QLoRA • Ollama • vLLM • Inference Optimization
+
💡 Decision Framework: Start with prompt engineering (cheapest, fastest) → Add RAG if model needs specific data → Fine-tune ONLY when prompting + RAG cannot achieve required quality, consistency, or latency.
- Fine-tuning: OpenAI API (easiest start), HuggingFace Transformers, LoRA and QLoRA
- Unsloth: 2x faster fine-tuning with 80% less memory on consumer hardware
- Ollama: run open-source LLMs locally with one command — Llama, Mistral, Gemma
- vLLM: production LLM serving, 2–4x faster than naive HuggingFace
- Quantization: GGUF, GPTQ, AWQ — reduce model size and cost for deployment
- Inference optimization: KV-cache, batching, TensorRT-LLM for NVIDIA GPUs
| Type | Resource | Category |
|---|---|---|
| Docs | OpenAI Fine-tuning Guide | Easiest fine-tuning start |
| Docs | HuggingFace Transformers Fine-tuning Tutorial | Open-source fine-tuning |
| Repo | Unsloth — 2x faster, 80% less memory | Fastest fine-tuning |
| Tool | Ollama — run open-source LLMs locally with one command | Local LLM experimentation |
| Library | vLLM — production inference, 2–4x faster | Production inference |
Track C — AI Automation Engineer
n8n • Temporal • Business Process Automation • CRM/Email/Support
+
- Real business automation = chains of actions across multiple systems, not single LLM calls
- n8n: visual workflow automation with AI nodes, 400+ integrations. Free to self-host.
- Temporal: durable workflows for long-running, fault-tolerant processes that survive crashes
- High-ROI targets: email triage, document processing, CRM enrichment, support automation
- Always build human-in-the-loop approval steps for consequential automations
- Measure actual time and money saved — the ROI is how you sell it
| Type | Resource | Category |
|---|---|---|
| Docs | n8n — visual AI automation, 400+ integrations, free to self-host | Best no-code AI automation |
| Docs | Temporal — durable workflows for fault-tolerant processes | Fault-tolerant automation |
| Docs | LangGraph: Multi-Agent Workflows | Code-first multi-agent orchestration |
🛠PROJECT: CAPSTONE: Lead Qualification System[Advanced] 3–4 weeks
(1) Import leads from CSV/API/form, (2) LLM researches each lead, (3) Score and rank against ICP, (4) Draft personalized outreach messages, (5) Log everything to CRM/spreadsheet.
Skills: n8n or LangGraph, LLM APIs, FastAPI, structured outputs, Pydantic, data export
Track D — Data Scientist / Analyst
Capstone Projects • Kaggle Strategy • Dashboard Tools
+
- Complete a full capstone project demonstrating end-to-end data science competency
- Kaggle strategy: start with Titanic (classification) and House Prices (regression)
- Aim for top 30% placement in at least one competition before applying for jobs
- Dashboard tools: Streamlit for Python-native, Tableau/Power BI for business stakeholders
🛠PROJECT: CAPSTONE: Choose One of Three[Advanced] 2 weeks
(A) AI-Powered Financial Intelligence Platform: sentiment analysis on earnings calls + XGBoost price prediction + RAG chatbot over annual reports + Streamlit dashboard. (B) Healthcare ML Pipeline: XGBoost + Stacking + SMOTE + SHAP per patient + LLM report generator + FastAPI endpoint. (C) E-Commerce Intelligence: K-Means segmentation + collaborative filtering + time-series forecasting + RAG over product catalog.
Skills: XGBoost, SHAP, LangChain, RAG, ChromaDB, FastAPI, Streamlit, Docker
Part 9 — Capstone, Portfolio & Launch
GitHub Profile Setup
Your GitHub IS your resume • README • Pinned Repos • Naming Conventions
+
- Create a profile README: github.com/username/username repository with README.md
- Pin your 6 best project repositories to your profile page
- Add a professional bio, location, LinkedIn link, and contact email
- Use consistent naming: project-name-ml, project-name-rag
- Write descriptive repository descriptions — 1–2 sentences shown on profile
- Capstone delivery must include: clean README, requirements.txt, organized folder structure (data/, notebooks/, src/, app/), working deployed app, 5-slide deck, model card, 2–3 min demo video
Portfolio Project Checklist
Interactive — click to check off completed projects
+
- Python CLI Grade Management System (Module 1) — All roles — shows Python basics
- COVID-19 Pandas Analysis (Module 2) — Data Analyst, Data Scientist
- EDA Report with 8+ visualizations (Part 2) — Data Analyst, Data Scientist
- House Price Predictor — deployed app (Module 7) — All ML roles
- Heart Disease Classifier with SHAP (Module 8) — Data Scientist, ML Engineer
- Customer Segmentation + Churn Prediction (Modules 9–10) — Data Scientist, ML Engineer
- ‘Chat with your docs’ RAG App (Part 5) — AI/GenAI Engineer
- Agent Loop from scratch (Part 6) — AI/GenAI Engineer
- Dockerized production app with auth + observability (Part 7) — ML/AI Engineer
- Track specialization capstone (Part 8) — All roles — most important
Job-Readiness Checklist
Technical Skills • GitHub • Kaggle • LinkedIn • Resume • Interview Prep
+
- Technical Skills: Python ✓, Pandas/NumPy ✓, Scikit-learn ✓, XGBoost ✓, LangChain ✓, FastAPI ✓, Docker ✓
- GitHub: 5+ public projects with good READMEs and deployed links
- Kaggle: Contributor status, at least 1 competition submission, 2+ public notebooks
- Free certs: Kaggle ML certificates, DeepLearning.AI short courses, Google ML Crash Course
- LinkedIn: updated with skills, project links, GitHub link, and an AI/ML-focused headline
- Resume: 1-page, quantified achievements, GitHub & portfolio links in header
- Interview prep: 50 Python coding questions (LeetCode Easy/Medium), ML concept flashcards
Essential Communities & Platforms
Kaggle • HuggingFace • Colab • DeepLearning.AI • fast.ai
+
| Type | Resource | Category |
|---|---|---|
| Tool | Kaggle — datasets, competitions, learning | Primary practice platform |
| Tool | HuggingFace — models, datasets, free hosting on Spaces | AI model hub |
| Tool | Google Colab — free GPU Jupyter notebooks | Free compute |
| Course | DeepLearning.AI Short Courses (all free) | GenAI specializations |
| Course | Google ML Crash Course | Core ML concepts |
| Course | course.fast.ai — practical deep learning top-down | Deep learning |
| Tool | Papers With Code — latest research with code | Stay current |
| Tool | MLflow — open source ML experiment tracking | ML experiment tracking |
| Docs | HuggingFace Transformers Documentation | Open-source LLMs |
| Community | AI Discord — EleutherAI & HuggingFace | Community learning |
🏁 Final Words
- You now have a complete, structured, project-based roadmap from zero to industry-ready in AI/ML.
- Consistency beats intensity. 1–2 hours every day beats 10 hours on weekends.
- Build in public — post your projects, insights, and learnings on LinkedIn.
- Your first job will come from a project someone saw, not a certificate on your wall.
- The field moves fast. This roadmap is a living document. Parts 4–6 will keep expanding.