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.