diff --git a/17-LangGraph/03-Use-Cases/07-LangGraph-Multi-Agent-Supervisor.ipynb b/17-LangGraph/03-Use-Cases/07-LangGraph-Multi-Agent-Supervisor.ipynb
new file mode 100644
index 000000000..31077ef9e
--- /dev/null
+++ b/17-LangGraph/03-Use-Cases/07-LangGraph-Multi-Agent-Supervisor.ipynb
@@ -0,0 +1,807 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Multi-Agent Supervisor\n",
+    "\n",
+    "- Author: [Sungchul Kim](https://github.com/rlatjcj)\n",
+    "- Design:\n",
+    "- Peer Review:\n",
+    "- This is a part of [LangChain Open Tutorial](https://github.com/LangChain-OpenTutorial/LangChain-OpenTutorial)\n",
+    "\n",
+    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/LangChain-OpenTutorial/LangChain-OpenTutorial/blob/main/17-LangGraph/03-Use-Cases/07-LangGraph-Multi-Agent-Supervisor.ipynb) [![Open in GitHub](https://img.shields.io/badge/Open%20in%20GitHub-181717?style=flat-square&logo=github&logoColor=white)](https://github.com/LangChain-OpenTutorial/LangChain-OpenTutorial/blob/main/17-LangGraph/03-Use-Cases/07-LangGraph-Multi-Agent-Supervisor.ipynb)\n",
+    "\n",
+    "## Overview\n",
+    "\n",
+    "In the previous tutorial, we showed how to automatically route messages based on the output of the initial Researcher agent.\n",
+    "However, when there are multiple agents that need to be coordinated, simple branching logic has limitations.\n",
+    "Here, we introduce how to manage agents through [LLM-based Supervisor](https://langchain-ai.github.io/langgraph/concepts/multi_agent/#supervisor) and coordinate the entire team based on the results of each agent node.\n",
+    "\n",
+    "\n",
+    "In this tutorial, we'll explore how to build **a multi-agent system** using **LangGraph** , efficiently coordinate tasks between agents, and manage them through **a Supervisor** .  \n",
+    "We'll cover handling multiple agents simultaneously, managing each agent to perform their role, and properly handling task completion.\n",
+    "\n",
+    "**Key Points** :\n",
+    "- The Supervisor brings together various expert agents and operates them as a single team.\n",
+    "- The Supervisor agent monitors the team's progress and executes logic such as calling appropriate agents for each step or terminating tasks.\n",
+    "\n",
+    "<div align=\"center\">\n",
+    "  <img src=\"./assets/07-langgraph-multi-agent-supervisor.png\"/>\n",
+    "</div>\n",
+    "\n",
+    "**What We'll Cover in This Tutorial**\n",
+    "\n",
+    "- **Setup** : How to install required packages and set up API keys\n",
+    "- **Tool Creation** : Defining tools for agents to use, such as web search and plot generation\n",
+    "- **Helper Utilities** : Defining utility functions needed for creating agent nodes\n",
+    "- **Creating the Supervisor** : Creating a Supervisor that contains logic for selecting Worker nodes and handling task completion\n",
+    "- **Constructing the Graph** : Constructing the complete graph by defining State and Worker nodes\n",
+    "- **Calling the Team** : Calling the graph to see how the multi-agent system actually works\n",
+    "\n",
+    "In this process, we'll use LangGraph's pre-built [create_react_agent](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.chat_agent_executor.create_react_agent) function to simplify each agent node.\n",
+    "\n",
+    "This use of \"advanced agents\" is meant to demonstrate specific design patterns in LangGraph, and can be combined with other basic patterns as needed to achieve optimal results.\n",
+    "\n",
+    "### Table of Contents\n",
+    "\n",
+    "- [Overview](#overview)\n",
+    "- [Environment Setup](#environment-setup)\n",
+    "- [Setting State](#setting-state)\n",
+    "- [Creating Agents](#creating-agents)\n",
+    "- [Constructing the Graph](#constructing-the-graph)\n",
+    "- [Calling the Team](#calling-the-team)\n",
+    "\n",
+    "### References\n",
+    "\n",
+    "- [LangGraph - Multi-Agent - Supervisor](https://langchain-ai.github.io/langgraph/concepts/multi_agent/#supervisor)\n",
+    "\n",
+    "----"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Environment Setup\n",
+    "\n",
+    "Set up the environment. You may refer to [Environment Setup](https://wikidocs.net/257836) for more details.\n",
+    "\n",
+    "**[Note]**\n",
+    "- `langchain-opentutorial` is a package that provides a set of easy-to-use environment setup, useful functions and utilities for tutorials. \n",
+    "- You can checkout the [`langchain-opentutorial`](https://github.com/LangChain-OpenTutorial/langchain-opentutorial-pypi) for more details."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install langchain-opentutorial"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install required packages\n",
+    "from langchain_opentutorial import package\n",
+    "\n",
+    "package.install(\n",
+    "    [\n",
+    "        \"python-dotenv\",\n",
+    "        \"langchain_core\",\n",
+    "        \"langchain_community\",\n",
+    "        \"langchain_openai\",\n",
+    "        \"langchain_experimental\",\n",
+    "        \"langgraph\",\n",
+    "        \"matplotlib\",\n",
+    "    ],\n",
+    "    verbose=False,\n",
+    "    upgrade=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Environment variables have been set successfully.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Set environment variables\n",
+    "from langchain_opentutorial import set_env\n",
+    "\n",
+    "set_env(\n",
+    "    {\n",
+    "        \"OPENAI_API_KEY\": \"\",\n",
+    "        \"LANGCHAIN_API_KEY\": \"\",\n",
+    "        \"TAVILY_API_KEY\": \"\",\n",
+    "        \"LANGCHAIN_TRACING_V2\": \"true\",\n",
+    "        \"LANGCHAIN_ENDPOINT\": \"https://api.smith.langchain.com\",\n",
+    "        \"LANGCHAIN_PROJECT\": \"Multi-Agent-Supervisor\",\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can alternatively set API keys such as `OPENAI_API_KEY` in a `.env` file and load them.\n",
+    "\n",
+    "[Note] This is not necessary if you've already set the required API keys in previous steps."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load API keys from .env file\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv(override=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting State\n",
+    "\n",
+    "Define **state** to be used in the multi-agent system."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import operator\n",
+    "from typing import Annotated, Sequence\n",
+    "\n",
+    "from langchain_core.messages import BaseMessage\n",
+    "from typing_extensions import TypedDict\n",
+    "\n",
+    "\n",
+    "class AgentState(TypedDict):\n",
+    "    \"\"\"Define state to be used in the multi-agent system.\"\"\"\n",
+    "    messages: Annotated[Sequence[BaseMessage], operator.add]  # messages\n",
+    "    next: str  # next agent to route to"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating Agents\n",
+    "\n",
+    "### Creating Tools\n",
+    "\n",
+    "In this example, we'll create agents that use a search engine to perform web research and generate plots.\n",
+    "\n",
+    "Define the tools to be used below.\n",
+    "\n",
+    "- **Research** : Use `TavilySearch` tool to perform web research. To use this tool, you need to set the `TAVILY_API_KEY` . Please refer to [previous tutorial](https://langchain-opentutorial.gitbook.io/langchain-opentutorial/15-agent/01-tools#search-api-tooltavily) for more details.\n",
+    "- **Coder** : Use `PythonREPLTool` tool to run code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.tools.tavily_search import TavilySearchResults\n",
+    "from langchain_experimental.tools import PythonREPLTool\n",
+    "\n",
+    "\n",
+    "# Initialize Tavily search tool that returns up to 5 search results\n",
+    "tavily_tool = TavilySearchResults(max_results=5)\n",
+    "\n",
+    "# Initialize Python REPL tool that runs code locally (may not be safe)\n",
+    "python_repl_tool = PythonREPLTool()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating Utility for Creating Agents\n",
+    "\n",
+    "When building a multi-agent system using LangGraph, **helper functions** play a crucial role in creating and managing agent nodes. These functions enhance code reusability and simplify interactions between agents.\n",
+    "\n",
+    "- **Creating Agent Nodes** : Define functions to create nodes for each agent's role\n",
+    "- **Managing Workflow** : Provide utilities to manage the workflow between agents\n",
+    "- **Error Handling** : Include mechanisms to handle errors that may occur during agent execution"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following is an example of defining a function called `agent_node` .\n",
+    "\n",
+    "This function creates an agent node using the given state and agent. We will call this function later using `functools.partial` ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import HumanMessage\n",
+    "\n",
+    "\n",
+    "# Create an agent node using the specified agent and name\n",
+    "def agent_node(state, agent, name):\n",
+    "    # Call the agent\n",
+    "    agent_response = agent.invoke(state)\n",
+    "    # Convert the last message of the agent to a HumanMessage and return it\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=agent_response[\"messages\"][-1].content, name=name)\n",
+    "        ]\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Below is an example of creating a `research_node` using `functools.partial` ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import functools\n",
+    "\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "from langgraph.prebuilt import create_react_agent\n",
+    "\n",
+    "\n",
+    "# Create a Research Agent\n",
+    "research_agent = create_react_agent(ChatOpenAI(model=\"gpt-4o\"), tools=[tavily_tool])\n",
+    "\n",
+    "# Create a Research Node\n",
+    "research_node = functools.partial(agent_node, agent=research_agent, name=\"Researcher\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "> **Note**\n",
+    ">\n",
+    "> Role of `functools.partial`\n",
+    ">\n",
+    "> `functools.partial` is used to create a new function by fixing some arguments or keyword arguments of an existing function. In other words, it helps simplify commonly used function call patterns.\n",
+    ">\n",
+    "> **Roles**\n",
+    ">\n",
+    "> 1. **Create new function with predefined values** : Returns a new function with some arguments of the existing function pre-specified.\n",
+    "> 2. **Code simplification** : Reduces code duplication by simplifying commonly used function call patterns.\n",
+    "> 3. **Improved readability** : Customizes function behavior for specific tasks to make it more intuitive to use.\n",
+    ">\n",
+    "> **Example code**\n",
+    "> ```python\n",
+    "> research_node = functools.partial(agent_node, agent=research_agent, names=\"Researcher\")\n",
+    "> ```\n",
+    ">\n",
+    "> 1. Assume there is an existing function called `agent_node` .\n",
+    ">    - This function can accept multiple arguments and keyword arguments.\n",
+    ">\n",
+    "> 2. `functools.partial` fixes the values `agent=research_agent` and `names=\"Researcher\"` for this function.\n",
+    ">    - This means that `research_node` no longer needs to specify the `agent` and `names` values when calling `agent_node` .\n",
+    ">    - For example:\n",
+    ">     ```python\n",
+    ">     agent_node(state, agent=research_agent, names=\"Researcher\")\n",
+    ">     ```\n",
+    ">     Instead, you can use:\n",
+    ">     ```python\n",
+    ">     research_node(state)\n",
+    ">     ```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's run the code and check the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'messages': [HumanMessage(content='To code a \"Hello, World!\" program and print it to the terminal, you can use various programming languages. Here\\'s how you can do it in a few popular languages:\\n\\n### Python\\n```python\\nprint(\"Hello, World!\")\\n```\\n\\n### JavaScript (Node.js)\\n```javascript\\nconsole.log(\"Hello, World!\");\\n```\\n\\n### Java\\n```java\\npublic class HelloWorld {\\n    public static void main(String[] args) {\\n        System.out.println(\"Hello, World!\");\\n    }\\n}\\n```\\n\\n### C\\n```c\\n#include <stdio.h>\\n\\nint main() {\\n    printf(\"Hello, World!\\\\n\");\\n    return 0;\\n}\\n```\\n\\n### C++\\n```cpp\\n#include <iostream>\\n\\nint main() {\\n    std::cout << \"Hello, World!\" << std::endl;\\n    return 0;\\n}\\n```\\n\\n### Ruby\\n```ruby\\nputs \"Hello, World!\"\\n```\\n\\n### Bash\\n```bash\\necho \"Hello, World!\"\\n```\\n\\nChoose the language you\\'re most comfortable with or the one you want to learn and execute the code in the respective environment for that language. For example, use a Python interpreter for Python, Node.js for JavaScript, etc.', additional_kwargs={}, response_metadata={}, name='Researcher')]}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "research_node(\n",
+    "    {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=\"Code hello world and print it to the terminal\")\n",
+    "        ]\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating Agent Supervisor\n",
+    "\n",
+    "Create an agent that manages and supervises agents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Literal\n",
+    "\n",
+    "from pydantic import BaseModel\n",
+    "\n",
+    "\n",
+    "# Define the list of member agents\n",
+    "members = [\"Researcher\", \"Coder\"]\n",
+    "\n",
+    "# Define the list of options for selecting the next worker\n",
+    "options_for_next = [\"FINISH\"] + members\n",
+    "\n",
+    "# Define the response model for selecting the next worker: indicates selecting the next worker or completing the task\n",
+    "class RouteResponse(BaseModel):\n",
+    "    next: Literal[*options_for_next]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "\n",
+    "# Define the system prompt: a supervisor tasked with managing a conversation between workers\n",
+    "system_prompt = (\n",
+    "    \"You are a supervisor tasked with managing a conversation between the\"\n",
+    "    \" following workers:  {members}. Given the following user request,\"\n",
+    "    \" respond with the worker to act next. Each worker will perform a\"\n",
+    "    \" task and respond with their results and status. When finished,\"\n",
+    "    \" respond with FINISH.\"\n",
+    ")\n",
+    "\n",
+    "# Create ChatPromptTemplate\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", system_prompt),\n",
+    "        MessagesPlaceholder(variable_name=\"messages\"),\n",
+    "        (\n",
+    "            \"system\",\n",
+    "            \"Given the conversation above, who should act next? \"\n",
+    "            \"Or should we FINISH? Select one of: {options}\",\n",
+    "        ),\n",
+    "    ]\n",
+    ").partial(options=str(options_for_next), members=\", \".join(members))\n",
+    "\n",
+    "# Initialize LLM\n",
+    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
+    "\n",
+    "# Create Supervisor Agent\n",
+    "def supervisor_agent(state):\n",
+    "    # Combine prompt and LLM to create a chain\n",
+    "    supervisor_chain = prompt | llm.with_structured_output(RouteResponse)\n",
+    "    # Call the agent\n",
+    "    return supervisor_chain.invoke(state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Constructing the Graph\n",
+    "\n",
+    "Now, we're ready to build the graph. Below, we'll use the functions we just defined to define `state` and `worker` nodes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import functools\n",
+    "\n",
+    "from langgraph.prebuilt import create_react_agent\n",
+    "\n",
+    "\n",
+    "# Create Research Agent\n",
+    "research_agent = create_react_agent(llm, tools=[tavily_tool])\n",
+    "research_node = functools.partial(agent_node, agent=research_agent, name=\"Researcher\")\n",
+    "\n",
+    "code_system_prompt = \"\"\"\n",
+    "Be sure to use the following font in your code for visualization.\n",
+    "\n",
+    "##### Font Settings #####\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Set universal font settings\n",
+    "plt.rcParams[\"font.family\"] = \"DejaVu Sans\"\n",
+    "plt.rcParams[\"axes.unicode_minus\"] = False  # Prevent minus sign from breaking\n",
+    "\n",
+    "# Set English locale\n",
+    "import locale\n",
+    "locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')\n",
+    "\"\"\"\n",
+    "\n",
+    "# Create Coder Agent\n",
+    "coder_agent = create_react_agent(\n",
+    "    llm,\n",
+    "    tools=[python_repl_tool],\n",
+    "    state_modifier=code_system_prompt,\n",
+    ")\n",
+    "coder_node = functools.partial(agent_node, agent=coder_agent, name=\"Coder\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import END, START, StateGraph\n",
+    "\n",
+    "\n",
+    "# Create graph\n",
+    "workflow = StateGraph(AgentState)\n",
+    "\n",
+    "# Add nodes to the graph\n",
+    "workflow.add_node(\"Researcher\", research_node)\n",
+    "workflow.add_node(\"Coder\", coder_node)\n",
+    "workflow.add_node(\"Supervisor\", supervisor_agent)\n",
+    "\n",
+    "# Add edges from member nodes to the Supervisor node\n",
+    "for member in members:\n",
+    "    workflow.add_edge(member, \"Supervisor\")\n",
+    "\n",
+    "# Add conditional edges\n",
+    "conditional_map = {k: k for k in members}\n",
+    "conditional_map[\"FINISH\"] = END\n",
+    "\n",
+    "def get_next(state):\n",
+    "    return state[\"next\"]\n",
+    "\n",
+    "# Add conditional edges from the Supervisor node\n",
+    "workflow.add_conditional_edges(\"Supervisor\", get_next, conditional_map)\n",
+    "\n",
+    "# Add starting point\n",
+    "workflow.add_edge(START, \"Supervisor\")\n",
+    "\n",
+    "# Compile the graph\n",
+    "graph = workflow.compile(checkpointer=MemorySaver())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Visualize the graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from langchain_opentutorial.graphs import visualize_graph\n",
+    "\n",
+    "visualize_graph(graph)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Calling the Team\n",
+    "\n",
+    "Now, we can check the performance by calling the graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36mSupervisor\u001b[0m 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "\u001b[1;32mnext\u001b[0m:\n",
+      "Researcher\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36magent\u001b[0m in [\u001b[1;33mResearcher\u001b[0m] 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Tool Calls:\n",
+      "  tavily_search_results_json (call_Agr9v67vqXFatamF7EXxEUjP)\n",
+      " Call ID: call_Agr9v67vqXFatamF7EXxEUjP\n",
+      "  Args:\n",
+      "    query: South Korea GDP per capita 2010 to 2024\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36mtools\u001b[0m in [\u001b[1;33mResearcher\u001b[0m] 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: tavily_search_results_json\n",
+      "\n",
+      "[{\"url\": \"https://statisticstimes.com/economy/country/south-korea-gdp-per-capita.php\", \"content\": \"GDP per capita of South Korea According to the IMF World Economic Outlook (October 2024), South Korea's nominal GDP per capita in 2024 is projected to be around $36,132 at current prices. Based on PPP, South Korea's GDP per capita in 2024 is forecast at 62,960 billion international dollars. South Korea ranks 33rd in the world by GDP (nominal) per capita and 29th by GDP (PPP) per capita on the 194 economies list. South Korea is ranked 8th in nominal and 10th in the PPP list among 49 European economies. GDP (Nominal) per capita of South Korea GDP (PPP) per capita of South Korea Year    GDP per capita ($/Int. Year    GDP (Nominal) per capita ($)    GDP (PPP) per capita (Int.\"}, {\"url\": \"https://www.statista.com/statistics/939347/gross-domestic-product-gdp-per-capita-in-south-korea/\", \"content\": \"Annual car sales worldwide 2010-2023, with a forecast for 2024; ... (GDP) per capita in South Korea was forecast to continuously increase between 2024 and 2029 by in total 8,215.6 U.S. dollars\"}, {\"url\": \"https://www.macrotrends.net/global-metrics/countries/KOR/south-korea/gdp-per-capita\", \"content\": \"South Korea gdp per capita for 2023 was $33,121, a 2.24% increase from 2022. South Korea gdp per capita for 2022 was $32,395, a 7.77% decline from 2021. South Korea gdp per capita for 2021 was $35,126, a 10.73% increase from 2020. South Korea gdp per capita for 2020 was $31,721, a 0.57% decline from 2019.\"}, {\"url\": \"https://tradingeconomics.com/south-korea/gdp-per-capita-constant-2000-us-dollar-wb-data.html\", \"content\": \"South Korea - GDP Per Capita (constant 2000 US$) - 2024 Data 2025 Forecast 1960-2023 Historical Interest Rate South Korea - GDP Per Capita (constant 2000 US$)2024 Data 2025 Forecast 1960-2023 Historical GDP per capita (constant 2015 US$) in South Korea was reported at 34121 USD in 2023, according to the World Bank collection of development indicators, compiled from officially recognized sources. South Korea - GDP per capita (constant 2000 US$) - actual values, historical data, forecasts and projections were sourced from the World Bank on December of 2024. GDP GDP GDP Constant Prices GDP Growth Rate GDP Growth Rate YoY Interest Rate Government Debt to GDP Government Spending to GDP Economic Calendar Historical Data News Stream Earnings Releases Credit Ratings Forecasts Markets Currencies Stocks Commodities Bonds Crypto Get Started Ratings\"}, {\"url\": \"https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(PPP)_per_capita\", \"content\": \"A country's gross domestic product (GDP) at purchasing power parity (PPP) per capita is the PPP value of all final goods and services produced within an economy in a given year, divided by the average (or mid-year) population for the same year. This is similar to nominal GDP per capita but adjusted for the cost of living in each country.. In 2023, the estimated average GDP per capita (PPP) of\"}]\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36magent\u001b[0m in [\u001b[1;33mResearcher\u001b[0m] 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Here is the GDP per capita of South Korea from 2010 to 2024 based on the available data:\n",
+      "\n",
+      "- **2010**: $24,000 (approx.)\n",
+      "- **2011**: $25,000 (approx.)\n",
+      "- **2012**: $26,000 (approx.)\n",
+      "- **2013**: $27,000 (approx.)\n",
+      "- **2014**: $28,000 (approx.)\n",
+      "- **2015**: $29,000 (approx.)\n",
+      "- **2016**: $30,000 (approx.)\n",
+      "- **2017**: $31,000 (approx.)\n",
+      "- **2018**: $32,000 (approx.)\n",
+      "- **2019**: $33,000 (approx.)\n",
+      "- **2020**: $31,721\n",
+      "- **2021**: $35,126\n",
+      "- **2022**: $32,395\n",
+      "- **2023**: $33,121\n",
+      "- **2024**: $36,132 (projected)\n",
+      "\n",
+      "This data shows a general upward trend in GDP per capita over the years, with some fluctuations in specific years. The projected GDP per capita for 2024 indicates a continued increase. \n",
+      "\n",
+      "For a visual representation, you can create a line graph using this data, plotting the years on the x-axis and the GDP per capita on the y-axis.\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36mResearcher\u001b[0m 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "Name: Researcher\n",
+      "\n",
+      "Here is the GDP per capita of South Korea from 2010 to 2024 based on the available data:\n",
+      "\n",
+      "- **2010**: $24,000 (approx.)\n",
+      "- **2011**: $25,000 (approx.)\n",
+      "- **2012**: $26,000 (approx.)\n",
+      "- **2013**: $27,000 (approx.)\n",
+      "- **2014**: $28,000 (approx.)\n",
+      "- **2015**: $29,000 (approx.)\n",
+      "- **2016**: $30,000 (approx.)\n",
+      "- **2017**: $31,000 (approx.)\n",
+      "- **2018**: $32,000 (approx.)\n",
+      "- **2019**: $33,000 (approx.)\n",
+      "- **2020**: $31,721\n",
+      "- **2021**: $35,126\n",
+      "- **2022**: $32,395\n",
+      "- **2023**: $33,121\n",
+      "- **2024**: $36,132 (projected)\n",
+      "\n",
+      "This data shows a general upward trend in GDP per capita over the years, with some fluctuations in specific years. The projected GDP per capita for 2024 indicates a continued increase. \n",
+      "\n",
+      "For a visual representation, you can create a line graph using this data, plotting the years on the x-axis and the GDP per capita on the y-axis.\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36mSupervisor\u001b[0m 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "\u001b[1;32mnext\u001b[0m:\n",
+      "Coder\n",
+      "==================================================\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Python REPL can execute arbitrary code. Use with caution.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36magent\u001b[0m in [\u001b[1;33mCoder\u001b[0m] 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Tool Calls:\n",
+      "  Python_REPL (call_9Lc3Q5Vp2vrJwIOy7L9uDwJP)\n",
+      " Call ID: call_9Lc3Q5Vp2vrJwIOy7L9uDwJP\n",
+      "  Args:\n",
+      "    query: import matplotlib.pyplot as plt\n",
+      "\n",
+      "# Data for GDP per capita of South Korea from 2010 to 2024\n",
+      "years = [2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024]\n",
+      "gdp_per_capita = [24000, 25000, 26000, 27000, 28000, 29000, 30000, 31000, 32000, 33000, 31721, 35126, 32395, 33121, 36132]\n",
+      "\n",
+      "# Create the plot\n",
+      "plt.figure(figsize=(10, 6))\n",
+      "plt.plot(years, gdp_per_capita, marker='o', linestyle='-', color='b')\n",
+      "plt.title('GDP per Capita of South Korea (2010-2024)', fontsize=16)\n",
+      "plt.xlabel('Year', fontsize=14)\n",
+      "plt.ylabel('GDP per Capita (USD)', fontsize=14)\n",
+      "plt.xticks(years, rotation=45)\n",
+      "plt.grid(True)\n",
+      "plt.tight_layout()\n",
+      "\n",
+      "# Show the plot\n",
+      "plt.show()\n",
+      "==================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36mtools\u001b[0m in [\u001b[1;33mCoder\u001b[0m] 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: Python_REPL\n",
+      "\n",
+      "\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36magent\u001b[0m in [\u001b[1;33mCoder\u001b[0m] 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Here is the visualization of the GDP per capita of South Korea from 2010 to 2024. The line graph illustrates the general upward trend in GDP per capita over the years, with some fluctuations in specific years. The projected GDP per capita for 2024 indicates a continued increase.\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36mCoder\u001b[0m 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "Name: Coder\n",
+      "\n",
+      "Here is the visualization of the GDP per capita of South Korea from 2010 to 2024. The line graph illustrates the general upward trend in GDP per capita over the years, with some fluctuations in specific years. The projected GDP per capita for 2024 indicates a continued increase.\n",
+      "==================================================\n",
+      "\n",
+      "==================================================\n",
+      "🔄 Node: \u001b[1;36mSupervisor\u001b[0m 🔄\n",
+      "- - - - - - - - - - - - - - - - - - - - - - - - - \n",
+      "\u001b[1;32mnext\u001b[0m:\n",
+      "FINISH\n",
+      "==================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "import uuid\n",
+    "\n",
+    "from langchain_core.runnables import RunnableConfig\n",
+    "from langchain_opentutorial.messages import invoke_graph\n",
+    "\n",
+    "# Set config (recursion limit, thread_id)\n",
+    "config = RunnableConfig(recursion_limit=10, configurable={\"thread_id\": str(uuid.uuid4())})\n",
+    "\n",
+    "# Set input (question)\n",
+    "inputs = {\n",
+    "    \"messages\": [\n",
+    "        HumanMessage(\n",
+    "            content=\"Visualize the GDP per capita of South Korea from 2010 to 2024.\"\n",
+    "        )\n",
+    "    ],\n",
+    "}\n",
+    "\n",
+    "# Run the graph\n",
+    "invoke_graph(graph, inputs, config)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "langchain_tutorial_1",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/17-LangGraph/03-Use-Cases/assets/07-langgraph-multi-agent-supervisor.png b/17-LangGraph/03-Use-Cases/assets/07-langgraph-multi-agent-supervisor.png
new file mode 100644
index 000000000..2dcbf8b8f
Binary files /dev/null and b/17-LangGraph/03-Use-Cases/assets/07-langgraph-multi-agent-supervisor.png differ