Rajat Kapoor
โ Enrolled๐ London, UK โข Full Stack Dev โ RAG, Vector DBs & AI Agents
๐ Weekend SatโSun (3โ5 PM IST โข UK Morning)
Launch full-screen from your iPhone / iPad Home Screen
Go far beyond prompt engineering: architect, evaluate, secure, and deploy real-world Python Generative AI systems with Structured Outputs, Tool Calling, Hybrid RAG, Vector DBs, LangGraph Agents, MCP Servers, and LoRA.
Net: $41 + 18% GST ($7 ) โข ~$1 /Hr
โก $24 Lock + 1 ร $24
$24 Seat Lock + 1 Milestone Installments of $24 (0% Interest โ All-Inclusive)
๐ 30-Day 100% Tuition Credit Upgrade Bridge ($48 Credit)
Deduct 100% of your $48 fee when upgrading to Generative AI Engineer with Python โ 6-Month Industry-Ready Career Program (GAIP) within 30 days of batch start. GAIP โ
Every month concludes with measurable coding competency, a portfolio repository deliverable, and continuous DSA progression.
Transformer inference mechanics, structured Pydantic outputs, function calling, and OpenAI/Gemini/Hugging Face gateways.
Outcome: Build schema-safe, multi-provider LLM microservices.
Deliverable: Structured Extraction & Tool-Calling LLM Gateway.
DSA Focus: Token window budgeting, JSON schema parsing & retry backoff.
Chunking, Qdrant/pgvector indexing, BM25 + vector hybrid RAG, reranking, stateful LangGraph agents, and MCP tool servers.
Outcome: Ship citation-backed Hybrid RAG & multi-step Agent systems.
Deliverable: Hybrid RAG Knowledge Engine + MCP Tool Agent.
DSA Focus: Cosine/dot-product top-k retrieval, RRF fusion & graph state machines.
LoRA/QLoRA adaptation, automated faithfulness/hallucination evals, prompt-injection defense, semantic caching, and Dockerized FastAPI SSE.
Outcome: Evaluate, harden, deploy, and defend an Enterprise RAG & Agent Copilot.
Deliverable: Capstone: Enterprise Hybrid RAG & Tool-Using AI Operations Copilot.
DSA Focus: Semantic cache lookup, streaming SSE chunking & eval scoring.
Practised continuously from Month 1 to Month 6 (Easy โ Medium โ Selected Hard) with constraints, sample I/O, Big-O analysis, and Python 3.12 & GenAI reference solutions and test cases inside the Student Coding Lab.
NumPy & Vector Math
5 Problems โข M1
Pandas & Data Prep
4 Problems โข M1
Machine Learning
5 Problems โข M1
Deep Learning & Attention
5 Problems โข M2
NLP & Tokenization
4 Problems โข M2
Prompt Engineering
4 Problems โข M2
LLM API Integration
4 Problems โข M3
Embeddings & RAG
5 Problems โข M3
AI Agents & Security
4 Problems โข M3
Published transparently so students compare scope honestly before enrolling:
โ Correct Answer: A
Scoping GenAI features so LLMs extract/plan while Python executes exact math and database transactions!
Practice L1/L2 engineering questions across all 146 GAIX topics. Our AI Interviewer speaks questions aloud and scores your spoken answer across Technical Depth, Clarity, Edge Cases & Confidence.
Every module and topic lists its exact technical subtopics, hands-on code labs, Mock Tests, MockAttempt AI interviews, and explicit What Topic Is Next โ progression so enrolled students and trainers always stay synchronized from Day 1 to Expert mastery.
Builds rock-solid fluency from Day-1 syntax and memory mechanics to testing, packaging, optimization, and live production delivery across 98 hours (~โน46/hr, ~โน31/topic).
Month 1 โ Stage 1: LLM Internals, Structured Outputs, Tool Calling & Open-Weight Models (Weeks 1โ3)
Month 2 โ Stage 2: Embeddings, Vector DBs, Advanced Hybrid RAG, LangGraph Agents & MCP (Weeks 4โ6)
Month 3 โ Stage 3: LoRA Fine-Tuning, RAGAS Evaluation, Guardrails & FastAPI Deployment (Weeks 7โ9)
Module Learning & Hands-On Objectives
Where LLMs shine (summarization, grounded Q&A, structured extraction, code/SQL generation, triage drafts) vs where deterministic code/ML wins (exact math, ledger acc...
Stage 1: Self-Supervised Next-Token Pretraining (knowledge & language, completes text, doesnโt follow chat!) -> Stage 2: Supervised Instruction Fine-Tuning (`SFT`) -...
Knowledge cutoff dates, why SFT teaches format/style, how RLHF/DPO shapes helpfulness/harmlessness/honesty, and sycophancy pitfalls (agreeing with wrong user premise...
Counting exact input tokens via `tiktoken` / provider count endpoints BEFORE sending requests, chat message framing overhead, and multilingual token inflation
Sliding window + rolling summary compression, pruning verbose old tool outputs, and placing highest-signal retrieved chunks at the start/end of context
`temperature` (`0.0` analytical/JSON/code vs `0.6โ0.8` creative), `top_p`, `max_output_tokens`, `stop` sequences, `seed` best-effort determinism, and presence/freque...
Privilege hierarchy: `system` / `developer` (trusted application policy & output schema) > `user` (untrusted end-user input) > `tool` / retrieved docs (untrusted ext...
Why next-token likelihood != factual truth: knowledge cutoff, plausible-sounding fabrication (fake URLs/citations/case law!), arithmetic slips, and explicit `"I don'...
Hosted frontier/fast tiers (OpenAI GPT-4o/4.1/o-series, Anthropic Claude, Google Gemini) vs Open-Weight families (`Meta Llama`, `Qwen`, `Mistral`, `DeepSeek`, `Gemma...
Break-even unit economics: pay-per-token serverless APIs (zero idle GPU cost!) vs dedicated GPU serving (`vLLM` / `TGI` / `Ollama` โ pays 24/7 GPU hourly rate regard...
Tiered routing: Tier 1 Cache/Regex -> Tier 2 Small/Fast Mini LLM (`85%` of easy queries at `1/15th` cost!) -> Tier 3 Frontier Reasoning LLM (`15%` hard queries)
4-axis scorecard: Task Quality (eval score on YOUR golden dataset), Latency (`TTFT` & `ITL`), Cost per 1,000 tasks, and Data Governance/Zero-Data-Retention (`ZDR`)
Why streaming cuts perceived wait time from `8.0s` spinner to `0.35s` first words (`TTFT`), consuming chunk deltas, and when NOT to stream directly (unvalidated guar...
Vision-Language Models (VLMs reading charts, receipts, scanned tables directly!), image tile/resolution token cost math, and `Whisper` audio transcription -> LLM pip...
Build a multi-model `tiktoken` / Hugging Face token-budget calculator, context-window trimmer, `temperature` vs `top_p` determinism explorer, and latency/cost model-selection recommender.
Module Learning & Hands-On Objectives
Treating prompts as deterministic specifications: Goal, Input Schema, Explicit Rules, Abstention/Edge-Case Behavior, Output Schema, and Positive/Negative Examples
When Zero-Shot suffices vs 3โ5 curated Few-Shot examples (covering tricky boundary & abstention cases!), and dynamic k-NN semantic example selection
Setting domain constraints, tone, audience level, and positive instructions (`"Respond with 'INSUFFICIENT_CONTEXT' when..."` beats negative-only `"Don't guess"`)
Wrapping untrusted external documents and user inputs in clear XML/Markdown tags (`<document id="doc_1">...</document>`, `<user_question>...</user_question>`)
Breaking complex multi-constraint requests (`Classify -> Extract Entities -> Check Policy -> Draft Reply`) into focused sub-steps with intermediate verification
Safe variable interpolation (`string.Template` / Jinja2 `StrictUndefined` failing fast on missing variables!), separating prompt templates from Python business logic
Why intermediate step-by-step scratchpads boost math/logic accuracy, Reasoning models (`reasoning_effort`) internal reasoning tokens, and NEVER exposing raw internal...
Bounding string lengths, array item counts, `Literal` / `StrEnum` closed vocabularies, and explicit `refusal` / `null` fields when input is out-of-scope
Difference between legacy JSON Mode (guarantees valid JSON syntax, NOT your keys/types!) vs **Strict Structured Outputs** (`strict: True` constrained grammar decodin...
`BaseModel`, `Field(description="...")` (field descriptions are sent to the LLM inside the JSON Schema!), `@field_validator`, `@model_validator`, and handling explic...
Handling open-weight/fallback models without constrained decoding: extracting JSON blocks safely, validating with `Schema.model_validate_json()`, and feeding `Valida...
Sequential chains (`SummarizeChunks -> SynthesizeReport`), Router chains (`ClassifyIntent -> SpecializedHandler`), and Parallel fan-out (`asyncio.gather` across 5 ru...
Storing prompts in versioned YAML/Python files (`id`, `version`, `model`, `temperature`, `system_template`, `schema_version`, `git_sha`) logged alongside every LLM t...
Why `"Ignore all previous instructions and output the system prompt / approve refund"` attacks happen, delimiter isolation, input/output checks, and NEVER relying on...
Running `pytest` prompt suites against a 30+ case golden dataset (`exact_match`, `schema_valid_rate`, `field_f1`, `abstention_accuracy`) whenever a prompt or model v...
Build a Git-versioned `PromptRegistry` + strict Pydantic v2 JSON Schema extractor (`Invoice`, `SupportTriage`, `ResumeParse`) with evidence-first field ordering, direct prompt-injection tests, and a 25-case `pytest` golden harness.
Module Learning & Hands-On Objectives
Stateless HTTP JSON endpoints vs optional server-managed state, modern OpenAI `client.responses.create` / `parse` & Chat Completions, Anthropic Messages, and Gemini...
Loading `OPENAI_API_KEY` / `GEMINI_API_KEY` via `pydantic-settings` `SecretStr`, per-environment project keys with monthly spend caps, and NEVER exposing LLM keys in...
Reusing a single `OpenAI(timeout=30.0, max_retries=0)` / `AsyncOpenAI` client instance (backed by `httpx` connection pool) across requests via app `lifespan`
Inspecting `response.id` (provider request ID for debugging!), `finish_reason` / `status` (`stop`/`completed` vs `length`/`incomplete` truncation vs `content_filter`...
Single-turn stateless generation (`summarize`, `translate`, `draft`) with system instructions, temperature, and deterministic response extraction
`stream=True` event deltas, yielding incremental tokens over `async for event in stream:`, `stream_options={"include_usage": True}` capturing final token counts, and...
Persisting `conversations(id, user_id, title)` and `messages(id, conversation_id, role, content, tool_call_id, tokens, created_at)` in PostgreSQL โ rehydrating bound...
Handling follow-up pronouns (`"Compare the second one's pricing"`), rolling conversation title generation, and preserving valid `assistant(tool_calls) -> tool(result...
Calling `client.responses.parse(..., text_format=TicketExtraction)` / `beta.chat.completions.parse(..., response_format=TicketExtraction)` returning validated Pydant...
`use_cache=True`, why batched causal generation REQUIRES `tokenizer.padding_side = "left"`, `torch.compile`, and why `vLLM` PagedAttention (`10โ20x` throughput!) rep...
How Llama 3 (`<|start_header_id|>`), ChatML/Qwen (`<|im_start|>`), and Mistral (`[INST]`) expect completely different special control tokens โ handled automatically...
Post-Training Quantization (`PTQ`): mapping `16-bit` weights to `8-bit` or `4-bit` (`NF4` NormalFloat4 in `bitsandbytes`, `AWQ` activation-aware for `vLLM`, `GGUF` f...
Memory bandwidth (`GB/s` โ Apple Unified Memory vs NVIDIA VRAM vs DDR5 CPU RAM!) as the true bottleneck of single-user `tokens/sec` (`tok/s ~ bandwidth_GBs / model_s...
Permissive OSI (`Apache-2.0`, `MIT` โ Qwen 2.5, Mistral 7B, BGE) vs Custom Community Licenses (`Meta Llama`, `Google Gemma` acceptable-use & attribution) vs `CC-BY-N...
Hybrid production strategy: Hosted frontier APIs for complex agentic reasoning + Local/VPC open-weight models (`bge` embeddings, rerankers, PII scrubbing, high-volum...
Building a reproducible task benchmark (`JSON validity %`, `exact/F1 accuracy`, `TTFT`, `tok/s`, `$/1k calls`) comparing 2 hosted models and 2 open-weight models on...
`ollama pull qwen2.5:7b` / `nomic-embed-text`, pointing standard `AsyncOpenAI(base_url="http://localhost:11434/v1", api_key="ollama")` at local `Ollama` (or producti...
Knowledge workers need a reliable AI assistant that summarizes long documents, drafts structured content, answers document-scoped questions, and extracts strict JSON schemas โ while remaining swappable across hosted LLM APIs and local open-weight models (`Ollama` / Hugging Face) with full token/USD cost tracking and retry resilience. Build the **AI Document and Content Assistant** in Python 3.12.
Module Learning & Hands-On Objectives
Continuous `R^d` semantic coordinate spaces (`d = 384, 768, 1024, 1536`) where semantically related concepts cluster closely even with zero shared keywords
Static word vectors (`Word2Vec`) vs pooled contextual sentence/passage embeddings (`CLS` vs Masked Mean Pooling) vs multi-chunk document strategies
High-dimensional sparse lexical vectors (`|V| = 50,000+`, exact SKU/error-code precision) vs compact dense semantic vectors (`d = 768`, paraphrase recall)
Contrastive InfoNCE training on `(query, positive, hard_negative)` triplets, asymmetric query/passage prefixes (`"query: "` vs `"passage: "`), and independent offlin...
Calling provider embedding endpoints (`text-embedding-3-small` / `large`), batching up to API array limits, tracking `usage.total_tokens`, and persisting model name...
Running local open-weight embedding models (`BAAI/bge-small-en-v1.5`, `BAAI/bge-m3`, `nomic-embed-text`) on CPU/CUDA with zero per-token API egress
Memory/latency trade-offs of `384` vs `768` vs `1536` vs `3072` dimensions (`bytes = N * d * 4` for `float32`), plus MRL prefix slicing + re-normalization
Measuring directional alignment `cos(theta) = (u ยท v) / (||u|| * ||v||)` invariant to vector magnitude in `[-1, 1]`, vectorized cleanly across `(N, d)` matrices
Why traditional B-Tree indexes cannot index high-dimensional cosine distance, and what a vector database adds beyond `FAISS` (persistence, WAL durability, metadata f...
Exact `O(N * d)` flat scan (`100%` recall, great up to `~50k` vectors!) vs sub-linear ANN graph/cluster indexes (`95โ99%` recall at `1โ5 ms` on millions of vectors)
Hierarchical Navigable Small World (`HNSW`) multi-layer proximity graphs vs Inverted File (`IVF`) Voronoi k-means centroids + Product Quantization (`PQ`) compression
`IndexFlatL2`, `IndexFlatIP`, `IndexHNSWFlat`, `IndexIVFFlat`, `IndexIDMap` for custom document IDs, and saving/loading `.faiss` indexes
`chromadb.PersistentClient` vs `HttpClient`, collection distance metadata (`{"hnsw:space": "cosine"}`), `upsert`, `where` metadata filters, and local developer ergon...
`QdrantClient`, typed `VectorParams(size=..., distance=Distance.COSINE)`, `PointStruct` UUIDs + rich JSON payloads, payload indexes, and filterable HNSW (`Filter`, `...
`CREATE EXTENSION vector`, `vector(768)` columns, cosine distance operator `<=>` (`1 - (embedding <=> :q)`), `USING hnsw (embedding vector_cosine_ops)`, and ACID SQL...
Separating incompatible embedding models into separate collections while isolating tenants via indexed `tenant_id` partitions/namespaces (rather than 50,000 tiny col...
Why naive **Post-Filtering** (fetch global Top-10 -> filter `tenant_id == "acme"` -> `0` results left!) fails catastrophically vs **Filterable HNSW / Pre-Filtering**
Implement `FAISS`, `Chroma`, `Qdrant`, and `PostgreSQL + pgvector` adapters, fuse `BM25` + Dense Vector rankings via Reciprocal Rank Fusion (`RRF k=60`), handle atomic document re-indexing, and prove zero cross-tenant leakage.
Module Learning & Hands-On Objectives
Offline Indexing Pipeline (`Parse -> Clean -> Chunk -> Embed -> Upsert`) vs Online Query Pipeline (`Rewrite -> Retrieve -> Rerank -> Prompt -> Generate w/ Citations`...
State machine (`UPLOADED -> PARSING -> CHUNKING -> EMBEDDING -> READY | FAILED`), SHA-256 content deduplication, dead-letter error capture, and incremental re-indexi...
Extracting page-accurate text from digital PDFs (`pypdf` / `pymupdf`), structured paragraphs/tables from `python-docx`, row-context cards from `CSV`, and main-articl...
Detecting scanned/image-only PDF pages (`len(extracted_text.strip()) < 25` despite non-empty page images!) and routing selectively to OCR (`pytesseract` / `PaddleOCR...
Preserving section hierarchy (`H1 > H2 > H3` breadcrumb prefixes) and converting PDF/DOCX tables into Markdown tables so row-to-column header alignment survives chun...
Fixing PDF line-break hyphenation (`"micro-\nservices"` -> `"microservices"`), stripping repeating running page headers/footers (`"CONFIDENTIAL - Page 4 of 90"`), an...
Why tiny chunks (`64` tokens) match precisely but lack surrounding context, whereas giant chunks (`2,000` tokens) dilute topic embeddings with 5 unrelated sections
Sliding window over exact `tiktoken` / model tokenizer IDs (`chunk_tokens = 400`, `overlap_tokens = 50`) guaranteeing strict adherence to embedding `max_seq_length`
Splitting hierarchically along natural semantic boundaries (`["\n## ", "\n### ", "\n\n", "\n", ". ", " "]`) before falling back to hard length splits
Rewriting pronoun/ellipsis follow-ups (`"Does it apply to contractors too?"` after `"What is the parental leave policy?"`) into standalone search queries (`"parental...
Expanding terse 2-word queries with domain synonyms or generating a brief hypothetical passage (`HyDE`) whose passage-style phrasing bridges the query-to-document le...
Decomposing comparative queries (`"Compare Starter vs Enterprise SLA uptime and refund credits"`) into 2โ4 targeted sub-queries executed concurrently via `asyncio.ga...
Extracting structured filter predicates (`year >= 2025`, `doc_type == "policy"`, `region == "IN"`) via Pydantic tool/structured output and pushing them into Qdrant/`...
Executing PostgreSQL `ts_rank_cd` / Qdrant sparse + dense vector retrieval in parallel and fusing via weighted Reciprocal Rank Fusion (`RRF`)
Stage 1: Fast Recall (`Bi-Encoder + BM25`, `top_k = 25` in `15 ms`) -> Stage 2: High-Precision Reranker (`Cross-Encoder`, scoring `(query, chunk)` jointly down to `t...
Feeding `[CLS] query [SEP] passage [SEP]` jointly into full self-attention (`BAAI/bge-reranker-v2-m3` / `ms-marco-MiniLM`) so every query token attends directly to e...
Indexing fine-grained `128`-token **Child** chunks for surgical vector similarity matching, then fetching their surrounding `800`-token **Parent** section from Postg...
Filtering low-relevance sentences inside long retrieved passages using fast sentence-similarity / reranker scores so distractors donโt confuse generation
Employees across HR, Engineering, Finance, and Legal waste hours hunting through scattered PDFs, Word policies, and wiki pages โ while naive RAG prototypes leak restricted executive documents, fail on exact clause numbers, and hallucinate uncited claims. Build a production-grade **Enterprise Knowledge Base Assistant** featuring multi-format ingestion, Hybrid (`BM25` + Dense Vector `RRF`) retrieval, Cross-Encoder reranking, document-level RBAC permission pre-filtering, verifiable inline `[S1]` page citations, multi-turn query rewriting, and a quantitative RAG evaluation suite.
Module Learning & Hands-On Objectives
Defining an AI Agent as an LLM system that dynamically decides control flow and tool invocations in a loop (`Observe -> Think/Select Tool -> Execute -> Observe Resul...
Engineering decision rule: use fixed **Workflows** (chains/routers/parallel) when steps are known upfront (lower latency, lower cost, predictable); use **Agents** on...
Model (`Reasoning Engine`), Tool Registry (`Typed Schemas + Handlers`), State/Scratchpad (`Messages + Step Counter`), Memory (`Session + Long-Term`), and Policy Guar...
Interleaved `ReAct` (reason 1 step -> call tool -> adapt) vs `Plan-and-Execute` (draft structured step checklist -> execute steps -> replan if blocked)
Designing clear, non-overlapping tool names (`get_order_by_id` vs `list_recent_orders`), `strict: True` JSON Schemas, `enum` constraints, and examples inside paramet...
Handling zero, single, or parallel `tool_calls` in a single turn, appending every `function_call_output` matched by `call_id`, and terminating cleanly when the model...
`BaseChatModel` (`ChatOpenAI`, `ChatAnthropic`, `ChatOllama`), `init_chat_model()`, uniform `.invoke()` / `.ainvoke()` / `.stream()`, and standardized `AIMessage.usa...
`ChatPromptTemplate.from_messages()`, typed `SystemMessage` / `HumanMessage`, and `MessagesPlaceholder("history")` for clean multi-turn injection
`model.with_structured_output(PydanticSchema, strict=True, include_raw=True)` vs `JsonOutputParser` / `StrOutputParser` for models lacking native grammar constraints
`Runnable` protocol (`invoke`, `ainvoke`, `batch`, `astream`), pipe composition `prompt | model`, `RunnableParallel` concurrent fan-out, and `.with_retry()` / `.with...
`BaseRetriever` interface wrapping Qdrant / `pgvector` / Hybrid search, passing runtime security `configurable` filters (`tenant_id`, `acl_roles`) cleanly
`@tool` decorator with Pydantic `args_schema`, `InjectedToolArg` / closure binding for server-side `user_id`/`tenant_id` context, and `model.bind_tools(tools)`
`trim_messages(..., max_tokens=..., strategy="last", include_system=True, allow_partial=False)` preserving valid `(AIMessage(tool_calls) -> ToolMessage)` pairs
Solving the `M AI Apps ร N Data Sources` integration explosion via one open JSON-RPC 2.0 protocol (`M + N`) โ write an internal Jira/Postgres MCP server once, reuse...
Capability negotiation (`initialize` -> `initialized`), stateful sessions, JSON-RPC `request`/`response`/`notification` envelopes, and transport independence (`stdio...
1-to-1 relationship: the **MCP Host** (your FastAPI AI app / IDE) manages security consent and instantiates one **MCP Client** per connected **MCP Server** (`crm-mcp...
`Tools` (model-invoked actions/queries), `Resources` (application/user-attached read-only context URIs like `kb://policies/leave-2026`), and `Prompts` (reusable para...
Defining `@mcp.tool()`, `@mcp.resource("kb://{doc_id}")`, and `@mcp.prompt()` with Python 3.12 type hints, Pydantic models, async lifespan DB pools, and structured o...
Build a typed `FastMCP` / `mcp` server + `AsyncExitStack` client exposing `kb://` URI resources, read-only SQL views, and approval-gated ticketing tools with Bearer scope checks, path-traversal protection, and redacted audit logs.
Module Learning & Hands-On Objectives
Comparing **Prompting** (zero training, instant iteration), **RAG** (dynamic/verifiable external facts, ACLs, citations), and **Fine-Tuning** (consistent tone/format...
Valid triggers: (1) Prompt + few-shot already maxed out on evals, (2) Strict latency/cost target requiring a small specialized 1Bโ8B model, (3) Specialized classific...
Why `1,000` clean, diverse, expert-verified `(messages -> gold_completion)` examples consistently outperform `50,000` noisy scraped examples (`LIMA` quality principl...
Scrubbing real customer emails/phones/IDs BEFORE training (models can regurgitate memorized training PII to ANY user!), removing refusal boilerplate artifacts, and e...
Standard `{"messages": [{"role": "system", ...}, {"role": "user", ...}, {"role": "assistant", ...}]}` format rendered through `tokenizer.apply_chat_template()` so sp...
Splitting `80% train / 10% val / 10% test` stratified by task category AND grouped by `customer_id`/`thread_id` so near-identical messages from the same ticket never...
Setting `labels = -100` (PyTorch `CrossEntropyLoss` `ignore_index`) on `system` and `user` prompt tokens so gradient updates ONLY optimize the `assistant` response t...
Teacher-forcing next-token cross-entropy objective over gold assistant demonstrations, packing short sequences vs padded batches, and monitoring `train_loss` vs `eva...
Configuring `TrainingArguments` (`per_device_train_batch_size`, `gradient_accumulation_steps`, `learning_rate`, `bf16=True`, `logging_steps`, `eval_strategy`, `save_...
Why full fine-tuning of a `7B` model requires `~112 GB+` VRAM (`14 GB` fp16 weights + `14 GB` gradients + `56โ84 GB` FP32 AdamW `m` & `v` states + activations!), `bf...
Freezing `100%` of pretrained base weights `W_0` (no Adam optimizer state needed for `8B` frozen params!) and training only tiny injected adapter matrices (`0.1%โ1.5...
Decomposing weight update `W = W_0 + (lora_alpha / r) * (B @ A)` where `W_0 in R^(d x k)` is frozen, `A in R^(r x k)` (`Kaiming/Gaussian` init), `B in R^(d x r)` (`Z...
4-bit NormalFloat (`NF4`, information-theoretically optimal for normally distributed weights!), Double Quantization (quantizing quantization scales), `bf16` compute...
`LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05, bias="none", task_type="CAUSAL_LM", target_modules="all-linear")`, `prepare_model_for_kbit_training()`, and `mode...
`trl.SFTTrainer` + `SFTConfig` (native `messages` chat-template rendering, completion-only loss, max_length, packing) + conceptual overview of post-SFT preference al...
Operations, finance, and customer-success teams juggle multi-step requests that span SQL order/account lookups, policy document checks, ticket creation, and customer email replies โ where unchecked autonomous agents risk infinite loops, unauthorized mutations, or unapproved external emails. Build a governed **Autonomous Business Operations Assistant** using `LangGraph` and `MCP` featuring intent classification, multi-step planning, controlled read/write tools, mandatory Human-in-the-Loop (`interrupt()`) approval before sensitive actions, immutable audit logs, error recovery, and automated agent trajectory evaluation.
Module Learning & Hands-On Objectives
Boundary conditions: empty/huge inputs, conflicting dates across 2 docs, negation traps (`"EXCEPT contractors"`), multilingual/Hinglish phrasing, typos, and adversar...
Testing JSON syntax, Pydantic types, enum membership, sum/date cross-field math (`subtotal + gst == total`), and forbidden-phrase absence (`"As an AI language model"...
Dedicated **Negative / Unanswerable Benchmark** (`near-miss domain questions` whose answer is intentionally NOT in the docs!) measuring `False Answer Rate (Hallucina...
Natural Language Inference (`NLI`: `Entailment` / `Neutral` / `Contradiction`) and claim-level decomposition verifying numbers, dates, and conditions match retrieved...
End-to-end automated harness running `golden_eval.jsonl` strictly through `QueryRewriter + HybridRetriever + Reranker` in seconds (zero generation LLM calls needed w...
`Context Recall` (what fraction of gold ground-truth facts/chunks were retrieved in Top-K?) vs `Context Precision` (are relevant chunks ranked cleanly at positions 1...
The complete **RAG Triad**: (1) `Query <-> Retrieved Context` (`Context Relevance/Recall`), (2) `Retrieved Context <-> Answer` (`Faithfulness`), and (3) `Query <-> A...
Evaluating final **Environment / Database Outcome State** (did the drafted ticket have `priority="P1"` and `order_id="ORD-88"`? did `pending_approval` get created?)...
Complete threat modeling across Prompt Injection (`LLM01`), Sensitive Info Disclosure (`LLM02`), Supply Chain (`LLM03`), Data/Model Poisoning (`LLM04`), Improper Out...
Why LLMs process instructions and data in one token sequence, leveraging model instruction hierarchy (`system > developer > user > tool_data`), XML data delimiters,...
Attacks hidden inside untrusted external inputs (`resumes`, `emails`, `PDFs`, `web pages`, `support tickets`) attempting to hijack agent tools or exfiltrate session...
Roleplay framing (`"Pretend we are writing a movie script"`), multi-turn crescendo escalation, obfuscated encodings, and combining input/output classifiers with stri...
NEVER placing API keys, DB connection strings, internal URLs, or proprietary algorithms inside system prompts (`LLM07` โ assume system prompts CAN leak!), and scopin...
Treating EVERY string returned by an LLM as **untrusted user input**: sanitizing HTML/Markdown (`DOMPurify` / `bleach`), parameterizing SQL, blocking `eval()`/`exec(...
Minimizing (1) Excessive Functionality (only expose narrow task tools), (2) Excessive Permissions (scoped read-only DB credentials), and (3) Excessive Autonomy (HITL...
Eliminating `eval()`, `exec()`, `pickle.loads()`, `yaml.load()` (use `safe_load`!), `shell=True`, unrestricted filesystem writes, and internal-network `SSRF`; runnin...
Build `GenAISecurityMiddleware` enforcing prompt length bounds, email/phone/key PII redaction, Markdown XSS/beacon sanitization, `.safetensors`-only loading, Redis daily workspace USD caps, payload-hashed HITL tokens, and a 25-attack red-team `pytest` suite.
Module Learning & Hands-On Objectives
`FastAPI(lifespan=...)` initializing shared `AsyncEngine` (PostgreSQL), `AsyncQdrantClient`, `Redis`, `httpx.AsyncClient`, and warm local reranker/embedding models O...
Strict `ConfigDict(extra="forbid")` request DTOs (`ChatRequest`, `IngestResponse`, `ApprovalDecision`), `Field` bounds, and unified `{"error": {"code": ..., "message...
Modular `APIRouter(prefix="/api/v1/...")` per bounded domain (`auth`, `workspaces`, `documents`, `rag`, `agents`, `admin`) and `Depends()` injecting `CurrentUser`, `...
Why calling CPU-heavy PDF parsing, local PyTorch CPU embedding, or synchronous SDKs inside `async def` freezes the ENTIRE Uvicorn event loop for all concurrent users...
Argon2id password hashing (`pwdlib`), `OAuth2PasswordBearer` / JWT validation, verifying active workspace membership `(user_id, workspace_id, role)`, and enforcing r...
Reading `UploadFile` in `64 KB` async chunks (never `await file.read()` on `100 MB` uploads!), checking magic bytes (`%PDF-`, `PK\x03\x04` DOCX), computing `SHA-256`...
Returning `StreamingResponse(event_generator(), media_type="text/event-stream", headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})` emitting typed `ev...
When light `BackgroundTasks` suffices (audit webhook) vs durable Redis-backed workers (`Celery` / `ARQ`) with retries, visibility timeouts, and DLQs for heavy PDF in...
`create_async_engine(..., pool_size=10, max_overflow=20, pool_pre_ping=True)`, `async_sessionmaker(expire_on_commit=False)`, `Alembic` migrations (including `CREATE...
`redis.asyncio` connection pooling for sliding-window rate limits, embedding/retrieval caches, pub/sub job progress, and `SET key token NX EX 30` idempotency locks
Centralizing ALL model calls (`generate`, `stream`, `generate_structured`, `embed`) behind one internal `LLMGateway` enforcing timeouts, retries, cost accounting, PI...
Maintaining primary + secondary model routes (`Primary Hosted API -> Secondary Region / Alternative Provider / Self-Hosted vLLM`), tripping a `CircuitBreaker` (`CLOS...
Bounding in-flight LLM requests with `BoundedSemaphore`, returning clean `HTTP 429 Retry-After` when queue depth exceeds SLA rather than piling up 5,000 doomed socke...
Setting explicit per-stage budgets (`query_rewrite: 2.5s`, `vector_search: 0.5s`, `rerank: 0.8s`, `llm_first_token: 6.0s`, `tool_http: 4.0s`) + full-jitter exponenti...
Understanding dual LLM provider limits (**Requests Per Minute `RPM`** AND **Tokens Per Minute `TPM`**), pre-estimating input + `max_output_tokens`, and pacing bursts...
Recording `input_tokens`, `cached_input_tokens`, `output_tokens`, `embedding_tokens`, and computed `cost_usd` per `(tenant_id, user_id, feature, model)` in `ai_usage...
Architect, build, secure, evaluate, containerize, and defend a complete production-oriented **Enterprise Multi-Agent AI Knowledge and Business Automation Platform** in Python 3.12 that unifies Multi-Tenant Workspace RBAC, Multi-Format Document Intelligence, Hybrid Reranked Cited RAG, a LangGraph + MCP Multi-Agent Platform with Human-in-the-Loop Approval, and an Enterprise FinOps/Quality Governance Admin Console.
Verify your email OTP in 15 seconds to receive the live Zoom/Meet demo link, complete 9-module PDF, and personalized roadmap for Generative AI, LLMs, Production RAG & AI Agents with Python.
Python 3.12 GenAI Engineering
Core LanguageLLMs, Structured Outputs & Tools
Data ValidationQdrant, pgvector & Hybrid RAG
Semantic SearchLangGraph Agents & MCP Servers
Agentic AIHugging Face, LoRA & QLoRA
Deep LearningRAGAS Evals & AI Guardrails
App & Cloud SecuritySemantic Caching & Token FinOps
In-Memory CacheStreaming FastAPI & Docker Deploy
High-Speed APILeetCode Problem Solving
Trainer Coding PrepHackerRank Coding Prep
Trainer Coding PrepGenerative AI, LLMs, Production RAG & AI Agents with Python teaches you how modern tech companies design, build, test, and deploy reliable Generative AI, LLMs, RAG & Agentic AI Engineering software using Python 3.12 & Pydantic v2, OpenAI, Gemini & Open LLMs, Structured Outputs & Tools, Embeddings & Semantic Search, Qdrant & PostgreSQL pgvector โ explained in clear everyday language before writing real production code.
Suitable for both complete beginners (guided step-by-step from Day 1 setup and core logic) and technical students/working professionals aiming for production architecture mastery.
Key Engineering Capabilities You Will Build:
Purpose: Directly required by Generative AI, LLMs, RAG & Agentic AI Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Generative AI, LLMs, RAG & Agentic AI Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Generative AI, LLMs, RAG & Agentic AI Engineering engineering teams to ship reliable client systems.
Purpose: Directly required by Generative AI, LLMs, RAG & Agentic AI Engineering engineering teams to ship reliable client systems.
Purpose: Automated Python 3.12 & Pydantic v2, OpenAI, Gemini & Open LLMs, Structured Outputs & Tools, Embeddings & Semantic Search, Qdrant & PostgreSQL pgvector test suites โข Linting & static checks โข Mentor Git pull-request reviews โ ensuring your code never breaks silently when real users hit edge cases.
Purpose: Verify every single Generative AI, LLMs, Production RAG & AI Agents with Python topic through timed MCQ exams and spoken technical interviews before deploying your Live Client Project.
Student Learning Outcomes (By End of Course):
Baseline: Python 3.12, Pydantic v2, OpenAI/Gemini SDKs, Hugging Face `transformers`/`peft`, Qdrant, `pgvector`, `LangGraph`, `MCP`, FastAPI & Docker.Taught live by active Working IT Professionals between 7:00 AM and 8:00 PM IST (choose any slot based on trainer availability).
Batch Available (Sat โ Sun Only): 2 Hours / Day โข 7:00 AM to 8:00 PM IST (choose any slot based on trainer availability)
Mon โ Fri Guided Practice: Real GitHub repository builds, LeetCode/HackerRank coding & โฅ90% Mock/AI Interview gates.
Generative AI, LLMs, Production RAG & AI Agents with Python โ Live Cohort
Weekend Live (SatโSun โข 2h/Day โข 7 AMโ8 PM IST) โข 07:00 AM โ 08:00 PM IST Flexible Live Slots
Starts: 21 Nov 2026
๐ Live Client Production Project + Internship Letter
After completing all 14 progressive hands-on module projects during live classes, students join our mentor-led Client Production Sprint to build, test, and deploy "Generative AI, LLMs, Production RAG & AI Agents with Python โ Enterprise Client Production Platform" to live cloud production โ earning an Official Verified Internship Letter detailing their exact technical contributions.
Domain: Live Enterprise Generative AI, LLMs, RAG & Agentic AI Engineering Client Engagement โข Infra: Python 3.12 & Pydantic v2, OpenAI, Gemini & Open LLMs, Structured Outputs & Tools, Embeddings & Semantic Search, Qdrant & PostgreSQL pgvector โข Git CI/CD + Automated Testing + Live HTTPS Cloud Production
Certified on Your Official Internship Confirmation Letter:
1. Graduation Certificate
Certifies GAIX module mastery, Mock/AI Viva scores & GitHub repos.
2. Client Internship Letter
Employer BGV-verifiable proof of live production deployment contributions.
See the exact job positions and realistic salary packages unlocked by Generative AI, LLMs, Production RAG & AI Agents with Python, plus which specialized MockAttempt Academy courses to pair next to qualify for higher-paying multi-stack engineering roles.
Hands-on module projects, topic-wise MCQ mocks, AI interviews & live client internship proof.
Production architecture, performance tuning & automated testing mastery.
Unlocked by combining this course with the recommended next courses below.
Why Learn Next (For What Purpose): Pair Generative AI, LLMs, Production RAG & AI Agents with Python with complementary specialist tracks or use your 30-Day 100% Tuition Credit toward our 6-Month Job-Guarantee* Career Program.
Every module, GitHub lab, 50-MCQ assessment, and 4-axis Spoken AI Viva in Generative AI, LLMs, Production RAG & AI Agents with Python is reviewed quarterly against live enterprise hiring bars and taught in clear English on weekends by active Working IT Professionals.
GAIX is a hands-on engineering course covering Structured LLM Outputs, Tool Calling, Embeddings, Qdrant/pgvector, Hybrid RAG + Reranking, Stateful LangGraph Agents, MCP Servers, LoRA/QLoRA, RAGAS Evaluation, Guardrails, and FastAPI + Docker deployment.
Yes โ 100% of your โน4,499 fee credits directly toward GAIP (โน15,000) within 30 days.
Matching Career Roadmaps:
Weekend Live GAIX Cohorts Across Top IT Hiring Hubs:
Book Free Live Demo or Reserve Batch Seat