Advanced LangGraph: Workflows, Multi-Agents, Deep Agents

LangGraph defines an autonomous agent as an LM in a loop that uses prompts, tools, and memory (short-term and long-term) to reason, act, and stream results.

Understand how the graph API models AI agent workflows as a stateful graph of nodes and edges, with start and end nodes, from state definition to compile and run.

Explore how graph state powers a line graph agent, detailing state schema and reducers, and demonstrate dict, typed dict, and pydantic examples with step counting and message updates.

Explore how state reducers in Landgraaf control updates to state variables, with default behavior or custom Python reducers. See counts increment and lists append, plus add messages for chat history.

Explore the add_messages reducer in line graph to manage LM conversations by correctly ordering human, AI, and base messages, preserving conversation history and context.

Explains how to manage messages in graph state, covering human, AI, tool, and system messages, using the messages state class and add messages with a reducer to preserve history.

Line graph nodes act as action takers and units, implemented as runnable lambdas that take state and return updates, connected from start to end with edges, config, and runtime context.

Explore graph edges in LangGraph, learning how normal and conditional edges route workflows between nodes, define start and end points, and support parallel workflows.

Use map-reduce in graph workflows with the send API to spin up multiple node instances in parallel, passing private state for each record. Synthesize results into a final report.

Learn to update state and navigate in one command, with conditional routing to next nodes, demonstrated through a temperature check graph in vscode.

Implement retry policies in LangGraph to handle transient API errors with configurable max attempts, intervals, backoff, and jitter. Create resilient, self-healing nodes that retry on network or API errors.

Explore line graph workflows that define predetermined steps for tasks, from augmented lm and prompt chaining to routing, parallelization, orchestrator workers, and evaluator optimiser workflows.

Explore the augmented LLM as the foundational workflow, learn to augment with tools for real-world actions, implement structured outputs via schemas, and understand memory integration for stateful interactions.

Augment your LLM with weather and tip tools to demonstrate tool calling. Bind tools to a GPT-4 model, run queries, and observe the tool calls and outputs.

Bind language model outputs to a schema to produce structured JSON for downstream services, using a product review analyzer to extract name, sentiment, rating, pros, cons, and a brief summary.

Explore prompt chaining as a sequential workflow where an LLM drafts, reviews, and sends emails through a series of prompt-driven steps, using tools and verifications to improve accuracy.

Demonstrate a four-step prompt chaining pipeline for blog generation with quality control, including draft creation, fact checking, revision, and publication formatting.

Explore the parallelization workflow by launching concurrent posts and analyses across platforms, using independent tasks and multiple llms to speed up marketing copy and document analysis.

Demonstrate parallelization in a social media posts generator by producing Instagram, Twitter, and LinkedIn posts in parallel and aggregating them into a final content package.

Learn how the routing pattern directs tasks to specialized nodes via a personal assistant, using conditional edges for efficient, modular workflows in customer support, document processing, and medical triage.

Design a customer support routing system with LangGraph: classify queries into billing, technical issues, refunds, or general issues, route to the right handler, and generate emails.

Break a LangGraph task into chapters, assign each to a summarization worker, and aggregate a final summary. Learn how the orchestrator coordinates dynamic subtasks, parallel processing, and scalable synthesis.

Demonstrates a LangGraph orchestrator/worker workflow demo that splits a topic into subtopics, launches workers for each subtopic, and synthesizes findings into a final report.

Explore evaluator/optimizer workflow where a generator produces a draft, an evaluator scores it against criteria, and iterative feedback refines until a threshold is met, with legal and code-generation use cases.

Explore the evaluator optimizer workflow to automatically generate and evaluate a compelling product page for an e-commerce product, using OpenAI for generation and Gemini for evaluation.

Explore how short-term memory in a graph preserves session context with thread IDs, checkpoints, and snapshots. See how check pointers save state across runs and enable time travel between checkpoints.

Demonstrates building a memory-enabled chat app with checkpoints to persist user context across turns. Attach a thread id and use a memory saver to remember dialogue.

Explore how to retrieve and replay state from snapshots in a document analysis graph, including final states, specific checkpoints, and full history, with insights into quality scores and revisions.

Learn to replace states by replaying a graph from a selected checkpoint using its checkpoint id, then observe the analyze, revise, and finalize steps and the final quality score.

Learn to manually override graph state by fetching state and applying a manual update via update state method, adjusting quality score, approval, processing stage, and issues, producing a new checkpoint.

