Production AI Agents with LangChain + LangGraph [2026]

Explore the LangChain ecosystem by examining core packages, Langraph and LangSmith tooling, and deployment through LangServe, plus integration packages like OpenAI and Anthropic for production-ready AI workflows.

Set up the dev environment, obtain OpenAI and Anthropic API keys, verify with a script using UV and VS Code, and learn to build LLMs with LangGraph and LangChain.

Create and save OpenAI and Anthropic API keys, configure them in your project with LangChain and LangGraph, then verify the setup by testing OpenAI and Anthropic models.

Understand the v1 LangChain architecture, from top-level applications to runnables and the lang chain layer, including lcel, runnables, and model integrations.

Explore LangChain core concepts LCEL and runnable chains by building a basic chain with a chat prompt template, a model, and an output parser, then execute and batch process inputs.

Master batch execution in production ai agents by building a basic chain with runnables, batching multiple inputs, and translating text to French using LangChain and LangGraph.

Demonstrate streaming real-time outputs in a LangChain-based AI agent using LCEL, prompts, a chat model like Chat OpenAI, a parser, and chain.stream to display chunks as they arrive.

Inspect the input and output schemas of a LangChain chain using model JSON schema. See how the chat prompt template and parser reveal the internal structure and workflow.

Practice building your first chain in LangChain by creating a prompt, querying a model, using a string output parser, and generating a marketing tagline from a product name and audience.

Build your first chain in LangChain by creating a prompt with product and audience variables, configuring a model, instantiating a parser, and testing the tagline output.

Paolo checks in and invites reviews and ratings to help others decide. He invites questions to build a supportive course community and will answer them.

Master the Lang Chain Expression Language pipe operator to chain the prompt, model, and parser into a single runnable chain, with the chain itself as the runnable object.

Learn the universal way to initialize chat models with init chat model in LangChain. Review available models in 2026, including GPT 4.0, GPT 5.2, Anthropic options, and OLAMA.

Explore why output parsers structure language model outputs into dictionaries or sections, enabling JSON parsing, downstream processing, and graceful error handling for reliable data transport.

Configure model settings—temperature, max tokens, timeouts, retries, and model quarks—and optimize cost by streaming responses, choosing cheaper models, and caching identical requests.

Explore configuring LangChain with multiple providers, and use system, human, and AI messages to manage multi-turn LLM conversations across OpenAI and Anthropic.

Create a function that accepts a question and a list of model names for a multi-model setup, retrieves responses from all models, and returns a model-to-response dictionary.

Implement a getResponse function that iterates a list of model names, initializes chat models, collects their string responses in a dictionary, and returns it; test with GPT-4 mini and GPT-4.

Explore how to build reusable chat prompt templates and multi-message prompts. Understand system, human, AI, and tool messages in LangChain, and master prompt composition for modular AI agents.

Learn to build and format chat prompts with LangChain by using chat prompt templates, variables, and from messages constructs, including system, human, and AI messages, plus few shots examples.

Explore prompt templates in LangChain v1 by running a consolidated file that demonstrates chat templates, message types, dynamic history, few-shot examples, and prompt composition.

Learn how output parsers convert LLM strings into structured data, using JSON and string parsers with identic output and Pydantic validation for robust error handling and downstream processing.

Explore hands-on output parsers, including string, JSON, and Pydantic, to produce structured outputs with prompts, an LLM, and chained invocations.

Demonstrates running the final output parser and structured output in line chain v1, integrating string, json, and pydentic parsers with nested company, address, and headquarters schemas.

Explore the smart q&a bot architecture, transforming a user question with a LangChain chat prompts template and OpenAI model, then producing a structured output via QnA response structured output class.

Build a production-ready smart Q&A bot using LangChain concepts, structured outputs with answers, confidence scores, sources, and metadata, and robust error handling with optional Langsmith monitoring.

Attach LangSmith for logging and tracing to a production-ready LangChain Q&A bot, using LangGraph for observability and structured outputs.

Learn to build modular runnable sequences with LangChain using LCL, moving from legacy chains to pipe-based prompts, models, and parsers, covering RAG, memory, and patterns like sequence, parallel, and pass-through.

Explore building basic and parallel chains using LangChain: create a chat model, define prompts and parsers, run sequential and parallel analyses (summary, sentiment, keywords), and handle parallel results.

