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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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

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.

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 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.

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.

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.

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.

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.

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'.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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.