Day_3_Building_an_agent_with_LangGraph.ipynb

{
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.10.14",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "toc_visible": true,
      "name": "Day 3 - Building an agent with LangGraph",
      "provenance": [],
      "include_colab_link": true
    },
    "kaggle": {
      "accelerator": "none",
      "dataSources": [],
      "dockerImageVersionId": 30786,
      "isInternetEnabled": true,
      "language": "python",
      "sourceType": "notebook",
      "isGpuEnabled": false
    }
  },
  "nbformat_minor": 0,
  "nbformat": 4,
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nf15/handson-ml/blob/master/Day_3_Building_an_agent_with_LangGraph.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### Copyright 2024 Google LLC."
      ],
      "metadata": {
        "id": "b6e13eef3f5d",
        "jp-MarkdownHeadingCollapsed": true
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# @title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ],
      "metadata": {
        "cellView": "form",
        "id": "d6597b11df14",
        "execution": {
          "iopub.status.busy": "2024-11-08T19:51:22.994279Z",
          "iopub.execute_input": "2024-11-08T19:51:22.994732Z",
          "iopub.status.idle": "2024-11-08T19:51:23.020642Z",
          "shell.execute_reply.started": "2024-11-08T19:51:22.994688Z",
          "shell.execute_reply": "2024-11-08T19:51:23.019234Z"
        },
        "jupyter": {
          "source_hidden": true
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Day 3 - Building an agent with LangGraph and the Gemini API\n",
        "\n",
        "Welcome back to the Kaggle 5-day Generative AI course!\n",
        "\n",
        "In this notebook, you will use [LangGraph](https://www.langchain.com/langgraph) to define a stateful graph-based application built on top of the Gemini API.\n",
        "\n",
        "You will build a simulated cafe ordering system, called BaristaBot. It will provide a looping chat interface to customers where they can order cafe beverages using natural language, and you will build nodes to represent the cafe's live menu and the \"back room\" ordering system.\n",
        "\n",
        "BaristaBot is used in other Gemini API demos, so if you are looking to explore something with a more minimal implementation, check out the [BaristaBot function calling example](https://github.com/google-gemini/cookbook/blob/main/examples/Agents_Function_Calling_Barista_Bot.ipynb) that implements a similar system using only the Gemini API Python SDK and function calling.\n",
        "\n",
        "## **IMPORTANT!**\n",
        "\n",
        "The app built in this notebook takes **user input** using a **text box** ([Python's `input`](https://docs.python.org/3/library/functions.html#input)). These are commented-out to ensure that you can use the `Run all` feature without interruption. Keep an eye out for the steps where you need to uncomment the `.invoke(...)` calls in order to interact with the app.\n",
        "\n",
        "If you wish to save a version of this notebook with `Save and Run all`, you will need to **re-comment** the lines you commented-out to ensure that the notebook can run without human input.\n",
        "\n",
        "## For help\n",
        "\n",
        "**Common issues are covered in the [FAQ and troubleshooting guide](https://www.kaggle.com/code/markishere/day-0-troubleshooting-and-faqs).**"
      ],
      "metadata": {
        "id": "KDnGropl9aiH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Get set up\n",
        "\n",
        "Start by installing and importing the LangGraph SDK and LangChain support for the Gemini API."
      ],
      "metadata": {
        "id": "aKMOcAKnGBPL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%pip install -qU 'langgraph==0.2.45' 'langchain-google-genai==2.0.4'"
      ],
      "metadata": {
        "id": "04fZ8d37ifOS",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:20:50.852076Z",
          "iopub.execute_input": "2024-11-16T00:20:50.852541Z",
          "iopub.status.idle": "2024-11-16T00:21:03.244644Z",
          "shell.execute_reply.started": "2024-11-16T00:20:50.852499Z",
          "shell.execute_reply": "2024-11-16T00:21:03.242969Z"
        },
        "trusted": true,
        "outputId": "b24f6966-fb86-4fe7-a0a3-bbccae700bfa"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "text": "Note: you may need to restart the kernel to use updated packages.\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You may see output containing `ERROR: pip's dependency resolver does not currently take into account all the packages that are installed` - this is OK, the packages are still installed and compatible for this codelab.\n",
        "\n",
        "You do not neeed to restart the kernel."
      ],
      "metadata": {
        "id": "AzaBWaIYfeBl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Set up your API key\n",
        "\n",
        "The `GOOGLE_API_KEY` environment variable can be set to automatically configure the underlying API. This works for both the official Gemini Python SDK and for LangChain/LangGraph.\n",
        "\n",
        "To run the following cell, your API key must be stored it in a [Kaggle secret](https://www.kaggle.com/discussions/product-feedback/114053) named `GOOGLE_API_KEY`.\n",
        "\n",
        "If you don't already have an API key, you can grab one from [AI Studio](https://aistudio.google.com/app/apikey). You can find [detailed instructions in the docs](https://ai.google.dev/gemini-api/docs/api-key).\n",
        "\n",
        "To make the key available through Kaggle secrets, choose `Secrets` from the `Add-ons` menu and follow the instructions to add your key or enable it for this notebook."
      ],
      "metadata": {
        "id": "GecNc73VGfpk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "from kaggle_secrets import UserSecretsClient\n",
        "\n",
        "GOOGLE_API_KEY = UserSecretsClient().get_secret(\"GOOGLE_API_KEY\")\n",
        "os.environ[\"GOOGLE_API_KEY\"] = GOOGLE_API_KEY"
      ],
      "metadata": {
        "id": "xaiioUQni_ga",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:21:18.236291Z",
          "iopub.execute_input": "2024-11-16T00:21:18.236747Z",
          "iopub.status.idle": "2024-11-16T00:21:18.439759Z",
          "shell.execute_reply.started": "2024-11-16T00:21:18.236703Z",
          "shell.execute_reply": "2024-11-16T00:21:18.438587Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you received an error response along the lines of `No user secrets exist for kernel id ...`, then you need to add your API key via `Add-ons`, `Secrets` **and** enable it.\n",
        "\n",
        "![Screenshot of the checkbox to enable GOOGLE_API_KEY secret](https://storage.googleapis.com/kaggle-media/Images/5gdai_sc_3.png)"
      ],
      "metadata": {
        "id": "e67a91692d36"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Key concepts\n",
        "\n",
        "LangGraph applications are built around a **graph** structure. As the developer, you define an application graph that models the state transitions for your application. Your app will define a **state** schema, and an instance of that schema is propagated through the graph.\n",
        "\n",
        "Each **node** in the graph represents an action or step that can be taken. Nodes will make changes to the state in some way through code that you define. These changes can be the result of invoking an LLM, by calling an API, or executing any logic that the node defines.\n",
        "\n",
        "Each **edge** in the graph represents a transition between states, defining the flow of the program. Edge transitions can be fixed, for example if you define a text-only chatbot where output is always displayed to a user, you may always transition from `chatbot -> user`. The transitions can also be conditional, allowing you to add branching (like an `if-else` statement) or looping (like `for` or `while` loops).\n",
        "\n",
        "LangGraph is highly extensible and provides a number of features that are not part of this tutorial, such as memory, persistance and streaming. To better understand the key concepts and philophies behind LangGraph, check out their [Conceptual guides](https://langchain-ai.github.io/langgraph/concepts/) and [High-level overview](https://langchain-ai.github.io/langgraph/concepts/high_level/)."
      ],
      "metadata": {
        "jp-MarkdownHeadingCollapsed": true,
        "id": "1XNzf5MDfeBn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define core instructions\n",
        "\n",
        "State is a fundamental concept for a LangGraph app. A state object is passed between every node and transition in the app. Here you define a state object, `OrderState`, that holds the conversation history, a structured order, and a flag indicating if the customer has finished placing their order. For simplicity, the \"structure\" in this order is just a list of strings, but this can be expanded to any Python data structure.\n",
        "\n",
        "In Python, the LangGraph state object is a Python [dictionary](https://docs.python.org/3/library/stdtypes.html#dict). You can provide a schema for this dictionary by defining it as a [`TypedDict`](https://docs.python.org/3/library/typing.html#typing.TypedDict).\n",
        "\n",
        "Here you also define the system instruction that the Gemini model will use. You can capture tone and style here, as well as the playbook under which the chatbot should operate."
      ],
      "metadata": {
        "id": "IGShelaFLKP0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Annotated\n",
        "from typing_extensions import TypedDict\n",
        "\n",
        "from langgraph.graph.message import add_messages\n",
        "\n",
        "\n",
        "class OrderState(TypedDict):\n",
        "    \"\"\"State representing the customer's order conversation.\"\"\"\n",
        "\n",
        "    # The chat conversation. This preserves the conversation history\n",
        "    # between nodes. The `add_messages` annotation indicates to LangGraph\n",
        "    # that state is updated by appending returned messages, not replacing\n",
        "    # them.\n",
        "    messages: Annotated[list, add_messages]\n",
        "\n",
        "    # The customer's in-progress order.\n",
        "    order: list[str]\n",
        "\n",
        "    # Flag indicating that the order is placed and completed.\n",
        "    finished: bool\n",
        "\n",
        "\n",
        "# The system instruction defines how the chatbot is expected to behave and includes\n",
        "# rules for when to call different functions, as well as rules for the conversation, such\n",
        "# as tone and what is permitted for discussion.\n",
        "BARISTABOT_SYSINT = (\n",
        "    \"system\",  # 'system' indicates the message is a system instruction.\n",
        "    \"You are a BaristaBot, an interactive cafe ordering system. A human will talk to you about the \"\n",
        "    \"available products you have and you will answer any questions about menu items (and only about \"\n",
        "    \"menu items - no off-topic discussion, but you can chat about the products and their history). \"\n",
        "    \"The customer will place an order for 1 or more items from the menu, which you will structure \"\n",
        "    \"and send to the ordering system after confirming the order with the human. \"\n",
        "    \"\\n\\n\"\n",
        "    \"Add items to the customer's order with add_to_order, and reset the order with clear_order. \"\n",
        "    \"To see the contents of the order so far, call get_order (this is shown to you, not the user) \"\n",
        "    \"Always confirm_order with the user (double-check) before calling place_order. Calling confirm_order will \"\n",
        "    \"display the order items to the user and returns their response to seeing the list. Their response may contain modifications. \"\n",
        "    \"Always verify and respond with drink and modifier names from the MENU before adding them to the order. \"\n",
        "    \"If you are unsure a drink or modifier matches those on the MENU, ask a question to clarify or redirect. \"\n",
        "    \"You only have the modifiers listed on the menu. \"\n",
        "    \"Once the customer has finished ordering items, Call confirm_order to ensure it is correct then make \"\n",
        "    \"any necessary updates and then call place_order. Once place_order has returned, thank the user and \"\n",
        "    \"say goodbye!\",\n",
        ")\n",
        "\n",
        "# This is the message with which the system opens the conversation.\n",
        "WELCOME_MSG = \"Welcome to the BaristaBot cafe. Type `q` to quit. How may I serve you today?\""
      ],
      "metadata": {
        "id": "2RJQRlfVjqkJ",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:21:57.832982Z",
          "iopub.execute_input": "2024-11-16T00:21:57.833405Z",
          "iopub.status.idle": "2024-11-16T00:21:58.907277Z",
          "shell.execute_reply.started": "2024-11-16T00:21:57.833367Z",
          "shell.execute_reply": "2024-11-16T00:21:58.905918Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define a single turn chatboot\n",
        "\n",
        "To illustrate how LangGraph works, the following program defines a chatbot node that will execute a single turn in a chat conversation using the instructions supplied.\n",
        "\n",
        "Each node in the graph operates on the state object. The state (a Python dictionary) is passed as a parameter into the node (a function) and the new state is returned. This can be restated as pseudo-code, where `state = node(state)`.\n",
        "\n",
        "Note: For the `chatbot` node, the state is updated by *adding* the new conversation message. The `add_messages` annotation on `OrderState.messages` indicates that messages are *appended* when returned from a node. Typically state is updated by replacement, but this annotation causes `messages` to behave differently."
      ],
      "metadata": {
        "id": "PHkDsSI_NUp7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langgraph.graph import StateGraph, START, END\n",
        "from langchain_google_genai import ChatGoogleGenerativeAI\n",
        "\n",
        "# Try using different models. The `pro` models perform the best, especially\n",
        "# with tool-calling. The `flash` models are super fast, and are a good choice\n",
        "# if you need to use the higher free-tier quota.\n",
        "# Check out the features and quota differences here: https://ai.google.dev/pricing\n",
        "llm = ChatGoogleGenerativeAI(model=\"gemini-1.5-flash-latest\")\n",
        "\n",
        "\n",
        "def chatbot(state: OrderState) -> OrderState:\n",
        "    \"\"\"The chatbot itself. A simple wrapper around the model's own chat interface.\"\"\"\n",
        "    message_history = [BARISTABOT_SYSINT] + state[\"messages\"]\n",
        "    return {\"messages\": [llm.invoke(message_history)]}\n",
        "\n",
        "\n",
        "# Set up the initial graph based on our state definition.\n",
        "graph_builder = StateGraph(OrderState)\n",
        "\n",
        "# Add the chatbot function to the app graph as a node called \"chatbot\".\n",
        "graph_builder.add_node(\"chatbot\", chatbot)\n",
        "\n",
        "# Define the chatbot node as the app entrypoint.\n",
        "graph_builder.add_edge(START, \"chatbot\")\n",
        "\n",
        "chat_graph = graph_builder.compile()"
      ],
      "metadata": {
        "id": "Y359hoepjv6i",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:22:18.23321Z",
          "iopub.execute_input": "2024-11-16T00:22:18.233786Z",
          "iopub.status.idle": "2024-11-16T00:22:20.087575Z",
          "shell.execute_reply.started": "2024-11-16T00:22:18.233742Z",
          "shell.execute_reply": "2024-11-16T00:22:20.086279Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It can be helpful to visualise the graph you just defined. The following code renders the graph."
      ],
      "metadata": {
        "id": "T796a7eMJIjB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import Image, display\n",
        "\n",
        "Image(chat_graph.get_graph().draw_mermaid_png())"
      ],
      "metadata": {
        "id": "JP4vPWb1kPhG",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:22:32.208705Z",
          "iopub.execute_input": "2024-11-16T00:22:32.209366Z",
          "iopub.status.idle": "2024-11-16T00:22:32.277455Z",
          "shell.execute_reply.started": "2024-11-16T00:22:32.209321Z",
          "shell.execute_reply": "2024-11-16T00:22:32.276364Z"
        },
        "trusted": true,
        "outputId": "74fd5a52-0893-4614-eb19-88a599631bb8"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 6,
          "output_type": "execute_result",
          "data": {
            "image/png": "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",
            "text/plain": "<IPython.core.display.Image object>"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that the graph is defined, you can run it. It only has one node, and one transition into that node, so it will transition from `__start__` to `chatbot`, execute the `chatbot` node, and terminate.\n",
        "\n",
        "To run the graph, you call `invoke` and pass an initial state object. In this case it begins with the user's initial message."
      ],
      "metadata": {
        "id": "SZtG6b8vJTSl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pprint import pprint\n",
        "\n",
        "user_msg = \"Hello, what can you do?\"\n",
        "state = chat_graph.invoke({\"messages\": [user_msg]})\n",
        "\n",
        "# The state object contains lots of information. Uncomment the pprint lines to see it all.\n",
        "#pprint(state)\n",
        "\n",
        "# Note that the final state now has 2 messages. Our HumanMessage, and an additional AIMessage.\n",
        "for msg in state[\"messages\"]:\n",
        "    print(f\"{type(msg).__name__}: {msg.content}\")"
      ],
      "metadata": {
        "id": "swkexnSoO3RU",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:22:50.884249Z",
          "iopub.execute_input": "2024-11-16T00:22:50.884704Z",
          "iopub.status.idle": "2024-11-16T00:23:29.193533Z",
          "shell.execute_reply.started": "2024-11-16T00:22:50.884661Z",
          "shell.execute_reply": "2024-11-16T00:23:29.192048Z"
        },
        "trusted": true,
        "outputId": "a1cd6410-6dd1-4177-ea1d-a1b650b96ca7"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "text": "HumanMessage: Hello, what can you do?\nAIMessage: Hello! I'm BaristaBot, your friendly cafe ordering system.  I can help you order from our delicious menu.  What would you like to know or order today?\n\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "You could execute this in a Python loop, but for simplicity, manually invoke one more conversational turn. This second invocation takes the state from the first call and appends another user message to elicit another response from the chatbot."
      ],
      "metadata": {
        "id": "dsczQNk9PVlJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "user_msg = \"Oh great, what kinds of latte can you make?\"\n",
        "\n",
        "state[\"messages\"].append(user_msg)\n",
        "state = chat_graph.invoke(state)\n",
        "\n",
        "# pprint(state)\n",
        "for msg in state[\"messages\"]:\n",
        "    print(f\"{type(msg).__name__}: {msg.content}\")"
      ],
      "metadata": {
        "id": "OKGonO42Pe43",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:23:43.580092Z",
          "iopub.execute_input": "2024-11-16T00:23:43.580514Z",
          "iopub.status.idle": "2024-11-16T00:24:38.034054Z",
          "shell.execute_reply.started": "2024-11-16T00:23:43.580474Z",
          "shell.execute_reply": "2024-11-16T00:24:38.032735Z"
        },
        "trusted": true,
        "outputId": "96b239b1-7fdd-4fc3-8164-c94aef86f34c"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "text": "HumanMessage: Hello, what can you do?\nAIMessage: Hello! I'm BaristaBot, your friendly cafe ordering system.  I can help you order from our delicious menu.  What would you like to know or order today?\n\nHumanMessage: Oh great, what kinds of latte can you make?\nAIMessage: We offer a variety of delicious lattes!  We have our classic Latte, a Caramel Latte, a Vanilla Latte, and a seasonal Pumpkin Spice Latte.  Do any of those sound good to you?\n\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Add a human node\n",
        "\n",
        "Instead of repeatedly running the \"graph\" in a Python loop, you can use LangGraph to loop between nodes.\n",
        "\n",
        "The `human` node will display the last message from the LLM to the user, and then prompt them for their next input. Here this is done using standard Python `print` and `input` functions, but for a real cafe situation, you could render the chat to a display or audio, and accept input from a mic or on-screen keyboard.\n",
        "\n",
        "The `chatbot` node function has also been updated to include the welcome message to start the conversation."
      ],
      "metadata": {
        "id": "v4oN47R89Rx-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain_core.messages.ai import AIMessage\n",
        "\n",
        "\n",
        "def human_node(state: OrderState) -> OrderState:\n",
        "    \"\"\"Display the last model message to the user, and receive the user's input.\"\"\"\n",
        "    last_msg = state[\"messages\"][-1]\n",
        "    print(\"Model:\", last_msg.content)\n",
        "\n",
        "    user_input = input(\"User: \")\n",
        "\n",
        "    # If it looks like the user is trying to quit, flag the conversation\n",
        "    # as over.\n",
        "    if user_input in {\"q\", \"quit\", \"exit\", \"goodbye\"}:\n",
        "        state[\"finished\"] = True\n",
        "\n",
        "    return state | {\"messages\": [(\"user\", user_input)]}\n",
        "\n",
        "\n",
        "def chatbot_with_welcome_msg(state: OrderState) -> OrderState:\n",
        "    \"\"\"The chatbot itself. A wrapper around the model's own chat interface.\"\"\"\n",
        "\n",
        "    if state[\"messages\"]:\n",
        "        # If there are messages, continue the conversation with the Gemini model.\n",
        "        new_output = llm.invoke([BARISTABOT_SYSINT] + state[\"messages\"])\n",
        "    else:\n",
        "        # If there are no messages, start with the welcome message.\n",
        "        new_output = AIMessage(content=WELCOME_MSG)\n",
        "\n",
        "    return state | {\"messages\": [new_output]}\n",
        "\n",
        "\n",
        "# Start building a new graph.\n",
        "graph_builder = StateGraph(OrderState)\n",
        "\n",
        "# Add the chatbot and human nodes to the app graph.\n",
        "graph_builder.add_node(\"chatbot\", chatbot_with_welcome_msg)\n",
        "graph_builder.add_node(\"human\", human_node)\n",
        "\n",
        "# Start with the chatbot again.\n",
        "graph_builder.add_edge(START, \"chatbot\")\n",
        "\n",
        "# The chatbot will always go to the human next.\n",
        "graph_builder.add_edge(\"chatbot\", \"human\");"
      ],
      "metadata": {
        "id": "UtOpn68ospVj",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:25:31.720239Z",
          "iopub.execute_input": "2024-11-16T00:25:31.720659Z",
          "iopub.status.idle": "2024-11-16T00:25:31.731778Z",
          "shell.execute_reply.started": "2024-11-16T00:25:31.720619Z",
          "shell.execute_reply": "2024-11-16T00:25:31.730359Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Before you can run this, note that if you added an edge from `human` back to `chatbot`, the graph will cycle forever as there is no exit condition. One way to break the cycle is to add a check for a human input like `q` or `quit` and use that to break the loop.\n",
        "\n",
        "In LangGraph, this is achieved with a conditional edge. This is similar to a regular graph transition, except a custom function is called to determine which edge to traverse.\n",
        "\n",
        "Conditional edge functions take the state as input, and return a string representing the name of the node to which it will transition."
      ],
      "metadata": {
        "id": "SWXwd1ITUSPF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from typing import Literal\n",
        "\n",
        "\n",
        "def maybe_exit_human_node(state: OrderState) -> Literal[\"chatbot\", \"__end__\"]:\n",
        "    \"\"\"Route to the chatbot, unless it looks like the user is exiting.\"\"\"\n",
        "    if state.get(\"finished\", False):\n",
        "        return END\n",
        "    else:\n",
        "        return \"chatbot\"\n",
        "\n",
        "\n",
        "#graph_builder.add_conditional_edges(\"human\", maybe_exit_human_node)\n",
        "\n",
        "chat_with_human_graph = graph_builder.compile()\n",
        "\n",
        "Image(chat_with_human_graph.get_graph().draw_mermaid_png())"
      ],
      "metadata": {
        "id": "6468OAgSU2He",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:26:06.24597Z",
          "iopub.execute_input": "2024-11-16T00:26:06.246381Z",
          "iopub.status.idle": "2024-11-16T00:26:06.294209Z",
          "shell.execute_reply.started": "2024-11-16T00:26:06.246344Z",
          "shell.execute_reply": "2024-11-16T00:26:06.293032Z"
        },
        "trusted": true,
        "outputId": "1fb14b24-d450-41d4-ff39-22c16a06e64c"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 12,
          "output_type": "execute_result",
          "data": {
            "image/png": "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",
            "text/plain": "<IPython.core.display.Image object>"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Run this new graph to see how the interaction loop is now captured within the graph. Input `quit` to exit the program.\n",
        "\n",
        "**You must uncomment the `.invoke(...)` line to run this step.**"
      ],
      "metadata": {
        "id": "yrQI6-3FS_op"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Remember that this will loop forever, unless you input `q`, `quit` or one of the\n",
        "# other exit terms defined in `human_node`.\n",
        "# Uncomment this line to execute the graph:\n",
        "state = chat_with_human_graph.invoke({\"messages\": []})\n",
        "\n",
        "# Things to try:\n",
        "#  - Just chat! There's no ordering or menu yet.\n",
        "#  - 'q' to exit.\n",
        "\n",
        "# pprint(state)"
      ],
      "metadata": {
        "id": "udGNmyasTGJG",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:33:20.508636Z",
          "iopub.execute_input": "2024-11-16T00:33:20.509131Z",
          "iopub.status.idle": "2024-11-16T00:33:43.584399Z",
          "shell.execute_reply.started": "2024-11-16T00:33:20.509083Z",
          "shell.execute_reply": "2024-11-16T00:33:43.583106Z"
        },
        "trusted": true,
        "outputId": "ffebc14a-ce4a-4246-b843-3c97413a1f22"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "text": "Model: Welcome to the BaristaBot cafe. Type `q` to quit. How may I serve you today?\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  Breakfast please\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Add a \"live\" menu\n",
        "\n",
        "BaristaBot currently has no awareness of the available items at the cafe, so it will hallucinate a menu. One option would be to hard-code a menu into the system prompt. This would work well, but to simulate a system where the menu is more dynamic and could respond to fluctuating stock levels, you will put the menu into a custom tool.\n",
        "\n",
        "There are two types of tools that this system will use. Stateless tools that can be run automatically, and stateful tools that modify the order. The \"get current menu\" tool is stateless, in that it does not make any changes to the live order, so it can be called automatically.\n",
        "\n",
        "In a LangGraph app, you can annotate Python functions as tools by applying the `@tools` annotation.\n",
        "\n"
      ],
      "metadata": {
        "id": "iwDFpJreW66e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain_core.tools import tool\n",
        "\n",
        "\n",
        "@tool\n",
        "def get_menu() -> str:\n",
        "    \"\"\"Provide the latest up-to-date menu.\"\"\"\n",
        "    # Note that this is just hard-coded text, but you could connect this to a live stock\n",
        "    # database, or you could use Gemini's multi-modal capabilities and take live photos of\n",
        "    # your cafe's chalk menu or the products on the counter and assmble them into an input.\n",
        "\n",
        "    return \"\"\"\n",
        "    MENU:\n",
        "    Coffee Drinks:\n",
        "    Espresso\n",
        "    Americano\n",
        "    Cold Brew\n",
        "\n",
        "    Coffee Drinks with Milk:\n",
        "    Latte\n",
        "    Cappuccino\n",
        "    Cortado\n",
        "    Macchiato\n",
        "    Mocha\n",
        "    Flat White\n",
        "\n",
        "    Tea Drinks:\n",
        "    English Breakfast Tea\n",
        "    Green Tea\n",
        "    Earl Grey\n",
        "\n",
        "    Tea Drinks with Milk:\n",
        "    Chai Latte\n",
        "    Matcha Latte\n",
        "    London Fog\n",
        "\n",
        "    Other Drinks:\n",
        "    Steamer\n",
        "    Hot Chocolate\n",
        "\n",
        "    Modifiers:\n",
        "    Milk options: Whole, 2%, Oat, Almond, 2% Lactose Free; Default option: whole\n",
        "    Espresso shots: Single, Double, Triple, Quadruple; default: Double\n",
        "    Caffeine: Decaf, Regular; default: Regular\n",
        "    Hot-Iced: Hot, Iced; Default: Hot\n",
        "    Sweeteners (option to add one or more): vanilla sweetener, hazelnut sweetener, caramel sauce, chocolate sauce, sugar free vanilla sweetener\n",
        "    Special requests: any reasonable modification that does not involve items not on the menu, for example: 'extra hot', 'one pump', 'half caff', 'extra foam', etc.\n",
        "\n",
        "    \"dirty\" means add a shot of espresso to a drink that doesn't usually have it, like \"Dirty Chai Latte\".\n",
        "    \"Regular milk\" is the same as 'whole milk'.\n",
        "    \"Sweetened\" means add some regular sugar, not a sweetener.\n",
        "\n",
        "    Soy milk has run out of stock today, so soy is not available.\n",
        "  \"\"\""
      ],
      "metadata": {
        "id": "hG1n6mNFHsYW",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:34:26.376399Z",
          "iopub.execute_input": "2024-11-16T00:34:26.376874Z",
          "iopub.status.idle": "2024-11-16T00:34:26.39024Z",
          "shell.execute_reply.started": "2024-11-16T00:34:26.376803Z",
          "shell.execute_reply": "2024-11-16T00:34:26.388829Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now add the new tool to the graph. The `get_menu` tool is wrapped in a [`ToolNode`](https://langchain-ai.github.io/langgraph/reference/prebuilt/#toolnode) that handles calling the tool and passing the response as a message through the graph. The tools are also bound to the `llm` object so that the underlying model knows they exist. As you now have a different `llm` object to invoke, you need to update the `chatbot` node so that it is aware of the tools.\n"
      ],
      "metadata": {
        "id": "W82wDfAH-RMU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from langgraph.prebuilt import ToolNode\n",
        "\n",
        "\n",
        "# Define the tools and create a \"tools\" node.\n",
        "tools = [get_menu]\n",
        "tool_node = ToolNode(tools)\n",
        "\n",
        "# Attach the tools to the model so that it knows what it can call.\n",
        "llm_with_tools = llm.bind_tools(tools)\n",
        "\n",
        "\n",
        "def maybe_route_to_tools(state: OrderState) -> Literal[\"tools\", \"human\"]:\n",
        "    \"\"\"Route between human or tool nodes, depending if a tool call is made.\"\"\"\n",
        "    if not (msgs := state.get(\"messages\", [])):\n",
        "        raise ValueError(f\"No messages found when parsing state: {state}\")\n",
        "\n",
        "    # Only route based on the last message.\n",
        "    msg = msgs[-1]\n",
        "\n",
        "    # When the chatbot returns tool_calls, route to the \"tools\" node.\n",
        "    if hasattr(msg, \"tool_calls\") and len(msg.tool_calls) > 0:\n",
        "        return \"tools\"\n",
        "    else:\n",
        "        return \"human\"\n",
        "\n",
        "\n",
        "def chatbot_with_tools(state: OrderState) -> OrderState:\n",
        "    \"\"\"The chatbot with tools. A simple wrapper around the model's own chat interface.\"\"\"\n",
        "    defaults = {\"order\": [], \"finished\": False}\n",
        "\n",
        "    if state[\"messages\"]:\n",
        "        new_output = llm_with_tools.invoke([BARISTABOT_SYSINT] + state[\"messages\"])\n",
        "    else:\n",
        "        new_output = AIMessage(content=WELCOME_MSG)\n",
        "\n",
        "    # Set up some defaults if not already set, then pass through the provided state,\n",
        "    # overriding only the \"messages\" field.\n",
        "    return defaults | state | {\"messages\": [new_output]}\n",
        "\n",
        "\n",
        "graph_builder = StateGraph(OrderState)\n",
        "\n",
        "# Add the nodes, including the new tool_node.\n",
        "graph_builder.add_node(\"chatbot\", chatbot_with_tools)\n",
        "graph_builder.add_node(\"human\", human_node)\n",
        "graph_builder.add_node(\"tools\", tool_node)\n",
        "\n",
        "# Chatbot may go to tools, or human.\n",
        "graph_builder.add_conditional_edges(\"chatbot\", maybe_route_to_tools)\n",
        "# Human may go back to chatbot, or exit.\n",
        "graph_builder.add_conditional_edges(\"human\", maybe_exit_human_node)\n",
        "\n",
        "# Tools always route back to chat afterwards.\n",
        "graph_builder.add_edge(\"tools\", \"chatbot\")\n",
        "\n",
        "graph_builder.add_edge(START, \"chatbot\")\n",
        "graph_with_menu = graph_builder.compile()\n",
        "\n",
        "Image(graph_with_menu.get_graph().draw_mermaid_png())"
      ],
      "metadata": {
        "id": "KJVZGC2TlKqj",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:35:00.101697Z",
          "iopub.execute_input": "2024-11-16T00:35:00.102147Z",
          "iopub.status.idle": "2024-11-16T00:35:00.348856Z",
          "shell.execute_reply.started": "2024-11-16T00:35:00.102105Z",
          "shell.execute_reply": "2024-11-16T00:35:00.347659Z"
        },
        "trusted": true,
        "outputId": "24f6b4aa-4c18-4def-888a-acf72715e341"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 18,
          "output_type": "execute_result",
          "data": {
            "image/png": "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",
            "text/plain": "<IPython.core.display.Image object>"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now run the new graph to see how the model uses the menu.\n",
        "\n",
        "**You must uncomment the `.invoke(...)` line to run this step.**"
      ],
      "metadata": {
        "id": "kbFdxxWdauzz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Remember that you have not implemented ordering yet, so this will loop forever,\n",
        "# unless you input `q`, `quit` or one of the other exit terms defined in the\n",
        "# `human_node`.\n",
        "# Uncomment this line to execute the graph:\n",
        "state = graph_with_menu.invoke({\"messages\": []})\n",
        "\n",
        "# Things to try:\n",
        "# - I'd love an espresso drink, what have you got?\n",
        "# - What teas do you have?\n",
        "# - Can you do a long black? (this is on the menu as an \"Americano\" - see if it can figure it out)\n",
        "# - 'q' to exit.\n",
        "\n",
        "\n",
        "# pprint(state)"
      ],
      "metadata": {
        "id": "wcsVkMAApBGu",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:35:59.720174Z",
          "iopub.execute_input": "2024-11-16T00:35:59.720618Z",
          "iopub.status.idle": "2024-11-16T00:40:49.26373Z",
          "shell.execute_reply.started": "2024-11-16T00:35:59.720564Z",
          "shell.execute_reply": "2024-11-16T00:40:49.262384Z"
        },
        "trusted": true,
        "outputId": "0984e451-3456-4a88-f135-8fc2ad4ea9eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "text": "Model: Welcome to the BaristaBot cafe. Type `q` to quit. How may I serve you today?\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  Breakfast with egg and chease\n"
        },
        {
          "name": "stdout",
          "text": "Model: I am sorry, I cannot fulfill that request. We do not have breakfast sandwiches on our menu.  Would you like to order something else?\n\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  what do you have for breakfast?\n"
        },
        {
          "name": "stdout",
          "text": "Model: I'm sorry, we don't currently have any breakfast items on our menu.  Would you like to see what else we have to offer?\n\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  yes\n"
        },
        {
          "name": "stdout",
          "text": "Model: Okay, here is our menu:\n\nCoffee Drinks: Espresso, Americano, Cold Brew\n\nCoffee Drinks with Milk: Latte, Cappuccino, Cortado, Macchiato, Mocha, Flat White\n\nTea Drinks: English Breakfast Tea, Green Tea, Earl Grey\n\nTea Drinks with Milk: Chai Latte, Matcha Latte, London Fog\n\nOther Drinks: Steamer, Hot Chocolate\n\nModifiers:  Milk options: Whole, 2%, Oat, Almond, 2% Lactose Free (Default: whole); Espresso shots: Single, Double, Triple, Quadruple (Default: Double); Caffeine: Decaf, Regular (Default: Regular); Hot-Iced: Hot, Iced (Default: Hot); Sweeteners (option to add one or more): vanilla sweetener, hazelnut sweetener, caramel sauce, chocolate sauce, sugar free vanilla sweetener; Special requests: any reasonable modification that does not involve items not on the menu, for example: 'extra hot', 'one pump', 'half caff', 'extra foam', etc.  \"dirty\" means add a shot of espresso. \"Regular milk\" is the same as 'whole milk'. \"Sweetened\" means add some regular sugar.  Soy milk is currently unavailable.\n\nWhat would you like to order?\n\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  q\n"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Handle orders\n",
        "\n",
        "To build up an order during the chat conversation, you will need to update the state to track the order, and provide simple tools that update this state. These need to be explicit as the model should not directly have access to the apps internal state, or it risks being manipulated arbitrarily.\n",
        "\n",
        "The ordering tools will be added as stubs in a separate node so that you can edit the state directly. Using the `@tool` annotation is still a handy way to define their schema, so the ordering tools below are implemented as empty Python functions."
      ],
      "metadata": {
        "id": "ikO4M2fZDkyx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections.abc import Iterable\n",
        "from random import randint\n",
        "\n",
        "from langgraph.prebuilt import InjectedState\n",
        "from langchain_core.messages.tool import ToolMessage\n",
        "\n",
        "# These functions have no body; LangGraph does not allow @tools to update\n",
        "# the conversation state, so you will implement a separate node to handle\n",
        "# state updates. Using @tools is still very convenient for defining the tool\n",
        "# schema, so empty functions have been defined that will be bound to the LLM\n",
        "# but their implementation is deferred to the order_node.\n",
        "\n",
        "\n",
        "@tool\n",
        "def add_to_order(drink: str, modifiers: Iterable[str]) -> str:\n",
        "    \"\"\"Adds the specified drink to the customer's order, including any modifiers.\n",
        "\n",
        "    Returns:\n",
        "      The updated order in progress.\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "@tool\n",
        "def confirm_order() -> str:\n",
        "    \"\"\"Asks the customer if the order is correct.\n",
        "\n",
        "    Returns:\n",
        "      The user's free-text response.\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "@tool\n",
        "def get_order() -> str:\n",
        "    \"\"\"Returns the users order so far. One item per line.\"\"\"\n",
        "\n",
        "\n",
        "@tool\n",
        "def clear_order():\n",
        "    \"\"\"Removes all items from the user's order.\"\"\"\n",
        "\n",
        "\n",
        "@tool\n",
        "def place_order() -> int:\n",
        "    \"\"\"Sends the order to the barista for fulfillment.\n",
        "\n",
        "    Returns:\n",
        "      The estimated number of minutes until the order is ready.\n",
        "    \"\"\"\n",
        "\n",
        "\n",
        "def order_node(state: OrderState) -> OrderState:\n",
        "    \"\"\"The ordering node. This is where the order state is manipulated.\"\"\"\n",
        "    tool_msg = state.get(\"messages\", [])[-1]\n",
        "    order = state.get(\"order\", [])\n",
        "    outbound_msgs = []\n",
        "    order_placed = False\n",
        "\n",
        "    for tool_call in tool_msg.tool_calls:\n",
        "\n",
        "        if tool_call[\"name\"] == \"add_to_order\":\n",
        "\n",
        "            # Each order item is just a string. This is where it assembled as \"drink (modifiers, ...)\".\n",
        "            modifiers = tool_call[\"args\"][\"modifiers\"]\n",
        "            modifier_str = \", \".join(modifiers) if modifiers else \"no modifiers\"\n",
        "\n",
        "            order.append(f'{tool_call[\"args\"][\"drink\"]} ({modifier_str})')\n",
        "            response = \"\\n\".join(order)\n",
        "\n",
        "        elif tool_call[\"name\"] == \"confirm_order\":\n",
        "\n",
        "            # We could entrust the LLM to do order confirmation, but it is a good practice to\n",
        "            # show the user the exact data that comprises their order so that what they confirm\n",
        "            # precisely matches the order that goes to the kitchen - avoiding hallucination\n",
        "            # or reality skew.\n",
        "\n",
        "            # In a real scenario, this is where you would connect your POS screen to show the\n",
        "            # order to the user.\n",
        "\n",
        "            print(\"Your order:\")\n",
        "            if not order:\n",
        "                print(\"  (no items)\")\n",
        "\n",
        "            for drink in order:\n",
        "                print(f\"  {drink}\")\n",
        "\n",
        "            response = input(\"Is this correct? \")\n",
        "\n",
        "        elif tool_call[\"name\"] == \"get_order\":\n",
        "\n",
        "            response = \"\\n\".join(order) if order else \"(no order)\"\n",
        "\n",
        "        elif tool_call[\"name\"] == \"clear_order\":\n",
        "\n",
        "            order.clear()\n",
        "            response = None\n",
        "\n",
        "        elif tool_call[\"name\"] == \"place_order\":\n",
        "\n",
        "            order_text = \"\\n\".join(order)\n",
        "            print(\"Sending order to kitchen!\")\n",
        "            print(order_text)\n",
        "\n",
        "            # TODO(you!): Implement cafe.\n",
        "            order_placed = True\n",
        "            response = randint(1, 5)  # ETA in minutes\n",
        "\n",
        "        else:\n",
        "            raise NotImplementedError(f'Unknown tool call: {tool_call[\"name\"]}')\n",
        "\n",
        "        # Record the tool results as tool messages.\n",
        "        outbound_msgs.append(\n",
        "            ToolMessage(\n",
        "                content=response,\n",
        "                name=tool_call[\"name\"],\n",
        "                tool_call_id=tool_call[\"id\"],\n",
        "            )\n",
        "        )\n",
        "\n",
        "    return {\"messages\": outbound_msgs, \"order\": order, \"finished\": order_placed}\n",
        "\n",
        "\n",
        "def maybe_route_to_tools(state: OrderState) -> str:\n",
        "    \"\"\"Route between chat and tool nodes if a tool call is made.\"\"\"\n",
        "    if not (msgs := state.get(\"messages\", [])):\n",
        "        raise ValueError(f\"No messages found when parsing state: {state}\")\n",
        "\n",
        "    msg = msgs[-1]\n",
        "\n",
        "    if state.get(\"finished\", False):\n",
        "        # When an order is placed, exit the app. The system instruction indicates\n",
        "        # that the chatbot should say thanks and goodbye at this point, so we can exit\n",
        "        # cleanly.\n",
        "        return END\n",
        "\n",
        "    elif hasattr(msg, \"tool_calls\") and len(msg.tool_calls) > 0:\n",
        "        # Route to `tools` node for any automated tool calls first.\n",
        "        if any(\n",
        "            tool[\"name\"] in tool_node.tools_by_name.keys() for tool in msg.tool_calls\n",
        "        ):\n",
        "            return \"tools\"\n",
        "        else:\n",
        "            return \"ordering\"\n",
        "\n",
        "    else:\n",
        "        return \"human\""
      ],
      "metadata": {
        "id": "jqsLovPBQe0I",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:42:57.432602Z",
          "iopub.execute_input": "2024-11-16T00:42:57.433028Z",
          "iopub.status.idle": "2024-11-16T00:42:57.475185Z",
          "shell.execute_reply.started": "2024-11-16T00:42:57.432985Z",
          "shell.execute_reply": "2024-11-16T00:42:57.473959Z"
        },
        "trusted": true
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now define the graph. The LLM needs to know about the tools too, so that it can invoke them. Here you set up 2 sets of tools corresponding to the nodes under which they operate: automated and ordering."
      ],
      "metadata": {
        "id": "UzfKW3lkxtS_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Auto-tools will be invoked automatically by the ToolNode\n",
        "auto_tools = [get_menu]\n",
        "tool_node = ToolNode(auto_tools)\n",
        "\n",
        "# Order-tools will be handled by the order node.\n",
        "order_tools = [add_to_order, confirm_order, get_order, clear_order, place_order]\n",
        "\n",
        "# The LLM needs to know about all of the tools, so specify everything here.\n",
        "llm_with_tools = llm.bind_tools(auto_tools + order_tools)\n",
        "\n",
        "\n",
        "graph_builder = StateGraph(OrderState)\n",
        "\n",
        "# Nodes\n",
        "graph_builder.add_node(\"chatbot\", chatbot_with_tools)\n",
        "graph_builder.add_node(\"human\", human_node)\n",
        "graph_builder.add_node(\"tools\", tool_node)\n",
        "graph_builder.add_node(\"ordering\", order_node)\n",
        "\n",
        "# Chatbot -> {ordering, tools, human, END}\n",
        "graph_builder.add_conditional_edges(\"chatbot\", maybe_route_to_tools)\n",
        "# Human -> {chatbot, END}\n",
        "graph_builder.add_conditional_edges(\"human\", maybe_exit_human_node)\n",
        "\n",
        "# Tools (both kinds) always route back to chat afterwards.\n",
        "graph_builder.add_edge(\"tools\", \"chatbot\")\n",
        "graph_builder.add_edge(\"ordering\", \"chatbot\")\n",
        "\n",
        "graph_builder.add_edge(START, \"chatbot\")\n",
        "graph_with_order_tools = graph_builder.compile()\n",
        "\n",
        "Image(graph_with_order_tools.get_graph().draw_mermaid_png())"
      ],
      "metadata": {
        "id": "9rqkQzlZxrzp",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:45:56.456237Z",
          "iopub.execute_input": "2024-11-16T00:45:56.457228Z",
          "iopub.status.idle": "2024-11-16T00:45:56.535579Z",
          "shell.execute_reply.started": "2024-11-16T00:45:56.45717Z",
          "shell.execute_reply": "2024-11-16T00:45:56.534283Z"
        },
        "trusted": true,
        "outputId": "7dc7083d-64ee-424d-a070-223add0f45c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "execution_count": 22,
          "output_type": "execute_result",
          "data": {
            "image/png": "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",
            "text/plain": "<IPython.core.display.Image object>"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now run the complete ordering system graph.\n",
        "\n",
        "**You must uncomment the `.invoke(...)` line to run this step.**"
      ],
      "metadata": {
        "id": "G0SVsDu4gD_T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# The default recursion limit for traversing nodes is 25 - setting it higher\n",
        "# means you can try a more complex order with multiple steps and round-trips.\n",
        "config = {\"recursion_limit\": 100}\n",
        "\n",
        "# Uncomment this line to execute the graph:\n",
        "state = graph_with_order_tools.invoke({\"messages\": []}, config)\n",
        "\n",
        "# Things to try:\n",
        "# - Order a drink!\n",
        "# - Make a change to your order.\n",
        "# - \"Which teas are from England?\"\n",
        "# - Note that the graph should naturally exit after placing an order.\n",
        "\n",
        "# pprint(state)"
      ],
      "metadata": {
        "id": "NCRSgaBUfIHF",
        "execution": {
          "iopub.status.busy": "2024-11-16T00:51:07.740542Z",
          "iopub.execute_input": "2024-11-16T00:51:07.741418Z",
          "iopub.status.idle": "2024-11-16T01:00:02.685304Z",
          "shell.execute_reply.started": "2024-11-16T00:51:07.741367Z",
          "shell.execute_reply": "2024-11-16T01:00:02.684143Z"
        },
        "trusted": true,
        "outputId": "8e5f7eb1-a686-4adc-e6dd-7aa55cfe1af3"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "text": "Model: Welcome to the BaristaBot cafe. Type `q` to quit. How may I serve you today?\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  Order a drink!\n"
        },
        {
          "name": "stdout",
          "text": "Model: What would you like to order?  I have Espresso, Americano, Cold Brew, Latte, Cappuccino, Cortado, Macchiato, Mocha, Flat White, English Breakfast Tea, Green Tea, Earl Grey, Chai Latte, Matcha Latte, London Fog, Steamer, and Hot Chocolate.  I can also make modifications to your drink.  Please tell me your order, including the drink and any modifications you'd like.\n\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  Macchiato\n"
        },
        {
          "name": "stdout",
          "text": "Model: Okay, a Macchiato. What kind of milk would you like?  Your options are Whole, 2%, Oat, Almond, and 2% Lactose Free.  And would you like a single, double, triple, or quadruple shot of espresso?  Do you want it Hot or Iced?  Any other modifications?\n\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  2%, double shot, Hot\n"
        },
        {
          "name": "stdout",
          "text": "Model: Okay, one Macchiato, 2% milk, double shot, hot. Anything else?\n\n\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  That's it\n"
        },
        {
          "name": "stdout",
          "text": "Model: Okay, so you'd like one Macchiato with 2% milk, a double shot of espresso, hot. Is that correct?\n\n\n\n",
          "output_type": "stream"
        },
        {
          "output_type": "stream",
          "name": "stdin",
          "text": "User:  Yes\n"
        },
        {
          "name": "stdout",
          "text": "Sending order to kitchen!\nMacchiato (2% milk, double shot, Hot)\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The order state has been captured both in the `place_order` function and in the final conversational state returned from executing the graph. This iillustrates how you can integrate your own systems to a graph app, as well as collect the final results of executing such an app."
      ],
      "metadata": {
        "id": "8KM4-akgEVSZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Uncomment this once you have run the graph from the previous cell.\n",
        "pprint(state[\"order\"])"
      ],
      "metadata": {
        "id": "n4jUJCr3fJpy",
        "execution": {
          "iopub.status.busy": "2024-11-16T01:00:02.811719Z",
          "iopub.execute_input": "2024-11-16T01:00:02.812855Z",
          "iopub.status.idle": "2024-11-16T01:00:02.818668Z",
          "shell.execute_reply.started": "2024-11-16T01:00:02.812771Z",
          "shell.execute_reply": "2024-11-16T01:00:02.817227Z"
        },
        "trusted": true,
        "outputId": "8dcc0c97-6be4-4df9-a7a8-88af60ad43f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "text": "['Macchiato (2% milk, double shot, Hot)']\n",
          "output_type": "stream"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Further exercises\n",
        "\n",
        "Congratulations on building an agentic, human-in-the-loop, natural-language powered cafe ordering system using LangGraph and the Gemini API!\n",
        "\n",
        "This example app could be taken in many different directions. You should try and build out your own ideas, but for some inspiration, consider:\n",
        "\n",
        "* Adding more structure the order (`OrderState.order`) - e.g. separate fields for item, modifiers and even quantity.\n",
        "* Currently the model can only clear and re-add items, so add a function to `remove_item`s from the order.\n",
        "* Try building a UI that displays the in-progress order and hosts the chat. Frameworks like [Gradio](https://www.gradio.app/) or [Mesop](https://google.github.io/mesop/) are great for this.\n",
        "\n",
        "This system works well for a single person ordering, but agentic systems can interact with many sources. For a big stretch exercise, try and extend this app to run at a specific schedule, and contact your friends or colleagues over [Chat](https://developers.google.com/workspace/chat/api/reference/rest) to collect their daily coffee orders."
      ],
      "metadata": {
        "id": "1BV4euQjRR4w"
      }
    }
  ]
}