Building applications with large language models<\/a> (LLMs) is exciting, as it lets us create smart, interactive systems. However, making these apps more complex brings along challenges, especially when several LLMs work together. So, how do we manage the flow of information between them? How do we make sure they work smoothly and understand the task? LangGraph is the answer to all such questions. This free tutorial is a great way for beginners to understand how LangGraph can solve these problems. With hands-on examples and complete code, this guide will teach you how to manage multiple LLMs effectively, making your applications more powerful and efficient.<\/span><\/p>\n LangGraph is a powerful library, which is a part of LangChain<\/a> tools. It helps streamline the integration of LLMs, ensuring they work together seamlessly to understand and execute tasks. It offers a neat way to build and handle LLM apps with many agents.<\/p>\n LangGraph lets developers set up how multiple LLM agents talk to each other. It shows these workflows as graphs with cycles. This helps in keeping the communication smooth and performing complex tasks well. LangGraph is best when using Directed Acyclic Graphs<\/a> (DAGs) for straight line tasks. But since it is cyclic and adds the ability to loop back, it allows for more complex and flexible systems. It\u2019s like how a smart agent might rethink things and use new information to update responses or change its choices.<\/p>\n Also Read: What is LangGraph?<\/a><\/p>\n Here are some of the key concepts of LangGraph that you need to know:<\/p>\n LangGraph\u2019s core idea is using a graph for the application\u2019s workflow. This graph has two main parts \u2013 nodes and edges.<\/p>\n Keeping track of what\u2019s happening is vital when you have many agents. All agents need to know the current status of the task. LangGraph handles this by managing the state automatically. The library keeps track of and updates a main state object. It does this as the agents do their jobs. The state object holds important information. It\u2019s available at different points in the workflow. This could include the chat history.<\/p>\n In a chatbot, the state can save the conversation. This helps the bot respond using what was said before. It can also store context data, like user likes, past actions, etc. or external data. Agents can use this for making choices. Internal variables can also be kept here. Agents might use the state to track flags, counts, or other values. These help guide their actions and decisions.<\/p>\n A multi-agent system consists of multiple independent agents that work together or compete to achieve a common goal. These agents use LLMs to make decisions and control the flow of an application. The complexity of a system can grow as more agents and tasks are added. This may lead to challenges like poor decision making, context management, and the need for specialization. A multi-agent system solves these problems by breaking the system into smaller agents, each focusing on a specific task, such as planning or research.<\/p>\n The main benefits of using a multi-agent system is modularity, specialization, and control. Modularity is for easy development, testing and maintenance, while specialization ensures that expert agents improve overall performance. Control ensures that you can clearly tell how the agents should communicate.<\/p>\n Here are the various types of architectures followed in multi-agent systems.<\/p>\n 1. Network Architecture:<\/strong>\u00a0In this architecture, every agent communicates with every other agent, and each can then decide which agent they should call next. This is very helpful when there is no clear sequence of operations. Below is a simple example of how it works using StateGraph.<\/p>\n 2. Supervisor Architecture:<\/strong> A supervisor agent controls the decision making process and routes tasks to the appropriate agents. Here\u2019s a sample of how it\u2019s done:<\/p>\n 3. Supervisor with Tool-calling:<\/strong> In this architecture, a supervisor agent uses a tool-calling agent to decide which tool (or agent) to use. The tool executes tasks and returns results that guide the next control flow decision.. A common pattern here is to have a tool-wrapped function:<\/p>\n 4. Hierarchical Architecture:<\/strong> This approach addresses the complexity of multi-agent systems by organizing agents into teams, each with its own supervisor. The top-level supervisor directs which team to call. For instance:<\/p>\n 5. Handoffs in Multi-agent Systems:<\/strong> Handoffs allow one agent to pass control to another, facilitating a flow from one agent to the next. Each agent returns a Command object that specifies the next agent to call and send any updates to the state.<\/p>\n In complex systems, agents may be nested within subgraphs, where a node in a subgraph can direct control to another agent outside its graph:<\/p>\n Multi-agent systems enable modular and specialized designs where agents independently handle tasks and communicate for efficient problem-solving. Architectures like network, supervisor, and hierarchical systems each serve specific needs, while handoffs ensure smooth transitions between agents, maintaining flexibility and control.<\/p>\n Persistence means saving the progress of a process so that you can come back to it later, even after some interruptions. Each step\u2019s state is saved, which helps with error recovery. It supports human feedback during runs. You can also replay steps to debug or try new paths.<\/p>\n In LangGraph, persistence is done using checkpointers. Here, the graph\u2019s state is saved after every major step and each saved state is called a checkpoint. All the checkpoints are grouped inside a thread (the conversation history for a particular run).<\/p>\n Checkpointing is done automatically and you don\u2019t always need to configure it manually. A checkpoint is like a snapshot of the graph\u2019s state that includes:<\/p>\n Each graph, while execution, needs a thread ID to group its checkpoints. You can provide this thread id using config: Below is a sample of how it can be done:<\/p>\n To fetch the most recent state within a thread, use the below code:<\/p>\n The below code shows how you can get a specific checkpoint:<\/p>\n To get the state history or fetch all previous states, use this code:<\/p>\n You can also update or edit the state manually at any point, using:<\/p>\n Human-in-the-loop lets you add human feedback at key steps of an automated LangGraph workflow. This is crucial in certain tasks since LLMs may generate uncertain or risky outputs such as in tool calls, content generation, or decision-making. LangGraph\u2019s interrupt() function makes this possible by pausing the graph, surfacing data to a human, and resuming with their input using the Command(resume=value) method. This enables review, correction, or data entry.<\/p>\n Human-in-the-loop supports patterns like Approve\/Reject, Edit State, Provide Input, or Multi-turn Conversations. To use it, define a checkpointer and add an interrupt() inside a node. You can resume the graph using Command after human input.<\/p>\n Below is a sample of how you can use Human-in-the-loop in LangGraph.<\/p>\n This keeps workflows interactive, auditable, and accurate perfect for high-stakes or collaborative AI use cases.<\/p>\n LangGraph streams outputs as they are created which lets users see results faster. This improves their experience with LLMs. Streaming helps you build responsive apps by showing you real-time progress. There are 3 main data types to stream: workflow progress, LLM tokens, and custom updates.<\/p>\n Use .stream() (sync) or .astream() (async) to stream outputs. You can set stream_mode to control what you get:<\/p>\n You can pass multiple modes like this:<\/p>\n Use .astream_events() if you want a full event stream. This is perfect when migrating big apps.<\/p>\n Pro tip:<\/strong> For real-time UI feedback, use \u201cmessages\u201d for token-wise streaming and \u201cupdates\u201d for backend state.<\/p>\n LangGraph is ideal for developers building smart and flexible AI agents. Here\u2019s why:<\/p>\n You can also take the course from the Langchain academy<\/a>.<\/p>\n Now that we have seen the key components of LangGraph, let\u2019s try to build a basic graph with three nodes and one conditional edge. This simple example shows how to invoke a graph involving the key concepts of State, Nodes, and Edges.<\/p>\n The State defines the data structure which is shared between nodes. It acts like a shared memory that flows through the graph.<\/p>\n Here, we have used python\u2019s TypeDict to declare that our state will have a single key called the graph_state, which stores a string.<\/p>\n Nodes are just simple Python functions. Each one takes in the current state, modifies it, and returns the updated state.<\/p>\n This function appends \u201cI am\u201d to whatever string is in graph_state.<\/p>\n Here, these two nodes add an emotional tone of \u201chappy!\u201d or \u201csad!\u201d to the sentence.<\/p>\n Sometimes you want dynamic behavior, where the next step depends on logic or randomness. That\u2019s what conditional edges enable.<\/p>\n This function randomly picks between node_2 and node_3 with equal probability, simulating a simple mood selector.<\/p>\n Let\u2019s bring it all together using LangGraph\u2019s StateGraph class. This is where we define the full graph structure.<\/p>\n We start with the START node and route to node_1. Then, we add a conditional edge from node_1 using decide_mood. After that, the graph continues to either node_2 or node_3 and ends at the END node.<\/p>\n The compile() method performs basic validation, and draw_mermaid_png() lets you visualize the graph as a Mermaid diagram.<\/p>\n Finally, we can run the graph using the invoke() method.<\/p>\n This starts the graph at the START node and initializes graph_state with the sentence \u201cHi, this is Janvi.\u201d.<\/p>\n Output:<\/strong><\/p>\n This output shows how state flows and updates through each step of the graph.<\/p>\n Now that we have built the simplest graph in the above section, in this section,\u00a0I will show you how to use LangGraph to build a support chatbot, starting with basic functionality and progressively adding features like web search, memory, and human-in-loop. Along the way, we will see the\u00a0core LangGraph concepts as well.<\/p>\n Our goal here is to create a chatbot that can answer questions using web search, remember past conversations, ask a human for help when needed, use a custom state for behavior, and rewind conversation paths (enabled by checkpointing).<\/p>\n Before building the chatbot, let\u2019s install the necessary packages.<\/p>\n This command installs:<\/p>\n We need to securely provide the OpenAI API key so the application can authenticate and use the GPT models. This function prompts for the key if it\u2019s not already set in the environment.<\/p>\n We\u2019ll start by creating the simplest form of the chatbot.<\/p>\n The state defines the data structure that gets passed between nodes in the graph. Here, we define a state with a single key, messages, which will hold the list of conversation messages.<\/p>\n The StateGraph object is the entry point for defining the graph structure. It\u2019s initialized with the State definition we just created.<\/p>\n We define a Python function chatbot that takes the current state, invokes OpenAI\u2019s GPT model with the messages from the state, and returns the LLM\u2019s response as an update to the messages key in the state.<\/p>\n Define the entry point (START) and exit point (END) for the graph execution.<\/p>\n Once all nodes and edges are defined, compile the graph structure.<\/p>\n LangGraph allows visualizing the compiled graph structure. This helps understand the flow of execution. We can visualize the graph using tools like pygraphviz or mermaid.<\/p>\n Set up a loop to interact with the chatbot. It takes user input, packages it into the expected State format ({\u201cmessages\u201d: [\u2026]}), and uses graph.stream to execute the graph. The stream method returns events as the graph progresses, and we print the assistant\u2019s final message.<\/p>\n To make the chatbot more knowledgeable, especially about recent information, we\u2019ll integrate a web search tool (Tavily). This involves enabling the LLM to request tool usage and adding graph components to handle the execution of these tools.<\/p>\n Install the necessary library for the Tavily search tool.<\/p>\n Configure the API key for the Tavily service.<\/p>\n Instantiate the TavilySearchResults tool, which will return 2 results. This tool will be used by both the LLM and the graph.<\/p>\n To enable multi-turn conversations where the bot remembers previous messages, we introduce LangGraph\u2019s checkpointing feature.<\/p>\n Use the MemorySaver checkpointer to store the conversation state in memory. For production, you might use a persistent backend like SQLite or Postgres.<\/p>\n Sometimes, the AI agent might need human input before proceeding. We achieve this by creating a tool that pauses the graph\u2019s flow.<\/p>\n This tool pauses the graph and waits for human input before proceeding.<\/p>\n Once you have built your LangGraph application, the next thing which you need to do is running the app either on your local machine or cloud platforms for further development and testing. LangGraph provides us with several deployment options which can have different workflows and infrastructure.<\/p>\n For deployment, LangGraph supports several options. The Cloud SaaS model<\/a> handles everything for you. The Self-Hosted Data Plane<\/a> lets you run apps in your own cloud while using LangChain\u2019s control plane. With the Self-Hosted Control Plane, you manage everything yourself. Or go with Standalone Containers<\/a> for full flexibility using Docker.<\/p>\n LangGraph is used to build interactive and intelligent AI Agents. Let\u2019s explore and see some of its use cases.<\/p>\n Improved Customer Service<\/strong>: LangGraph is capable of developing advanced chatbots for customer support. These chatbots are able to recall past purchases and customer preferences.With the recalled past they can respond to the queries about the order and can link to humans when necessary. With this the customer\u2019s problem can be solved faster.<\/p>\n Research Assistant for AI<\/strong>: A research assistant can also be created using LangGraph. It can look for scholarly articles and then highlight important information. The assistant can then extract the information and this information then can be used by researchers and students to gain more insights from various fields.<\/p>\n Personalized Learning:<\/strong> With LangGraph we can also build personalized or customized learning systems which will adjust the content based on the learner. This will help the learner understand the weaker area and then recommend resources based on that. This creates a personalized learning experience, improving engagement and outcomes.<\/p>\n Streamlining Business Tasks:<\/strong> LangGraph can also help us in automating business processes. With this document approval and project management can be automated and also the agent can also be used to analyze data. Automation helps in increasing productivity and reduces human error, allowing teams to focus on higher-level tasks.<\/p>\nUnderstanding LangGraph<\/h2>\n
![\"LangGraph](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/sjaf030qvifnk9ko17z6.webp\")
<\/figure>\nKey Concepts of LangGraph<\/h2>\n
1. Graph Structures<\/h3>\n
\n
\n
2. State Management<\/h3>\n
3. Multi-agent Systems<\/h3>\n
Architectures in Multi-agent Systems<\/h4>\n
![\"\"](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/frtawnmwoclycbbvzss4.webp\")
from langchain_openai import ChatOpenAI\nfrom langgraph.types import Command\nfrom langgraph.graph import StateGraph\n\nmodel = ChatOpenAI()\n\ndef agent_1(state) -> Command:\n response = model.invoke(...)\n return Command(goto=response[\"next_agent\"], update={\"messages\": [response[\"content\"]]})\n\nbuilder = StateGraph()\nbuilder.add_node(agent_1)\nbuilder.compile()\n<\/code><\/pre>\ndef supervisor(state) -> Command:\n response = model.invoke(...)\n return Command(goto=response[\"next_agent\"])\n\nbuilder = StateGraph()\nbuilder.add_node(supervisor)\nbuilder.compile()<\/code><\/pre>\ndef agent_1(state):\n response = model.invoke(...)\n return response.content<\/code><\/pre>\ndef top_level_supervisor(state):\n response = model.invoke(...)\n return Command(goto=response[\"next_team\"])\n\nbuilder = StateGraph()\nbuilder.add_node(top_level_supervisor)\nbuilder.compile()<\/code><\/pre>\ndef agent(state) -> Command:\n goto = get_next_agent(...)\n return Command(goto=goto, update={\"my_state_key\": \"my_state_value\"})<\/code><\/pre>\ndef some_node_inside_alice(state):\n return Command(goto=\"bob\", graph=Command.PARENT)<\/code><\/pre>\n4. Persistence<\/h3>\n
![\"Persistence](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/sim24timpx9ogme53yxl.webp\")
\n
config = {\"configurable\": {\"thread_id\": \"1\"}}\n<\/code><\/pre>\ngraph.get_state({\"configurable\": {\"thread_id\": \"1\"}})\n<\/code><\/pre>\ngraph.get_state({\n \"configurable\": {\n \"thread_id\": \"1\", \n \"checkpoint_id\": \"your_checkpoint_id\"\n }\n})\n<\/code><\/pre>\nhistory = graph.get_state_history({\"configurable\": {\"thread_id\": \"1\"}})<\/code><\/pre>\ngraph.update_state(\n config={\"configurable\": {\"thread_id\": \"1\"}},\n values={\"foo\": \"new_value\"}\n)\n<\/code><\/pre>\n5. Human-in-the-Loop Integration<\/h3>\n
![\"Human-in-the-loop](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/glro39hrthujo3xino0u.webp\")
from langgraph.types import interrupt, Command\n\ndef human_node(state):\n value = interrupt({\"text_to_revise\": state[\"some_text\"]})\n return {\"some_text\": value}\n\ngraph = graph_builder.compile(checkpointer=checkpointer)\ngraph.invoke(some_input, config={\"configurable\": {\"thread_id\": \"some_id\"}})\ngraph.invoke(Command(resume=\"Edited text\"), config={\"configurable\": {\"thread_id\": \"some_id\"}})<\/code><\/pre>\n6. Streaming<\/h3>\n
\n
for stream_type, data in graph.stream(inputs, stream_mode=[\"updates\", \"messages\"]):\n if stream_type == \"messages\":\n print(data[0].content) # AIMessageChunk\n elif stream_type == \"updates\":\n print(data) # State update\n<\/code><\/pre>\nWhy Use LangGraph?<\/h2>\n
\n
Building the Simplest Graph<\/h2>\n
![\"building](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/uxfs09bmvnibwie5lvie.webp\")
<\/figure>\nStep 1: Define the Graph State<\/h3>\n
from typing_extensions import TypedDict\nclass State(TypedDict):\n graph_state: str<\/code><\/pre>\nStep 2: Create the Nodes<\/h3>\n
def node_1(state):\n print(\"---Node 1---\")\n return {\"graph_state\": state['graph_state'] + \" I am\"}<\/code><\/pre>\ndef node_2(state):\n print(\"---Node 2---\")\n return {\"graph_state\": state['graph_state'] + \" extremely happy!\"}\n\ndef node_3(state):\n print(\"---Node 3---\")\n return {\"graph_state\": state['graph_state'] + \" extremely sad!\"}<\/code><\/pre>\nStep 3: Add Conditional Logic<\/h3>\n
import random\nfrom typing import Literal\n\ndef decide_mood(state) -> Literal[\"node_2\", \"node_3\"]:\n if random.random() <\/code><\/pre>\nStep 4: Construct the Graph<\/h3>\n
from IPython.display import Image, display\nfrom langgraph.graph import StateGraph, START, END\n\n# Initialize the graph with the state schema\nbuilder = StateGraph(State)\n\n# Add nodes to the graph\nbuilder.add_node(\"node_1\", node_1)\nbuilder.add_node(\"node_2\", node_2)\nbuilder.add_node(\"node_3\", node_3)<\/code><\/pre>\n# Add edges to define flow\nbuilder.add_edge(START, \"node_1\")\nbuilder.add_conditional_edges(\"node_1\", decide_mood)\nbuilder.add_edge(\"node_2\", END)\nbuilder.add_edge(\"node_3\", END)\n\n# Compile and visualize the graph\ngraph = builder.compile()\ndisplay(Image(graph.get_graph().draw_mermaid_png()))\n<\/code><\/pre>\n![\"Construct](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/bszsrfpirhhnsanym2zh.webp\")
<\/figure>\nStep 5: Invoke the Graph<\/h3>\n
graph.invoke({\"graph_state\" : \"Hi, this is Janvi.\"})\n<\/code><\/pre>\n\n
![\"LangChain](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/LangChain-output.webp\")
<\/figure>\nBuilding a Support Chatbot with LangGraph Using OpenAI<\/h2>\n
Setup<\/h3>\n
!pip install -U langgraph langchain openai<\/code><\/pre>\n\n
import getpass\nimport os\n\ndef _set_env(var: str):\n if not os.environ.get(var):\n os.environ[var] = getpass.getpass(f\"{var}: \")\n\n_set_env(\"OPENAI_API_KEY\")\n<\/code><\/pre>\nPart 1: Build a Basic Chatbot<\/h3>\n
1. Define State<\/h4>\n
from typing import Annotated\nfrom typing_extensions import TypedDict\nfrom langgraph.graph import StateGraph, START, END\nfrom langgraph.graph.messae import add_messages\n\nclass State(TypedDict):\n # 'messages' holds the list of chat messages.\n # 'add_messages' ensures new messages are added, not replaced.\n messages: Annotated[list, add_messages]\n<\/code><\/pre>\n2. Create Graph Builder<\/h4>\n
graph_builder = StateGraph(State)\n<\/code><\/pre>\n3. Add Chatbot Node<\/h4>\n
import openai\n\n# Initialize OpenAI GPT model\nopenai.api_key = os.environ[\"OPENAI_API_KEY\"]\n\ndef chatbot(state: State):\n response = openai.Completion.create(\n model=\"gpt-4\", # You can also use \"gpt-3.5-turbo\" or any other OpenAI model\n prompt=state[\"messages\"],\n max_tokens=150\n )\n return {\"messages\": [response.choices[0].text.strip()]}\n\ngraph_builder.add_node(\"chatbot\", chatbot)\n<\/code><\/pre>\n4. Set Entry and Exit Points<\/h4>\n
graph_builder.add_edge(START, \"chatbot\")\ngraph_builder.add_edge(\"chatbot\", END)\n<\/code><\/pre>\n5. Compile the Graph<\/h4>\n
graph = graph_builder.compile()\n<\/code><\/pre>\n6. Visualize (Optional)<\/h4>\n
from IPython.display import Image, display\n\ntry:\n display(Image(graph.get_graph().draw_mermaid_png()))\nexcept Exception:\n pass # Optional visualization\n<\/code><\/pre>\n![\"LangGraph](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/tkzjcmb29agzao1rriop.webp\")
<\/figure>\n7. Run the Chatbot<\/h4>\n
def stream_graph_updates(user_input: str):\n for event in graph.stream({\"messages\": [{\"role\": \"user\", \"content\": user_input}]}):\n for value in event.values():\n print(\"Assistant:\", value[\"messages\"][-1].content)\n\n# Loop to chat with the bot\nwhile True:\n try:\n user_input = input(\"User: \")\n if user_input.lower() in [\"quit\", \"exit\", \"q\"]:\n print(\"Goodbye!\")\n break\n stream_graph_updates(user_input)\n except: # Fallback for environments without input()\n user_input = \"What do you know about LangGraph?\"\n print(\"User: \" + user_input)\n stream_graph_updates(user_input)\n break\n<\/code><\/pre>\n![\"Chatbot](\"https:\/\/cdn.analyticsvidhya.com\/wp-content\/uploads\/2025\/05\/wlfxrmjxdirufzfb8cuv-1.webp\")
<\/figure>\nPart 2: Enhancing the Chatbot with Tools<\/h3>\n
1. Install Tool Requirements<\/h4>\n
%pip install -U tavily-python langchain_community\n<\/code><\/pre>\n2. Set Tool API Key<\/h4>\n
_set_env(\"TAVILY_API_KEY\") # Uses the function defined earlier\n<\/code><\/pre>\n3. Define the Tool<\/h4>\n
from langchain_community.tools.tavily_search import TavilySearchResults\n# Create a Tavily search tool instance, limiting to 2 results\ntool = TavilySearchResults(max_results=2)\ntools = [tool] # List of tools the bot can use\n<\/code><\/pre>\nPart 3: Add Memory to the Chatbot<\/h3>\n
Add Checkpointer<\/h4>\n
from langgraph.checkpoint.memory import MemorySaver\nmemory = MemorySaver()\n<\/code><\/pre>\nPart 4: Human-in-the-loop<\/h3>\n
Define Human Assistance Tool<\/h4>\n
from langchain_core.tools import tool\nfrom langgraph.types import interrupt\n@tool\ndef human_assistance(query: str) -> str:\n print(f\"Pausing for human assistance regarding: {query}\")\n # interrupt pauses graph execution and waits for input\n human_response = interrupt({\"query\": query})\n return human_response[\"data\"]\n<\/code><\/pre>\nDeploying Your LangGraph Applications<\/h2>\n
Use Cases of LangGraph<\/h2>\n
![\"Janvi](\"https:\/\/av-eks-lekhak.s3.amazonaws.com\/media\/lekhak-profile-images\/converted_image_ToTu2tx.webp\")
<\/p>\n