Building with LLMs

Using the OpenAI API with Python

Building Your First AI App with the Claude API: Complete Beginner's Guide

Learn to build a real AI-powered customer support assistant from scratch using Anthropic's Claude API. No prior AI experience required—just practical Python skills and clear explanations.

OpenAI vs Anthropic vs Open Source: Choosing the Right LLM

Structured Output: Getting JSON, Tables, and Code from LLMs

Master the techniques to get reliable JSON, formatted tables, and executable code from any large language model instead of parsing unpredictable text responses.

Function Calling and Tool Use with LLMs: Building Intelligent Agents

Learn to give LLMs access to external tools and data sources, transforming them from text generators into powerful problem-solving agents that can interact with real systems.

Building a Production Document Q&A System with Vector Embeddings

Learn to build a scalable document Q&A system using embeddings and RAG. Covers advanced chunking, vector search optimization, prompt engineering, and production deployment with real-world regulatory compliance examples.

Building a Document Q&A System with Embeddings: A Complete Beginner's Guide

Learn to build an AI-powered document Q&A system from scratch using embeddings and language models. No prior AI experience required—just practical Python skills and clear explanations.

Building Streaming AI Interfaces: Real-Time Response Delivery

Learn to build responsive AI applications that stream tokens in real-time, creating conversational experiences that engage users from the first word.

Streaming Responses and Real-Time AI Interfaces

Cost Optimization: Token Counting, Caching, and Model Selection for LLMs

Master practical techniques to reduce your LLM API costs by 60-80% while maintaining quality. Learn token tracking, intelligent caching, and strategic model selection with hands-on examples.

Testing and Evaluating LLM Applications: A Comprehensive Guide to Quality Assurance

Master the art of testing non-deterministic LLM applications with rule-based validation, model-based evaluation, automated testing pipelines, and production monitoring strategies that catch problems before they impact users.

Building AI Workflows with LangChain and LlamaIndex

Deploying LLM Applications: API Design and Infrastructure

Learn to build production-ready LLM applications with proper API design, infrastructure scaling, cost management, and monitoring. From local development to cloud deployment.

Implementing Hybrid Search for RAG: Combining Dense and Sparse Retrieval

Dense vector search misses exact matches; BM25 misses synonyms and paraphrase. This practical lesson shows you how to combine both into a hybrid RAG pipeline using Reciprocal Rank Fusion — with complete, production-ready Python code and tuning guidance.

Guardrails and Safety Layers: Implementing Input Validation, Output Filtering, and Jailbreak Defense in Production LLM Systems

Deploying an LLM without safety layers is like shipping a web app without input sanitization — you're hoping users behave, and they don't. This expert-level lesson walks through building a four-layer defense architecture that catches prompt injections, jailbreak attempts, and policy violations without making your application useless with false positives.

Prompt Engineering Fundamentals: System Prompts, Few-Shot Examples, and Temperature Control

Learn the three core techniques that separate reliable AI integrations from unpredictable ones. This hands-on lesson teaches you to write system prompts that constrain model behavior, use few-shot examples to demonstrate quality, and tune temperature for consistent output — using a real customer support classification project as your guide.

Implementing Conversational Memory: Managing Context Windows and Chat History at Scale

Naive chatbots forget everything after a few dozen messages — or crash trying to hold it all in context. This lesson teaches you to build a production-grade tiered memory system that combines buffer management, summarization, and vector retrieval to give LLMs coherent, scalable long-term memory.

Agentic Loop Design: Building Reliable Multi-Step LLM Pipelines with Retry Logic, State Management, and Human-in-the-Loop Escalation

Most LLM agent tutorials show you the happy path. This lesson shows you the full picture — how to design agentic loops that survive tool failures, persist state across crashes, classify errors intelligently, and pause gracefully for human review without losing progress. By the end, you'll have the engineering foundations for agents you'd actually trust in production.

Handling LLM Errors, Timeouts, and Rate Limits in Python Applications

LLM APIs fail in predictable ways — but only if you know what to look for. This lesson teaches you how to build Python applications that handle rate limits, timeouts, and transient errors gracefully, with retry logic, proactive throttling, and real fallback strategies.

Multimodal LLM Integration: Processing Images, PDFs, and Documents with Vision APIs

Text-only LLMs can't handle scanned receipts, chart-heavy reports, or complex PDF tables — but multimodal models can. Learn how to build a production document intelligence pipeline that routes, processes, and extracts structured data from any document type using vision APIs, with full cost and accuracy control.

Fine-Tuning vs. RAG vs. Prompt Engineering: When to Use Each and How to Combine Them in Production

Most teams pick the wrong LLM customization technique — and don't find out until they've spent months building the wrong system. This lesson teaches you the decision mechanics, internal architectures, and production-ready patterns for combining fine-tuning, RAG, and prompt engineering into a coherent system that actually works.

