32_memory_agent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Memory Agent\n",
    "\n",
    "## Review\n",
    "\n",
    "We created a chatbot that saves semantic memories to a single [user profile](https://langchain-ai.github.io/langgraph/concepts/memory/#profile) or [collection](https://langchain-ai.github.io/langgraph/concepts/memory/#collection).\n",
    "\n",
    "We introduced [Trustcall](https://github.com/hinthornw/trustcall) as a way to update either schema.\n",
    "\n",
    "## Goals\n",
    "\n",
    "Now, we're going to pull together the pieces we've learned to build an [agent](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/) with long-term memory.\n",
    "\n",
    "Our agent, `task_mAIstro`, will help us manage a ToDo list! \n",
    "\n",
    "The chatbots we built previously *always* reflected on the conversation and saved memories. \n",
    "\n",
    "`task_mAIstro` will decide *when* to save memories (items to our ToDo list).\n",
    "\n",
    "The chatbots we built previously always saved one type of memory, a profile or a collection. \n",
    "\n",
    "`task_mAIstro` can decide to save to either a user profile or a collection of ToDo items.\n",
    "\n",
    "In addition semantic memory, `task_mAIstro` also will manage procedural memory.\n",
    "\n",
    "This allows the user to update their preferences for creating ToDo items. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr\n",
    "%pip install -U langchain_openai langgraph trustcall langchain_core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from google.colab import userdata\n",
    "\n",
    "os.environ[\"LANGCHAIN_API_KEY\"] = userdata.get('LANGCHAIN_API_KEY')\n",
    "\n",
    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
    "os.environ[\"LANGCHAIN_PROJECT\"] = \"langchain-academy\"\n",
    "\n",
    "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visibility into Trustcall updates\n",
    "\n",
    "Trustcall creates and updates JSON schemas.\n",
    "\n",
    "What if we want visibility into the *specific changes* made by Trustcall?\n",
    "\n",
    "For example, we saw before that Trustcall has some of its own tools to:\n",
    "\n",
    "* Self-correct from validation failures -- [see trace example here](https://smith.langchain.com/public/5cd23009-3e05-4b00-99f0-c66ee3edd06e/r/9684db76-2003-443b-9aa2-9a9dbc5498b7) \n",
    "* Update existing documents -- [see trace example here](https://smith.langchain.com/public/f45bdaf0-6963-4c19-8ec9-f4b7fe0f68ad/r/760f90e1-a5dc-48f1-8c34-79d6a3414ac3)\n",
    "\n",
    "Visibility into these tools can be useful for the agent we're going to build.\n",
    "\n",
    "Below, we'll show how to do this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel, Field\n",
    "\n",
    "class Memory(BaseModel):\n",
    "    content: str = Field(description=\"The main content of the memory. For example: User expressed interest in learning about French.\")\n",
    "\n",
    "class MemoryCollection(BaseModel):\n",
    "    memories: list[Memory] = Field(description=\"A list of memories about the user.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can add a [listener](https://python.langchain.com/docs/how_to/lcel_cheatsheet/#add-lifecycle-listeners) to the Trustcall extractor.\n",
    "\n",
    "This will pass runs from the extractor's execution to a class, `Spy`, that we will define.\n",
    "\n",
    "Our `Spy` class will extract information about what tool calls were made by Trustcall."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from trustcall import create_extractor\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "# Inspect the tool calls made by Trustcall\n",
    "class Spy:\n",
    "    def __init__(self):\n",
    "        self.called_tools = []\n",
    "\n",
    "    def __call__(self, run):\n",
    "        # Collect information about the tool calls made by the extractor.\n",
    "        q = [run]\n",
    "        while q:\n",
    "            r = q.pop()\n",
    "            if r.child_runs:\n",
    "                q.extend(r.child_runs)\n",
    "            if r.run_type == \"chat_model\":\n",
    "                self.called_tools.append(\n",
    "                    r.outputs[\"generations\"][0][0][\"message\"][\"kwargs\"][\"tool_calls\"]\n",
    "                )\n",
    "\n",
    "# Initialize the spy\n",
    "spy = Spy()\n",
    "\n",
    "# Initialize the model\n",
    "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
    "\n",
    "# Create the extractor\n",
    "trustcall_extractor = create_extractor(\n",
    "    model,\n",
    "    tools=[Memory],\n",
    "    tool_choice=\"Memory\",\n",
    "    enable_inserts=True,\n",
    ")\n",
    "\n",
    "# Add the spy as a listener\n",
    "trustcall_extractor_see_all_tool_calls = trustcall_extractor.with_listeners(on_end=spy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.messages import HumanMessage, SystemMessage, AIMessage\n",
    "\n",
    "# Instruction\n",
    "instruction = \"\"\"Extract memories from the following conversation:\"\"\"\n",
    "\n",
    "# Conversation\n",
    "conversation = [HumanMessage(content=\"Hi, I'm Lance.\"), \n",
    "                AIMessage(content=\"Nice to meet you, Lance.\"), \n",
    "                HumanMessage(content=\"This morning I had a nice bike ride in San Francisco.\")]\n",
    "\n",
    "# Invoke the extractor\n",
    "result = trustcall_extractor.invoke({\"messages\": [SystemMessage(content=instruction)] + conversation})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  Memory (call_NkjwwJGjrgxHzTb7KwD8lTaH)\n",
      " Call ID: call_NkjwwJGjrgxHzTb7KwD8lTaH\n",
      "  Args:\n",
      "    content: Lance had a nice bike ride in San Francisco this morning.\n"
     ]
    }
   ],
   "source": [
    "# Messages contain the tool calls\n",
    "for m in result[\"messages\"]:\n",
    "    m.pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "content='Lance had a nice bike ride in San Francisco this morning.'\n"
     ]
    }
   ],
   "source": [
    "# Responses contain the memories that adhere to the schema\n",
    "for m in result[\"responses\"]: \n",
    "    print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'id': 'call_NkjwwJGjrgxHzTb7KwD8lTaH'}\n"
     ]
    }
   ],
   "source": [
    "# Metadata contains the tool call  \n",
    "for m in result[\"response_metadata\"]: \n",
    "    print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('0',\n",
       "  'Memory',\n",
       "  {'content': 'Lance had a nice bike ride in San Francisco this morning.'})]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Update the conversation\n",
    "updated_conversation = [AIMessage(content=\"That's great, did you do after?\"), \n",
    "                        HumanMessage(content=\"I went to Tartine and ate a croissant.\"),                        \n",
    "                        AIMessage(content=\"What else is on your mind?\"),\n",
    "                        HumanMessage(content=\"I was thinking about my Japan, and going back this winter!\"),]\n",
    "\n",
    "# Update the instruction\n",
    "system_msg = \"\"\"Update existing memories and create new ones based on the following conversation:\"\"\"\n",
    "\n",
    "# We'll save existing memories, giving them an ID, key (tool name), and value\n",
    "tool_name = \"Memory\"\n",
    "existing_memories = [(str(i), tool_name, memory.model_dump()) for i, memory in enumerate(result[\"responses\"])] if result[\"responses\"] else None\n",
    "existing_memories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Invoke the extractor with our updated conversation and existing memories\n",
    "result = trustcall_extractor_see_all_tool_calls.invoke({\"messages\": updated_conversation, \n",
    "                                                        \"existing\": existing_memories})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'id': 'call_bF0w0hE4YZmGyDbuJVe1mh5H', 'json_doc_id': '0'}\n",
      "{'id': 'call_fQAxxRypV914Xev6nJ9VKw3X'}\n"
     ]
    }
   ],
   "source": [
    "# Metadata contains the tool call  \n",
    "for m in result[\"response_metadata\"]: \n",
    "    print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  Memory (call_bF0w0hE4YZmGyDbuJVe1mh5H)\n",
      " Call ID: call_bF0w0hE4YZmGyDbuJVe1mh5H\n",
      "  Args:\n",
      "    content: Lance had a nice bike ride in San Francisco this morning. Afterward, he went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.\n",
      "  Memory (call_fQAxxRypV914Xev6nJ9VKw3X)\n",
      " Call ID: call_fQAxxRypV914Xev6nJ9VKw3X\n",
      "  Args:\n",
      "    content: Lance went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.\n"
     ]
    }
   ],
   "source": [
    "# Messages contain the tool calls\n",
    "for m in result[\"messages\"]:\n",
    "    m.pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "content='Lance had a nice bike ride in San Francisco this morning. Afterward, he went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.'\n",
      "content='Lance went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.'\n"
     ]
    }
   ],
   "source": [
    "# Parsed responses\n",
    "for m in result[\"responses\"]:\n",
    "    print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[{'name': 'PatchDoc',\n",
       "   'args': {'json_doc_id': '0',\n",
       "    'planned_edits': '1. Replace the existing content with the updated memory that includes the new activities: going to Tartine for a croissant and thinking about going back to Japan this winter.',\n",
       "    'patches': [{'op': 'replace',\n",
       "      'path': '/content',\n",
       "      'value': 'Lance had a nice bike ride in San Francisco this morning. Afterward, he went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.'}]},\n",
       "   'id': 'call_bF0w0hE4YZmGyDbuJVe1mh5H',\n",
       "   'type': 'tool_call'},\n",
       "  {'name': 'Memory',\n",
       "   'args': {'content': 'Lance went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.'},\n",
       "   'id': 'call_fQAxxRypV914Xev6nJ9VKw3X',\n",
       "   'type': 'tool_call'}]]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inspect the tool calls made by Trustcall\n",
    "spy.called_tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Document 0 updated:\n",
      "Plan: 1. Replace the existing content with the updated memory that includes the new activities: going to Tartine for a croissant and thinking about going back to Japan this winter.\n",
      "Added content: Lance had a nice bike ride in San Francisco this morning. Afterward, he went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.\n",
      "\n",
      "New Memory created:\n",
      "Content: {'content': 'Lance went to Tartine and ate a croissant. He was also thinking about his trip to Japan and going back this winter.'}\n"
     ]
    }
   ],
   "source": [
    "def extract_tool_info(tool_calls, schema_name=\"Memory\"):\n",
    "    \"\"\"Extract information from tool calls for both patches and new memories.\n",
    "    \n",
    "    Args:\n",
    "        tool_calls: List of tool calls from the model\n",
    "        schema_name: Name of the schema tool (e.g., \"Memory\", \"ToDo\", \"Profile\")\n",
    "    \"\"\"\n",
    "\n",
    "    # Initialize list of changes\n",
    "    changes = []\n",
    "    \n",
    "    for call_group in tool_calls:\n",
    "        for call in call_group:\n",
    "            if call['name'] == 'PatchDoc':\n",
    "                changes.append({\n",
    "                    'type': 'update',\n",
    "                    'doc_id': call['args']['json_doc_id'],\n",
    "                    'planned_edits': call['args']['planned_edits'],\n",
    "                    'value': call['args']['patches'][0]['value']\n",
    "                })\n",
    "            elif call['name'] == schema_name:\n",
    "                changes.append({\n",
    "                    'type': 'new',\n",
    "                    'value': call['args']\n",
    "                })\n",
    "\n",
    "    # Format results as a single string\n",
    "    result_parts = []\n",
    "    for change in changes:\n",
    "        if change['type'] == 'update':\n",
    "            result_parts.append(\n",
    "                f\"Document {change['doc_id']} updated:\\n\"\n",
    "                f\"Plan: {change['planned_edits']}\\n\"\n",
    "                f\"Added content: {change['value']}\"\n",
    "            )\n",
    "        else:\n",
    "            result_parts.append(\n",
    "                f\"New {schema_name} created:\\n\"\n",
    "                f\"Content: {change['value']}\"\n",
    "            )\n",
    "    \n",
    "    return \"\\n\\n\".join(result_parts)\n",
    "\n",
    "# Inspect spy.called_tools to see exactly what happened during the extraction\n",
    "schema_name = \"Memory\"\n",
    "changes = extract_tool_info(spy.called_tools, schema_name)\n",
    "print(changes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating an agent\n",
    "\n",
    "There are many different [agent](https://langchain-ai.github.io/langgraph/concepts/high_level/) architectures to choose from.\n",
    "\n",
    "Here, we'll implement something simple, a [ReAct](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation) agent.\n",
    "\n",
    "This agent will be a helpful companion for creating and managing a ToDo list.\n",
    "\n",
    "This agent can make a decision to update three types of long-term memory: \n",
    "\n",
    "(a) Create or update a user `profile` with general user information \n",
    "\n",
    "(b) Add or update items in a ToDo list `collection`\n",
    "\n",
    "(c) Update its own `instructions` on how to update items to the ToDo list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import TypedDict, Literal\n",
    "\n",
    "# Update memory tool\n",
    "class UpdateMemory(TypedDict):\n",
    "    \"\"\" Decision on what memory type to update \"\"\"\n",
    "    update_type: Literal['user', 'todo', 'instructions']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "_set_env(\"OPENAI_API_KEY\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph definition \n",
    "\n",
    "We add a simple router, `route_message`, that makes a binary decision to save memories.\n",
    "\n",
    "The memory collection updating is handled by `Trustcall` in the `write_memory` node, as before!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import uuid\n",
    "from IPython.display import Image, display\n",
    "\n",
    "from datetime import datetime\n",
    "from trustcall import create_extractor\n",
    "from typing import Optional\n",
    "from pydantic import BaseModel, Field\n",
    "\n",
    "from langchain_core.runnables import RunnableConfig\n",
    "from langchain_core.messages import merge_message_runs, HumanMessage, SystemMessage\n",
    "\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "from langgraph.graph import StateGraph, MessagesState, END, START\n",
    "from langgraph.store.base import BaseStore\n",
    "from langgraph.store.memory import InMemoryStore\n",
    "\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "# Initialize the model\n",
    "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
    "\n",
    "# User profile schema\n",
    "class Profile(BaseModel):\n",
    "    \"\"\"This is the profile of the user you are chatting with\"\"\"\n",
    "    name: Optional[str] = Field(description=\"The user's name\", default=None)\n",
    "    location: Optional[str] = Field(description=\"The user's location\", default=None)\n",
    "    job: Optional[str] = Field(description=\"The user's job\", default=None)\n",
    "    connections: list[str] = Field(\n",
    "        description=\"Personal connection of the user, such as family members, friends, or coworkers\",\n",
    "        default_factory=list\n",
    "    )\n",
    "    interests: list[str] = Field(\n",
    "        description=\"Interests that the user has\", \n",
    "        default_factory=list\n",
    "    )\n",
    "\n",
    "# ToDo schema\n",
    "class ToDo(BaseModel):\n",
    "    task: str = Field(description=\"The task to be completed.\")\n",
    "    time_to_complete: Optional[int] = Field(description=\"Estimated time to complete the task (minutes).\")\n",
    "    deadline: Optional[datetime] = Field(\n",
    "        description=\"When the task needs to be completed by (if applicable)\",\n",
    "        default=None\n",
    "    )\n",
    "    solutions: list[str] = Field(\n",
    "        description=\"List of specific, actionable solutions (e.g., specific ideas, service providers, or concrete options relevant to completing the task)\",\n",
    "        min_items=1,\n",
    "        default_factory=list\n",
    "    )\n",
    "    status: Literal[\"not started\", \"in progress\", \"done\", \"archived\"] = Field(\n",
    "        description=\"Current status of the task\",\n",
    "        default=\"not started\"\n",
    "    )\n",
    "\n",
    "# Create the Trustcall extractor for updating the user profile \n",
    "profile_extractor = create_extractor(\n",
    "    model,\n",
    "    tools=[Profile],\n",
    "    tool_choice=\"Profile\",\n",
    ")\n",
    "\n",
    "# Chatbot instruction for choosing what to update and what tools to call \n",
    "MODEL_SYSTEM_MESSAGE = \"\"\"You are a helpful chatbot. \n",
    "\n",
    "You are designed to be a companion to a user, helping them keep track of their ToDo list.\n",
    "\n",
    "You have a long term memory which keeps track of three things:\n",
    "1. The user's profile (general information about them) \n",
    "2. The user's ToDo list\n",
    "3. General instructions for updating the ToDo list\n",
    "\n",
    "Here is the current User Profile (may be empty if no information has been collected yet):\n",
    "<user_profile>\n",
    "{user_profile}\n",
    "</user_profile>\n",
    "\n",
    "Here is the current ToDo List (may be empty if no tasks have been added yet):\n",
    "<todo>\n",
    "{todo}\n",
    "</todo>\n",
    "\n",
    "Here are the current user-specified preferences for updating the ToDo list (may be empty if no preferences have been specified yet):\n",
    "<instructions>\n",
    "{instructions}\n",
    "</instructions>\n",
    "\n",
    "Here are your instructions for reasoning about the user's messages:\n",
    "\n",
    "1. Reason carefully about the user's messages as presented below. \n",
    "\n",
    "2. Decide whether any of the your long-term memory should be updated:\n",
    "- If personal information was provided about the user, update the user's profile by calling UpdateMemory tool with type `user`\n",
    "- If tasks are mentioned, update the ToDo list by calling UpdateMemory tool with type `todo`\n",
    "- If the user has specified preferences for how to update the ToDo list, update the instructions by calling UpdateMemory tool with type `instructions`\n",
    "\n",
    "3. Tell the user that you have updated your memory, if appropriate:\n",
    "- Do not tell the user you have updated the user's profile\n",
    "- Tell the user them when you update the todo list\n",
    "- Do not tell the user that you have updated instructions\n",
    "\n",
    "4. Err on the side of updating the todo list. No need to ask for explicit permission.\n",
    "\n",
    "5. Respond naturally to user user after a tool call was made to save memories, or if no tool call was made.\"\"\"\n",
    "\n",
    "# Trustcall instruction\n",
    "TRUSTCALL_INSTRUCTION = \"\"\"Reflect on following interaction. \n",
    "\n",
    "Use the provided tools to retain any necessary memories about the user. \n",
    "\n",
    "Use parallel tool calling to handle updates and insertions simultaneously.\n",
    "\n",
    "System Time: {time}\"\"\"\n",
    "\n",
    "# Instructions for updating the ToDo list\n",
    "CREATE_INSTRUCTIONS = \"\"\"Reflect on the following interaction.\n",
    "\n",
    "Based on this interaction, update your instructions for how to update ToDo list items. \n",
    "\n",
    "Use any feedback from the user to update how they like to have items added, etc.\n",
    "\n",
    "Your current instructions are:\n",
    "\n",
    "<current_instructions>\n",
    "{current_instructions}\n",
    "</current_instructions>\"\"\"\n",
    "\n",
    "# Node definitions\n",
    "def task_mAIstro(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Load memories from the store and use them to personalize the chatbot's response.\"\"\"\n",
    "    \n",
    "    # Get the user ID from the config\n",
    "    user_id = config[\"configurable\"][\"user_id\"]\n",
    "\n",
    "    # Retrieve profile memory from the store\n",
    "    namespace = (\"profile\", user_id)\n",
    "    memories = store.search(namespace)\n",
    "    if memories:\n",
    "        user_profile = memories[0].value\n",
    "    else:\n",
    "        user_profile = None\n",
    "\n",
    "    # Retrieve task memory from the store\n",
    "    namespace = (\"todo\", user_id)\n",
    "    memories = store.search(namespace)\n",
    "    todo = \"\\n\".join(f\"{mem.value}\" for mem in memories)\n",
    "\n",
    "    # Retrieve custom instructions\n",
    "    namespace = (\"instructions\", user_id)\n",
    "    memories = store.search(namespace)\n",
    "    if memories:\n",
    "        instructions = memories[0].value\n",
    "    else:\n",
    "        instructions = \"\"\n",
    "    \n",
    "    system_msg = MODEL_SYSTEM_MESSAGE.format(user_profile=user_profile, todo=todo, instructions=instructions)\n",
    "\n",
    "    # Respond using memory as well as the chat history\n",
    "    response = model.bind_tools([UpdateMemory], parallel_tool_calls=False).invoke([SystemMessage(content=system_msg)]+state[\"messages\"])\n",
    "\n",
    "    return {\"messages\": [response]}\n",
    "\n",
    "def update_profile(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Reflect on the chat history and update the memory collection.\"\"\"\n",
    "    \n",
    "    # Get the user ID from the config\n",
    "    user_id = config[\"configurable\"][\"user_id\"]\n",
    "\n",
    "    # Define the namespace for the memories\n",
    "    namespace = (\"profile\", user_id)\n",
    "\n",
    "    # Retrieve the most recent memories for context\n",
    "    existing_items = store.search(namespace)\n",
    "\n",
    "    # Format the existing memories for the Trustcall extractor\n",
    "    tool_name = \"Profile\"\n",
    "    existing_memories = ([(existing_item.key, tool_name, existing_item.value)\n",
    "                          for existing_item in existing_items]\n",
    "                          if existing_items\n",
    "                          else None\n",
    "                        )\n",
    "\n",
    "    # Merge the chat history and the instruction\n",
    "    TRUSTCALL_INSTRUCTION_FORMATTED=TRUSTCALL_INSTRUCTION.format(time=datetime.now().isoformat())\n",
    "    updated_messages=list(merge_message_runs(messages=[SystemMessage(content=TRUSTCALL_INSTRUCTION_FORMATTED)] + state[\"messages\"][:-1]))\n",
    "\n",
    "    # Invoke the extractor\n",
    "    result = profile_extractor.invoke({\"messages\": updated_messages, \n",
    "                                         \"existing\": existing_memories})\n",
    "\n",
    "    # Save the memories from Trustcall to the store\n",
    "    for r, rmeta in zip(result[\"responses\"], result[\"response_metadata\"]):\n",
    "        store.put(namespace,\n",
    "                  rmeta.get(\"json_doc_id\", str(uuid.uuid4())),\n",
    "                  r.model_dump(mode=\"json\"),\n",
    "            )\n",
    "    tool_calls = state['messages'][-1].tool_calls\n",
    "    return {\"messages\": [{\"role\": \"tool\", \"content\": \"updated profile\", \"tool_call_id\":tool_calls[0]['id']}]}\n",
    "\n",
    "def update_todos(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Reflect on the chat history and update the memory collection.\"\"\"\n",
    "    \n",
    "    # Get the user ID from the config\n",
    "    user_id = config[\"configurable\"][\"user_id\"]\n",
    "\n",
    "    # Define the namespace for the memories\n",
    "    namespace = (\"todo\", user_id)\n",
    "\n",
    "    # Retrieve the most recent memories for context\n",
    "    existing_items = store.search(namespace)\n",
    "\n",
    "    # Format the existing memories for the Trustcall extractor\n",
    "    tool_name = \"ToDo\"\n",
    "    existing_memories = ([(existing_item.key, tool_name, existing_item.value)\n",
    "                          for existing_item in existing_items]\n",
    "                          if existing_items\n",
    "                          else None\n",
    "                        )\n",
    "\n",
    "    # Merge the chat history and the instruction\n",
    "    TRUSTCALL_INSTRUCTION_FORMATTED=TRUSTCALL_INSTRUCTION.format(time=datetime.now().isoformat())\n",
    "    updated_messages=list(merge_message_runs(messages=[SystemMessage(content=TRUSTCALL_INSTRUCTION_FORMATTED)] + state[\"messages\"][:-1]))\n",
    "\n",
    "    # Initialize the spy for visibility into the tool calls made by Trustcall\n",
    "    spy = Spy()\n",
    "    \n",
    "    # Create the Trustcall extractor for updating the ToDo list \n",
    "    todo_extractor = create_extractor(\n",
    "    model,\n",
    "    tools=[ToDo],\n",
    "    tool_choice=tool_name,\n",
    "    enable_inserts=True\n",
    "    ).with_listeners(on_end=spy)\n",
    "\n",
    "    # Invoke the extractor\n",
    "    result = todo_extractor.invoke({\"messages\": updated_messages, \n",
    "                                    \"existing\": existing_memories})\n",
    "\n",
    "    # Save the memories from Trustcall to the store\n",
    "    for r, rmeta in zip(result[\"responses\"], result[\"response_metadata\"]):\n",
    "        store.put(namespace,\n",
    "                  rmeta.get(\"json_doc_id\", str(uuid.uuid4())),\n",
    "                  r.model_dump(mode=\"json\"),\n",
    "            )\n",
    "        \n",
    "    # Respond to the tool call made in task_mAIstro, confirming the update\n",
    "    tool_calls = state['messages'][-1].tool_calls\n",
    "\n",
    "    # Extract the changes made by Trustcall and add the the ToolMessage returned to task_mAIstro\n",
    "    todo_update_msg = extract_tool_info(spy.called_tools, tool_name)\n",
    "    return {\"messages\": [{\"role\": \"tool\", \"content\": todo_update_msg, \"tool_call_id\":tool_calls[0]['id']}]}\n",
    "\n",
    "def update_instructions(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Reflect on the chat history and update the memory collection.\"\"\"\n",
    "    \n",
    "    # Get the user ID from the config\n",
    "    user_id = config[\"configurable\"][\"user_id\"]\n",
    "    \n",
    "    namespace = (\"instructions\", user_id)\n",
    "\n",
    "    existing_memory = store.get(namespace, \"user_instructions\")\n",
    "        \n",
    "    # Format the memory in the system prompt\n",
    "    system_msg = CREATE_INSTRUCTIONS.format(current_instructions=existing_memory.value if existing_memory else None)\n",
    "    new_memory = model.invoke([SystemMessage(content=system_msg)]+state['messages'][:-1] + [HumanMessage(content=\"Please update the instructions based on the conversation\")])\n",
    "\n",
    "    # Overwrite the existing memory in the store \n",
    "    key = \"user_instructions\"\n",
    "    store.put(namespace, key, {\"memory\": new_memory.content})\n",
    "    tool_calls = state['messages'][-1].tool_calls\n",
    "    return {\"messages\": [{\"role\": \"tool\", \"content\": \"updated instructions\", \"tool_call_id\":tool_calls[0]['id']}]}\n",
    "\n",
    "# Conditional edge\n",
    "def route_message(state: MessagesState, config: RunnableConfig, store: BaseStore) -> Literal[END, \"update_todos\", \"update_instructions\", \"update_profile\"]:\n",
    "\n",
    "    \"\"\"Reflect on the memories and chat history to decide whether to update the memory collection.\"\"\"\n",
    "    message = state['messages'][-1]\n",
    "    if len(message.tool_calls) ==0:\n",
    "        return END\n",
    "    else:\n",
    "        tool_call = message.tool_calls[0]\n",
    "        if tool_call['args']['update_type'] == \"user\":\n",
    "            return \"update_profile\"\n",
    "        elif tool_call['args']['update_type'] == \"todo\":\n",
    "            return \"update_todos\"\n",
    "        elif tool_call['args']['update_type'] == \"instructions\":\n",
    "            return \"update_instructions\"\n",
    "        else:\n",
    "            raise ValueError\n",
    "\n",
    "# Create the graph + all nodes\n",
    "builder = StateGraph(MessagesState)\n",
    "\n",
    "# Define the flow of the memory extraction process\n",
    "builder.add_node(task_mAIstro)\n",
    "builder.add_node(update_todos)\n",
    "builder.add_node(update_profile)\n",
    "builder.add_node(update_instructions)\n",
    "builder.add_edge(START, \"task_mAIstro\")\n",
    "builder.add_conditional_edges(\"task_mAIstro\", route_message)\n",
    "builder.add_edge(\"update_todos\", \"task_mAIstro\")\n",
    "builder.add_edge(\"update_profile\", \"task_mAIstro\")\n",
    "builder.add_edge(\"update_instructions\", \"task_mAIstro\")\n",
    "\n",
    "# Store for long-term (across-thread) memory\n",
    "across_thread_memory = InMemoryStore()\n",
    "\n",
    "# Checkpointer for short-term (within-thread) memory\n",
    "within_thread_memory = MemorySaver()\n",
    "\n",
    "# We compile the graph with the checkpointer and store\n",
    "graph = builder.compile(checkpointer=within_thread_memory, store=across_thread_memory)\n",
    "\n",
    "# View\n",
    "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "My name is Lance. I live in SF with my wife. I have a 1 year old daughter.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UpdateMemory (call_rOuw3bLYjFFKuSVWsIHF27k5)\n",
      " Call ID: call_rOuw3bLYjFFKuSVWsIHF27k5\n",
      "  Args:\n",
      "    update_type: user\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "\n",
      "updated profile\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Got it! How can I assist you today, Lance?\n"
     ]
    }
   ],
   "source": [
    "# We supply a thread ID for short-term (within-thread) memory\n",
    "# We supply a user ID for long-term (across-thread) memory \n",
    "config = {\"configurable\": {\"thread_id\": \"1\", \"user_id\": \"Lance\"}}\n",
    "\n",
    "# User input to create a profile memory\n",
    "input_messages = [HumanMessage(content=\"My name is Lance. I live in SF with my wife. I have a 1 year old daughter.\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "My wife asked me to book swim lessons for the baby.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UpdateMemory (call_VjLbRpbLqniJ8we2CNKQ0m3P)\n",
      " Call ID: call_VjLbRpbLqniJ8we2CNKQ0m3P\n",
      "  Args:\n",
      "    update_type: todo\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "\n",
      "New ToDo created:\n",
      "Content: {'task': 'Book swim lessons for 1-year-old daughter.', 'time_to_complete': 30, 'solutions': ['Check local swim schools in SF', 'Look for baby swim classes online', 'Ask friends for recommendations'], 'status': 'not started'}\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "I've added \"Book swim lessons for your 1-year-old daughter\" to your ToDo list. If you need any help with that, just let me know!\n"
     ]
    }
   ],
   "source": [
    "# User input for a ToDo\n",
    "input_messages = [HumanMessage(content=\"My wife asked me to book swim lessons for the baby.\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "When creating or updating ToDo items, include specific local businesses / vendors.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UpdateMemory (call_22w3V3Krhjf8WxDeH9YrQILa)\n",
      " Call ID: call_22w3V3Krhjf8WxDeH9YrQILa\n",
      "  Args:\n",
      "    update_type: instructions\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "\n",
      "updated instructions\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Got it! I'll make sure to include specific local businesses or vendors in San Francisco when creating or updating your ToDo items. Let me know if there's anything else you need!\n"
     ]
    }
   ],
   "source": [
    "# User input to update instructions for creating ToDos\n",
    "input_messages = [HumanMessage(content=\"When creating or updating ToDo items, include specific local businesses / vendors.\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'memory': '<current_instructions>\\nWhen creating or updating ToDo list items for Lance, include specific local businesses or vendors in San Francisco. For example, when adding a task like booking swim lessons, suggest local swim schools or classes in the area.\\n</current_instructions>'}\n"
     ]
    }
   ],
   "source": [
    "# Check for updated instructions\n",
    "user_id = \"Lance\"\n",
    "\n",
    "# Search \n",
    "for memory in across_thread_memory.search((\"instructions\", user_id)):\n",
    "    print(memory.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "I need to fix the jammed electric Yale lock on the door.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UpdateMemory (call_7ooNemi3d6qWMfjf2g2h97EF)\n",
      " Call ID: call_7ooNemi3d6qWMfjf2g2h97EF\n",
      "  Args:\n",
      "    update_type: todo\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "\n",
      "New ToDo created:\n",
      "Content: {'task': 'Fix the jammed electric Yale lock on the door.', 'time_to_complete': 60, 'solutions': ['Contact a local locksmith in SF', \"Check Yale's customer support for troubleshooting\", 'Look for repair guides online'], 'status': 'not started'}\n",
      "\n",
      "Document ed0af900-52fa-4f15-907c-1aed1e17b0ce updated:\n",
      "Plan: Add specific local businesses or vendors to the solutions for booking swim lessons.\n",
      "Added content: ['Check local swim schools in SF', 'Look for baby swim classes online', 'Ask friends for recommendations', 'Contact La Petite Baleen Swim School', 'Check with SF Recreation and Parks for classes']\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "I've added \"Fix the jammed electric Yale lock on the door\" to your ToDo list. If you need any specific recommendations or help, feel free to ask!\n"
     ]
    }
   ],
   "source": [
    "# User input for a ToDo\n",
    "input_messages = [HumanMessage(content=\"I need to fix the jammed electric Yale lock on the door.\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'task': 'Book swim lessons for 1-year-old daughter.', 'time_to_complete': 30, 'deadline': None, 'solutions': ['Check local swim schools in SF', 'Look for baby swim classes online', 'Ask friends for recommendations', 'Contact La Petite Baleen Swim School', 'Check with SF Recreation and Parks for classes'], 'status': 'not started'}\n",
      "{'task': 'Fix the jammed electric Yale lock on the door.', 'time_to_complete': 60, 'deadline': None, 'solutions': ['Contact a local locksmith in SF', \"Check Yale's customer support for troubleshooting\", 'Look for repair guides online'], 'status': 'not started'}\n"
     ]
    }
   ],
   "source": [
    "# Namespace for the memory to save\n",
    "user_id = \"Lance\"\n",
    "\n",
    "# Search \n",
    "for memory in across_thread_memory.search((\"todo\", user_id)):\n",
    "    print(memory.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "For the swim lessons, I need to get that done by end of November.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UpdateMemory (call_6AbsrTps4EPyD0gKBzkMIC90)\n",
      " Call ID: call_6AbsrTps4EPyD0gKBzkMIC90\n",
      "  Args:\n",
      "    update_type: todo\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "\n",
      "Document ed0af900-52fa-4f15-907c-1aed1e17b0ce updated:\n",
      "Plan: Add a deadline for the swim lessons task to ensure it is completed by the end of November.\n",
      "Added content: 2024-11-30T23:59:59\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "I've updated the swim lessons task with a deadline to be completed by the end of November. If there's anything else you need, just let me know!\n"
     ]
    }
   ],
   "source": [
    "# User input to update an existing ToDo\n",
    "input_messages = [HumanMessage(content=\"For the swim lessons, I need to get that done by end of November.\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that Trustcall performs patching of the existing memory:\n",
    "\n",
    "https://smith.langchain.com/public/4ad3a8af-3b1e-493d-b163-3111aa3d575a/r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "Need to call back City Toyota to schedule car service.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UpdateMemory (call_tDuYZL7njpwOkg2YMEcf6DDJ)\n",
      " Call ID: call_tDuYZL7njpwOkg2YMEcf6DDJ\n",
      "  Args:\n",
      "    update_type: todo\n",
      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
      "\n",
      "New ToDo created:\n",
      "Content: {'task': 'Call back City Toyota to schedule car service.', 'time_to_complete': 10, 'solutions': [\"Find City Toyota's contact number\", 'Check car service availability', 'Prepare car details for service scheduling'], 'status': 'not started'}\n",
      "\n",
      "Document a77482f0-d654-4b41-ab74-d6f2b343a969 updated:\n",
      "Plan: Add specific local businesses or vendors to the solutions for fixing the jammed electric Yale lock.\n",
      "Added content: Contact City Locksmith SF\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "I've added \"Call back City Toyota to schedule car service\" to your ToDo list. If you need any assistance with that, just let me know!\n"
     ]
    }
   ],
   "source": [
    "# User input for a ToDo\n",
    "input_messages = [HumanMessage(content=\"Need to call back City Toyota to schedule car service.\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'task': 'Book swim lessons for 1-year-old daughter.', 'time_to_complete': 30, 'deadline': '2024-11-30T23:59:59', 'solutions': ['Check local swim schools in SF', 'Look for baby swim classes online', 'Ask friends for recommendations', 'Contact La Petite Baleen Swim School', 'Check with SF Recreation and Parks for classes'], 'status': 'not started'}\n",
      "{'task': 'Fix the jammed electric Yale lock on the door.', 'time_to_complete': 60, 'deadline': None, 'solutions': ['Contact a local locksmith in SF', \"Check Yale's customer support for troubleshooting\", 'Look for repair guides online', 'Contact City Locksmith SF', 'Visit SF Lock and Key for assistance'], 'status': 'not started'}\n",
      "{'task': 'Call back City Toyota to schedule car service.', 'time_to_complete': 10, 'deadline': None, 'solutions': [\"Find City Toyota's contact number\", 'Check car service availability', 'Prepare car details for service scheduling'], 'status': 'not started'}\n"
     ]
    }
   ],
   "source": [
    "# Namespace for the memory to save\n",
    "user_id = \"Lance\"\n",
    "\n",
    "# Search \n",
    "for memory in across_thread_memory.search((\"todo\", user_id)):\n",
    "    print(memory.value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can create a new thread.\n",
    "\n",
    "This creates a new session. \n",
    "\n",
    "Profile, ToDos, and Instructions saved to long-term memory are accessed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "I have 30 minutes, what tasks can I get done?\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "You can work on the following tasks that fit within your 30-minute timeframe:\n",
      "\n",
      "1. **Book swim lessons for your 1-year-old daughter.** \n",
      "   - Estimated time to complete: 30 minutes\n",
      "   - Solutions include checking local swim schools in SF, looking for baby swim classes online, asking friends for recommendations, contacting La Petite Baleen Swim School, or checking with SF Recreation and Parks for classes.\n",
      "\n",
      "2. **Call back City Toyota to schedule car service.**\n",
      "   - Estimated time to complete: 10 minutes\n",
      "   - Solutions include finding City Toyota's contact number, checking car service availability, and preparing car details for service scheduling.\n",
      "\n",
      "You can choose either of these tasks to complete within your available time.\n"
     ]
    }
   ],
   "source": [
    "# We supply a thread ID for short-term (within-thread) memory\n",
    "# We supply a user ID for long-term (across-thread) memory \n",
    "config = {\"configurable\": {\"thread_id\": \"2\", \"user_id\": \"Lance\"}}\n",
    "\n",
    "# Chat with the chatbot\n",
    "input_messages = [HumanMessage(content=\"I have 30 minutes, what tasks can I get done?\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "Yes, give me some options to call for swim lessons.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Here are some options you can consider for booking swim lessons for your 1-year-old daughter in San Francisco:\n",
      "\n",
      "1. **La Petite Baleen Swim School**: Known for their baby swim classes, you can contact them to inquire about their schedule and availability.\n",
      "\n",
      "2. **SF Recreation and Parks**: They often offer swim classes for young children. Check their website or contact them for more information.\n",
      "\n",
      "3. **Local Swim Schools**: Search for other local swim schools in SF that offer baby swim classes. You might find some good options nearby.\n",
      "\n",
      "4. **Ask Friends for Recommendations**: Reach out to friends or family in the area who might have experience with swim lessons for young children.\n",
      "\n",
      "These options should help you get started on booking swim lessons.\n"
     ]
    }
   ],
   "source": [
    "# Chat with the chatbot\n",
    "input_messages = [HumanMessage(content=\"Yes, give me some options to call for swim lessons.\")]\n",
    "\n",
    "# Run the graph\n",
    "for chunk in graph.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
    "    chunk[\"messages\"][-1].pretty_print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trace: \n",
    "\n",
    "https://smith.langchain.com/public/84768705-be91-43e4-8a6f-f9d3cee93782/r\n",
    "\n",
    "## Studio\n",
    "\n",
    "![Screenshot 2024-11-04 at 1.00.19 PM.png](https://cdn.prod.website-files.com/65b8cd72835ceeacd4449a53/6732cfb05d9709862eba4e6c_Screenshot%202024-11-11%20at%207.46.40%E2%80%AFPM.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}