LLM APPLICATIONS
LangChain
Learn how LangChain connects models, prompts, tools, retrieval and agents into reliable AI applications — without losing sight of the underlying patterns beneath the framework.
LangChain Learning Path
Follow the modules in order to move from the mental model behind LangChain to real applications involving chat models, tools, retrieval, agents, safety and production best practices.
Why LangChain Exists (Before You Learn What It Is)
Start with raw API calls, hit the real problems every LLM app runs into, and see exactly why LangChain was built to solve them — with matching OpenAI and Gemini code.
The LangChain Mental Map: Where Everything Fits
Before writing more code, build a clear mental map of LangChain's pieces, how they relate to LangGraph and LangSmith, and how the package is actually organized under the hood.
Setting Up a Real LangChain Project
Build a proper project folder, install the right packages for OpenAI and Gemini, and handle API keys the safe way — before writing another line of LangChain logic.
Chat Models: The Foundation of Every LangChain App
Go deep on the one piece every LangChain app touches first — initialization, parameters, the response object, streaming, async, and a first look at structured output and tools.
Provider Abstraction: One Interface, Many Providers
See exactly what LangChain's shared interface genuinely buys you across OpenAI and Gemini — and where that abstraction honestly breaks down, so you never assume two providers are truly interchangeable.
Messages: Why Not Just Strings
Go deep on HumanMessage, SystemMessage, AIMessage, and ToolMessage — what each one actually represents, how a conversation is really built, and how multimodal input fits in.
Prompt Templates: Turning Prompts Into Reusable Components
Stop rebuilding message lists by hand. Learn how prompt templates turn prompts into reusable, parameterized components — from a single variable to full classification and extraction patterns.
Runnables and LCEL: Why the Pipe Operator Exists
Understand the shared interface behind every LangChain component, why it makes the | pipe operator possible, and how to compose real pipelines with parallel execution, passthroughs, and custom logic.
Chains and Composition: Building Real Pipelines with LCEL
Put Runnables to work building real, useful pipelines — translation, summarization, classification, extraction, and multi-stage generation — while clearing up what 'chain' actually means.
Streaming: Why Waiting 15 Seconds Feels Wrong
Go beyond the basic streaming preview from earlier modules — understand what a chunk actually is, how to reconstruct a full message from chunks, and how to peek inside a running chain.
Batching and Async for Real Throughput
Measure the real difference between sequential calls, .batch(), and true async concurrency — and learn exactly when each one is the right tool, not just how to call them.
Tools: Giving Models the Ability to Act
Go deep on turning ordinary Python functions into well-described, production-quality tools a model can genuinely understand and reliably request — the foundation every agent in this course builds on.
Tool Calling: The Complete Request-to-Answer Cycle
Finally complete the full cycle you've only seen in pieces — a model requesting a tool, your code executing it, and the model using that result to finish its answer, entirely by hand.
Building the Tool Loop by Hand
Fix the exact gap the last module left open — build a genuine, repeating loop that keeps calling tools until a real answer is reached, however many rounds that takes. This is what an agent actually is.
From Manual Loop to create_agent
Meet LangChain's official, current way to build an agent — and see it solve the exact same problem you just built by hand, line for line, so nothing about it feels like magic.
Ten Progressive Agent Patterns
Put create_agent through its paces with ten small, realistic agents — from a simple calculator to a full research assistant — each one teaching you one new, recognizable shape.
What create_agent Is Actually Doing
Go one level deeper than Module 14's simplified loop — watch the real loop unfold step by step, see how tool failures are actually handled, and understand exactly what happens when an agent hits its limit.
Structured Output, Properly: Two Real Strategies
The dedicated deep dive on structured output — Pydantic schemas, the two real mechanisms LangChain uses underneath, nested structures, validation failures, and when to trust it.
Agent State and Memory: Clearing Up the Terminology
Untangle messages, conversation history, short-term state, and persistent memory — genuinely different concepts that get blurred together — and see exactly which one to use for which real need.
Middleware: Customizing the Agent Loop
Step into any point of an agent's loop — before or after the model runs, before or after a tool runs — without rewriting the loop itself. Includes dynamic model and tool selection.
How LangChain Implements Retrieval
You already know why RAG works from your earlier course. This module maps that theory onto LangChain's actual components — the concrete pipeline behind the concept.
Document Loaders: Bringing Real Files Into LangChain
Load text, PDFs, web pages, CSVs, and entire directories into genuine Document objects — the raw material every retrieval pipeline in this course starts from.
Text Splitting: Chunking Documents That Actually Work
See what real chunk sizes and overlap settings actually produce on real text, and understand why recursive, structure-aware splitting is the practical default.
Embeddings and Vector Stores in LangChain
The LangChain-specific implementation of embeddings and vector storage — how chunks become searchable vectors, and how a vector store actually holds and searches them.
Retrievers: Beyond as_retriever()
Configure retrieval properly — top-k, metadata filtering, search type — and understand the critical difference between a retriever as a fixed pipeline step and a retriever as an agent tool.
Building RAG in LangChain, Version by Version
Bring every piece from the retrieval sequence together — manual retrieval, the retriever abstraction, structured responses, citations, and conversation-aware RAG — building one real system, one version at a time.
When Things Fail: Retries and Fallbacks
Real applications face real failures — timeouts, rate limits, provider outages. Build genuine resilience with .with_retry() and .with_fallbacks(), and know exactly what each one actually protects against.
Guardrails: Practical Protection via Middleware
Real safety measures for a deployed agent — input validation, output validation, tool permissions, and human approval — built directly on the middleware system from Module 20.
Seeing What Your Agent Actually Did
Why print(response) genuinely isn't enough once an agent has several steps, and how LangSmith gives you the full, inspectable execution trace — introduced just enough to support real development.
Testing Prompts, Chains, and Agents
Real, runnable tests for the components you've built throughout this course — prompt formatting, structured output, mocked models, tools, chains, and agent behavior.
LangChain vs. Calling the Provider SDK Directly
A balanced, honest comparison — abstraction, portability, and integrations against complexity, debugging, and dependency surface. LangChain isn't always the right choice, and this module explains exactly when it isn't.
Where LangChain Ends and LangGraph Begins
Everything you've built in this course was, quietly, running on LangGraph underneath. This module makes that relationship concrete, and prepares you for exactly where to pick up next.
Taking LangChain to Production
Gather the deployment-focused threads from throughout this course — timeouts, retries, secrets, logging, tracing, cost, and testing — into one real, practical readiness checklist.
Five Complete LangChain Applications
The capstone module — five real, complete applications, built by combining everything from this course, ending with a full, production-oriented project laid out file by file.
WHY LANGCHAIN?
Frameworks reduce the repetitive work, not the engineering judgment
LangChain helps you compose models, tools, prompts, retrieval and agents with a consistent API. The real value is not magic — it is making real-world AI systems easier to build, reason about and operationalize.