Managing API Keys and Authentication Secrets Securely in LLM Applications

Accidentally exposing an API key can cost you hundreds of dollars and compromise your account before you even notice it's gone. This lesson teaches you the right way to manage secrets in LLM applications from day one — using environment variables, .env files, and the habits that keep your credentials safe in every project.

Implementing LLM Observability: Tracing, Logging, and Monitoring Requests in Production

Most observability tools weren't built for LLMs—where a "successful" response can still be wrong, expensive, or incomplete. This lesson teaches you to build a production-grade observability stack with structured logging, distributed tracing, cost tracking, and quality monitoring across real LLM pipelines.

Building a Multi-Tenant LLM Platform: Isolating Contexts, Enforcing Usage Quotas, and Managing Costs Per Customer

Multi-tenant LLM platforms fail in ways traditional SaaS doesn't — context bleeds between tenants, quota enforcement has race conditions, and cost attribution is invisible until the bill arrives. This lesson builds the complete system: atomic quota enforcement, structural context isolation, and billing-grade cost attribution, with production-ready Python code throughout.

Prompt Versioning and Management: Tracking, Testing, and Deploying Prompt Changes in Production

Most LLM-based applications treat prompts as an afterthought — until a careless edit breaks production. This lesson shows you how to build a complete prompt versioning system with structured file storage, evaluation test suites, staged deployment pipelines, and rollback capabilities, all in plain Python.

Implementing LLM Response Caching with Redis: Semantic Deduplication, TTL Strategies, and Cache Invalidation Patterns

LLM API costs and latency compound fast when users phrase the same question seventeen different ways. This lesson builds a production-grade semantic caching layer in Redis that understands meaning — not just strings — with intelligent TTL tiers and surgical cache invalidation that doesn't nuke your entire cache when one piece of content changes.

Building a Self-Improving RAG Pipeline: Automated Chunk Quality Scoring, Retrieval Feedback Loops, and Index Optimization in Production

Most RAG systems are static — they index once and never improve. This expert-level lesson teaches you to build feedback infrastructure that captures every retrieval signal, scores chunk quality automatically, and continuously optimizes your index in production without downtime.

Understanding Tokens: How LLMs Tokenize Text and Why It Affects Your Inputs, Outputs, and Costs

Tokens are the hidden unit that controls everything about how LLMs read your prompts and generate responses — including what you pay. This lesson builds a complete, practical understanding of tokenization from first principles, with hands-on Python examples and real cost estimation techniques you can apply immediately.

Building a Reranking Layer for RAG: Improving Retrieval Precision with Cross-Encoders and LLM-Based Scoring

Standard vector retrieval finds related content — reranking finds relevant content. Learn how to build a two-stage retrieval pipeline using cross-encoders and LLM-based scoring that dramatically improves what your RAG system actually hands to the language model. Includes complete, production-ready Python code and an evaluation harness to measure the impact.

Implementing LLM Router Architecture: Dynamically Selecting Models by Cost, Latency, and Task Complexity in Production

Most teams route all their LLM traffic to a single model and pay for it — literally. Learn how to build a production-grade routing layer that classifies task complexity in real time and dispatches requests to the right model, cutting inference costs by 40–70% without sacrificing quality. This lesson covers complexity classification, policy engines, circuit breakers, and the observability infrastructure you need to tune routing decisions with real data.

Conversation Design for LLMs: Structuring System Prompts, Roles, and Message Threads with the Chat Completions API

Most LLM applications fail not because the model is wrong, but because the conversation is designed poorly. Learn how to structure system prompts, manage multi-turn message threads, and inject dynamic context using the Chat Completions API — the skills every serious LLM builder needs.

Orchestrating Parallel LLM Calls: Batching, Concurrency, and Async Patterns for High-Throughput Production Pipelines

Sequential LLM API calls will turn a 10-minute job into an 8-hour nightmare at scale. Learn how to use Python asyncio, semaphores, and smart batching to run hundreds of concurrent LLM requests safely — with full retry logic and failure handling for production pipelines.

Building a Knowledge Graph-Augmented RAG System: Combining Vector Search with Entity Relationships for Multi-Hop Reasoning

Standard RAG can retrieve relevant text — but it can't follow a chain of reasoning across connected entities in multiple documents. This deep-dive lesson shows you how to build a production-grade KG-RAG system using Neo4j, Qdrant, and GPT-4o that combines vector search with multi-hop graph traversal for genuinely connected reasoning.

Chunking Strategies for RAG: How to Split Documents by Size, Sentence, and Semantic Meaning

Bad chunking is the silent killer of RAG systems. This hands-on lesson teaches you three distinct chunking strategies — fixed-size, sentence-based, and semantic — with working Python code and clear guidance on when to use each one. By the end, you'll understand exactly why chunking decisions make or break retrieval quality.