Switch to a production Postgres database to store short term memories for a LangGraph chat app, including creating the production database, installing dependencies, and running migrations for checkpoints and schemas.

Learn how long term memory uses a persistent store to share information across threads, preserve user context, and enable semantic retrieval with structured memory management.

Explore how long-term memory is organized into a store with namespaces and memory items, including keys, values, and timestamps, and compare in-memory, Postgres, and Redis stores for different environments.

Initialize an in-memory store, save, update, retrieve, and delete memories by namespace and key. List namespaces, filter with prefix and depth, and enable semantic search with embedding models.

Demo shows a memory-enabled chat bot with three nodes—memory retrieval, chat responses using memory, and memory extraction to save facts in a long-term store via semantic search and embeddings.

Demonstrate inspecting and semantically querying a long-term memory store outside the graph workflow, revealing eight distinct memory items about Sarah (name, profession, hobbies, preferences).

Demonstrate long term memory across threads by recalling Sarah’s stored facts in a new chat. Show memory isolation for a new user, preventing leakage and filtering duplicates in retrieval.

explain the react agent pattern in LangChain, a thought-action-observation loop where agents understand tasks, decide actions, execute with tools, observe results, and repeat until completion.

Learn to build a single purpose agent with the create_agent builder, configuring model, tools, system prompt, structured output, context schema, state schema, checkpoint, and middleware in LangGraph.

Build a personal finance assistant agent using the create agent function. Enable balance reading, transaction retrieval, and budgeting via the 50/30/20 rule.

Learn to enable multi-user agents by injecting runtime user context, using a user context schema, updating balance and transactions tools, and personalized greetings based on membership tier and currency.

Learn to deliver tiered services by using middleware to dynamically swap models and prompts according to membership level (basic, premium, platinum).

Explore implementing a middleware to gracefully handle tool errors and validate a transfer tool, including amount, daily limit, accounts, and insufficient funds, with user-friendly recovery messages.

Learn to produce structured outputs for multi-agent systems by defining a schema with Pydantic and Long Chain strategies to ensure deterministic, well-formed results.

Add memory to the LangGraph agent by using an in-memory check pointer to preserve conversation context across turns; in production, switch to Postgres for persistent checkpoints.

Learn to stream agent outputs for long running tasks, processing results in chunks, and delivering real-time dashboard feedback using the stream method with updates and values modes.

Explore how multi-agent systems divide cognitive labor through coordinated agents and state, with entry and exit points. Learn LangGraph patterns like sub agents, handoffs, skills, router.

Explore the sub-agent pattern, where a central coordinator delegates tasks to specialized sub-agents exposed as tools, achieving centralized orchestration, context isolation, and stateless execution for scalable multi-agent workflows.

The hands-off multi-agent pattern uses a single active agent who transfers the user to specialized agents (billing, technical, general) in a sequential, stateful flow.

Explore the skills pattern in a single LangGraph agent that loads skills on demand, using additive context and a skills discovery tool.

The router pattern uses a classification step to break down a query, dispatches tasks to specialists in parallel, and synthesizes results into a final report.

Set up a virtual environment, install Lanchain and Langraff packages with OpenAI support via requirements.txt, and organize mock data and sub-agents for a smart travel planner.

Develop and configure the flights sub-agent to handle natural language flight queries, using search flights and compare flight prices tools to filter by destination, budget, and stops.

Create a hotels sub-agent that searches hotels by destination and budget and provides traveler-type driven recommendations using two tools: search hotels and get hotel recommendation, with a HotelsAgent prompt.

Design the activity sub-agent for advanced LangGraph workflows, implementing tools to search activities and restaurants. Guide the agent to generate curated recommendations based on destination, interests, budget, and trip style.

create the itinerary agent to organize flights, activities, and hotels into cohesive, optimized day-by-day schedules using create daily schedule, optimize route, and generate trip summary tools.

the supervisor agent orchestrates four sub-agents wrapped as tools—flights, hotels, activities, and itinerary—by initializing a model (OpenAI GPT-4-0-mini) and using memory when needed to synthesize travel plans.

Orchestrate a multi-agent system via a command line chat interface, with a supervisor coordinating sub-agents and streaming memory via UUID thread IDs.

Run a multi-agent system, set llm provider keys, and orchestrate parallel sub-agents to generate a Tokyo trip plan with flights, hotels, activities, and dining.