Explore a hands-on demo of a pass-through runnable in a retrieval-augmented workflow, demonstrating parallel context and question processing and a chain that formats prompts to a model.

Demonstrate chain branching in LangChain by creating a runnable branch with a classifier and code prompt. Route via classification and select the code or general prompt chain.

Debugging reveals how chains and LLM applications behave by exposing input and output schemas and runtime outputs. Learn three methods to inspect and verify chain inputs, outputs, and intermediate steps.

Load diverse documents with LangChain using pdf, text, html, docx, csv, and more, producing a compact document object with content and metadata.

Explore hands-on text loaders in LangChain by loading a temporary text file with a text loader, inspecting loaded documents, page content, and metadata, and previewing content.

Instantiate a web loader, scrape Wikipedia pages, and preview the loaded content with a documents loader. Install BeautifulSoup 4, configure html parser, and refine requests per second to customize loading.

Load large text file sets lazily using a directory loader with a .txt filter. Demo lazy loading, view metadata, and verify memory efficient handling for big data.

Explore the document class structure in linkchain by building a sample document with page content, metadata, and author fields, then update and inspect immutable documents.

Learn to load pdf documents with LangChain using the pypdf loader, extract content previews and metadata, and understand document structure and provenance.

Explore why chunking matters for large-language models and retrieval augmented generation, covering text splitters like recursive character text splitter, chunk size and overlap, embeddings, vector databases, and semantic chunking strategies.

Explore hands-on use of text splitters with a focus on the recursive character text splitter in LangChain to preserve semantic coherence and natural text boundaries for downstream LLM tasks.

Explore how chunk size and 20% overlap affect retrieval quality in a rag system by comparing 200, 500, and 1000-sized chunks with a recursive text splitter.

Explore why overlap matters in code by comparing non-overlapping and overlapping text chunking, demonstrating how overlap preserves boundary context and improves retrieval accuracy.

Use the markdown header text splitter to divide documents by headers (h1, h2, h3), creating chunks with metadata and preserving each piece’s header-origin context for downstream processing.

Learn to build a code-aware splitter using a recursive character text splitter, specifying the Python language to preserve functions and logical blocks while creating coherent chunks.

Learn how to split pdf documents with LangChain tools, using the pypdfloader and a recursive character text splitter to split documents into chunks with metadata.

Explore retrieval augmented generation, embeddings, and chunked indexing to feed documents into large-language models via a vector store, boosting accuracy, up-to-date data, and scalable responses.

Discover how vectors capture direction, magnitude, and features across dimensions. See how embeddings convert text to vectors and measure similarity with cosine or euclidean distance, stored in a vector database.

Learn how to create embeddings with OpenAI embeddings models via LangChain, choosing TextEmbedding3Small or TextEmbedding3Large for different dimensions, and embed single or multiple texts for vector databases.

Switch from OpenAI embeddings to local options using HuggingFace sentence transformers like all mini L6v2, and use LangChain OLAMA embeddings locally for testing with 384 vs 1536 dimensions.

Explore generating basic and batch embeddings, normalize vectors, and perform similarity search using Langtrain wrappers; implement embedding calls, batch processing, and cosine similarity to rank documents.

Learn how embedding caching reduces API calls and costs by storing embeddings locally with a file-based cache in LangChain, validating cache hits vs. live calls.

Explore vector store architecture, embeddings, and similarity search to retrieve relevant documents, using chroma for local development and production options like Pinecone and Quadrant.

Set up chroma within LangChain to create a vector store from documents using an embedding model, persist it, and run a similarity search to retrieve relevant documents.

Master similarity search with scores using Chroma and LangChain, retrieving top results and their scores from a vector store with embeddings, and learn how distance versus similarity scores affect relevance.

Apply metadata filtering to similarity search by passing a filter object with a topic criterion, narrowing results to database-related documents from Pinecone, Chroma, and vector stores.

Persist the chroma db locally by creating and saving a vector store to a persist directory, reload from disk, and verify with a similarity search.

Explore using a vector store as a retriever for chains, compare similarity and MMR retrieval, and fetch three documents to illustrate diverse, well-rounded results.

