·LangChain
Capstone Project: The Autonomous Market Analyst
The Final Challenge. Build a production-ready, agentic RAG system that analyzes companies and returns structured research reports via a REST API.
LangChain
68 articles
·LangChain
Module 1 Lesson 1: Python and Virtual Environments
The starting point. How to set up a clean, isolated Python environment for your LangChain projects.
·LangChain
Module 1 Lesson 2: Installing LangChain
The core installation. Learning about LangChain's modular package structure and how to install the base library.
·LangChain
Module 1 Lesson 3: Installing Model Providers
Connecting to the brains. How to install specialized packages for OpenAI, Anthropic, and local model providers.
·LangChain
Module 1 Lesson 4: API Keys and Environment Variables
Security First. How to securely manage your API keys using .env files and prevent accidental leaks.
·LangChain
Module 1 Lesson 5: First LangChain Run
The Hello World of AI. Initializing your first chat model and making a successful invocation.
·LangChain
Module 1 Wrap-up: Verification and First Call
Hands-on: Verify your complete installation and take the Module 1 challenge.
·LangChain
Module 10 Lesson 1: Agent Fundamentals
The Autonomous Mind. Understanding the difference between a static Chain and a dynamic Agent that makes its own decisions.
·LangChain
Module 10 Lesson 2: The Agent Loop and Tool Selection
How the Agent decides. Deep dive into the mechanics of tool selection and processing tool outputs.
·LangChain
Module 10 Lesson 3: Safety Limits (Max Iterations & Timeouts)
Guarding the Budget. How to prevent your agents from getting stuck in infinite loops and burning through your API credits.
·LangChain
Module 10 Wrap-up: Building Your First Agent
Hands-on: Combine tools, memory, and reasoning into a single autonomous Research Agent.
·LangChain
Module 11 Lesson 1: Why Structured Output Matters
From Stories to Schema. Why production AI must return machine-readable data (JSON) to interact with other software systems.
·LangChain
Module 11 Lesson 2: Output Parsers (Pydantic & JSON)
Parsing the Mess. Learning how to use OutputParsers to extract structured data even from older or less capable models.
·LangChain
Module 11 Wrap-up: Getting Reliable Data
Hands-on: Build an Information Extraction agent that converts raw text into a clean Python object.
·LangChain
Module 12 Lesson 1: Introduction to Callbacks
Listening to the Chain. How to use the Callback system to intercept events like 'LLM Start' or 'Tool End' for logging and UI updates.
·LangChain
Module 12 Lesson 2: Implementing Callbacks in Chains
Connecting the Hearths. How to pass your custom handlers to models, tools, and executors to start capturing events.
·LangChain
Module 12 Wrap-up: Inspecting the Machine
Hands-on: Build a Cost-Monitoring Callback that calculates and prints the price of every AI request.
·LangChain
Module 13 Lesson 1: Debugging Chains
Finding the Bug. Techniques and tools for identifying where a multi-step chain is failing or hallucinating.
·LangChain
Module 13 Lesson 2: LangSmith Overview
The Cloud Control Room. Introduction to LangSmith, the enterprise platform for tracing and optimizing your AI applications.
·LangChain
Module 13 Wrap-up: Professional Observability
Hands-on: Set up LangSmith and trace a complex multi-tool agentic decision.
·LangChain
Module 14 Lesson 1: API Design with FastAPI
Connecting to the Frontend. How to wrap your LangChain apps in a professional REST API using FastAPI.
·LangChain
Module 14 Lesson 2: Caching and Retries
Stability and Speed. How to use caching to save money on redundant queries and retries to handle common network errors.
·LangChain
Module 14 Wrap-up: Shipping to Millions
Hands-on: Create a production-ready FastAPI endpoint with caching and retry logic.
·LangChain
Module 15 Lesson 1: Packaging LangChain Apps
From Script to Service. How to organize your code and dependencies for reliable deployment on any server.
·LangChain
Module 15 Lesson 2: Dockerizing LangChain
Isolation at Scale. How to create a Docker container for your AI app to ensure it runs everywhere from AWS to Azure.
·LangChain
Module 15 Wrap-up: Your App on the Internet
Hands-on: Finalize your deployment package and learn about cloud hosting options for LangChain apps.
·LangChain
Module 2 Lesson 1: What is a Model Abstraction?
The Power of Agnosticism. Why LangChain uses wrappers to ensure you can switch models without rewriting your code.
·LangChain
Module 2 Lesson 2: Chat vs. Completion Models
Messages vs. Strings. Understanding the different ways LLMs process input and why Chat models are the modern standard.
·LangChain
Module 2 Lesson 3: Streaming Responses
Zero Latency UX. How to use LangChain's .stream() method to display text as it's being generated.
·LangChain
Module 2 Lesson 4: Batching Requests
Parallel Processing. How to use .batch() to send multiple independent queries to an LLM at once.
·LangChain
Module 2 Lesson 5: Provider-Agnostic Setup
Hands-on: Implementing a model switcher that allows you to change the 'Brain' of your app via a simple configuration.
·LangChain
Module 2 Wrap-up: Designing the Brain
Reviewing model abstractions, streaming, and batching. Your final check before moving to Prompts.
·LangChain
Module 3 Lesson 1: Prompt Fundamentals
The Art of Instruction. Learning the basic principles of prompt engineering: Context, Task, and Format.
·LangChain
Module 3 Lesson 2: PromptTemplate (String Abstraction)
From Static to Dynamic. Using PromptTemplate to create reusable instructions with variables.
·LangChain
Module 3 Lesson 3: ChatPromptTemplate (Messaging Abstraction)
The Agent's Blueprint. How to create templates for multi-role conversations (System, Human, AI).
·LangChain
Module 3 Lesson 4: Few-Shot Prompting
Leading by Example. How to provide the model with sample Q&A pairs to enforce style and accuracy.
·LangChain
Module 3 Lesson 5: Prompt Versioning and the Hub
Prompts as Code. How to version-control your instructions and use the LangChain Hub to share and pull best-in-class prompts.
·LangChain
Module 3 Wrap-up: Your Reusable Library
Hands-on: Build a reusable prompt library and implement a few-shot dynamic classifier.
·LangChain
Module 4 Lesson 1: What are Chains?
The Connection Logic. Understanding how LangChain 'links' prompts, models, and output parsers into a single executable object.
·LangChain
Module 4 Lesson 2: Single-Step Chains (LCEL Basics)
Piping the Brain. Learning how to use the | operator to create your first executable LangChain Expression Language chain.
·LangChain
Module 4 Lesson 3: Sequential Chains
Multi-Step reasoning. How to pipe the output of one LLM call directly into the input of a second LLM call.
·LangChain
Module 4 Lesson 4: Router Chains
Dynamic Decision Making. How to use an LLM to decide which sub-chain should handle a specific user request.
·LangChain
Module 4 Lesson 5: Chain Composition and Aggregation
Parallel Reasoning. How to run multiple chains at the same time and combine their results into a final synthesized answer.
·LangChain
Module 4 Wrap-up: Designing Complex Flows
Hands-on: Build a Parallel-Sequential Research Chain that writes, reviews, and translates a report.
·LangChain
Module 5 Lesson 1: Introduction to Document Loaders
Inbound Data. How LangChain standardizes the mess of real-world file formats into a single 'Document' object.
·LangChain
Module 5 Lesson 2: PDF and Web Loaders
Handling the Web. How to scrape data from websites and extract text from multi-page PDF documents.
·LangChain
Module 5 Lesson 3: Text Splitters and Chunking
Optimizing for Logic. Why we must split long documents into smaller 'Chunks' to fit within LLM context windows.
·LangChain
Module 5 Lesson 4: Special Case Splitters (Code & Markdown)
Context-Aware Splitting. How to split Python code by functions and Markdown by headers to maintain semantic integrity.
·LangChain
Module 5 Wrap-up: Processing Your Knowledge Base
Hands-on: Build a pipeline that loads a multi-page PDF and splits it into optimized chunks.
·LangChain
Module 6 Lesson 1: What are Embeddings?
The Math of Meaning. How to turn human words into a list of numbers that represent their semantic soul.
·LangChain
Module 6 Lesson 2: Embedding Providers (Cloud vs. Local)
Choosing your engine. Comparing OpenAI cloud embeddings with local HuggingFace models for speed and privacy.
·LangChain
Module 6 Lesson 3: Introduction to Vector Stores
The Semantic Database. How to store thousands of vectors so you can search them in milliseconds.
·LangChain
Module 6 Lesson 4: Similarity Search and k-Values
Fine-Tuning Retrieval. Learning how to control how many results (k) your vector store returns and what 'Score' means.
·LangChain
Module 6 Wrap-up: Storing Your AI's Memory
Hands-on: Build a local knowledge base using ChromaDB and perform semantic queries.
·LangChain
Module 7 Lesson 1: Why RAG Matters
Fighting Hallucinations. Understanding the architectural pattern of grounding AI responses in factual, retrieved context.
·LangChain
Module 7 Lesson 2: The Retriever Interface
The Search Object. How LangChain standardizes vector store lookups into a 'Retriever' that can be used in any chain.
·LangChain
Module 7 Lesson 3: Building the RAG Chain
Piping Facts. Putting it all together into a single LCEL chain that retrieves context and generates an answer.
·LangChain
Module 7 Lesson 4: Designing RAG Prompts
The Art of Grounding. How to write the perfect system prompt to ensure your AI stays factual and cites its sources.
·LangChain
Module 7 Wrap-up: Building a Q&A Bot
Hands-on: Finalize your first production-ready RAG system over your own local documents.
·LangChain
Module 8 Lesson 1: Why Memory is Needed
Breaking the Amnesia. Understanding why LLMs are stateless and how we provide 'history' to simulate a conversation.
·LangChain
Module 8 Lesson 2: ConversationBufferMemory
The Raw Transcript. Using the simplest memory type to keep a literal record of every message in a conversation.
·LangChain
Module 8 Lesson 3: Summary Memory
Dense context. How to use an LLM to periodically summarize a conversation to keep the memory footprint small.
·LangChain
Module 8 Lesson 4: External Memory (Redis & Postgres)
Production State. How to move your memory from local RAM to persistent databases for multi-user applications.
·LangChain
Module 8 Wrap-up: Conversations that Stick
Hands-on: Build a persistent chatbot that remembers your name across different CLI sessions.
·LangChain
Module 9 Lesson 1: What are Tools?
The Agent's Hands. Understanding how to give an LLM the ability to execute code and interact with the physical world.
·LangChain
Module 9 Lesson 2: Defining Custom Tools (The @tool Decorator)
Creating Superpowers. How to turn any Python function into a LangChain tool using a simple decorator.
·LangChain
Module 9 Lesson 3: Built-in LangChain Tools
Instant Capabilities. Exploring the library of pre-made tools for web search, calculation, and database interaction.
·LangChain
Module 9 Wrap-up: Giving Your Agent Powers
Hands-on: Build a toolbox for an agent that can multiply numbers and search Wikipedia.