The AI Concepts Podcast

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...

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...

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 shif...

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 co...

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 w...

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 chun...

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 throu...

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 consist...

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 ...

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 ...