Set up a vector store with Chroma, split documents into chunks using a recursive splitter, and configure a retriever to test with sample text and queries for a rag system.

Ground LLM responses in retrieved, embedded documents indexed in a vector store. Connect the user query to the retriever with context and sources via an output parser.

Build and test a basic rag pipeline using LangChain, embeddings, and a vector store; combine a prompt template, retriever, and llm to answer questions grounded in retrieved documents.

Learn how to implement RAG with sources by building a vector store, retriever, and OpenAI LLM, then format docs with sources to display citations.

Build a RAG with fallback that gracefully handles unknown questions using a vector store, retriever, and context prompts, returning 'I don't have information about that in my knowledge base'.

Build a document Q&A system using a RAG pipeline to split, embed, and retrieve text with a vector store and confidence scores; ground the LLM and prompts for precise results.

Identify the limitations of basic RAG and describe advanced techniques—multi query retrievers, self query retrievers, contextual compression, and hybrid search—for better precision and context.

Explore advanced rag patterns with multi-query retriever, contextual compression, and hypersearch as you build a base vector store, generate multi queries with an LLM, and retrieve documents.

Explore contextual compression that uses an LLM-based compressor to retrieve only relevant chunks from the vector store via a compressed retriever, reducing tokens, costs, and latency.

Implement hybrid search for rag by combining bm25 keyword retrieval with semantic retrieval. Build vector store, deploy an ensemble retriever with 40% keyword and 60% semantic weights, and evaluate results.

Learn to build a two-stage parent document retriever for rag, balancing small-chunk search precision with large-chunk context using in-memory vector stores, embeddings, and recursive text splitters.

Combine multi-query retrieval with compression to build a complete rag chain. Leverage vectors, embeddings, and an llm for enhanced recall and precision.

Explore memory in LangChain: a session-based message history with IDs and a runnable memory store, plus strategies like buffer, window, summary, and SQLite persistence.

The lecture demonstrates building a basic conversation memory in memory.py, saving context pieces in an in-memory chat history to let the language model recall previous topics across a chat.

Demonstrate multiple sessions by creating per-session memory with a chain and prompt to an LLM, attaching each user to separate conversation histories for memory retrieval.

Trim messages to fit the context window using token-aware strategies, preserving system messages, and demonstrating last-token trimming and max tokens for memory efficiency.

Explore windowed memory by implementing a sliding window that keeps the last K exchanges, balancing cost and context limitations while dropping older messages.

Adopt a hybrid summary memory that keeps recent messages verbatim and compresses older ones into summaries, using a windowed memory to preserve context efficiently.

Build a chat bot with persistent memory using SQLite, storing chat history with SQL chat message history and session data, and demonstrate recall across restarts.

Develop a production-ready rag system that ingests documents, uses smart chunking with metadata, multi-query retrieval, and contextual compression, storing in a Chroma vector store to deliver sources and confidence.

Demonstrates building an AI research assistant that indexes documents using embeddings, a text splitter, and a chroma db vector store, with add documents and test persistence.

Build an ai research assistant with LangChain by adding an llm, a prompt, and an output parser, plus a similarity-based retriever for context-rich, source-cited q&a.

Add memory to an AI research assistant by storing session history as a list of messages, injecting memory into prompts, and preserving isolated session histories for each user.

Explore advanced retrieval in AI research assistants by implementing a multi-query retriever atop a base retriever, using an llm to generate multiple queries for more relevant chunks.

Build a research assistant with structured outputs in LangChain, returning a research response with fields like answer, confidence, sources, key quotes, and follow-ups for clean downstream processing.

Explore LangGraph, the stateful alternative to simple chains, with pillars of state, nodes, and edges. Learn about conditional routing, crash recovery, and built-in persistence for production-ready workflows.

Define a simple state with input, output, and step; build Langraph graph with a process node, connect start to end, then compile and run to reveal input, output, and step.

Discover how accumulating state with reducers in LangGraph preserves context across a graph workflow, letting messages concatenate while counts sum without being overwritten.

Implement the message state pattern in LangGraph to build chat apps and agents, using a chat node and LLM invocation to preserve messages across the conversation.

Build your first node in a line graph by generating three questions about a topic, answering the first, and returning both questions and the answer using a LangGraph workflow.

