Production AI Agents with LangChain + LangGraph [2026]

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.