TechnologyEducationCoursesScience

The AI Concepts Podcast

Sheetal ’Shay’ Dhar

The AI Concepts Podcast is my attempt to turn the complex world of artificial intelligence into bite-sized, easy-to-digest episodes. Imagine a space where you can pick any AI topic and immediately grasp it, like flipping through an Audio Lexicon - but even better! Using vivid analogies and storytelling, I guide you through intricate ideas, helping you create mental images that stick. Whether you’re a tech enthusiast, business leader, technologist or just curious, my episodes bridge the gap between cutting-edge AI and everyday understanding. Dive in and let your imagination bring these concepts to life!

Play

Open in

20 episodes
Avg 9 min
English

Episodes 20

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

#77
August 21 · 10 min
Module 7: The LLM Application Loop
Who actually decides what happens next inside an LLM application? This episode explores the difference between decisions made by code and decisions made by the model, and why real applications often use both. We follow the loop that emerges when a model can request information or actions, receive the results and decide what to do next, revealing what developers mean when they talk about “owning the loop” and setting the stage for orchestration.
#76
August 19 · 10 min
Module 7: Why Do We Need LLM Frameworks?
If LLM applications can be built with regular code and APIs, why do frameworks exist at all? This episode explores what happens as a simple application grows and starts needing retrieval, memory, routing, multiple models, retries and tracing. We look at what frameworks actually take off the developer’s plate, when those abstractions become useful, and why sometimes plain code is still the better choice.
#75
August 19 · 10 min
Module 7: Building LLM Applications | What Is an LLM Application, Really?
What actually sits behind an LLM application? This episode takes one simple request and follows it beneath the surface, revealing how the model, application code, APIs, external data and context work together to produce something genuinely useful. As the request gets more complex, we begin to see why concepts like memory, tools and orchestration enter the picture. It is a practical look at what we are really building when we say we are building with LLMs.
#74
June 12 · 8 min
Module 6: RAG | Long Context vs RAG - Do You Still Need Retrieval at All
This episode closes out Module 6 by tackling the question that has been getting louder since large context windows arrived. If a model can hold hundreds of thousands or even millions of tokens at once, do we still need all the architecture we just spent this module building? We explore why RAG was never just about fitting text into a small prompt, what retrieval is actually doing that a large context window cannot, and how the shift from compression to curation changes what good RAG looks like today. We cover when long context is genuinely the better tool, when retrieval still matters deeply, and why in most real enterprise systems the best answer is both working together. The episode closes with the argument that RAG is not disappearing. It is maturing. And everything we built in this module is part of that stronger foundation. By the end you will have a clear and honest picture of where these two approaches fit, and why understanding both puts you well ahead of most people working in this space.
#73
June 10 · 8 min
Module 6: RAG | GraphRAG - When Relationships Matter More Than Text
This episode addresses the category of questions that vector search fundamentally cannot answer, questions about relationships between things. We explore what a knowledge graph is and why traversing connections between entities requires a completely different data structure than semantic similarity search. We break down Microsoft's GraphRAG approach, how it extracts entities and relationships from documents during indexing, uses community detection to identify clusters of related knowledge, and generates summaries that enable global queries across an entire corpus rather than just local document retrieval. We cover the cost improvements brought by LazyGraphRAG, the hybrid vector-plus-graph pattern most production teams are moving toward, Neo4j as the go-to graph database, and a lighter-weight entity extraction approach for teams not ready for a full knowledge graph. By the end you will understand when relationships matter more than text and how to build systems that can answer both kinds of questions.
#72
June 10 · 7 min
Module 6: RAG | Query Transformation - When the Question Is the Bottleneck
This episode addresses a retrieval failure that has nothing to do with your index and everything to do with the query itself. We explore the vocabulary gap between how people ask questions and how documents are written, and why even strong embedding models cannot always bridge it. We break down three techniques that fix the query before the search runs: query rewriting to reformulate casual language into formal search terms, HyDE which generates a hypothetical answer and uses that as the search query instead of the question, and multi-query expansion which generates multiple phrasings to cast a wider retrieval net. We also cover step-back prompting for queries that need broader conceptual grounding before searching. By the end you will understand why the question itself is often the highest-leverage thing to improve in a retrieval pipeline.
#71
June 10 · 7 min
Module 6: RAG | Parent-Child Indexing - Search Small, Retrieve Big
This episode addresses the fundamental tension between retrieval precision and generation context. We explore why small chunks produce tight embeddings that retrieve well but leave the model without enough surrounding information, and why large chunks give the model context but dilute the embedding and hurt search quality. We break down parent-child indexing as the solution that decouples these two problems entirely, how child chunks handle the search and parent chunks handle the generation, and how to structure the hierarchy for documents of different complexity. We cover practical implementations in LlamaIndex and LangChain and close with guidance on when this pattern earns its place in a pipeline. By the end you will understand how to stop choosing between finding the right thing and giving the model enough to work with.
#70
June 10 · 9 min
Module 6: RAG | Reranking - The Second Stage That Gets Retrieval Right
This episode addresses the gap between finding candidate chunks and finding the right ones. We explore the bi-encoder bottleneck, why compressing text into a single vector for comparison loses critical nuance, and how cross-encoders fix this by reading the query and document together in a single forward pass. We introduce ColBERT as a powerful middle ground between speed and accuracy through token-level late interaction, walk through the production tooling landscape including Cohere Rerank, BGE models, and RAGatouille, and close by stitching hybrid search and reranking into a complete three-stage retrieval funnel. By the end you will understand why two-stage retrieval is now the standard architecture for any serious RAG pipeline.
#69
June 10 · 11 min
Module 6: RAG | Dense and Sparse Search - Why Vector Search Alone Is Not Enough
This episode addresses one of the most common gaps in RAG pipelines, relying solely on semantic search. We explore how dense retrieval works and where it excels, then introduce sparse retrieval with BM25 and why it catches what vector search misses entirely, particularly exact identifiers like part numbers, codes, and proper nouns. We break down how hybrid search combines both approaches using Reciprocal Rank Fusion, why it consistently outperforms either method alone, and how modern vector databases like Weaviate, Pinecone, and Qdrant support this natively. By the end you will understand why the best retrieval systems are not choosing between semantic and keyword search but running both.
#68
April 29 · 10 min
Module 6: RAG | Chunking - Where You Cut Decides What Gets Found
This episode is about chunking, the quiet step in a RAG pipeline that decides whether your system retrieves the right answer or a confidently wrong one. It covers why the chunk is the real unit of retrieval, the tradeoff between context and precision, the main strategies teams use to split documents, and why testing your chunks against real questions matters more than picking the perfect size.
#67
April 27 · 11 min
Module 6: RAG | Data Ingestion - Before Your Documents Can Be Found
This episode is about the step that every RAG system depends on. Before meaning can be stored or retrieved, your raw documents have to become clean text. What goes wrong here breaks the entire pipeline in ways that are surprisingly hard to catch.
#66
April 27 · 10 min
Module 6: RAG | Vector Databases - Where That Meaning Gets Stored
This episode is about the infrastructure underneath every RAG system. It covers the purpose-built engine that stores all that meaning and searches millions of vectors in milliseconds, in a way no traditional database can. This is what makes retrieval fast enough to actually work in production.
#65
April 27 · 8 min
Module 6: RAG | Embeddings - Teaching Machines to Understand Meaning
This episode is about the layer of RAG that makes semantic search possible. It covers how machines turn language into math that clusters similar ideas together, so a question and its answer can find each other even when they share no words in common. Without this, RAG is just keyword search with extra steps.
#64
April 25 · 12 min
Module 6: The RAG Pipeline - End to End
This episode maps out the full RAG pipeline end to end using one concrete scenario, a defense contractor building an AI assistant for fighter jet maintenance crews. It walks through both phases of the architecture, offline and online, following a real question all the way from a raw document to a grounded answer. It also covers why the architecture is modular and closes with the four failure modes that quietly break RAG systems in production.
#63
April 25 · 8 min
Module 6: What is RAG and Why it Exists
This episode kicks off Module 6 with RAG (Retrieval Augmented Generation), the #1 architecture every serious enterprise actually uses. Discover why regular LLMs hallucinate on your private data and high-stakes queries, and how RAG fixes it by forcing the model to retrieve real documents first.
#62
April 17 · 8 min
Module 5: Reasoning Models
This episode covers reasoning models, the shift from manually guiding a model's thinking to letting the model reason through complex problems on its own before responding. It explains the concept of test-time compute, why reasoning models take longer but perform dramatically better on hard tasks, and how they change the way you should prompt. It walks through when to reach for a reasoning model versus a standard one, and closes by framing the full prompt engineering toolkit in context, from few-shot examples through reasoning models.
#61
April 17 · 7 min
Module 5: Structured Output and the Language of Software
This episode covers structured output, how you get a model to respond in predictable, machine-readable formats like JSON instead of natural language paragraphs. It walks through three approaches, from simply asking in the prompt, to JSON mode, to schema-based constraints, and explains why each level adds more reliability. It uses real-world examples to show how structured output turns AI from a conversation partner into a software component that can feed databases, trigger workflows, and drive automation. It closes with practical tips for writing schemas and validating output in production.
#60
April 17 · 10 min
Module 5: System Prompts and the Invisible Rules
This episode covers system prompts, the invisible instruction layer that shapes every model interaction before the user says a word. It explains the three-role message format, why the model is trained to treat system instructions as higher authority than user messages, and how persona prompting works by shifting which region of the training distribution the model samples from. It walks through the anatomy of a good system prompt and closes with what happens when system and user instructions conflict, including a preview of the prompt injection problem.
#59
April 17 · 7 min
Module 5: Chain of Thought Prompting
This episode covers chain of thought prompting, how asking a model to show its reasoning makes it measurably better at complex tasks, and why that works at a mechanical level. It walks through manual and zero-shot chain of thought, then three advanced extensions: self-consistency, Tree of Thought, and step-back prompting. It closes with when chain of thought actually helps versus when it just adds overhead.
#58
April 8 · 11 min
Module 5: In-Context Learning, Zero-Shot, and Few-Shot Prompting
This episode explores in-context learning, the idea that you can dramatically change how a model behaves just by showing it examples inside the prompt, without changing a single weight. It walks through zero-shot, one-shot, and few-shot prompting, when each one tends to work best, and why examples shape not just the answer but also the format, tone, and structure of the response. It also gets into some of the more surprising research around this, including how models can still perform well even when example labels are wrong, why example order can materially affect accuracy, and why one strong example can sometimes outperform several mediocre ones. The episode closes by framing few-shot prompting as one of the most practical and powerful skills in prompt engineering, while also pointing to the limits of prompting when a task becomes too complex.

Showing 1–20 of 20 episodes