LangGraph in Action: Develop Advanced AI Agents with LLMs

Compare TypedDict and Pydantic BaseModel to define and validate objects in LangGraph. Understand static type checking with mypy versus runtime validation and parsing, and learn when to use each approach.

Define a state with string and int, add nodes and edges. Set the entry point and compile to validate, then visualize with mermaid PNG.

Discover why LCEL is easy for simple workflows but becomes convoluted for complex graph workflows, and see how combining LTL with a land graph workflow delivers best of both worlds.

Route between nodes with cycles and conditional edges in LangGraph using a router function and modify state, creating a start node, branches A and B, and a mapped end node.

Apply per-key reducers to manage state updates with typed dict annotations and the add operator. Learn how reducers preserve chat history by updating string, numeric, and list values.

Explore using pydantic base model for state management in LangGraph, replacing dict-based state with dot-operator attribute access and automatic type validation.

Learn how tool calling enables AI agents to query databases and APIs for real-time information, generate tool-arguments per a defined schema, and defer execution to the user.

Learn to define and bind tools with the LangChain core tools decorator, enabling the language model to call weather and seating tools for live data.

Create your first LLM based agent that interacts with the world using Landgraaf, a state graph, and weather tool; learn tool calls, a reducer, and the checkpoint persistence layer.

Learn to persist conversations with Landgraf's memory check pointer by using the memory saver to store chat history via thread IDs and config, enabling authentic workflows.

Explore rag with a rack agent, detailing indexing and retrieval stages, embeddings into a vector database, and prompts that guide the language model to a well informed human like response.

Explore rag in practice by loading api keys, embedding restaurant documents about Bella Vista, and building chroma vector store; retrieve opening hours with a retriever and generate answers from OpenAI.

Explore a rag agent with a classifier that routes on-topic questions to vector-store retrieval and answer generation, while off-topic queries return a simple response.

Explore tool calling with LangChain to turn a retriever into a tool, decorate off-topic responses, and build a simple agent workflow with a state graph and tool nodes.

LangGraph in action guides building a complex rag agent using chat history and a vector store, with a rewriter, classifier, retrieval grader, and finite refine cycles to produce an answer.

Implement a memory-enabled RAC agent with a vector store, retrieval, and chat history routing to classify questions, retrieve documents, and generate answers with an LLM.

Define input state, private state, intermediate state, and output state to filter lm calls and reveal only the final answer within a simple state graph from start to end.

Learn to add runtime configuration to enable on-the-fly LLM switching and multilingual responses without recompiling the graph, using a runnable config and configurable language keys.

Replace the config object with a runtime parameter using a data class and dataclass decorator, enabling language context to drive system prompts and multilingual model responses.

In high-stakes settings, shift from autonomous agents to human in the loop workflows that interrupt automation for human review and override, then resume the process, improving reliability and reducing errors.

Explore how to implement human-in-the-loop workflows in LangGraph using check pointers and interrupt controls to route tools and persist state.

Use time travel to replay past actions in the graph, edit the state, and explore alternative tool outcomes, while checkpoints let you resume from precise states.

Explore LangGraph in action by escalating to a human expert via a request assistance tool, integrating tool calls within a chatbot–tool graph, and interrupting before expert input.

Explore the new command class in Landgraf 257, enabling edgeless graphs and flexible transitions between nodes for human in the loop workflows using a command with go to and update.

Implement a human-in-the-loop workflow using interrupt and command to control tool calls, update state, and route weather queries through a LangGraph graph toward production-grade, parallel, and async workflows.

Explore the new durability argument and the three checkpoint modes—exit, async, and sync. Learn how to configure a memory checkpoint, run a simple graph, and read state history.

Learn parallel node execution in LangGraph by branching to append nodes that write to a shared state and merge with a combine node, using a reducer with annotated keys.

Compare synchronous invoke with asynchronous code to run production-grade graphs and process multiple requests concurrently, reducing total processing time. Understand streaming delivery and when to avoid streaming in complex workflows.

Explore async and streaming in practice by building a weather tool workflow in an IPython notebook, enabling A-invoke method, await, and token-by-token outputs for AI agents.