Build a LangGraph step-by-step workflow to construct a conversation graph with states and edges, analyze sentiment, and generate responses using a modern init LLM, then simulate test messages.

Explore direct edges and conditional edges, implement a routing function to branch from A to B or C based on state, and map routes to nodes for dynamic workflows.

Build a literal routing system with an LLM-driven router state, classify queries, and route by type (question, command, statement) using a graph with conditional edges.

Explore building a conditional loop in a LangGraph workflow, using evaluate, improve, and finalize nodes to iteratively refine content based on a quality score and iteration state.

Learn multipath routing using a graph-based flow that analyzes task urgency and complexity via a large-language model, routing tasks to senior team, specialist, or quick response.

Explore cycles and loops to turn a simple chain into a self-correcting code writer that uses LangGraph, validates with real Python compilation, and iterates until correct.

Explore how an iterative research agent analyzes a topic, generates deeper questions, revisits findings, and synthesizes everything into a final summary through loops, cycles, and a max depth.

Leverage a human-in-the-loop workflow using line graph to interrupt before approval, review, modify, and resume with memory saver checkpoints that store draft, feedback, and final results.

Experience a human-in-the-loop, iterative review workflow with multiple revision rounds, a graph-based router leveraging a large language model to apply feedback, and memory to track progress until finalization.

Explore how checkpointing turns stateless graphs into durable memory by persisting conversations with SQLite via line graph checkpoints, enabling history, branching conversations, and undo capabilities.

Dive into the internals of a checkpoint by inspecting state snapshots, messages, and checkpoint metadata within a two-node graph, then review the full checkpoint history and time-travel data.

Explore LangGraph fundamentals—state, nodes, and edges—along with conditional routing, loops, reducers, human in the loop, and checkpointing with memory backends.

Define tools (calculate, get weather, search web) and bind them to an LLM in LangGraph to build a tool calling agent with a tool node and state.

Learn to build a custom tool with error handling and return error strings for division by zero, binding tools to an LLM for a resilient, crash-free agent.

Learn how the supervisor pattern handles a user query by understanding intent, breaking work into substacks, routing tasks to specialists, and collecting and synthesizing results into a final response.

Explore agent handoffs in LangGraph by building a triage routing system with structured outputs that direct queries to sales, support, or billing specialists.

Learn parallel agent execution for research, creative, and technical tasks, then apply map-reduce and hierarchical reduce to map documents to summaries and reduce to a cohesive final overview.

Explore how agents communicate using a shared blackboard and reducers to resolve conflicts with last right wins, add messages, and typed fields for scalable, observable workflows.

Explore a hands-on message passing pattern by building a multi-agent pipeline (researcher, fact checker, summarizer) that grounds prompts, validates findings, and generates a final summary.

Explore shared field state where agents write to their own typed fields and read from a common raw data field, enabling data collection, analysis, and confidence-backed recommendations.

Explore the blackboard pattern by implementing an iterative refinement loop where a drafter and critic share a workspace, read and write drafts, critiques, and approvals across iterations.

Explore hierarchical architecture to scale agent teams with a top-level supervisor routing to department sub-supervisors (research, content, analytics) and independent, testable subgraphs that share state through overlapping keys.

Construct a single department subgraph in isolation with a shared state, parallel web researcher and paper reviewer, and a research lead to produce the final answer.

Explore production ai agents with a hierarchical routing and full tracing system across research, content, and analytics departments, featuring editor, writer, data analyst, and strategy advisor roles.

Coordinate a production multi-agent research system with a supervisor, search agents, an analyst, and a report writer to produce and quality-check a final report.

Explore a hands-on multi-agent research workflow with a supervisor, state schema, and send api-driven parallel search agents, using a blackboard analyst and a report writer for iterative quality checks.

Build a production-grade research system with LangChain and LangGraph, wiring search agents, an analyst, a report writer, and a quality gate using a blackboard workflow.

Master multi-agent systems by building a production-ready research system with tool calling agents, supervisor architecture, agent handoffs, and parallel execution, and learn three core communication patterns with hierarchical teams.

Explore observability for multi-agent systems and learn how traces, metrics, and evals reveal how supervisors, writers, and LLM calls perform, using LangSmith for end-to-end traceability.

