Learn LLMs, prompt engineering, embeddings, RAG, fine-tuning, tool calling and production AI development with practical examples and projects.
What generative AI is, how it differs from AI/ML/DL, and how it works.
How large language models are trained, run, and their real limitations.
Tokenization and why it drives cost, context limits and latency.
Attention, self-attention and the architecture behind modern LLMs.
Structuring prompts, few-shot patterns, chaining and prompt security.
Chat completions, sampling parameters, streaming and provider-agnostic API design.
Getting reliable JSON out of an LLM, and validating it.
Turning text into vectors, and measuring semantic similarity.
Storing and searching embeddings at scale — indexes and hybrid search.
Retrieval-augmented generation — chunking, retrieval, and evaluating RAG systems.
When to fine-tune vs prompt vs RAG, and parameter-efficient methods like LoRA.
Vision-language models, speech, image/video generation, and multimodal RAG.
Letting an LLM call functions/APIs, and validating those calls safely.
LangChain and LangGraph fundamentals for building LLM applications.
Measuring faithfulness, relevance and correctness of LLM applications.
Observability, caching, cost/latency, and shipping reliable LLM applications.
Prompt injection, data leakage and defensive engineering for LLM apps.
Topic-wise Generative AI interview questions with explained answers.
Implementation-oriented exercises across prompting, RAG and tool calling.
End-to-end builds — chatbots, RAG systems, document assistants and more.
No notes found. Try a different search term, or browse all Generative AI notes.
What generative AI actually is, and how it differs from discriminative AI.
Why generative AI is one capability within the broader field of AI.
How generative AI relates to traditional machine learning techniques.
How generative AI relates to deep learning, and the transformer breakthrough.
LLMs, diffusion models, GANs and the different generative AI architectures.
Real production use cases, and why narrow tasks work better than open-ended assistants.
The training-to-inference pipeline behind text generation, step by step.
Technical limitations, operational risks and security/ethical challenges.
What makes a language model "large," and what it actually learns from training.
The training vs inference split, and where prompting and fine-tuning fit in.
The decoder-only transformer pipeline, from tokens to next-token prediction.
The three-stage training pipeline: pretraining, instruction tuning, alignment.
Self-supervised learning on raw text, and the knowledge cutoff it creates.
Teaching a base model to follow instructions and respond helpfully.
RLHF and preference-based training toward helpful, honest, harmless behavior.
Prefill vs decode, KV caching, and why output length drives latency.
What counts toward it, why conversations "forget," and long-context tradeoffs.
What a parameter/weight actually is, and what "7B" or "70B" means.
The capability-vs-cost tradeoff, and how to choose the right model size.
Knowledge cutoff, bounded context, and inconsistent multi-step reasoning.
Why models fabricate confident, wrong answers — and how to detect and reduce it.
The basic unit an LLM reads and writes, and why it matters practically.
How Byte Pair Encoding builds a vocabulary and splits text into tokens.
Why you can't estimate tokens by word count, and how to count them precisely.
Two related but distinct constraints — model capacity vs an API output cap.
Why input tokens often dominate cost in RAG and context-heavy applications.
Why output tokens cost more and directly drive generation latency.
How LLM API pricing works, and the real cost levers available to you.
Practical techniques to reduce token usage without hurting output quality.
The 2017 breakthrough that made today's LLMs computationally feasible.
Inside one transformer block — attention, feed-forward, residuals and normalization.
The core mechanism that lets a model weigh relevance between tokens.
Attention applied within one sequence, and causal masking for generation.
Running several attention computations in parallel to capture different relationships.
The actual mathematical mechanism behind attention, with the scaled dot-product formula.
Why attention needs word-order information injected back in.
How tokens become vectors before entering the attention layers.
The original transformer design, cross-attention, and where it's still used.
The simpler, unified architecture behind most modern general-purpose LLMs.
Sequential vs parallel processing, and why long-range dependencies favor transformers.
Why LSTM's gating improvements still didn't solve the sequential bottleneck.
What prompt engineering actually is, and the techniques covered in this section.
Separating instructions, context and task so the model parses intent clearly.
Setting persistent behavior and persona, and why it's not a security guarantee.
The per-turn request, and how applications construct it dynamically.
Supplying grounding information, and instructing the model to actually use it.
Asking for a task with no examples, and when it works well.
Using exactly one example to establish a consistent output pattern.
Using multiple examples to lock in format and demonstrate variation.
Working through steps before a final answer to improve multi-step accuracy.
Self-consistency, sub-question decomposition, and verification patterns.
Assigning a persona to shape tone and framing — and its real limits.
Breaking one large prompt into a sequence of smaller, testable ones.
Reusable, testable prompt structures instead of ad hoc prompt strings.
Connecting multiple LLM calls in sequence, with real error-handling considerations.
A systematic, testable process for improving prompt performance.
Building a test set and measuring prompt quality before shipping changes.
Direct vs indirect injection, and practical defense-in-depth strategies.
The broader threat surface beyond injection — leakage and unsafe output use.
A practical checklist across structure, technique, evaluation, security and cost.
The common request/response shape across most LLM API providers.
The role-based message structure behind modern conversational LLM APIs.
A practical framework for choosing which model to call, and model routing.
How temperature controls output randomness, with a worked example.
How top-p restricts the candidate token pool, and how it differs from temperature.
Capping response length, and why checking the finish reason matters.
Delivering output incrementally, and what it does (and doesn't) improve.
Lower-cost, non-real-time processing for bulk LLM workloads.
Designing around API rate limits proactively, not just reacting to errors.
Exponential backoff, jitter, and which errors are actually worth retrying.
Handling malformed output, content rejections and empty responses gracefully.
The full cost picture beyond simple token pricing, and practical controls.
Credential handling, data privacy, and access control for LLM integrations.
Why predictable, parseable output matters for production LLM apps.
Practical prompting techniques for reliable JSON, with defensive parsing.
Formally specifying expected structure, and using it to guide generation.
Provider-enforced schema conformance at the generation level.
Validating LLM output as untrusted input, with real handling strategies.
When rigid structure helps, and when it hurts a genuinely conversational response.
Two related but distinct patterns — a final answer vs a request to act.
The text-to-vector-to-similarity pipeline that powers semantic search and RAG.
Generating embeddings in practice, and what they're used for.
How embedding models differ from LLMs and from each other.
How meaning is encoded as position in a high-dimensional space.
Measuring meaning-based closeness, and where it can still fall short.
The standard formula for comparing embedding vectors, with a worked example.
What vector size means practically, and the storage/quality tradeoff.
The full semantic search flow, from setup to query-time retrieval.
Practical guidance covering consistency, chunking, scale and evaluation.
What vector databases do, and a conceptual landscape of tools.
The database-level similarity search operation, exact vs approximate.
The underlying computational problem vector databases solve.
Trading a small accuracy margin for dramatically faster search at scale.
The pre-built structure that makes fast similarity search possible.
Different query strengths, and why they're usually used together.
Overlapping but distinct strengths, and a practical decision angle.
Combining exact-match filters with similarity search — critical for security.
Combining semantic and keyword search for the best of both.
The full RAG pipeline, and why grounding answers beats relying on memorized knowledge.
The offline ingestion vs online query split, and every component involved.
A concrete, working ingestion and query pipeline implementation.
Extracting clean, usable text — the critical first step of ingestion.
Why documents are split before embedding, and the core size tradeoff.
Fixed-size, semantic, and structure-aware chunking compared.
The tradeoff behind this key parameter, and how to choose it empirically.
Preventing information loss at chunk boundaries.
The RAG-specific retrieval step, and choosing top_k.
Combining semantic and keyword retrieval within a RAG pipeline.
A second, more precise relevance pass over initial retrieval candidates.
Ordering, formatting and fitting retrieved chunks before generation.
The prompt template that drives grounded, citable, hallucination-resistant answers.
Measuring retrieval and generation quality as two separate stages.
Why RAG reduces but doesn't eliminate hallucination, with real failure patterns.
A diagnostic table of common RAG failures and where to look for each.
Access control on retrieved content, and indirect injection via documents.
Knowledge injection vs behavior change — a practical decision framework.
Why retrieval still matters even as context windows grow larger.
Query transformation, multi-query retrieval, and self-correction loops.
Why PDFs are deceptively hard to extract cleanly, and how to approach it.
Plain text vs structure-aware parsing, and why structure matters.
Extracting text from scanned documents, and the errors OCR introduces.
Separating real content from navigation and boilerplate on web pages.
Why Markdown's explicit structure makes it the easiest source format.
Removing artifacts and boilerplate before chunking and embedding.
What to capture at ingestion time, and why it can't be added retroactively.
What fine-tuning is good and not good at, and where it fits.
A practical escalation path, and when prompting has genuinely plateaued.
The standard example-based fine-tuning approach, with real training pairs.
Training small adapter matrices instead of the full model's weights.
Combining LoRA with a quantized base model for even lower memory use.
The broader category of techniques LoRA and QLoRA belong to.
Why dataset quality matters more than volume, and how to build one.
Comparing against the baseline, and watching for overfitting.
A project checklist covering validation, dataset, technique and evaluation.
The difference between a multimodal model and a multimodal system.
Models that reason about images and text together, with real limitations.
Practical image tasks, prompting discipline, and cost considerations.
Reading forms and invoices — OCR-then-LLM vs direct vision models.
The STT-LLM-TTS voice pipeline, and where latency and errors compound.
Transcription accuracy factors, and streaming vs batch processing.
Synthesizing natural speech, and preparing text for how it will sound.
Creating images from text descriptions, and real current limitations.
Why video generation is harder than image generation, with realistic expectations.
Retrieving and reasoning over images, not just text.
The full request-validate-execute-respond flow, end to end.
How this term relates to "tool calling" — largely interchangeable.
A technical, step-by-step look at the full mechanism with code.
Describing a tool so the model can use it correctly and reliably.
How the model decides which tool to call, and what drives accuracy.
Formatting execution results for the model, including error handling.
Validation, permissions and least privilege for every tool call.
How tool calling adds a natural-language decision layer over existing APIs.
A single tool call vs an adaptive, multi-step agentic loop.
Join CodingNow's Generative AI Engineering course — live mentorship, hands-on projects, and 100% placement support in Delhi NCR.
Enroll Now — Free Demo Available
Insights on AI, Data Science, Full Stack & Career
