30_memoryschema_profile.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chatbot with Profile Schema \n",
    "\n",
    "## Review\n",
    "\n",
    "We introduced the [LangGraph Memory Store](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore) as a way to save and retrieve long-term memories.\n",
    "\n",
    "We built a simple chatbot that uses both `short-term (within-thread)` and `long-term (across-thread)` memory.\n",
    "\n",
    "It saved long-term [semantic memory](https://langchain-ai.github.io/langgraph/concepts/memory/#semantic-memory) (facts about the user) [\"in the hot path\"](https://langchain-ai.github.io/langgraph/concepts/memory/#writing-memories), as the user is chatting with it.\n",
    "\n",
    "## Goals\n",
    "\n",
    "Our chatbot saved memories as a string. In practice, we often want memories to have a structure. \n",
    " \n",
    "For example, memories can be a [single, continuously updated schema]((https://langchain-ai.github.io/langgraph/concepts/memory/#profile)). \n",
    " \n",
    "In our case, we want this to be a single user profile.\n",
    " \n",
    "We'll extend our chatbot to save semantic memories to a single [user profile](https://langchain-ai.github.io/langgraph/concepts/memory/#profile). \n",
    "\n",
    "We'll also introduce a library, [Trustcall](https://github.com/hinthornw/trustcall), to update this schema with new information. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a user profile schema\n",
    "\n",
    "Python has many different types for [structured data](https://python.langchain.com/docs/concepts/structured_outputs/#schema-definition), such as TypedDict, Dictionaries, JSON, and [Pydantic](https://docs.pydantic.dev/latest/). \n",
    "\n",
    "Let's start by using TypedDict to define a user profile schema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import TypedDict, List\n",
    "\n",
    "class UserProfile(TypedDict):\n",
    "    \"\"\"User profile schema with typed fields\"\"\"\n",
    "    user_name: str  # The user's preferred name\n",
    "    interests: List[str]  # A list of the user's interests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving a schema to the store\n",
    "\n",
    "The [LangGraph Store](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore) accepts any Python dictionary as the `value`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'user_name': 'Lance', 'interests': ['biking', 'technology', 'coffee']}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TypedDict instance\n",
    "user_profile: UserProfile = {\n",
    "    \"user_name\": \"Lance\",\n",
    "    \"interests\": [\"biking\", \"technology\", \"coffee\"]\n",
    "}\n",
    "user_profile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the [put](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore.put) method to save the TypedDict to the store."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import uuid\n",
    "from langgraph.store.memory import InMemoryStore\n",
    "\n",
    "# Initialize the in-memory store\n",
    "in_memory_store = InMemoryStore()\n",
    "\n",
    "# Namespace for the memory to save\n",
    "user_id = \"1\"\n",
    "namespace_for_memory = (user_id, \"memory\")\n",
    "\n",
    "# Save a memory to namespace as key and value\n",
    "key = \"user_profile\"\n",
    "value = user_profile\n",
    "in_memory_store.put(namespace_for_memory, key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use [search](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore.search) to retrieve objects from the store by namespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'value': {'user_name': 'Lance', 'interests': ['biking', 'technology', 'coffee']}, 'key': 'user_profile', 'namespace': ['1', 'memory'], 'created_at': '2024-11-04T23:37:34.871675+00:00', 'updated_at': '2024-11-04T23:37:34.871680+00:00'}\n"
     ]
    }
   ],
   "source": [
    "# Search \n",
    "for m in in_memory_store.search(namespace_for_memory):\n",
    "    print(m.dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use [get](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore.get) to retrieve a specific object by namespace and key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'user_name': 'Lance', 'interests': ['biking', 'technology', 'coffee']}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get the memory by namespace and key\n",
    "profile = in_memory_store.get(namespace_for_memory, \"user_profile\")\n",
    "profile.value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chatbot with profile schema\n",
    "\n",
    "Now we know how to specify a schema for the memories and save it to the store.\n",
    "\n",
    "Now, how do we actually *create* memories with this particular schema?\n",
    "\n",
    "In our chatbot, we [want to create memories from a user chat](https://langchain-ai.github.io/langgraph/concepts/memory/#profile). \n",
    "\n",
    "This is where the concept of [structured outputs](https://python.langchain.com/docs/concepts/structured_outputs/#recommended-usage) is useful. \n",
    "\n",
    "LangChain's [chat model](https://python.langchain.com/docs/concepts/chat_models/) interface has a [`with_structured_output`](https://python.langchain.com/docs/concepts/structured_outputs/#recommended-usage) method to enforce structured output.\n",
    "\n",
    "This is useful when we want to enforce that the output conforms to a schema, and it parses the output for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ[\"OPENAI_API_KEY\"] = userdata.get('OPENAI_API_KEY')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's pass the `UserProfile` schema we created to the `with_structured_output` method.\n",
    "\n",
    "We can then invoke the chat model with a list of [messages](https://python.langchain.com/docs/concepts/messages/) and get a structured output that conforms to our schema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'user_name': 'Lance', 'interests': ['biking']}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pydantic import BaseModel, Field\n",
    "\n",
    "from langchain_core.messages import HumanMessage\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "# Initialize the model\n",
    "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
    "\n",
    "# Bind schema to model\n",
    "model_with_structure = model.with_structured_output(UserProfile)\n",
    "\n",
    "# Invoke the model to produce structured output that matches the schema\n",
    "structured_output = model_with_structure.invoke([HumanMessage(\"My name is Lance, I like to bike.\")])\n",
    "structured_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's use this with our chatbot.\n",
    "\n",
    "This only requires minor changes to the `write_memory` function. \n",
    "\n",
    "We use `model_with_structure`, as defined above, to produce a profile that matches our schema. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "from langgraph.graph import StateGraph, MessagesState, START, END\n",
    "from langgraph.store.base import BaseStore\n",
    "\n",
    "from langchain_core.messages import HumanMessage, SystemMessage, AIMessage\n",
    "from langchain_core.runnables.config import RunnableConfig\n",
    "\n",
    "# Chatbot instruction\n",
    "MODEL_SYSTEM_MESSAGE = \"\"\"You are a helpful assistant with memory that provides information about the user. \n",
    "If you have memory for this user, use it to personalize your responses.\n",
    "Here is the memory (it may be empty): {memory}\"\"\"\n",
    "\n",
    "# Create new memory from the chat history and any existing memory\n",
    "CREATE_MEMORY_INSTRUCTION = \"\"\"Create or update a user profile memory based on the user's chat history. \n",
    "This will be saved for long-term memory. If there is an existing memory, simply update it. \n",
    "Here is the existing memory (it may be empty): {memory}\"\"\"\n",
    "\n",
    "def call_model(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Load memory from the store and use it 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 memory from the store\n",
    "    namespace = (\"memory\", user_id)\n",
    "    existing_memory = store.get(namespace, \"user_memory\")\n",
    "\n",
    "    # Format the memories for the system prompt\n",
    "    if existing_memory and existing_memory.value:\n",
    "        memory_dict = existing_memory.value\n",
    "        formatted_memory = (\n",
    "            f\"Name: {memory_dict.get('user_name', 'Unknown')}\\n\"\n",
    "            f\"Interests: {', '.join(memory_dict.get('interests', []))}\"\n",
    "        )\n",
    "    else:\n",
    "        formatted_memory = None\n",
    "\n",
    "    # Format the memory in the system prompt\n",
    "    system_msg = MODEL_SYSTEM_MESSAGE.format(memory=formatted_memory)\n",
    "\n",
    "    # Respond using memory as well as the chat history\n",
    "    response = model.invoke([SystemMessage(content=system_msg)]+state[\"messages\"])\n",
    "\n",
    "    return {\"messages\": response}\n",
    "\n",
    "def write_memory(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Reflect on the chat history and save a memory to the store.\"\"\"\n",
    "    \n",
    "    # Get the user ID from the config\n",
    "    user_id = config[\"configurable\"][\"user_id\"]\n",
    "\n",
    "    # Retrieve existing memory from the store\n",
    "    namespace = (\"memory\", user_id)\n",
    "    existing_memory = store.get(namespace, \"user_memory\")\n",
    "\n",
    "    # Format the memories for the system prompt\n",
    "    if existing_memory and existing_memory.value:\n",
    "        memory_dict = existing_memory.value\n",
    "        formatted_memory = (\n",
    "            f\"Name: {memory_dict.get('user_name', 'Unknown')}\\n\"\n",
    "            f\"Interests: {', '.join(memory_dict.get('interests', []))}\"\n",
    "        )\n",
    "    else:\n",
    "        formatted_memory = None\n",
    "        \n",
    "    # Format the existing memory in the instruction\n",
    "    system_msg = CREATE_MEMORY_INSTRUCTION.format(memory=formatted_memory)\n",
    "\n",
    "    # Invoke the model to produce structured output that matches the schema\n",
    "    new_memory = model_with_structure.invoke([SystemMessage(content=system_msg)]+state['messages'])\n",
    "\n",
    "    # Overwrite the existing use profile memory\n",
    "    key = \"user_memory\"\n",
    "    store.put(namespace, key, new_memory)\n",
    "\n",
    "# Define the graph\n",
    "builder = StateGraph(MessagesState)\n",
    "builder.add_node(\"call_model\", call_model)\n",
    "builder.add_node(\"write_memory\", write_memory)\n",
    "builder.add_edge(START, \"call_model\")\n",
    "builder.add_edge(\"call_model\", \"write_memory\")\n",
    "builder.add_edge(\"write_memory\", END)\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",
    "# Compile the graph with the checkpointer fir 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": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "Hi, my name is Lance and I like to bike around San Francisco and eat at bakeries.\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Hi Lance! It's great to meet you. Biking around San Francisco sounds like a fantastic way to explore the city, and there are so many amazing bakeries to try. Do you have any favorite bakeries or biking routes in the city?\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\": \"1\"}}\n",
    "\n",
    "# User input \n",
    "input_messages = [HumanMessage(content=\"Hi, my name is Lance and I like to bike around San Francisco and eat at bakeries.\")]\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": [
    "Let's check the memory in the store. \n",
    "\n",
    "We can see that the memory is a dictionary that matches our schema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'user_name': 'Lance', 'interests': ['biking', 'bakeries', 'San Francisco']}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Namespace for the memory to save\n",
    "user_id = \"1\"\n",
    "namespace = (\"memory\", user_id)\n",
    "existing_memory = across_thread_memory.get(namespace, \"user_memory\")\n",
    "existing_memory.value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## When can this fail?\n",
    "\n",
    "[`with_structured_output`](https://python.langchain.com/docs/concepts/structured_outputs/#recommended-usage) is very useful, but what happens if we're working with a more complex schema? \n",
    "\n",
    "[Here's](https://github.com/hinthornw/trustcall?tab=readme-ov-file#complex-schema) an example of a more complex schema, which we'll test below. \n",
    "\n",
    "This is a [Pydantic](https://docs.pydantic.dev/latest/) model that describes a user's preferences for communication and trust fall."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Optional\n",
    "\n",
    "class OutputFormat(BaseModel):\n",
    "    preference: str\n",
    "    sentence_preference_revealed: str\n",
    "\n",
    "class TelegramPreferences(BaseModel):\n",
    "    preferred_encoding: Optional[List[OutputFormat]] = None\n",
    "    favorite_telegram_operators: Optional[List[OutputFormat]] = None\n",
    "    preferred_telegram_paper: Optional[List[OutputFormat]] = None\n",
    "\n",
    "class MorseCode(BaseModel):\n",
    "    preferred_key_type: Optional[List[OutputFormat]] = None\n",
    "    favorite_morse_abbreviations: Optional[List[OutputFormat]] = None\n",
    "\n",
    "class Semaphore(BaseModel):\n",
    "    preferred_flag_color: Optional[List[OutputFormat]] = None\n",
    "    semaphore_skill_level: Optional[List[OutputFormat]] = None\n",
    "\n",
    "class TrustFallPreferences(BaseModel):\n",
    "    preferred_fall_height: Optional[List[OutputFormat]] = None\n",
    "    trust_level: Optional[List[OutputFormat]] = None\n",
    "    preferred_catching_technique: Optional[List[OutputFormat]] = None\n",
    "\n",
    "class CommunicationPreferences(BaseModel):\n",
    "    telegram: TelegramPreferences\n",
    "    morse_code: MorseCode\n",
    "    semaphore: Semaphore\n",
    "\n",
    "class UserPreferences(BaseModel):\n",
    "    communication_preferences: CommunicationPreferences\n",
    "    trust_fall_preferences: TrustFallPreferences\n",
    "\n",
    "class TelegramAndTrustFallPreferences(BaseModel):\n",
    "    pertinent_user_preferences: UserPreferences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's try extraction of this schema using the `with_structured_output` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 validation error for TelegramAndTrustFallPreferences\n",
      "pertinent_user_preferences.communication_preferences.semaphore\n",
      "  Input should be a valid dictionary or instance of Semaphore [type=model_type, input_value=None, input_type=NoneType]\n",
      "    For further information visit https://errors.pydantic.dev/2.9/v/model_type\n"
     ]
    }
   ],
   "source": [
    "from pydantic import ValidationError\n",
    "\n",
    "# Bind schema to model\n",
    "model_with_structure = model.with_structured_output(TelegramAndTrustFallPreferences)\n",
    "\n",
    "# Conversation\n",
    "conversation = \"\"\"Operator: How may I assist with your telegram, sir?\n",
    "Customer: I need to send a message about our trust fall exercise.\n",
    "Operator: Certainly. Morse code or standard encoding?\n",
    "Customer: Morse, please. I love using a straight key.\n",
    "Operator: Excellent. What's your message?\n",
    "Customer: Tell him I'm ready for a higher fall, and I prefer the diamond formation for catching.\n",
    "Operator: Done. Shall I use our \"Daredevil\" paper for this daring message?\n",
    "Customer: Perfect! Send it by your fastest carrier pigeon.\n",
    "Operator: It'll be there within the hour, sir.\"\"\"\n",
    "\n",
    "# Invoke the model\n",
    "try:\n",
    "    model_with_structure.invoke(f\"\"\"Extract the preferences from the following conversation:\n",
    "    <convo>\n",
    "    {conversation}\n",
    "    </convo>\"\"\")\n",
    "except ValidationError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we naively extract more complex schemas, even using high capacity model like `gpt-4o`, it is prone to failure.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trustcall for creating and updating profile schemas\n",
    "\n",
    "As we can see, working with schemas can be tricky.\n",
    "\n",
    "Complex schemas can be difficult to extract. \n",
    "\n",
    "In addition, updating even simple schemas can pose challenges.\n",
    "\n",
    "Consider our above chatbot. \n",
    "\n",
    "We regenerated the profile schema *from scratch* each time we chose to save a new memory.\n",
    "\n",
    "This is inefficient, potentially wasting model tokens if the schema contains a lot of information to re-generate each time.\n",
    "\n",
    "Worse, we may loose information when regenerating the profile from scratch.\n",
    "\n",
    "Addressing these problems is the motivation for [TrustCall](https://github.com/hinthornw/trustcall)!\n",
    "\n",
    "This is an open-source library for updating JSON schemas developed by one [Will Fu-Hinthorn](https://github.com/hinthornw) on the LangChain team.\n",
    "\n",
    "It's motivated by exactly these challenges while working on memory.\n",
    "\n",
    "Let's first show simple usage of extraction with TrustCall on this list of [messages](https://python.langchain.com/docs/concepts/messages/).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conversation\n",
    "conversation = [HumanMessage(content=\"Hi, I'm Lance.\"), \n",
    "                AIMessage(content=\"Nice to meet you, Lance.\"), \n",
    "                HumanMessage(content=\"I really like biking around San Francisco.\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use `create_extractor`, passing in the model as well as our schema as a [tool](https://python.langchain.com/docs/concepts/tools/).\n",
    "\n",
    "With TrustCall, can supply supply the schema in various ways. \n",
    "\n",
    "For example, we can pass a JSON object / Python dictionary or Pydantic model.\n",
    "\n",
    "Under the hood, TrustCall uses [tool calling](https://python.langchain.com/docs/concepts/tool_calling/) to produce [structured output](https://python.langchain.com/docs/concepts/structured_outputs/) from an input list of [messages](https://python.langchain.com/docs/concepts/messages/).\n",
    "\n",
    "To force Trustcall to produce [structured output](https://python.langchain.com/docs/concepts/structured_outputs/), we can include the schema name in the `tool_choice` argument.\n",
    "\n",
    "We can invoke the extractor with  the above conversation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from trustcall import create_extractor\n",
    "\n",
    "# Schema \n",
    "class UserProfile(BaseModel):\n",
    "    \"\"\"User profile schema with typed fields\"\"\"\n",
    "    user_name: str = Field(description=\"The user's preferred name\")\n",
    "    interests: List[str] = Field(description=\"A list of the user's interests\")\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=[UserProfile],\n",
    "    tool_choice=\"UserProfile\"\n",
    ")\n",
    "\n",
    "# Instruction\n",
    "system_msg = \"Extract the user profile from the following conversation\"\n",
    "\n",
    "# Invoke the extractor\n",
    "result = trustcall_extractor.invoke({\"messages\": [SystemMessage(content=system_msg)]+conversation})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we invoke the extractor, we get a few things:\n",
    "\n",
    "* `messages`: The list of `AIMessages` that contain the tool calls. \n",
    "* `responses`: The resulting parsed tool calls that match our schema.\n",
    "* `response_metadata`: Applicable if updating existing tool calls. It says which of the responses correspond to which of the existing objects.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UserProfile (call_spGGUsoaUFXU7oOrUNCASzfL)\n",
      " Call ID: call_spGGUsoaUFXU7oOrUNCASzfL\n",
      "  Args:\n",
      "    user_name: Lance\n",
      "    interests: ['biking around San Francisco']\n"
     ]
    }
   ],
   "source": [
    "for m in result[\"messages\"]: \n",
    "    m.pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[UserProfile(user_name='Lance', interests=['biking around San Francisco'])]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "schema = result[\"responses\"]\n",
    "schema"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'user_name': 'Lance', 'interests': ['biking around San Francisco']}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "schema[0].model_dump()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'id': 'call_spGGUsoaUFXU7oOrUNCASzfL'}]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[\"response_metadata\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how we can use it to *update* the profile.\n",
    "\n",
    "For updating, TrustCall takes a set of messages as well as the existing schema. \n",
    "\n",
    "The central idea is that it prompts the model to produce a [JSON Patch](https://jsonpatch.com/) to update only the relevant parts of the schema.\n",
    "\n",
    "This is less error-prone than naively overwriting the entire schema.\n",
    "\n",
    "It's also more efficient since the model only needs to generate the parts of the schema that have changed.\n",
    "\n",
    "We can save the existing schema as a dict.\n",
    "\n",
    "We can use `model_dump()` to serialize a Pydantic model instance into a dict. \n",
    "\n",
    "We pass it to the `\"existing\"` argument along with the schema name, `UserProfile`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Update the conversation\n",
    "updated_conversation = [HumanMessage(content=\"Hi, I'm Lance.\"), \n",
    "                        AIMessage(content=\"Nice to meet you, Lance.\"), \n",
    "                        HumanMessage(content=\"I really like biking around San Francisco.\"),\n",
    "                        AIMessage(content=\"San Francisco is a great city! Where do you go after biking?\"),\n",
    "                        HumanMessage(content=\"I really like to go to a bakery after biking.\"),]\n",
    "\n",
    "# Update the instruction\n",
    "system_msg = f\"\"\"Update the memory (JSON doc) to incorporate new information from the following conversation\"\"\"\n",
    "\n",
    "# Invoke the extractor with the updated instruction and existing profile with the corresponding tool name (UserProfile)\n",
    "result = trustcall_extractor.invoke({\"messages\": [SystemMessage(content=system_msg)]+updated_conversation}, \n",
    "                                    {\"existing\": {\"UserProfile\": schema[0].model_dump()}})  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "Tool Calls:\n",
      "  UserProfile (call_WeZl0ACfQStxblim0ps8LNKT)\n",
      " Call ID: call_WeZl0ACfQStxblim0ps8LNKT\n",
      "  Args:\n",
      "    user_name: Lance\n",
      "    interests: ['biking', 'visiting bakeries']\n"
     ]
    }
   ],
   "source": [
    "for m in result[\"messages\"]: \n",
    "    m.pretty_print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'id': 'call_WeZl0ACfQStxblim0ps8LNKT'}]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result[\"response_metadata\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'user_name': 'Lance', 'interests': ['biking', 'visiting bakeries']}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "updated_schema = result[\"responses\"][0]\n",
    "updated_schema.model_dump()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LangSmith trace:\n",
    "\n",
    "https://smith.langchain.com/public/229eae22-1edb-44c6-93e6-489124a43968/r\n",
    "\n",
    "Now, let's also test Trustcall on the [challenging schema](https://github.com/hinthornw/trustcall?tab=readme-ov-file#complex-schema) that we saw earlier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TelegramAndTrustFallPreferences(pertinent_user_preferences=UserPreferences(communication_preferences=CommunicationPreferences(telegram=TelegramPreferences(preferred_encoding=[OutputFormat(preference='standard encoding', sentence_preference_revealed='standard encoding')], favorite_telegram_operators=None, preferred_telegram_paper=[OutputFormat(preference='Daredevil', sentence_preference_revealed='Daredevil')]), morse_code=MorseCode(preferred_key_type=[OutputFormat(preference='straight key', sentence_preference_revealed='straight key')], favorite_morse_abbreviations=None), semaphore=Semaphore(preferred_flag_color=None, semaphore_skill_level=None)), trust_fall_preferences=TrustFallPreferences(preferred_fall_height=[OutputFormat(preference='higher', sentence_preference_revealed='higher')], trust_level=None, preferred_catching_technique=[OutputFormat(preference='diamond formation', sentence_preference_revealed='diamond formation')])))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bound = create_extractor(\n",
    "    model,\n",
    "    tools=[TelegramAndTrustFallPreferences],\n",
    "    tool_choice=\"TelegramAndTrustFallPreferences\",\n",
    ")\n",
    "\n",
    "# Conversation\n",
    "conversation = \"\"\"Operator: How may I assist with your telegram, sir?\n",
    "Customer: I need to send a message about our trust fall exercise.\n",
    "Operator: Certainly. Morse code or standard encoding?\n",
    "Customer: Morse, please. I love using a straight key.\n",
    "Operator: Excellent. What's your message?\n",
    "Customer: Tell him I'm ready for a higher fall, and I prefer the diamond formation for catching.\n",
    "Operator: Done. Shall I use our \"Daredevil\" paper for this daring message?\n",
    "Customer: Perfect! Send it by your fastest carrier pigeon.\n",
    "Operator: It'll be there within the hour, sir.\"\"\"\n",
    "\n",
    "result = bound.invoke(\n",
    "    f\"\"\"Extract the preferences from the following conversation:\n",
    "<convo>\n",
    "{conversation}\n",
    "</convo>\"\"\"\n",
    ")\n",
    "\n",
    "# Extract the preferences\n",
    "result[\"responses\"][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trace: \n",
    "\n",
    "https://smith.langchain.com/public/5cd23009-3e05-4b00-99f0-c66ee3edd06e/r\n",
    "\n",
    "For more examples, you can see an overview video [here](https://www.youtube.com/watch?v=-H4s0jQi-QY)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chatbot with profile schema updating\n",
    "\n",
    "Now, let's bring Trustcall into our chatbot to create *and update* a memory profile."
   ]
  },
  {
   "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": [
    "from IPython.display import Image, display\n",
    "\n",
    "from langchain_core.messages import HumanMessage, SystemMessage\n",
    "from langgraph.graph import StateGraph, MessagesState, START, END\n",
    "from langchain_core.runnables.config import RunnableConfig\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "from langgraph.store.base import BaseStore\n",
    "\n",
    "# Initialize the model\n",
    "model = ChatOpenAI(model=\"gpt-4o\", temperature=0)\n",
    "\n",
    "# Schema \n",
    "class UserProfile(BaseModel):\n",
    "    \"\"\" Profile of a user \"\"\"\n",
    "    user_name: str = Field(description=\"The user's preferred name\")\n",
    "    user_location: str = Field(description=\"The user's location\")\n",
    "    interests: list = Field(description=\"A list of the user's interests\")\n",
    "\n",
    "# Create the extractor\n",
    "trustcall_extractor = create_extractor(\n",
    "    model,\n",
    "    tools=[UserProfile],\n",
    "    tool_choice=\"UserProfile\", # Enforces use of the UserProfile tool\n",
    ")\n",
    "\n",
    "# Chatbot instruction\n",
    "MODEL_SYSTEM_MESSAGE = \"\"\"You are a helpful assistant with memory that provides information about the user. \n",
    "If you have memory for this user, use it to personalize your responses.\n",
    "Here is the memory (it may be empty): {memory}\"\"\"\n",
    "\n",
    "# Extraction instruction\n",
    "TRUSTCALL_INSTRUCTION = \"\"\"Create or update the memory (JSON doc) to incorporate information from the following conversation:\"\"\"\n",
    "\n",
    "def call_model(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Load memory from the store and use it 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 memory from the store\n",
    "    namespace = (\"memory\", user_id)\n",
    "    existing_memory = store.get(namespace, \"user_memory\")\n",
    "\n",
    "    # Format the memories for the system prompt\n",
    "    if existing_memory and existing_memory.value:\n",
    "        memory_dict = existing_memory.value\n",
    "        formatted_memory = (\n",
    "            f\"Name: {memory_dict.get('user_name', 'Unknown')}\\n\"\n",
    "            f\"Location: {memory_dict.get('user_location', 'Unknown')}\\n\"\n",
    "            f\"Interests: {', '.join(memory_dict.get('interests', []))}\"      \n",
    "        )\n",
    "    else:\n",
    "        formatted_memory = None\n",
    "\n",
    "    # Format the memory in the system prompt\n",
    "    system_msg = MODEL_SYSTEM_MESSAGE.format(memory=formatted_memory)\n",
    "\n",
    "    # Respond using memory as well as the chat history\n",
    "    response = model.invoke([SystemMessage(content=system_msg)]+state[\"messages\"])\n",
    "\n",
    "    return {\"messages\": response}\n",
    "\n",
    "def write_memory(state: MessagesState, config: RunnableConfig, store: BaseStore):\n",
    "\n",
    "    \"\"\"Reflect on the chat history and save a memory to the store.\"\"\"\n",
    "    \n",
    "    # Get the user ID from the config\n",
    "    user_id = config[\"configurable\"][\"user_id\"]\n",
    "\n",
    "    # Retrieve existing memory from the store\n",
    "    namespace = (\"memory\", user_id)\n",
    "    existing_memory = store.get(namespace, \"user_memory\")\n",
    "        \n",
    "    # Get the profile as the value from the list, and convert it to a JSON doc\n",
    "    existing_profile = {\"UserProfile\": existing_memory.value} if existing_memory else None\n",
    "    \n",
    "    # Invoke the extractor\n",
    "    result = trustcall_extractor.invoke({\"messages\": [SystemMessage(content=TRUSTCALL_INSTRUCTION)]+state[\"messages\"], \"existing\": existing_profile})\n",
    "    \n",
    "    # Get the updated profile as a JSON object\n",
    "    updated_profile = result[\"responses\"][0].model_dump()\n",
    "\n",
    "    # Save the updated profile\n",
    "    key = \"user_memory\"\n",
    "    store.put(namespace, key, updated_profile)\n",
    "\n",
    "# Define the graph\n",
    "builder = StateGraph(MessagesState)\n",
    "builder.add_node(\"call_model\", call_model)\n",
    "builder.add_node(\"write_memory\", write_memory)\n",
    "builder.add_edge(START, \"call_model\")\n",
    "builder.add_edge(\"call_model\", \"write_memory\")\n",
    "builder.add_edge(\"write_memory\", END)\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",
    "# Compile the graph with the checkpointer fir 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",
      "Hi, my name is Lance\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Hello, Lance! It's nice to meet you. How can I assist you today?\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\": \"1\"}}\n",
    "\n",
    "# User input \n",
    "input_messages = [HumanMessage(content=\"Hi, my name is Lance\")]\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",
      "I like to bike around San Francisco\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "That sounds like a great way to explore the city! San Francisco has some beautiful routes and views. Do you have any favorite trails or spots you like to visit while biking?\n"
     ]
    }
   ],
   "source": [
    "# User input \n",
    "input_messages = [HumanMessage(content=\"I like to bike around San Francisco\")]\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": [
    {
     "data": {
      "text/plain": [
       "{'value': {'user_name': 'Lance',\n",
       "  'user_location': 'San Francisco',\n",
       "  'interests': ['biking']},\n",
       " 'key': 'user_memory',\n",
       " 'namespace': ['memory', '1'],\n",
       " 'created_at': '2024-11-04T23:51:17.662428+00:00',\n",
       " 'updated_at': '2024-11-04T23:51:41.697652+00:00'}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Namespace for the memory to save\n",
    "user_id = \"1\"\n",
    "namespace = (\"memory\", user_id)\n",
    "existing_memory = across_thread_memory.get(namespace, \"user_memory\")\n",
    "existing_memory.dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'user_name': 'Lance',\n",
       " 'user_location': 'San Francisco',\n",
       " 'interests': ['biking']}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The user profile saved as a JSON object\n",
    "existing_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 also enjoy going to bakeries\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Biking and visiting bakeries sounds like a delightful combination! San Francisco has some fantastic bakeries. Do you have any favorites, or are you looking for new recommendations to try out?\n"
     ]
    }
   ],
   "source": [
    "# User input \n",
    "input_messages = [HumanMessage(content=\"I also enjoy going to bakeries\")]\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": [
    "Continue the conversation in a new thread."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\u001b[1m Human Message \u001b[0m=================================\n",
      "\n",
      "What bakeries do you recommend for me?\n",
      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
      "\n",
      "Since you're in San Francisco and enjoy going to bakeries, here are a few recommendations you might like:\n",
      "\n",
      "1. **Tartine Bakery** - Known for its delicious bread and pastries, it's a must-visit for any bakery enthusiast.\n",
      "2. **B. Patisserie** - Offers a delightful selection of French pastries, including their famous kouign-amann.\n",
      "3. **Arsicault Bakery** - Renowned for its croissants, which have been praised as some of the best in the country.\n",
      "4. **Craftsman and Wolves** - Known for their inventive pastries and the \"Rebel Within,\" a savory muffin with a soft-cooked egg inside.\n",
      "5. **Mr. Holmes Bakehouse** - Famous for their cruffins and other creative pastries.\n",
      "\n",
      "These spots should offer a great variety of treats for you to enjoy. Happy bakery hopping!\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\": \"1\"}}\n",
    "\n",
    "# User input \n",
    "input_messages = [HumanMessage(content=\"What bakeries do you recommend for me?\")]\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/f45bdaf0-6963-4c19-8ec9-f4b7fe0f68ad/r\n",
    "\n",
    "## Studio\n",
    "\n",
    "![Screenshot 2024-10-30 at 11.26.31 AM.png](https://cdn.prod.website-files.com/65b8cd72835ceeacd4449a53/6732d0437060f1754ea79908_Screenshot%202024-11-11%20at%207.48.53%E2%80%AFPM.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}