Set up LangSmith with LangChain and LangGraph to enable observability through tracing, API keys, and the LangSmith dashboard. Learn to implement traceable functions, metadata, and tags for detailed run insights.

Explore defenses against prompt injection and PII leakage in production AI agents, using input sanitization, guardrails, monitoring, and PII detection categories.

Apply defense in depth for LLM apps by layering input sanitization, PII detection, an LLM guard, and output validation; mask PII and block prompt injection with regex.

Explore the LLM guard as a bouncer that classifies user input for prompt injection attempts, requests for harmful content, and private information, returning JSON and enabling audit trails with LangSmith.

Demonstrates a multi-layer security pipeline that sanitizes input, detects and masks PII, blocks harmful content, and validates outputs before delivery.

Adopt production considerations by applying input validation, guard, process, and output validation, and add rate limiting, user authentication, OpenAI moderation or Azure content safety, PII services, and WAF protections.

Discover how testing LLMs differs from traditional testing, using unit tests with mocks and integration tests, while applying metrics like correctness, relevance, coherence, helpfulness, and harmlessness.

Run integration tests with real LLM calls, track results in Langsmith, validate q&a by asserting keyword containment to handle non-determinism, and run them nightly before deployments.

Use an LLM evaluator to grade a question, response, and reference, scoring correctness, relevance, clarity, and completeness, and return a JSON object.

Learn regression testing for language models with a test runner and LLM evaluator, scoring responses against fixed test cases using a seven-point threshold and detailed logging to monitor health.

Explore Langsmith evaluation datasets and the production approach, using a Q&A data set, evaluators for correctness and helpfulness, and the Langsmith dashboard to compare experiments.

Apply the LLM testing pyramid—from unit tests with mocks to integration and regression tests—using Lang Smith data sets weekly or before deploy, with nightly drift checks.

Learn production error handling for llm apps with exponential back off and a retry decorator, and implement a fallback chain to ensure graceful degradation.

Demonstrate the circuit breaker pattern to stop retries after consecutive failures, protecting resources by moving through closed, open, and half-open states, fail-fast, and testing recovery.

Implement a fallback chain that tries models in order: gpt40, cloud sonnet, gpt40mini, using timeouts and caching to serve cached results instantly and raise a full error if all fail.

Embed error handling inside the LangGraph state machine to track errors, count retries, and route outcomes with a three-way router, delivering graceful failure handling and clear user messages.

Apply model routing to use cheap models for simple tasks and reserve expensive models for complex ones, while semantic caching, token budgeting, and prompt optimization cut costs.

Demonstrates semantic caching with a two-layer cache that normalizes queries, hashes them, and caches responses to reduce LLM calls; highlights exact-match limitations and embedding extensions.

Apply token budgeting to control inference costs by tracking input and output tokens and request counts, rejecting over-budget calls before LLM invocation, with usage logged in Langsmith.

Explore the three pillars of production visibility—structured logging, metrics collection, and instrumented LLM—and learn to monitor latency, tokens, errors, and cost using json logs and LangSmith.

build a production-ready api with Lang Smith tracing, input sanitization, PI detection and masking, add rate limiting, caching, error handling, retries, logging, health checks, docker deployment for FastAPI, LangGraph.

Build a robust security layer for production APIs by implementing prompt injection defense, input sanitization, pii detection and masking, and output validation in a single security pipeline.

Implement an in-memory TTL cache with lowercase key normalization to cut duplicate LLM calls and save costs. Use JSON logging and metrics to monitor latency and cache performance in production.

Build the lang graph agent—the brain with a safety net—featuring built-in error handling that retries the primary model, falls back to a secondary model, and returns a graceful error.

Wire five independent modules—security, caching, monitoring, the agent, and config models—into a single FastAPI app with health, metrics, and rate-limiting endpoints powered by LangChain and LangGraph.

Test and dockerize the production LangGraph API, validating security with input sanitizer, PII detector, and output validator, while enabling caching, health checks, and Docker Compose deployment.

Deploy your production API to Render and obtain a live URL, with health checks, auto deploy on git push, security, and monitoring through infrastructure as code.

Explore building production-grade ai agents with LangChain and LangGraph, grounded in blankchain fundamentals, rag pipelines, and landgraf state management for scalable multi-agent workflows.