Building a Feedback Collection and Human Preference Dataset Pipeline for Continuous LLM Application Improvement

Most LLM applications ship and stagnate. This lesson shows you how to instrument your app to capture user feedback, structure preference pairs for DPO and RLHF workflows, and build a complete pipeline that turns raw signals into training data — so your model actually gets better over time.

Implementing LLM Gateway Middleware: Centralized Auth, Rate Limiting, Audit Logging, and Fallback Routing Across Multiple Providers

Direct API calls to multiple LLM providers create fragile, unobservable, ungovernable systems. This lesson walks you through building a production-grade LLM gateway middleware in Python — with JWT auth, Redis-backed token bucket rate limiting, circuit-breaker fallback routing, and async audit logging that doesn't block the critical path.

Retrieval-Augmented Generation Explained: How RAG Works and When to Use It

LLMs are powerful reasoners, but they can't answer questions about your data — unless you give them a way to look things up. This lesson explains exactly how RAG works, walks you through building a real pipeline in Python, and shows you when to use it versus other approaches.

Building a Citation and Source Attribution System for RAG: Linking LLM Responses Back to Source Documents with Confidence Scores

Most RAG systems retrieve documents and generate answers — but never connect the two in a way users can actually trust or verify. This lesson builds a complete citation pipeline that maps every LLM claim back to a specific source chunk, complete with composite confidence scores and hallucination detection.

Implementing Structured Agent Memory: Building Long-Term Persistent State with Episodic, Semantic, and Working Memory Layers for Production LLM Agents

Most LLM agents are amnesiac by default — every conversation starts cold, no matter how much history exists. This deep-dive lesson teaches you to build a production-grade, three-layer memory architecture with episodic event storage, semantic fact extraction, and intelligent working memory management that makes your agents genuinely smarter over time.

Prompt Injection Attacks: What They Are and How to Defend Against Them in LLM Applications

Prompt injection is the most dangerous and misunderstood security threat in LLM application development. Learn how direct and indirect attacks work, why you can't just "tell the model to ignore them," and how to build defense-in-depth systems that actually hold up in production.

Implementing Query Decomposition and Sub-Question Synthesis for Complex RAG Pipelines*

Implementing LLM-as-Judge Evaluation Pipelines: Automated Quality Scoring, Rubric Design, and Calibration Against Human Ratings for Production LLM Systems

LLM-as-Judge lets you evaluate thousands of AI responses automatically — but only if your rubric is sharp, your judge is calibrated, and your sampling strategy is deliberate. This lesson teaches you to build evaluation pipelines that actually predict human judgment, with production-grade code, calibration statistics, and regression detection.

Embeddings Explained: What They Are, How They Work, and How to Generate Them with the OpenAI and Sentence Transformers APIs

Embeddings are the secret engine behind semantic search, RAG pipelines, and AI recommendation systems — but most explanations skip the intuition. This lesson builds your understanding from first principles and walks you through generating, comparing, and applying embeddings using both the OpenAI API and the open-source Sentence Transformers library.

Implementing Tool Result Validation and Error Recovery in LLM Function Calling Pipelines

Function calling pipelines fail in three distinct zones — and most tutorials only handle one of them. Learn how to build complete validation, typed error taxonomies, retry logic, and graceful degradation for production LLM agents that actually stay reliable.

Implementing Context-Aware Prompt Compression: Reducing Token Costs Without Losing Retrieval Fidelity in High-Volume RAG Pipelines

Token costs in production RAG systems are dominated by retrieved context — and most of that context can be compressed intelligently without degrading answer quality. This lesson walks through building a complete compression middleware layer with extractive, abstractive, and selective strategies, query-aware routing, fidelity measurement, and production observability.

Vector Databases Explained: Choosing, Configuring, and Querying Pinecone, Weaviate, and pgvector for LLM Applications

Most LLM applications need to search by meaning, not keywords — and that requires a vector database. This hands-on lesson walks you through Pinecone, Weaviate, and pgvector with real Python code, so you can choose the right tool and start shipping.

Implementing Semantic Routing in LLM Applications: Classifying User Intent to Dispatch Queries Across Specialized Chains, Indexes, and Agents

Learn how to build a production-grade semantic router that classifies user intent and dispatches queries to specialized handlers. Covers embedding-based and LLM-based classification, hybrid routing with confidence thresholds, and wiring everything to real downstream chains, indexes, and agents.

Implementing Cross-Document Reasoning: Building Multi-Hop RAG Pipelines That Synthesize Evidence Across Source Boundaries

Standard RAG pipelines fail at questions requiring evidence from multiple documents — the answer lives in the connections between sources, not in any single chunk. This deep-dive lesson walks you through building a complete multi-hop RAG pipeline with iterative retrieval, evidence buffering, conditioned query expansion, and cross-document synthesis that actually works on complex knowledge work questions.