x

Update trim messages notebook to include common use cases and explain
what the desired behavior is

.github/DISCUSSION_TEMPLATE/q-a.yml

@@ -96,22 +96,27 @@ body:
   - type: textarea
     id: system-info
     attributes:
+      label: System Info
       description: |
-        Please share your system info with us. Do NOT skip this step and please don't trim
-        the output. Most users don't include enough information here and it makes it harder
-        for us to help you.
+        Please share your system info with us. 
         
-        Run the following command in your terminal and paste the output here:
+        "pip freeze | grep langchain" 
+        platform (windows / linux / mac)
+        python version
+        
+        OR if you're on a recent version of langchain-core you can paste the output of:
         
         python -m langchain_core.sys_info
-        
-        or if you have an existing python interpreter running:
-        
-        from langchain_core import sys_info
-        sys_info.print_sys_info()
-        
-        alternatively, put the entire output of `pip freeze` here.
       placeholder: |
+        "pip freeze | grep langchain"
+        platform
+        python version
+        
+        Alternatively, if you're on a recent version of langchain-core you can paste the output of:
+        
         python -m langchain_core.sys_info
+        
+        These will only surface LangChain packages, don't forget to include any other relevant
+        packages you're using (if you're not sure what's relevant, you can paste the entire output of `pip freeze`).
     validations:
       required: true

docs/docs/how_to/chatbots_memory.ipynb

@@ -23,6 +23,14 @@
     "\n",
     "We'll go into more detail on a few techniques below!\n",
     "\n",
+    ":::{.callout-note}\n",
+    "\n",
+    "This how-to guide previously built a chatbot using [RunnableWithMessageHistory](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html). You can access this version of the tutorial in the [v0.2 docs](https://python.langchain.com/v0.2/docs/how_to/chatbots_memory/).\n",
+    "\n",
+    "The LangGraph implementation offers a number of advantages over `RunnableWithMessageHistory`, including the ability to persist arbitrary components of an application's state (instead of only messages).\n",
+    "\n",
+    ":::\n",
+    "\n",
     "## Setup\n",
     "\n",
     "You'll need to install a few packages, and have your OpenAI API key set as an environment variable named `OPENAI_API_KEY`:"
@@ -33,15 +41,6 @@
    "execution_count": 1,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[33mWARNING: You are using pip version 22.0.4; however, version 23.3.2 is available.\n",
-      "You should consider upgrading via the '/Users/jacoblee/.pyenv/versions/3.10.5/bin/python -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n",
-      "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
@@ -54,12 +53,13 @@
     }
    ],
    "source": [
-    "%pip install --upgrade --quiet langchain langchain-openai\n",
+    "%pip install --upgrade --quiet langchain langchain-openai langgraph\n",
     "\n",
-    "# Set env var OPENAI_API_KEY or load from a .env file:\n",
-    "import dotenv\n",
+    "import getpass\n",
+    "import os\n",
     "\n",
-    "dotenv.load_dotenv()"
+    "if not os.environ.get(\"OPENAI_API_KEY\"):\n",
+    "    os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
    ]
   },
   {
@@ -71,13 +71,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain_openai import ChatOpenAI\n",
     "\n",
-    "chat = ChatOpenAI(model=\"gpt-4o-mini\")"
+    "model = ChatOpenAI(model=\"gpt-4o-mini\")"
    ]
   },
   {
@@ -98,34 +98,33 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "I said \"J'adore la programmation,\" which means \"I love programming\" in French.\n"
+      "I translated the sentence \"I love programming\" into French, which is \"J'adore la programmation.\"\n"
      ]
     }
    ],
    "source": [
-    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.messages import AIMessage, HumanMessage, SystemMessage\n",
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
     "\n",
     "prompt = ChatPromptTemplate.from_messages(\n",
     "    [\n",
-    "        (\n",
-    "            \"system\",\n",
-    "            \"You are a helpful assistant. Answer all questions to the best of your ability.\",\n",
+    "        SystemMessage(\n",
+    "            content=\"You are a helpful assistant. Answer all questions to the best of your ability.\"\n",
     "        ),\n",
-    "        (\"placeholder\", \"{messages}\"),\n",
+    "        MessagesPlaceholder(variable_name=\"messages\"),\n",
     "    ]\n",
     ")\n",
     "\n",
-    "chain = prompt | chat\n",
+    "chain = prompt | model\n",
     "\n",
     "ai_msg = chain.invoke(\n",
     "    {\n",
     "        \"messages\": [\n",
-    "            (\n",
-    "                \"human\",\n",
-    "                \"Translate this sentence from English to French: I love programming.\",\n",
+    "            HumanMessage(\n",
+    "                content=\"Translate this sentence from English to French: I love programming.\"\n",
     "            ),\n",
-    "            (\"ai\", \"J'adore la programmation.\"),\n",
-    "            (\"human\", \"What did you just say?\"),\n",
+    "            AIMessage(content=\"J'adore la programmation.\"),\n",
+    "            HumanMessage(content=\"What did you just say?\"),\n",
     "        ],\n",
     "    }\n",
     ")\n",
@@ -136,51 +135,57 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can see that by passing the previous conversation into a chain, it can use it as context to answer questions. This is the basic concept underpinning chatbot memory - the rest of the guide will demonstrate convenient techniques for passing or reformatting messages.\n",
-    "\n",
-    "## Chat history\n",
-    "\n",
-    "It's perfectly fine to store and pass messages directly as an array, but we can use LangChain's built-in [message history class](https://python.langchain.com/api_reference/langchain/index.html#module-langchain.memory) to store and load messages as well. Instances of this class are responsible for storing and loading chat messages from persistent storage. LangChain integrates with many providers - you can see a [list of integrations here](/docs/integrations/memory) - but for this demo we will use an ephemeral demo class.\n",
-    "\n",
-    "Here's an example of the API:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[HumanMessage(content='Translate this sentence from English to French: I love programming.'),\n",
-       " AIMessage(content=\"J'adore la programmation.\")]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_community.chat_message_histories import ChatMessageHistory\n",
-    "\n",
-    "demo_ephemeral_chat_history = ChatMessageHistory()\n",
-    "\n",
-    "demo_ephemeral_chat_history.add_user_message(\n",
-    "    \"Translate this sentence from English to French: I love programming.\"\n",
-    ")\n",
-    "\n",
-    "demo_ephemeral_chat_history.add_ai_message(\"J'adore la programmation.\")\n",
-    "\n",
-    "demo_ephemeral_chat_history.messages"
+    "We can see that by passing the previous conversation into a chain, it can use it as context to answer questions. This is the basic concept underpinning chatbot memory - the rest of the guide will demonstrate convenient techniques for passing or reformatting messages."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can use it directly to store conversation turns for our chain:"
+    "## Automatic history management\n",
+    "\n",
+    "The previous examples pass messages to the chain (and model) explicitly. This is a completely acceptable approach, but it does require external management of new messages. LangChain also provides a way to build applications that have memory using LangGraph's [persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/). You can [enable persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence/) in LangGraph applications by providing a `checkpointer` when compiling the graph."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, MessagesState, StateGraph\n",
+    "\n",
+    "workflow = StateGraph(state_schema=MessagesState)\n",
+    "\n",
+    "\n",
+    "# Define the function that calls the model\n",
+    "def call_model(state: MessagesState):\n",
+    "    system_prompt = (\n",
+    "        \"You are a helpful assistant. \"\n",
+    "        \"Answer all questions to the best of your ability.\"\n",
+    "    )\n",
+    "    messages = [SystemMessage(content=system_prompt)] + state[\"messages\"]\n",
+    "    response = model.invoke(messages)\n",
+    "    return {\"messages\": response}\n",
+    "\n",
+    "\n",
+    "# Define the node and edge\n",
+    "workflow.add_node(\"model\", call_model)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "\n",
+    "# Add simple in-memory checkpointer\n",
+    "# highlight-start\n",
+    "memory = MemorySaver()\n",
+    "app = workflow.compile(checkpointer=memory)\n",
+    "# highlight-end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " We'll pass the latest input to the conversation here and let the LangGraph keep track of the conversation history using the checkpointer:"
    ]
   },
   {
@@ -191,7 +196,8 @@
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='You just asked me to translate the sentence \"I love programming\" from English to French.', response_metadata={'token_usage': {'completion_tokens': 18, 'prompt_tokens': 61, 'total_tokens': 79}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-5cbb21c2-9c30-4031-8ea8-bfc497989535-0', usage_metadata={'input_tokens': 61, 'output_tokens': 18, 'total_tokens': 79})"
+       "{'messages': [HumanMessage(content='Translate this sentence from English to French: I love programming.', additional_kwargs={}, response_metadata={}, id='200f88bb-936a-4877-990c-8b4112d82cfe'),\n",
+       "  AIMessage(content='The translation of \"I love programming\" in French is \"J\\'aime programmer.\"', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 16, 'prompt_tokens': 39, 'total_tokens': 55, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_1bb46167f9', 'finish_reason': 'stop', 'logprobs': None}, id='run-d4ebcdcf-9a60-4471-ad8d-96169f614ada-0', usage_metadata={'input_tokens': 39, 'output_tokens': 16, 'total_tokens': 55})]}"
       ]
      },
      "execution_count": 5,
@@ -200,159 +206,35 @@
     }
    ],
    "source": [
-    "demo_ephemeral_chat_history = ChatMessageHistory()\n",
-    "\n",
-    "input1 = \"Translate this sentence from English to French: I love programming.\"\n",
-    "\n",
-    "demo_ephemeral_chat_history.add_user_message(input1)\n",
-    "\n",
-    "response = chain.invoke(\n",
-    "    {\n",
-    "        \"messages\": demo_ephemeral_chat_history.messages,\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "demo_ephemeral_chat_history.add_ai_message(response)\n",
-    "\n",
-    "input2 = \"What did I just ask you?\"\n",
-    "\n",
-    "demo_ephemeral_chat_history.add_user_message(input2)\n",
-    "\n",
-    "chain.invoke(\n",
-    "    {\n",
-    "        \"messages\": demo_ephemeral_chat_history.messages,\n",
-    "    }\n",
+    "app.invoke(\n",
+    "    {\"messages\": [HumanMessage(content=\"Translate to French: I love programming.\")]},\n",
+    "    config={\"configurable\": {\"thread_id\": \"1\"}},\n",
     ")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Automatic history management\n",
-    "\n",
-    "The previous examples pass messages to the chain explicitly. This is a completely acceptable approach, but it does require external management of new messages. LangChain also includes an wrapper for LCEL chains that can handle this process automatically called `RunnableWithMessageHistory`.\n",
-    "\n",
-    "To show how it works, let's slightly modify the above prompt to take a final `input` variable that populates a `HumanMessage` template after the chat history. This means that we will expect a `chat_history` parameter that contains all messages BEFORE the current messages instead of all messages:"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\n",
-    "            \"system\",\n",
-    "            \"You are a helpful assistant. Answer all questions to the best of your ability.\",\n",
-    "        ),\n",
-    "        (\"placeholder\", \"{chat_history}\"),\n",
-    "        (\"human\", \"{input}\"),\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "chain = prompt | chat"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    " We'll pass the latest input to the conversation here and let the `RunnableWithMessageHistory` class wrap our chain and do the work of appending that `input` variable to the chat history.\n",
-    " \n",
-    " Next, let's declare our wrapped chain:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
-    "\n",
-    "demo_ephemeral_chat_history_for_chain = ChatMessageHistory()\n",
-    "\n",
-    "chain_with_message_history = RunnableWithMessageHistory(\n",
-    "    chain,\n",
-    "    lambda session_id: demo_ephemeral_chat_history_for_chain,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This class takes a few parameters in addition to the chain that we want to wrap:\n",
-    "\n",
-    "- A factory function that returns a message history for a given session id. This allows your chain to handle multiple users at once by loading different messages for different conversations.\n",
-    "- An `input_messages_key` that specifies which part of the input should be tracked and stored in the chat history. In this example, we want to track the string passed in as `input`.\n",
-    "- A `history_messages_key` that specifies what the previous messages should be injected into the prompt as. Our prompt has a `MessagesPlaceholder` named `chat_history`, so we specify this property to match.\n",
-    "- (For chains with multiple outputs) an `output_messages_key` which specifies which output to store as history. This is the inverse of `input_messages_key`.\n",
-    "\n",
-    "We can invoke this new chain as normal, with an additional `configurable` field that specifies the particular `session_id` to pass to the factory function. This is unused for the demo, but in real-world chains, you'll want to return a chat history corresponding to the passed session:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Parent run dc4e2f79-4bcd-4a36-9506-55ace9040588 not found for run 34b5773e-3ced-46a6-8daf-4d464c15c940. Treating as a root run.\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='\"J\\'adore la programmation.\"', response_metadata={'token_usage': {'completion_tokens': 9, 'prompt_tokens': 39, 'total_tokens': 48}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-648b0822-b0bb-47a2-8e7d-7d34744be8f2-0', usage_metadata={'input_tokens': 39, 'output_tokens': 9, 'total_tokens': 48})"
+       "{'messages': [HumanMessage(content='Translate this sentence from English to French: I love programming.', additional_kwargs={}, response_metadata={}, id='200f88bb-936a-4877-990c-8b4112d82cfe'),\n",
+       "  AIMessage(content='The translation of \"I love programming\" in French is \"J\\'aime programmer.\"', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 16, 'prompt_tokens': 39, 'total_tokens': 55, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_1bb46167f9', 'finish_reason': 'stop', 'logprobs': None}, id='run-d4ebcdcf-9a60-4471-ad8d-96169f614ada-0', usage_metadata={'input_tokens': 39, 'output_tokens': 16, 'total_tokens': 55}),\n",
+       "  HumanMessage(content='What did I just ask you?', additional_kwargs={}, response_metadata={}, id='df32f0a6-38fe-418a-98fe-7a5f17d0b812'),\n",
+       "  AIMessage(content='You asked me to translate the sentence \"I love programming\" from English to French.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 70, 'total_tokens': 87, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_1bb46167f9', 'finish_reason': 'stop', 'logprobs': None}, id='run-1ee8ad67-d7f0-4bb9-adff-e632be6e2825-0', usage_metadata={'input_tokens': 70, 'output_tokens': 17, 'total_tokens': 87})]}"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "chain_with_message_history.invoke(\n",
-    "    {\"input\": \"Translate this sentence from English to French: I love programming.\"},\n",
-    "    {\"configurable\": {\"session_id\": \"unused\"}},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Parent run cc14b9d8-c59e-40db-a523-d6ab3fc2fa4f not found for run 5b75e25c-131e-46ee-9982-68569db04330. Treating as a root run.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='You asked me to translate the sentence \"I love programming\" from English to French.', response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 63, 'total_tokens': 80}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-5950435c-1dc2-43a6-836f-f989fd62c95e-0', usage_metadata={'input_tokens': 63, 'output_tokens': 17, 'total_tokens': 80})"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_message_history.invoke(\n",
-    "    {\"input\": \"What did I just ask you?\"}, {\"configurable\": {\"session_id\": \"unused\"}}\n",
+    "app.invoke(\n",
+    "    {\"messages\": [HumanMessage(content=\"What did I just ask you?\")]},\n",
+    "    config={\"configurable\": {\"thread_id\": \"1\"}},\n",
     ")"
    ]
   },
@@ -366,80 +248,44 @@
     "\n",
     "### Trimming messages\n",
     "\n",
-    "LLMs and chat models have limited context windows, and even if you're not directly hitting limits, you may want to limit the amount of distraction the model has to deal with. One solution is trim the historic messages before passing them to the model. Let's use an example history with some preloaded messages:"
+    "LLMs and chat models have limited context windows, and even if you're not directly hitting limits, you may want to limit the amount of distraction the model has to deal with. One solution is trim the history messages before passing them to the model. Let's use an example history with the `app` we declared above:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[HumanMessage(content=\"Hey there! I'm Nemo.\"),\n",
-       " AIMessage(content='Hello!'),\n",
-       " HumanMessage(content='How are you today?'),\n",
-       " AIMessage(content='Fine thanks!')]"
+       "{'messages': [HumanMessage(content=\"Hey there! I'm Nemo.\", additional_kwargs={}, response_metadata={}, id='99321048-3390-4da6-919b-4ad933c4913b'),\n",
+       "  AIMessage(content='Hello!', additional_kwargs={}, response_metadata={}, id='1c3eaf4a-b698-4bc6-a7a6-549290c3fc7e'),\n",
+       "  HumanMessage(content='How are you today?', additional_kwargs={}, response_metadata={}, id='6f96db9d-ac30-4b4a-9ebc-bc11ae87646b'),\n",
+       "  AIMessage(content='Fine thanks!', additional_kwargs={}, response_metadata={}, id='e783fbb6-2892-42ea-9859-ae449e4cfdf6'),\n",
+       "  HumanMessage(content=\"What's my name?\", additional_kwargs={}, response_metadata={}, id='854065c4-09a0-4c2a-9f2c-eb7182dcc9d5'),\n",
+       "  AIMessage(content='Your name is Nemo.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 63, 'total_tokens': 68, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_1bb46167f9', 'finish_reason': 'stop', 'logprobs': None}, id='run-eed15b83-b215-47a3-b374-404d6a05ab94-0', usage_metadata={'input_tokens': 63, 'output_tokens': 5, 'total_tokens': 68})]}"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "demo_ephemeral_chat_history = ChatMessageHistory()\n",
+    "demo_ephemeral_chat_history = [\n",
+    "    HumanMessage(content=\"Hey there! I'm Nemo.\"),\n",
+    "    AIMessage(content=\"Hello!\"),\n",
+    "    HumanMessage(content=\"How are you today?\"),\n",
+    "    AIMessage(content=\"Fine thanks!\"),\n",
+    "]\n",
     "\n",
-    "demo_ephemeral_chat_history.add_user_message(\"Hey there! I'm Nemo.\")\n",
-    "demo_ephemeral_chat_history.add_ai_message(\"Hello!\")\n",
-    "demo_ephemeral_chat_history.add_user_message(\"How are you today?\")\n",
-    "demo_ephemeral_chat_history.add_ai_message(\"Fine thanks!\")\n",
-    "\n",
-    "demo_ephemeral_chat_history.messages"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's use this message history with the `RunnableWithMessageHistory` chain we declared above:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Parent run 7ff2d8ec-65e2-4f67-8961-e498e2c4a591 not found for run 3881e990-6596-4326-84f6-2b76949e0657. Treating as a root run.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Your name is Nemo.', response_metadata={'token_usage': {'completion_tokens': 6, 'prompt_tokens': 66, 'total_tokens': 72}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-f8aabef8-631a-4238-a39b-701e881fbe47-0', usage_metadata={'input_tokens': 66, 'output_tokens': 6, 'total_tokens': 72})"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_message_history = RunnableWithMessageHistory(\n",
-    "    chain,\n",
-    "    lambda session_id: demo_ephemeral_chat_history,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
-    ")\n",
-    "\n",
-    "chain_with_message_history.invoke(\n",
-    "    {\"input\": \"What's my name?\"},\n",
-    "    {\"configurable\": {\"session_id\": \"unused\"}},\n",
+    "app.invoke(\n",
+    "    {\n",
+    "        \"messages\": demo_ephemeral_chat_history\n",
+    "        + [HumanMessage(content=\"What's my name?\")]\n",
+    "    },\n",
+    "    config={\"configurable\": {\"thread_id\": \"2\"}},\n",
     ")"
    ]
   },
@@ -447,35 +293,88 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can see the chain remembers the preloaded name.\n",
+    "We can see the app remembers the preloaded name.\n",
     "\n",
-    "But let's say we have a very small context window, and we want to trim the number of messages passed to the chain to only the 2 most recent ones. We can use the built in [trim_messages](/docs/how_to/trim_messages/) util to trim messages based on their token count before they reach our prompt. In this case we'll count each message as 1 \"token\" and keep only the last two messages:"
+    "But let's say we have a very small context window, and we want to trim the number of messages passed to the model to only the 2 most recent ones. We can use the built in [trim_messages](/docs/how_to/trim_messages/) util to trim messages based on their token count before they reach our prompt. In this case we'll count each message as 1 \"token\" and keep only the last two messages:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from operator import itemgetter\n",
-    "\n",
     "from langchain_core.messages import trim_messages\n",
-    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, MessagesState, StateGraph\n",
     "\n",
+    "# Define trimmer\n",
+    "# highlight-start\n",
+    "# count each message as 1 \"token\" (token_counter=len) and keep only the last two messages\n",
     "trimmer = trim_messages(strategy=\"last\", max_tokens=2, token_counter=len)\n",
+    "# highlight-end\n",
     "\n",
-    "chain_with_trimming = (\n",
-    "    RunnablePassthrough.assign(chat_history=itemgetter(\"chat_history\") | trimmer)\n",
-    "    | prompt\n",
-    "    | chat\n",
-    ")\n",
+    "workflow = StateGraph(state_schema=MessagesState)\n",
     "\n",
-    "chain_with_trimmed_history = RunnableWithMessageHistory(\n",
-    "    chain_with_trimming,\n",
-    "    lambda session_id: demo_ephemeral_chat_history,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
+    "\n",
+    "# Define the function that calls the model\n",
+    "def call_model(state: MessagesState):\n",
+    "    # highlight-start\n",
+    "    trimmed_messages = trimmer.invoke(state[\"messages\"])\n",
+    "    system_prompt = (\n",
+    "        \"You are a helpful assistant. \"\n",
+    "        \"Answer all questions to the best of your ability.\"\n",
+    "    )\n",
+    "    messages = [SystemMessage(content=system_prompt)] + trimmed_messages\n",
+    "    # highlight-end\n",
+    "    response = model.invoke(messages)\n",
+    "    return {\"messages\": response}\n",
+    "\n",
+    "\n",
+    "# Define the node and edge\n",
+    "workflow.add_node(\"model\", call_model)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "\n",
+    "# Add simple in-memory checkpointer\n",
+    "memory = MemorySaver()\n",
+    "app = workflow.compile(checkpointer=memory)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's call this new app and check the response"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'messages': [HumanMessage(content=\"Hey there! I'm Nemo.\", additional_kwargs={}, response_metadata={}, id='99321048-3390-4da6-919b-4ad933c4913b'),\n",
+       "  AIMessage(content='Hello!', additional_kwargs={}, response_metadata={}, id='1c3eaf4a-b698-4bc6-a7a6-549290c3fc7e'),\n",
+       "  HumanMessage(content='How are you today?', additional_kwargs={}, response_metadata={}, id='6f96db9d-ac30-4b4a-9ebc-bc11ae87646b'),\n",
+       "  AIMessage(content='Fine thanks!', additional_kwargs={}, response_metadata={}, id='e783fbb6-2892-42ea-9859-ae449e4cfdf6'),\n",
+       "  HumanMessage(content='What is my name?', additional_kwargs={}, response_metadata={}, id='c8ba5e90-89cb-4b34-ad4c-11c0478422d8'),\n",
+       "  AIMessage(content=\"I'm sorry, but I don't know your name. How can I assist you today?\", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 39, 'total_tokens': 56, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_1bb46167f9', 'finish_reason': 'stop', 'logprobs': None}, id='run-aa86d3f8-898e-4146-aa3c-2c424934b0f5-0', usage_metadata={'input_tokens': 39, 'output_tokens': 17, 'total_tokens': 56})]}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "app.invoke(\n",
+    "    {\n",
+    "        \"messages\": demo_ephemeral_chat_history\n",
+    "        + [HumanMessage(content=\"What is my name?\")]\n",
+    "    },\n",
+    "    config={\"configurable\": {\"thread_id\": \"3\"}},\n",
     ")"
    ]
   },
@@ -483,101 +382,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's call this new chain and check the messages afterwards:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Parent run 775cde65-8d22-4c44-80bb-f0b9811c32ca not found for run 5cf71d0e-4663-41cd-8dbe-e9752689cfac. Treating as a root run.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='P. Sherman is a fictional character from the animated movie \"Finding Nemo\" who lives at 42 Wallaby Way, Sydney.', response_metadata={'token_usage': {'completion_tokens': 27, 'prompt_tokens': 53, 'total_tokens': 80}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-5642ef3a-fdbe-43cf-a575-d1785976a1b9-0', usage_metadata={'input_tokens': 53, 'output_tokens': 27, 'total_tokens': 80})"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_trimmed_history.invoke(\n",
-    "    {\"input\": \"Where does P. Sherman live?\"},\n",
-    "    {\"configurable\": {\"session_id\": \"unused\"}},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[HumanMessage(content=\"Hey there! I'm Nemo.\"),\n",
-       " AIMessage(content='Hello!'),\n",
-       " HumanMessage(content='How are you today?'),\n",
-       " AIMessage(content='Fine thanks!'),\n",
-       " HumanMessage(content=\"What's my name?\"),\n",
-       " AIMessage(content='Your name is Nemo.', response_metadata={'token_usage': {'completion_tokens': 6, 'prompt_tokens': 66, 'total_tokens': 72}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-f8aabef8-631a-4238-a39b-701e881fbe47-0', usage_metadata={'input_tokens': 66, 'output_tokens': 6, 'total_tokens': 72}),\n",
-       " HumanMessage(content='Where does P. Sherman live?'),\n",
-       " AIMessage(content='P. Sherman is a fictional character from the animated movie \"Finding Nemo\" who lives at 42 Wallaby Way, Sydney.', response_metadata={'token_usage': {'completion_tokens': 27, 'prompt_tokens': 53, 'total_tokens': 80}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-5642ef3a-fdbe-43cf-a575-d1785976a1b9-0', usage_metadata={'input_tokens': 53, 'output_tokens': 27, 'total_tokens': 80})]"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "demo_ephemeral_chat_history.messages"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "And we can see that our history has removed the two oldest messages while still adding the most recent conversation at the end. The next time the chain is called, `trim_messages` will be called again, and only the two most recent messages will be passed to the model. In this case, this means that the model will forget the name we gave it the next time we invoke it:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Parent run fde7123f-6fd3-421a-a3fc-2fb37dead119 not found for run 061a4563-2394-470d-a3ed-9bf1388ca431. Treating as a root run.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content=\"I'm sorry, but I don't have access to your personal information, so I don't know your name. How else may I assist you today?\", response_metadata={'token_usage': {'completion_tokens': 31, 'prompt_tokens': 74, 'total_tokens': 105}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0ab03495-1f7c-4151-9070-56d2d1c565ff-0', usage_metadata={'input_tokens': 74, 'output_tokens': 31, 'total_tokens': 105})"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_trimmed_history.invoke(\n",
-    "    {\"input\": \"What is my name?\"},\n",
-    "    {\"configurable\": {\"session_id\": \"unused\"}},\n",
-    ")"
+    "We can see that `trim_messages` was called and only the two most recent messages will be passed to the model. In this case, this means that the model forgot the name we gave it."
    ]
   },
   {
@@ -593,114 +398,82 @@
    "source": [
     "### Summary memory\n",
     "\n",
-    "We can use this same pattern in other ways too. For example, we could use an additional LLM call to generate a summary of the conversation before calling our chain. Let's recreate our chat history and chatbot chain:"
+    "We can use this same pattern in other ways too. For example, we could use an additional LLM call to generate a summary of the conversation before calling our app. Let's recreate our chat history:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[HumanMessage(content=\"Hey there! I'm Nemo.\"),\n",
-       " AIMessage(content='Hello!'),\n",
-       " HumanMessage(content='How are you today?'),\n",
-       " AIMessage(content='Fine thanks!')]"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "demo_ephemeral_chat_history = ChatMessageHistory()\n",
-    "\n",
-    "demo_ephemeral_chat_history.add_user_message(\"Hey there! I'm Nemo.\")\n",
-    "demo_ephemeral_chat_history.add_ai_message(\"Hello!\")\n",
-    "demo_ephemeral_chat_history.add_user_message(\"How are you today?\")\n",
-    "demo_ephemeral_chat_history.add_ai_message(\"Fine thanks!\")\n",
-    "\n",
-    "demo_ephemeral_chat_history.messages"
+    "demo_ephemeral_chat_history = [\n",
+    "    HumanMessage(content=\"Hey there! I'm Nemo.\"),\n",
+    "    AIMessage(content=\"Hello!\"),\n",
+    "    HumanMessage(content=\"How are you today?\"),\n",
+    "    AIMessage(content=\"Fine thanks!\"),\n",
+    "]"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We'll slightly modify the prompt to make the LLM aware that will receive a condensed summary instead of a chat history:"
+    "And now, let's update the model-calling function to distill previous interactions into a summary:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\n",
-    "            \"system\",\n",
-    "            \"You are a helpful assistant. Answer all questions to the best of your ability. The provided chat history includes facts about the user you are speaking with.\",\n",
-    "        ),\n",
-    "        (\"placeholder\", \"{chat_history}\"),\n",
-    "        (\"user\", \"{input}\"),\n",
-    "    ]\n",
-    ")\n",
+    "from langchain_core.messages import HumanMessage, RemoveMessage\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, MessagesState, StateGraph\n",
     "\n",
-    "chain = prompt | chat\n",
+    "workflow = StateGraph(state_schema=MessagesState)\n",
     "\n",
-    "chain_with_message_history = RunnableWithMessageHistory(\n",
-    "    chain,\n",
-    "    lambda session_id: demo_ephemeral_chat_history,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "And now, let's create a function that will distill previous interactions into a summary. We can add this one to the front of the chain too:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def summarize_messages(chain_input):\n",
-    "    stored_messages = demo_ephemeral_chat_history.messages\n",
-    "    if len(stored_messages) == 0:\n",
-    "        return False\n",
-    "    summarization_prompt = ChatPromptTemplate.from_messages(\n",
-    "        [\n",
-    "            (\"placeholder\", \"{chat_history}\"),\n",
-    "            (\n",
-    "                \"user\",\n",
-    "                \"Distill the above chat messages into a single summary message. Include as many specific details as you can.\",\n",
-    "            ),\n",
-    "        ]\n",
+    "\n",
+    "# Define the function that calls the model\n",
+    "def call_model(state: MessagesState):\n",
+    "    system_prompt = (\n",
+    "        \"You are a helpful assistant. \"\n",
+    "        \"Answer all questions to the best of your ability. \"\n",
+    "        \"The provided chat history includes a summary of the earlier conversation.\"\n",
     "    )\n",
-    "    summarization_chain = summarization_prompt | chat\n",
+    "    system_message = SystemMessage(content=system_prompt)\n",
+    "    # Summarize the messages\n",
+    "    if len(state[\"messages\"]) > 1:\n",
+    "        *message_history, last_human_message = state[\"messages\"]\n",
+    "        # Invoke the model to generate conversation summary\n",
+    "        summary_prompt = (\n",
+    "            \"Distill the above chat messages into a single summary message. \"\n",
+    "            \"Include as many specific details as you can.\"\n",
+    "        )\n",
+    "        summary_message = model.invoke(\n",
+    "            message_history + [HumanMessage(content=summary_prompt)]\n",
+    "        )\n",
+    "        # Delete messages that we no longer want to show up\n",
+    "        delete_messages = [RemoveMessage(id=m.id) for m in state[\"messages\"]]\n",
+    "        # Re-add user message\n",
+    "        human_message = HumanMessage(content=last_human_message.content)\n",
+    "        # Call the model with summary & response\n",
+    "        response = model.invoke([system_message, summary_message, human_message])\n",
+    "        message_updates = [summary_message, human_message, response] + delete_messages\n",
+    "    else:\n",
+    "        message_updates = model.invoke([system_message] + state[\"messages\"])\n",
     "\n",
-    "    summary_message = summarization_chain.invoke({\"chat_history\": stored_messages})\n",
-    "\n",
-    "    demo_ephemeral_chat_history.clear()\n",
-    "\n",
-    "    demo_ephemeral_chat_history.add_message(summary_message)\n",
-    "\n",
-    "    return True\n",
+    "    return {\"messages\": message_updates}\n",
     "\n",
     "\n",
-    "chain_with_summarization = (\n",
-    "    RunnablePassthrough.assign(messages_summarized=summarize_messages)\n",
-    "    | chain_with_message_history\n",
-    ")"
+    "# Define the node and edge\n",
+    "workflow.add_node(\"model\", call_model)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "\n",
+    "# Add simple in-memory checkpointer\n",
+    "memory = MemorySaver()\n",
+    "app = workflow.compile(checkpointer=memory)"
    ]
   },
   {
@@ -712,54 +485,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='You introduced yourself as Nemo. How can I assist you today, Nemo?')"
+       "{'messages': [AIMessage(content='Nemo greeted me, and I responded positively, indicating that I am doing fine.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 60, 'total_tokens': 77, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_1bb46167f9', 'finish_reason': 'stop', 'logprobs': None}, id='run-94df0e9f-6b1c-4e68-858c-5b23058b16d8-0', usage_metadata={'input_tokens': 60, 'output_tokens': 17, 'total_tokens': 77}),\n",
+       "  HumanMessage(content='What did I say my name was?', additional_kwargs={}, response_metadata={}, id='d3f57f56-dd1a-45f9-add2-146f54c1180c'),\n",
+       "  AIMessage(content='You mentioned that your name is Nemo.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 8, 'prompt_tokens': 68, 'total_tokens': 76, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_1bb46167f9', 'finish_reason': 'stop', 'logprobs': None}, id='run-ea144209-5d37-4bb5-8529-be235626fc74-0', usage_metadata={'input_tokens': 68, 'output_tokens': 8, 'total_tokens': 76})]}"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "chain_with_summarization.invoke(\n",
-    "    {\"input\": \"What did I say my name was?\"},\n",
-    "    {\"configurable\": {\"session_id\": \"unused\"}},\n",
+    "app.invoke(\n",
+    "    {\n",
+    "        \"messages\": demo_ephemeral_chat_history\n",
+    "        + [HumanMessage(\"What did I say my name was?\")]\n",
+    "    },\n",
+    "    config={\"configurable\": {\"thread_id\": \"4\"}},\n",
     ")"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[AIMessage(content='The conversation is between Nemo and an AI. Nemo introduces himself and the AI responds with a greeting. Nemo then asks the AI how it is doing, and the AI responds that it is fine.'),\n",
-       " HumanMessage(content='What did I say my name was?'),\n",
-       " AIMessage(content='You introduced yourself as Nemo. How can I assist you today, Nemo?')]"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "demo_ephemeral_chat_history.messages"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note that invoking the chain again will generate another summary generated from the initial summary plus new messages and so on. You could also design a hybrid approach where a certain number of messages are retained in chat history while others are summarized."
+    "Note that invoking the app again will generate another summary generated from the initial summary plus new messages and so on. You could also design a hybrid approach where a certain number of messages are retained in chat history while others are summarized."
    ]
   }
  ],
@@ -779,7 +535,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

docs/docs/how_to/langgraph_persistence.md

@@ -0,0 +1,31 @@
+# How to upgrade to LangGraph persistence
+
+As of the v0.3 release of LangChain, we recommend that LangChain users take advantage of [LangGraph persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/) to incorporate `memory` into their LangChain application.
+
+## Evolution of memory in LangChain 
+
+The concept of memory has evolved significantly in LangChain since its initial release.
+
+In LangChain 0.0.x, memory was based on the [BaseMemory](https://api.python.langchain.com/en/latest/memory/langchain_core.memory.BaseMemory.html) interface and the [BaseChatMessageHistory](https://api.python.langchain.com/en/latest/history/langchain_core.runnables.history.BaseChatMessageHistory.html) interface.
+
+There were number of useful [memory implementations](https://python.langchain.com/api_reference/langchain/memory.html) based
+on the `BaseMemory` interface (e.g.[ConversationBufferMemory](https://python.langchain.com/api_reference/langchain/memory/langchain.memory.buffer.ConversationBufferMemory.html), [ConversationBufferWindowMemory](https://python.langchain.com/api_reference/langchain/memory/langchain.memory.buffer_window.ConversationBufferWindowMemory.html)); however, these lacked built-in support for multi-user, multi-conversation scenarios, which are essential for practical conversational AI systems.
+
+:::note
+If you are relying on any deprecated memory abstractions in LangChain 0.0.x, we recommend that you follow
+the given steps to upgrade to the new LangGraph persistence feature in LangChain 0.3.x.
+https://python.langchain.com/docs/versions/migrating_memory/
+:::
+
+As of LangChain v0.1, we started recommending that users rely primarily on [BaseChatMessageHistory](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html#langchain_core.runnables.history.RunnableWithMessageHistory). `BaseChatMessageHistory` is a simple persistence layer for a chat history that can be used to store and retrieve messages in a conversation. At this time, the only option for orchestrating LangChain chains was via [LCEL](https://python.langchain.com/docs/how_to/#langchain-expression-language-lcel). When using `LCEL`, memory can be added using the [RunnableWithMessageHistory](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html#langchain_core.runnables.history.RunnableWithMessageHistory) interface. While this option is sufficient for building a simple chat application, many users found the API to be unintuitive and difficult to work with.
+
+As of LangChain v0.3, we are commending that new code rely on LangGraph for both orchestration and persistence.
+
+Specifically, for orchestration instead of writing `LCEL` code, users can define LangGraph [graphs](https://langchain-ai.github.io/langgraph/concepts/low_level/). This allows users to keep using `LCEL` within individual nodes when `LCEL` is needed, while
+making it easy to define complex orchestration logic that is more readable and maintainable.
+
+For persistence, users can use LangGraph's [persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/) feature to store and retrieve data from a graph database. LangGraph persistence is extremely flexible and can support a much wider range of use cases than the `RunnableWithMessageHistory` interface.
+
+:::important
+If you have been using `RunnableWithMessageHistory` or `BaseChatMessageHistory`, you do not need to make any changes. We do not plan on deprecating either functionality in the near future. This functionality is sufficient for simple chat applications and any code that uses `RunnableWithMessageHistory` will continue to work as expected.
+:::

docs/docs/how_to/qa_chat_history_how_to.ipynb

@@ -7,6 +7,15 @@
    "source": [
     "# How to add chat history\n",
     "\n",
+    "\n",
+    ":::{.callout-note}\n",
+    "\n",
+    "This tutorial previously built a chatbot using [RunnableWithMessageHistory](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html). You can access this version of the tutorial in the [v0.2 docs](https://python.langchain.com/v0.2/docs/how_to/qa_chat_history_how_to/).\n",
+    "\n",
+    "The LangGraph implementation offers a number of advantages over `RunnableWithMessageHistory`, including the ability to persist arbitrary components of an application's state (instead of only messages).\n",
+    "\n",
+    ":::\n",
+    "\n",
     "In many Q&A applications we want to allow the user to have a back-and-forth conversation, meaning the application needs some sort of \"memory\" of past questions and answers, and some logic for incorporating those into its current thinking.\n",
     "\n",
     "In this guide we focus on **adding logic for incorporating historical messages.**\n",
@@ -29,7 +38,7 @@
     "\n",
     "### Dependencies\n",
     "\n",
-    "We'll use OpenAI embeddings and a Chroma vector store in this walkthrough, but everything shown here works with any [Embeddings](/docs/concepts#embedding-models), and [VectorStore](/docs/concepts#vectorstores) or [Retriever](/docs/concepts#retrievers). \n",
+    "We'll use OpenAI embeddings and an InMemory vector store in this walkthrough, but everything shown here works with any [Embeddings](/docs/concepts#embedding-models), and [VectorStore](/docs/concepts#vectorstores) or [Retriever](/docs/concepts#retrievers). \n",
     "\n",
     "We'll use the following packages:"
    ]
@@ -42,7 +51,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install --upgrade --quiet  langchain langchain-community langchain-chroma beautifulsoup4"
+    "%pip install --upgrade --quiet  langchain langchain-community beautifulsoup4"
    ]
   },
   {
@@ -64,11 +73,7 @@
     "import os\n",
     "\n",
     "if not os.environ.get(\"OPENAI_API_KEY\"):\n",
-    "    os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()\n",
-    "\n",
-    "# import dotenv\n",
-    "\n",
-    "# dotenv.load_dotenv()"
+    "    os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()"
    ]
   },
   {
@@ -155,7 +160,7 @@
    "id": "15f8ad59-19de-42e3-85a8-3ba95ee0bd43",
    "metadata": {},
    "source": [
-    "For the retriever, we will use [WebBaseLoader](https://python.langchain.com/api_reference/community/document_loaders/langchain_community.document_loaders.web_base.WebBaseLoader.html) to load the content of a web page. Here we instantiate a `Chroma` vectorstore and then use its [.as_retriever](https://python.langchain.com/api_reference/core/vectorstores/langchain_core.vectorstores.VectorStore.html#langchain_core.vectorstores.VectorStore.as_retriever) method to build a retriever that can be incorporated into [LCEL](/docs/concepts/#langchain-expression-language) chains."
+    "For the retriever, we will use [WebBaseLoader](https://python.langchain.com/api_reference/community/document_loaders/langchain_community.document_loaders.web_base.WebBaseLoader.html) to load the content of a web page. Here we instantiate a `InMemoryVectorStore` vectorstore and then use its [.as_retriever](https://python.langchain.com/api_reference/core/vectorstores/langchain_core.vectorstores.VectorStore.html#langchain_core.vectorstores.VectorStore.as_retriever) method to build a retriever that can be incorporated into [LCEL](/docs/concepts/#langchain-expression-language) chains."
    ]
   },
   {
@@ -163,16 +168,24 @@
    "execution_count": 5,
    "id": "820244ae-74b4-4593-b392-822979dd91b8",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "USER_AGENT environment variable not set, consider setting it to identify your requests.\n"
+     ]
+    }
+   ],
    "source": [
     "import bs4\n",
     "from langchain.chains import create_retrieval_chain\n",
     "from langchain.chains.combine_documents import create_stuff_documents_chain\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import WebBaseLoader\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
     "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain_core.vectorstores import InMemoryVectorStore\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "\n",
@@ -188,7 +201,8 @@
     "\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)\n",
     "splits = text_splitter.split_documents(docs)\n",
-    "vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())\n",
+    "vectorstore = InMemoryVectorStore(embedding=OpenAIEmbeddings())\n",
+    "vectorstore.add_documents(splits)\n",
     "retriever = vectorstore.as_retriever()"
    ]
   },
@@ -288,8 +302,8 @@
     "        (\"human\", \"{input}\"),\n",
     "    ]\n",
     ")\n",
-    "question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)\n",
     "\n",
+    "question_answer_chain = create_stuff_documents_chain(llm, qa_prompt)\n",
     "rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)"
    ]
   },
@@ -298,20 +312,17 @@
    "id": "53a662c2-f38b-45f9-95c4-66de15637614",
    "metadata": {},
    "source": [
-    "### Adding chat history\n",
+    "### Stateful Management of chat history\n",
     "\n",
-    "To manage the chat history, we will need:\n",
+    "We have added application logic for incorporating chat history, but we are still manually plumbing it through our application. In production, the Q&A application we usually persist the chat history into a database, and be able to read and update it appropriately.\n",
     "\n",
-    "1. An object for storing the chat history;\n",
-    "2. An object that wraps our chain and manages updates to the chat history.\n",
+    "[LangGraph](https://langchain-ai.github.io/langgraph/) implements a built-in [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/), making it ideal for chat applications that support multiple conversational turns.\n",
     "\n",
-    "For these we will use [BaseChatMessageHistory](https://python.langchain.com/api_reference/core/chat_history/langchain_core.chat_history.BaseChatMessageHistory.html) and [RunnableWithMessageHistory](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html). The latter is a wrapper for an LCEL chain and a `BaseChatMessageHistory` that handles injecting chat history into inputs and updating it after each invocation.\n",
+    "Wrapping our chat model in a minimal LangGraph application allows us to automatically persist the message history, simplifying the development of multi-turn applications.\n",
     "\n",
-    "For a detailed walkthrough of how to use these classes together to create a stateful conversational chain, head to the [How to add message history (memory)](/docs/how_to/message_history/) LCEL how-to guide.\n",
+    "LangGraph comes with a simple [in-memory checkpointer](https://langchain-ai.github.io/langgraph/reference/checkpoints/#memorysaver), which we use below. See its documentation for more detail, including how to use different persistence backends (e.g., SQLite or Postgres).\n",
     "\n",
-    "Below, we implement a simple example of the second option, in which chat histories are stored in a simple dict. LangChain manages memory integrations with [Redis](/docs/integrations/memory/redis_chat_message_history/) and other technologies to provide for more robust persistence.\n",
-    "\n",
-    "Instances of `RunnableWithMessageHistory` manage the chat history for you. They accept a config with a key (`\"session_id\"` by default) that specifies what conversation history to fetch and prepend to the input, and append the output to the same conversation history. Below is an example:"
+    "For a detailed walkthrough of how to manage message history, head to the How to add message history (memory) guide."
    ]
   },
   {
@@ -321,26 +332,48 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_community.chat_message_histories import ChatMessageHistory\n",
-    "from langchain_core.chat_history import BaseChatMessageHistory\n",
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+    "from typing import Sequence\n",
     "\n",
-    "store = {}\n",
+    "from langchain_core.messages import AIMessage, BaseMessage, HumanMessage\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, StateGraph\n",
+    "from langgraph.graph.message import add_messages\n",
+    "from typing_extensions import Annotated, TypedDict\n",
     "\n",
     "\n",
-    "def get_session_history(session_id: str) -> BaseChatMessageHistory:\n",
-    "    if session_id not in store:\n",
-    "        store[session_id] = ChatMessageHistory()\n",
-    "    return store[session_id]\n",
+    "# We define a dict representing the state of the application.\n",
+    "# This state has the same input and output keys as `rag_chain`.\n",
+    "class State(TypedDict):\n",
+    "    input: str\n",
+    "    chat_history: Annotated[Sequence[BaseMessage], add_messages]\n",
+    "    context: str\n",
+    "    answer: str\n",
     "\n",
     "\n",
-    "conversational_rag_chain = RunnableWithMessageHistory(\n",
-    "    rag_chain,\n",
-    "    get_session_history,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
-    "    output_messages_key=\"answer\",\n",
-    ")"
+    "# We then define a simple node that runs the `rag_chain`.\n",
+    "# The `return` values of the node update the graph state, so here we just\n",
+    "# update the chat history with the input message and response.\n",
+    "def call_model(state: State):\n",
+    "    response = rag_chain.invoke(state)\n",
+    "    return {\n",
+    "        \"chat_history\": [\n",
+    "            HumanMessage(state[\"input\"]),\n",
+    "            AIMessage(response[\"answer\"]),\n",
+    "        ],\n",
+    "        \"context\": response[\"context\"],\n",
+    "        \"answer\": response[\"answer\"],\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "# Our graph consists only of one node:\n",
+    "workflow = StateGraph(state_schema=State)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_node(\"model\", call_model)\n",
+    "\n",
+    "# Finally, we compile the graph with a checkpointer object.\n",
+    "# This persists the state, in this case in memory.\n",
+    "memory = MemorySaver()\n",
+    "app = workflow.compile(checkpointer=memory)"
    ]
   },
   {
@@ -350,23 +383,21 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable and easier to accomplish. This process can be done using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Task decomposition can be facilitated by providing simple prompts to a language model, task-specific instructions, or human inputs.'"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This process helps agents or models tackle difficult tasks by dividing them into more manageable subtasks. Task decomposition can be achieved through methods like Chain of Thought or Tree of Thoughts, which guide the model in thinking step by step or exploring multiple reasoning possibilities at each step.\n"
+     ]
     }
    ],
    "source": [
-    "conversational_rag_chain.invoke(\n",
+    "config = {\"configurable\": {\"thread_id\": \"abc123\"}}\n",
+    "\n",
+    "result = app.invoke(\n",
     "    {\"input\": \"What is Task Decomposition?\"},\n",
-    "    config={\n",
-    "        \"configurable\": {\"session_id\": \"abc123\"}\n",
-    "    },  # constructs a key \"abc123\" in `store`.\n",
-    ")[\"answer\"]"
+    "    config=config,\n",
+    ")\n",
+    "print(result[\"answer\"])"
    ]
   },
   {
@@ -376,21 +407,19 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'Task decomposition can be achieved through various methods, including using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Common ways of task decomposition include providing simple prompts to a language model, task-specific instructions, or human inputs to break down complex tasks into smaller and more manageable steps. Additionally, task decomposition can involve utilizing resources like internet access for information gathering, long-term memory management, and GPT-3.5 powered agents for delegation of simple tasks.'"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "One way of task decomposition is by using a Language Model (LLM) with simple prompting, such as providing instructions like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\" This method guides the LLM to break down the task into smaller components for easier processing and execution.\n"
+     ]
     }
    ],
    "source": [
-    "conversational_rag_chain.invoke(\n",
-    "    {\"input\": \"What are common ways of doing it?\"},\n",
-    "    config={\"configurable\": {\"session_id\": \"abc123\"}},\n",
-    ")[\"answer\"]"
+    "result = app.invoke(\n",
+    "    {\"input\": \"What is one way of doing it?\"},\n",
+    "    config=config,\n",
+    ")\n",
+    "print(result[\"answer\"])"
    ]
   },
   {
@@ -398,7 +427,7 @@
    "id": "3ab59258-84bc-4904-880e-2ebfebbca563",
    "metadata": {},
    "source": [
-    "The conversation history can be inspected in the `store` dict:"
+    "The conversation history can be inspected via the state of the application:"
    ]
   },
   {
@@ -411,27 +440,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "User: What is Task Decomposition?\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
       "\n",
-      "AI: Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable and easier to accomplish. This process can be done using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Task decomposition can be facilitated by providing simple prompts to a language model, task-specific instructions, or human inputs.\n",
+      "What is Task Decomposition?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
       "\n",
-      "User: What are common ways of doing it?\n",
+      "Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This process helps agents or models tackle difficult tasks by dividing them into more manageable subtasks. Task decomposition can be achieved through methods like Chain of Thought or Tree of Thoughts, which guide the model in thinking step by step or exploring multiple reasoning possibilities at each step.\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
       "\n",
-      "AI: Task decomposition can be achieved through various methods, including using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Common ways of task decomposition include providing simple prompts to a language model, task-specific instructions, or human inputs to break down complex tasks into smaller and more manageable steps. Additionally, task decomposition can involve utilizing resources like internet access for information gathering, long-term memory management, and GPT-3.5 powered agents for delegation of simple tasks.\n",
-      "\n"
+      "What is one way of doing it?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "One way of task decomposition is by using a Language Model (LLM) with simple prompting, such as providing instructions like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\" This method guides the LLM to break down the task into smaller components for easier processing and execution.\n"
      ]
     }
    ],
    "source": [
-    "from langchain_core.messages import AIMessage\n",
-    "\n",
-    "for message in store[\"abc123\"].messages:\n",
-    "    if isinstance(message, AIMessage):\n",
-    "        prefix = \"AI\"\n",
-    "    else:\n",
-    "        prefix = \"User\"\n",
-    "\n",
-    "    print(f\"{prefix}: {message.content}\\n\")"
+    "chat_history = app.get_state(config).values[\"chat_history\"]\n",
+    "for message in chat_history:\n",
+    "    message.pretty_print()"
    ]
   },
   {
@@ -459,17 +486,24 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from typing import Sequence\n",
+    "\n",
     "import bs4\n",
     "from langchain.chains import create_history_aware_retriever, create_retrieval_chain\n",
     "from langchain.chains.combine_documents import create_stuff_documents_chain\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.chat_message_histories import ChatMessageHistory\n",
     "from langchain_community.document_loaders import WebBaseLoader\n",
     "from langchain_core.chat_history import BaseChatMessageHistory\n",
+    "from langchain_core.messages import AIMessage, BaseMessage, HumanMessage\n",
     "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
     "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+    "from langchain_core.vectorstores import InMemoryVectorStore\n",
     "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, StateGraph\n",
+    "from langgraph.graph.message import add_messages\n",
+    "from typing_extensions import Annotated, TypedDict\n",
     "\n",
     "llm = ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0)\n",
     "\n",
@@ -487,7 +521,9 @@
     "\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)\n",
     "splits = text_splitter.split_documents(docs)\n",
-    "vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())\n",
+    "\n",
+    "vectorstore = InMemoryVectorStore(embedding=OpenAIEmbeddings())\n",
+    "vectorstore.add_documents(documents=splits)\n",
     "retriever = vectorstore.as_retriever()\n",
     "\n",
     "\n",
@@ -534,22 +570,41 @@
     "\n",
     "\n",
     "### Statefully manage chat history ###\n",
-    "store = {}\n",
     "\n",
     "\n",
-    "def get_session_history(session_id: str) -> BaseChatMessageHistory:\n",
-    "    if session_id not in store:\n",
-    "        store[session_id] = ChatMessageHistory()\n",
-    "    return store[session_id]\n",
+    "# We define a dict representing the state of the application.\n",
+    "# This state has the same input and output keys as `rag_chain`.\n",
+    "class State(TypedDict):\n",
+    "    input: str\n",
+    "    chat_history: Annotated[Sequence[BaseMessage], add_messages]\n",
+    "    context: str\n",
+    "    answer: str\n",
     "\n",
     "\n",
-    "conversational_rag_chain = RunnableWithMessageHistory(\n",
-    "    rag_chain,\n",
-    "    get_session_history,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
-    "    output_messages_key=\"answer\",\n",
-    ")"
+    "# We then define a simple node that runs the `rag_chain`.\n",
+    "# The `return` values of the node update the graph state, so here we just\n",
+    "# update the chat history with the input message and response.\n",
+    "def call_model(state: State):\n",
+    "    response = rag_chain.invoke(state)\n",
+    "    return {\n",
+    "        \"chat_history\": [\n",
+    "            HumanMessage(state[\"input\"]),\n",
+    "            AIMessage(response[\"answer\"]),\n",
+    "        ],\n",
+    "        \"context\": response[\"context\"],\n",
+    "        \"answer\": response[\"answer\"],\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "# Our graph consists only of one node:\n",
+    "workflow = StateGraph(state_schema=State)\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_node(\"model\", call_model)\n",
+    "\n",
+    "# Finally, we compile the graph with a checkpointer object.\n",
+    "# This persists the state, in this case in memory.\n",
+    "memory = MemorySaver()\n",
+    "app = workflow.compile(checkpointer=memory)"
    ]
   },
   {
@@ -559,23 +614,21 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable. Techniques like Chain of Thought (CoT) and Tree of Thoughts help in decomposing hard tasks into multiple manageable tasks by instructing models to think step by step and explore multiple reasoning possibilities at each step. Task decomposition can be achieved through various methods such as using prompting techniques, task-specific instructions, or human inputs.'"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This process helps agents or models tackle difficult tasks by dividing them into more manageable subtasks. Different methods like Chain of Thought and Tree of Thoughts are used to guide the decomposition process, enabling a step-by-step approach to problem-solving.\n"
+     ]
     }
    ],
    "source": [
-    "conversational_rag_chain.invoke(\n",
+    "config = {\"configurable\": {\"thread_id\": \"abc123\"}}\n",
+    "\n",
+    "result = app.invoke(\n",
     "    {\"input\": \"What is Task Decomposition?\"},\n",
-    "    config={\n",
-    "        \"configurable\": {\"session_id\": \"abc123\"}\n",
-    "    },  # constructs a key \"abc123\" in `store`.\n",
-    ")[\"answer\"]"
+    "    config=config,\n",
+    ")\n",
+    "print(result[\"answer\"])"
    ]
   },
   {
@@ -585,21 +638,19 @@
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'Task decomposition can be done in common ways such as using prompting techniques like Chain of Thought (CoT) or Tree of Thoughts, which instruct models to think step by step and explore multiple reasoning possibilities at each step. Another way is to provide task-specific instructions, such as asking to \"Write a story outline\" for writing a novel, to guide the decomposition process. Additionally, task decomposition can also involve human inputs to break down complex tasks into smaller and simpler steps.'"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "One way of task decomposition is by using Large Language Models (LLMs) with simple prompting, such as providing instructions like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\" This method leverages the capabilities of LLMs to break down tasks into smaller components, making them easier to manage and solve.\n"
+     ]
     }
    ],
    "source": [
-    "conversational_rag_chain.invoke(\n",
-    "    {\"input\": \"What are common ways of doing it?\"},\n",
-    "    config={\"configurable\": {\"session_id\": \"abc123\"}},\n",
-    ")[\"answer\"]"
+    "result = app.invoke(\n",
+    "    {\"input\": \"What is one way of doing it?\"},\n",
+    "    config=config,\n",
+    ")\n",
+    "print(result[\"answer\"])"
    ]
   },
   {
@@ -672,22 +723,11 @@
    "id": "52ae46d9-43f7-481b-96d5-df750be3ad65",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in LangChainTracer.on_tool_end callback: TracerException(\"Found chain run at ID 5cd28d13-88dd-4eac-a465-3770ac27eff6, but expected {'tool'} run.\")\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_TbhPPPN05GKi36HLeaN4QM90', 'function': {'arguments': '{\"query\":\"Task Decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 68, 'total_tokens': 87}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-2e60d910-879a-4a2a-b1e9-6a6c5c7d7ebc-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Task Decomposition'}, 'id': 'call_TbhPPPN05GKi36HLeaN4QM90'}])]}}\n",
-      "----\n",
-      "{'tools': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.', name='blog_post_retriever', tool_call_id='call_TbhPPPN05GKi36HLeaN4QM90')]}}\n",
-      "----\n",
-      "{'agent': {'messages': [AIMessage(content='Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This approach helps in transforming big tasks into multiple manageable tasks, making it easier for autonomous agents to handle and interpret the thinking process. One common method for task decomposition is the Chain of Thought (CoT) technique, where models are instructed to \"think step by step\" to decompose hard tasks. Another extension of CoT is the Tree of Thoughts, which explores multiple reasoning possibilities at each step by creating a tree structure of multiple thoughts per step. Task decomposition can be facilitated through various methods such as using simple prompts, task-specific instructions, or human inputs.', response_metadata={'token_usage': {'completion_tokens': 130, 'prompt_tokens': 636, 'total_tokens': 766}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-3ef17638-65df-4030-a7fe-795e6da91c69-0')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='Task decomposition is a problem-solving strategy that involves breaking down a complex task or problem into smaller, more manageable subtasks. By decomposing a task, individuals can better understand the components of the task, allocate resources effectively, and solve the problem more efficiently. This approach allows for a systematic and organized way of approaching complex tasks by dividing them into smaller, more achievable steps.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 75, 'prompt_tokens': 68, 'total_tokens': 143, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-01d17f40-c853-4e16-96bd-1e231e2486b5-0', usage_metadata={'input_tokens': 68, 'output_tokens': 75, 'total_tokens': 143})]}}\n",
       "----\n"
      ]
     }
@@ -748,7 +788,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='Hello Bob! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 67, 'total_tokens': 78}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-1cd17562-18aa-4839-b41b-403b17a0fc20-0')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='Hello Bob! How can I assist you today?', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 67, 'total_tokens': 78, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-e41bbdf4-da73-43e3-b980-f0d258c4713d-0', usage_metadata={'input_tokens': 67, 'output_tokens': 11, 'total_tokens': 78})]}}\n",
       "----\n"
      ]
     }
@@ -777,22 +817,15 @@
    "id": "e2c570ae-dd91-402c-8693-ae746de63b16",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in LangChainTracer.on_tool_end callback: TracerException(\"Found chain run at ID c54381c0-c5d9-495a-91a0-aca4ae755663, but expected {'tool'} run.\")\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_rg7zKTE5e0ICxVSslJ1u9LMg', 'function': {'arguments': '{\"query\":\"Task Decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 91, 'total_tokens': 110}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-122bf097-7ff1-49aa-b430-e362b51354ad-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Task Decomposition'}, 'id': 'call_rg7zKTE5e0ICxVSslJ1u9LMg'}])]}}\n",
+      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_ygtIVKtuMQEsY95j31BvhzzN', 'function': {'arguments': '{\"query\":\"Task Decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 91, 'total_tokens': 110, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-61b7e948-e450-4902-b21c-66db5df816fc-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Task Decomposition'}, 'id': 'call_ygtIVKtuMQEsY95j31BvhzzN', 'type': 'tool_call'}], usage_metadata={'input_tokens': 91, 'output_tokens': 19, 'total_tokens': 110})]}}\n",
       "----\n",
-      "{'tools': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.', name='blog_post_retriever', tool_call_id='call_rg7zKTE5e0ICxVSslJ1u9LMg')]}}\n",
+      "{'tools': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\n(3) Task execution: Expert models execute on the specific tasks and log results.\\nInstruction:\\n\\nWith the input and the inference results, the AI assistant needs to describe the process and results. The previous stages can be formed as - User Input: {{ User Input }}, Task Planning: {{ Tasks }}, Model Selection: {{ Model Assignment }}, Task Execution: {{ Predictions }}. You must first answer the user\\'s request in a straightforward manner. Then describe the task process and show your analysis and model inference results to the user in the first person. If inference results contain a file path, must tell the user the complete file path.\\n\\nFig. 11. Illustration of how HuggingGPT works. (Image source: Shen et al. 2023)\\nThe system comprises of 4 stages:\\n(1) Task planning: LLM works as the brain and parses the user requests into multiple tasks. There are four attributes associated with each task: task type, ID, dependencies, and arguments. They use few-shot examples to guide LLM to do task parsing and planning.\\nInstruction:', name='blog_post_retriever', tool_call_id='call_ygtIVKtuMQEsY95j31BvhzzN')]}}\n",
       "----\n",
-      "{'agent': {'messages': [AIMessage(content='Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This approach helps in managing and solving intricate problems by dividing them into more manageable components. By decomposing tasks, agents or models can better understand the steps involved and plan their actions accordingly. Techniques like Chain of Thought (CoT) and Tree of Thoughts are examples of methods that enhance model performance on complex tasks by breaking them down into smaller steps.', response_metadata={'token_usage': {'completion_tokens': 87, 'prompt_tokens': 659, 'total_tokens': 746}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-b9166386-83e5-4b82-9a4b-590e5fa76671-0')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This approach helps autonomous agents or models to handle challenging tasks by dividing them into more manageable subtasks. One common method for task decomposition is the Chain of Thought (CoT) technique, where models are prompted to think step by step to decompose difficult tasks.\\n\\nAnother extension of CoT is the Tree of Thoughts, which explores multiple reasoning possibilities at each step by creating a tree structure of multiple thoughts per step. Task decomposition can be facilitated by providing simple prompts to language models, using task-specific instructions, or incorporating human inputs.\\n\\nOverall, task decomposition plays a crucial role in enabling autonomous agents to plan and execute complex tasks effectively by breaking them down into smaller, more manageable components.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 153, 'prompt_tokens': 611, 'total_tokens': 764, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-68aed524-fdf4-4d34-8546-dfb02f2a03cd-0', usage_metadata={'input_tokens': 611, 'output_tokens': 153, 'total_tokens': 764})]}}\n",
       "----\n"
      ]
     }
@@ -827,24 +860,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_6kbxTU5CDWLmF9mrvR7bWSkI', 'function': {'arguments': '{\"query\":\"Common ways of task decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 21, 'prompt_tokens': 769, 'total_tokens': 790}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-2d2c8327-35cd-484a-b8fd-52436657c2d8-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Common ways of task decomposition'}, 'id': 'call_6kbxTU5CDWLmF9mrvR7bWSkI'}])]}}\n",
-      "----\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in LangChainTracer.on_tool_end callback: TracerException(\"Found chain run at ID 29553415-e0f4-41a9-8921-ba489e377f68, but expected {'tool'} run.\")\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'tools': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.', name='blog_post_retriever', tool_call_id='call_6kbxTU5CDWLmF9mrvR7bWSkI')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_QOoWDqK4Bopi8P9HzGmnHAd5', 'function': {'arguments': '{\"query\":\"common ways of task decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 21, 'prompt_tokens': 787, 'total_tokens': 808, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-096ddff3-9505-4b2f-ae87-c5af6924dd00-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'common ways of task decomposition'}, 'id': 'call_QOoWDqK4Bopi8P9HzGmnHAd5', 'type': 'tool_call'}], usage_metadata={'input_tokens': 787, 'output_tokens': 21, 'total_tokens': 808})]}}\n",
       "----\n",
-      "{'agent': {'messages': [AIMessage(content='Common ways of task decomposition include:\\n1. Using LLM with simple prompting like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\"\\n2. Using task-specific instructions, for example, \"Write a story outline\" for writing a novel.\\n3. Involving human inputs in the task decomposition process.', response_metadata={'token_usage': {'completion_tokens': 67, 'prompt_tokens': 1339, 'total_tokens': 1406}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-9ad14cde-ca75-4238-a868-f865e0fc50dd-0')]}}\n",
+      "{'tools': {'messages': [ToolMessage(content='Tree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nResources:\\n1. Internet access for searches and information gathering.\\n2. Long Term memory management.\\n3. GPT-3.5 powered Agents for delegation of simple tasks.\\n4. File output.\\n\\nPerformance Evaluation:\\n1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.\\n2. Constructively self-criticize your big-picture behavior constantly.\\n3. Reflect on past decisions and strategies to refine your approach.\\n4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.\\n\\n(3) Task execution: Expert models execute on the specific tasks and log results.\\nInstruction:\\n\\nWith the input and the inference results, the AI assistant needs to describe the process and results. The previous stages can be formed as - User Input: {{ User Input }}, Task Planning: {{ Tasks }}, Model Selection: {{ Model Assignment }}, Task Execution: {{ Predictions }}. You must first answer the user\\'s request in a straightforward manner. Then describe the task process and show your analysis and model inference results to the user in the first person. If inference results contain a file path, must tell the user the complete file path.', name='blog_post_retriever', tool_call_id='call_QOoWDqK4Bopi8P9HzGmnHAd5')]}}\n",
+      "----\n",
+      "{'agent': {'messages': [AIMessage(content='Common ways of task decomposition include:\\n\\n1. Using Language Models (LLM) with simple prompting: Language models can be prompted with instructions like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\" to break down tasks into smaller steps.\\n\\n2. Task-specific instructions: Providing specific instructions tailored to the task at hand, such as \"Write a story outline\" for writing a novel, can help in decomposing tasks effectively.\\n\\n3. Human inputs: Involving human inputs in the task decomposition process can also be a common approach to breaking down complex tasks into manageable subtasks.\\n\\nThese methods of task decomposition play a crucial role in enabling autonomous agents to effectively plan and execute complex tasks by breaking them down into smaller, more manageable components.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 152, 'prompt_tokens': 1332, 'total_tokens': 1484, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-41868dd4-a1d9-4323-b7b0-ac52c228a2ac-0', usage_metadata={'input_tokens': 1332, 'output_tokens': 152, 'total_tokens': 1484})]}}\n",
       "----\n"
      ]
     }
@@ -879,18 +899,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 1,
    "id": "b1d2b4d4-e604-497d-873d-d345b808578e",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "USER_AGENT environment variable not set, consider setting it to identify your requests.\n"
+     ]
+    }
+   ],
    "source": [
     "import bs4\n",
     "from langchain.tools.retriever import create_retriever_tool\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import WebBaseLoader\n",
+    "from langchain_core.vectorstores import InMemoryVectorStore\n",
     "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.prebuilt import create_react_agent\n",
     "\n",
     "memory = MemorySaver()\n",
     "llm = ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0)\n",
@@ -909,7 +938,8 @@
     "\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)\n",
     "splits = text_splitter.split_documents(docs)\n",
-    "vectorstore = Chroma.from_documents(documents=splits, embedding=OpenAIEmbeddings())\n",
+    "vectorstore = InMemoryVectorStore(embedding=OpenAIEmbeddings())\n",
+    "vectorstore.add_documents(documents=splits)\n",
     "retriever = vectorstore.as_retriever()\n",
     "\n",
     "\n",
@@ -961,7 +991,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/tool_calling.ipynb

@@ -179,7 +179,7 @@
     "    b: Annotated[int, ..., \"Second integer\"]\n",
     "\n",
     "\n",
-    "class multiply(BaseModel):\n",
+    "class multiply(TypedDict):\n",
     "    \"\"\"Multiply two integers.\"\"\"\n",
     "\n",
     "    a: Annotated[int, ..., \"First integer\"]\n",

docs/docs/how_to/trim_messages.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "b5ee5b75-6876-4d62-9ade-5a7a808ae5a2",
+   "id": "eaad9a82-0592-4315-9931-0621054bdd0e",
    "metadata": {},
    "source": [
     "# How to trim messages\n",
@@ -22,33 +22,77 @@
     "\n",
     "All models have finite context windows, meaning there's a limit to how many tokens they can take as input. If you have very long messages or a chain/agent that accumulates a long message is history, you'll need to manage the length of the messages you're passing in to the model.\n",
     "\n",
-    "The `trim_messages` util provides some basic strategies for trimming a list of messages to be of a certain token length.\n",
+    "[trim_messages](https://python.langchain.com/api_reference/core/messages/langchain_core.messages.utils.trim_messages.html) can be used to reduce the size of a chat history to a specified token count or specified message count.\n",
     "\n",
-    "## Getting the last `max_tokens` tokens\n",
     "\n",
-    "To get the last `max_tokens` in the list of Messages we can set `strategy=\"last\"`. Notice that for our `token_counter` we can pass in a function (more on that below) or a language model (since language models have a message token counting method). It makes sense to pass in a model when you're trimming your messages to fit into the context window of that specific model:"
+    "If passing the trimmed chat history back into a chat model directly, the trimmed chat history should satisfy the following properties:\n",
+    "\n",
+    "1. The resulting chat history should be **valid**. Most chat models expect that chat\n",
+    "   history starts with either (1) a `HumanMessage` or (2) a [SystemMessage](/docs/concepts/#systemmessage) followed\n",
+    "   by a `HumanMessage`. In addition, generally a `ToolMessage` can only appear after an `AIMessage`\n",
+    "   that involved a tool call. This can be achieved by setting `start_on=\"human\"`.\n",
+    "2. It includes recent messages and drops old messages in the chat history.\n",
+    "   This can be achieved by setting `strategy=\"last\"`.\n",
+    "4. Usually, the new chat history should include the `SystemMessage` if it\n",
+    "   was present in the original chat history since the `SystemMessage` includes\n",
+    "   special instructions to the chat model. The `SystemMessage` is almost always\n",
+    "   the first message in the history if present. This can be achieved by setting\n",
+    "   `include_system=True`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e4bffc37-78c0-46c3-ad0c-b44de0ed3e90",
+   "metadata": {},
+   "source": [
+    "## Trimming based on token count\n",
+    "\n",
+    "Here, we'll trim the chat history based on token count. The trimmed chat history will produce a **valid** chat history that includes the `SystemMessage`.\n",
+    "\n",
+    "To keep the most recent messages, we set `strategy=\"last\"`.  We'll also set `include_system=True` to include the `SystemMessage`, and `start_on=\"human\"` to make sure the resulting chat history is valid. \n",
+    "\n",
+    "This is a good default configuration when using `trim_messages` based on token count. Remember to adjust `token_counter` and `max_tokens` for your use case.\n",
+    "\n",
+    "Notice that for our `token_counter` we can pass in a function (more on that below) or a language model (since language models have a message token counting method). It makes sense to pass in a model when you're trimming your messages to fit into the context window of that specific model:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "c974633b-3bd0-4844-8a8f-85e3e25f13fe",
+   "id": "c91edeb2-9978-4665-9fdb-fc96cdb51caa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "pip install -qU langchain-openai"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "40ea972c-d424-4bc4-9f2e-82f01c3d7598",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[AIMessage(content=\"Hmmm let me think.\\n\\nWhy, he's probably chasing after the last cup of coffee in the office!\"),\n",
-       " HumanMessage(content='what do you call a speechless parrot')]"
+       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content='what do you call a speechless parrot', additional_kwargs={}, response_metadata={})]"
       ]
      },
-     "execution_count": 1,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# pip install -U langchain-openai\n",
     "from langchain_core.messages import (\n",
     "    AIMessage,\n",
     "    HumanMessage,\n",
@@ -70,36 +114,66 @@
     "    HumanMessage(\"what do you call a speechless parrot\"),\n",
     "]\n",
     "\n",
+    "\n",
     "trim_messages(\n",
     "    messages,\n",
-    "    max_tokens=45,\n",
+    "    # Keep the last <= n_count tokens of the messages.\n",
     "    strategy=\"last\",\n",
+    "    # highlight-start\n",
+    "    # Remember to adjust based on your model\n",
+    "    # or else pass a custom token_encoder\n",
     "    token_counter=ChatOpenAI(model=\"gpt-4o\"),\n",
+    "    # highlight-end\n",
+    "    # Most chat models expect that chat history starts with either:\n",
+    "    # (1) a HumanMessage or\n",
+    "    # (2) a SystemMessage followed by a HumanMessage\n",
+    "    # highlight-start\n",
+    "    # Remember to adjust based on the desired conversation\n",
+    "    # length\n",
+    "    max_tokens=45,\n",
+    "    # highlight-end\n",
+    "    # Most chat models expect that chat history starts with either:\n",
+    "    # (1) a HumanMessage or\n",
+    "    # (2) a SystemMessage followed by a HumanMessage\n",
+    "    # start_on=\"human\" makes sure we produce a valid chat history\n",
+    "    start_on=\"human\",\n",
+    "    # Usually, we want to keep the SystemMessage\n",
+    "    # if it's present in the original history.\n",
+    "    # The SystemMessage has special instructions for the model.\n",
+    "    include_system=True,\n",
+    "    allow_partial=False,\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d3f46654-c4b2-4136-b995-91c3febe5bf9",
+   "id": "28fcfc94-0d4a-415c-9506-8ae7634253a2",
    "metadata": {},
    "source": [
-    "If we want to always keep the initial system message we can specify `include_system=True`:"
+    "## Trimming based on message count\n",
+    "\n",
+    "Alternatively, we can trim the chat history based on **message count**, by setting `token_counter=len`. In this case, each message will count as a single token, and `max_tokens` will control\n",
+    "the maximum number of messages.\n",
+    "\n",
+    "This is a good default configuration when using `trim_messages` based on message count. Remember to adjust `max_tokens` for your use case."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "589b0223-3a73-44ec-8315-2dba3ee6117d",
+   "execution_count": 3,
+   "id": "c8fdedae-0e6b-4901-a222-81fc95e265c2",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\"),\n",
-       " HumanMessage(content='what do you call a speechless parrot')]"
+       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content='and who is harrison chasing anyways', additional_kwargs={}, response_metadata={}),\n",
+       " AIMessage(content=\"Hmmm let me think.\\n\\nWhy, he's probably chasing after the last cup of coffee in the office!\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content='what do you call a speechless parrot', additional_kwargs={}, response_metadata={})]"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -107,36 +181,56 @@
    "source": [
     "trim_messages(\n",
     "    messages,\n",
-    "    max_tokens=45,\n",
+    "    # Keep the last <= n_count tokens of the messages.\n",
     "    strategy=\"last\",\n",
-    "    token_counter=ChatOpenAI(model=\"gpt-4o\"),\n",
+    "    # highlight-next-line\n",
+    "    token_counter=len,\n",
+    "    # When token_counter=len, each message\n",
+    "    # will be counted as a single token.\n",
+    "    # highlight-start\n",
+    "    # Remember to adjust for your use case\n",
+    "    max_tokens=5,\n",
+    "    # highlight-end\n",
+    "    # Most chat models expect that chat history starts with either:\n",
+    "    # (1) a HumanMessage or\n",
+    "    # (2) a SystemMessage followed by a HumanMessage\n",
+    "    # start_on=\"human\" makes sure we produce a valid chat history\n",
+    "    start_on=\"human\",\n",
+    "    # Usually, we want to keep the SystemMessage\n",
+    "    # if it's present in the original history.\n",
+    "    # The SystemMessage has special instructions for the model.\n",
     "    include_system=True,\n",
     ")"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
-   "id": "8a8b542c-04d1-4515-8d82-b999ea4fac4f",
+   "id": "9367857f-7f9a-4d17-9f9c-6ffc5aae909c",
    "metadata": {},
    "source": [
+    "## Advanced Usage\n",
+    "\n",
+    "You can use `trim_message` as a building-block to create more complex processing logic.\n",
+    "\n",
     "If we want to allow splitting up the contents of a message we can specify `allow_partial=True`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "8c46a209-dddd-4d01-81f6-f6ae55d3225c",
+   "execution_count": 4,
+   "id": "8bcca1fe-674c-4713-bacc-8e8e6d6f56c3",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\"),\n",
-       " AIMessage(content=\"\\nWhy, he's probably chasing after the last cup of coffee in the office!\"),\n",
-       " HumanMessage(content='what do you call a speechless parrot')]"
+       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\", additional_kwargs={}, response_metadata={}),\n",
+       " AIMessage(content=\"\\nWhy, he's probably chasing after the last cup of coffee in the office!\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content='what do you call a speechless parrot', additional_kwargs={}, response_metadata={})]"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -154,26 +248,26 @@
   },
   {
    "cell_type": "markdown",
-   "id": "306adf9c-41cd-495c-b4dc-e4f43dd7f8f8",
+   "id": "245bee9b-e515-4e89-8f2a-84bda9a25de8",
    "metadata": {},
    "source": [
-    "If we need to make sure that our first message (excluding the system message) is always of a specific type, we can specify `start_on`:"
+    "By default, the `SystemMessage` will not be included, so you can drop it by either setting `include_system=False` or by dropping the `include_system` argument."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "878a730b-fe44-4e9d-ab65-7b8f7b069de8",
+   "execution_count": 5,
+   "id": "94351736-28a1-44a3-aac7-82356c81d171",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\"),\n",
-       " HumanMessage(content='what do you call a speechless parrot')]"
+       "[AIMessage(content=\"Hmmm let me think.\\n\\nWhy, he's probably chasing after the last cup of coffee in the office!\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content='what do you call a speechless parrot', additional_kwargs={}, response_metadata={})]"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -181,11 +275,9 @@
    "source": [
     "trim_messages(\n",
     "    messages,\n",
-    "    max_tokens=60,\n",
+    "    max_tokens=45,\n",
     "    strategy=\"last\",\n",
     "    token_counter=ChatOpenAI(model=\"gpt-4o\"),\n",
-    "    include_system=True,\n",
-    "    start_on=\"human\",\n",
     ")"
    ]
   },
@@ -194,25 +286,23 @@
    "id": "7f5d391d-235b-4091-b2de-c22866b478f3",
    "metadata": {},
    "source": [
-    "## Getting the first `max_tokens` tokens\n",
-    "\n",
     "We can perform the flipped operation of getting the *first* `max_tokens` by specifying `strategy=\"first\"`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "5f56ae54-1a39-4019-9351-3b494c003d5b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\"),\n",
-       " HumanMessage(content=\"i wonder why it's called langchain\")]"
+       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content=\"i wonder why it's called langchain\", additional_kwargs={}, response_metadata={})]"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -238,18 +328,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 60,
+   "id": "d930c089-e8e6-4980-9d39-11d41e794772",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "pip install -qU tiktoken"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
    "id": "1c1c3b1e-2ece-49e7-a3b6-e69877c1633b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[AIMessage(content=\"Hmmm let me think.\\n\\nWhy, he's probably chasing after the last cup of coffee in the office!\"),\n",
-       " HumanMessage(content='what do you call a speechless parrot')]"
+       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content='what do you call a speechless parrot', additional_kwargs={}, response_metadata={})]"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -257,7 +365,6 @@
    "source": [
     "from typing import List\n",
     "\n",
-    "# pip install tiktoken\n",
     "import tiktoken\n",
     "from langchain_core.messages import BaseMessage, ToolMessage\n",
     "\n",
@@ -298,9 +405,25 @@
     "\n",
     "trim_messages(\n",
     "    messages,\n",
-    "    max_tokens=45,\n",
-    "    strategy=\"last\",\n",
+    "    # highlight-next-line\n",
     "    token_counter=tiktoken_counter,\n",
+    "    # Keep the last <= n_count tokens of the messages.\n",
+    "    strategy=\"last\",\n",
+    "    # When token_counter=len, each message\n",
+    "    # will be counted as a single token.\n",
+    "    # highlight-start\n",
+    "    # Remember to adjust for your use case\n",
+    "    max_tokens=45,\n",
+    "    # highlight-end\n",
+    "    # Most chat models expect that chat history starts with either:\n",
+    "    # (1) a HumanMessage or\n",
+    "    # (2) a SystemMessage followed by a HumanMessage\n",
+    "    # start_on=\"human\" makes sure we produce a valid chat history\n",
+    "    start_on=\"human\",\n",
+    "    # Usually, we want to keep the SystemMessage\n",
+    "    # if it's present in the original history.\n",
+    "    # The SystemMessage has special instructions for the model.\n",
+    "    include_system=True,\n",
     ")"
    ]
   },
@@ -311,22 +434,22 @@
    "source": [
     "## Chaining\n",
     "\n",
-    "`trim_messages` can be used in an imperatively (like above) or declaratively, making it easy to compose with other components in a chain"
+    "`trim_messages` can be used imperatively (like above) or declaratively, making it easy to compose with other components in a chain"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 62,
    "id": "96aa29b2-01e0-437c-a1ab-02fb0141cb57",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='A: A \"Polly-gone\"!', response_metadata={'token_usage': {'completion_tokens': 9, 'prompt_tokens': 32, 'total_tokens': 41}, 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_66b29dffce', 'finish_reason': 'stop', 'logprobs': None}, id='run-83e96ddf-bcaa-4f63-824c-98b0f8a0d474-0', usage_metadata={'input_tokens': 32, 'output_tokens': 9, 'total_tokens': 41})"
+       "AIMessage(content='A \"polygon!\"', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 4, 'prompt_tokens': 32, 'total_tokens': 36, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_3537616b13', 'finish_reason': 'stop', 'logprobs': None}, id='run-995342be-0443-4e33-9b54-153f5c8771d3-0', usage_metadata={'input_tokens': 32, 'output_tokens': 4, 'total_tokens': 36})"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 62,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -340,7 +463,15 @@
     "    max_tokens=45,\n",
     "    strategy=\"last\",\n",
     "    token_counter=llm,\n",
+    "    # Usually, we want to keep the SystemMessage\n",
+    "    # if it's present in the original history.\n",
+    "    # The SystemMessage has special instructions for the model.\n",
     "    include_system=True,\n",
+    "    # Most chat models expect that chat history starts with either:\n",
+    "    # (1) a HumanMessage or\n",
+    "    # (2) a SystemMessage followed by a HumanMessage\n",
+    "    # start_on=\"human\" makes sure we produce a valid chat history\n",
+    "    start_on=\"human\",\n",
     ")\n",
     "\n",
     "chain = trimmer | llm\n",
@@ -359,18 +490,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 63,
    "id": "1ff02d0a-353d-4fac-a77c-7c2c5262abd9",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\"),\n",
-       " HumanMessage(content='what do you call a speechless parrot')]"
+       "[SystemMessage(content=\"you're a good assistant, you always respond with a joke.\", additional_kwargs={}, response_metadata={}),\n",
+       " HumanMessage(content='what do you call a speechless parrot', additional_kwargs={}, response_metadata={})]"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 63,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -391,17 +522,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "id": "a9517858-fc2f-4dc3-898d-bf98a0e905a0",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='A \"polly-no-wanna-cracker\"!', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 32, 'total_tokens': 42}, 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_5bf7397cd3', 'finish_reason': 'stop', 'logprobs': None}, id='run-054dd309-3497-4e7b-b22a-c1859f11d32e-0', usage_metadata={'input_tokens': 32, 'output_tokens': 10, 'total_tokens': 42})"
+       "AIMessage(content='A polygon! (Because it\\'s a \"poly-gone\" quiet!)', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 32, 'total_tokens': 46, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_e375328146', 'finish_reason': 'stop', 'logprobs': None}, id='run-8569a119-ca02-4232-bee1-20caea61cd6d-0', usage_metadata={'input_tokens': 32, 'output_tokens': 14, 'total_tokens': 46})"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -425,7 +556,15 @@
     "    max_tokens=45,\n",
     "    strategy=\"last\",\n",
     "    token_counter=llm,\n",
+    "    # Usually, we want to keep the SystemMessage\n",
+    "    # if it's present in the original history.\n",
+    "    # The SystemMessage has special instructions for the model.\n",
     "    include_system=True,\n",
+    "    # Most chat models expect that chat history starts with either:\n",
+    "    # (1) a HumanMessage or\n",
+    "    # (2) a SystemMessage followed by a HumanMessage\n",
+    "    # start_on=\"human\" makes sure we produce a valid chat history\n",
+    "    start_on=\"human\",\n",
     ")\n",
     "\n",
     "chain = trimmer | llm\n",
@@ -471,7 +610,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/integrations/document_loaders/index.mdx

@@ -31,6 +31,8 @@ The below document loaders allow you to load webpages.
 
 The below document loaders allow you to load PDF documents.
 
+See this guide for a starting point: [How to: load PDF files](/docs/how_to/document_loader_pdf).
+
 <CategoryTable category="pdf_loaders" />
 
 ## Cloud Providers

docs/docs/integrations/document_loaders/unstructured_file.ipynb

@@ -16,7 +16,7 @@
     "\n",
     "| Class | Package | Local | Serializable | [JS support](https://js.langchain.com/docs/integrations/document_loaders/file_loaders/unstructured/)|\n",
     "| :--- | :--- | :---: | :---: |  :---: |\n",
-    "| [UnstructuredLoader](https://python.langchain.com/api_reference/unstructured/document_loaders/langchain_unstructured.document_loaders.UnstructuredLoader.html) | [langchain_community](https://python.langchain.com/api_reference/unstructured/index.html) | ✅ | ❌ | ✅ | \n",
+    "| [UnstructuredLoader](https://python.langchain.com/api_reference/unstructured/document_loaders/langchain_unstructured.document_loaders.UnstructuredLoader.html) | [langchain_unstructured](https://python.langchain.com/api_reference/unstructured/index.html) | ✅ | ❌ | ✅ | \n",
     "### Loader features\n",
     "| Source | Document Lazy Loading | Native Async Support\n",
     "| :---: | :---: | :---: | \n",
@@ -519,6 +519,47 @@
     "print(\"Length of text in the document:\", len(docs[0].page_content))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "3ec3c22d-02cd-498b-921f-b839d1404f32",
+   "metadata": {},
+   "source": [
+    "## Loading web pages\n",
+    "\n",
+    "`UnstructuredLoader` accepts a `web_url` kwarg when run locally that populates the `url` parameter of the underlying Unstructured [partition](https://docs.unstructured.io/open-source/core-functionality/partitioning). This allows for the parsing of remotely hosted documents, such as HTML web pages.\n",
+    "\n",
+    "Example usage:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "bf9a8546-659d-4861-bff2-fdf1ad93ac65",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page_content='Example Domain' metadata={'category_depth': 0, 'languages': ['eng'], 'filetype': 'text/html', 'url': 'https://www.example.com', 'category': 'Title', 'element_id': 'fdaa78d856f9d143aeeed85bf23f58f8'}\n",
+      "\n",
+      "page_content='This domain is for use in illustrative examples in documents. You may use this domain in literature without prior coordination or asking for permission.' metadata={'languages': ['eng'], 'parent_id': 'fdaa78d856f9d143aeeed85bf23f58f8', 'filetype': 'text/html', 'url': 'https://www.example.com', 'category': 'NarrativeText', 'element_id': '3652b8458b0688639f973fe36253c992'}\n",
+      "\n",
+      "page_content='More information...' metadata={'category_depth': 0, 'link_texts': ['More information...'], 'link_urls': ['https://www.iana.org/domains/example'], 'languages': ['eng'], 'filetype': 'text/html', 'url': 'https://www.example.com', 'category': 'Title', 'element_id': '793ab98565d6f6d6f3a6d614e3ace2a9'}\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_unstructured import UnstructuredLoader\n",
+    "\n",
+    "loader = UnstructuredLoader(web_url=\"https://www.example.com\")\n",
+    "docs = loader.load()\n",
+    "\n",
+    "for doc in docs:\n",
+    "    print(f\"{doc}\\n\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "ce01aa40",
@@ -546,7 +587,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/integrations/llm_caching.ipynb

@@ -14,7 +14,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "88486f6f",
    "metadata": {},
    "outputs": [],
@@ -30,7 +30,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "10ad9224",
    "metadata": {
     "ExecuteTime": {
@@ -2400,7 +2400,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "id": "9b4764e4-c75f-4185-b326-524287a826be",
    "metadata": {},
    "outputs": [],
@@ -2430,7 +2430,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "id": "4b5e73c5-92c1-4eab-84e2-77924ea9c123",
    "metadata": {},
    "outputs": [],
@@ -2452,7 +2452,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "id": "db8d28cc-8d93-47b4-8326-57a29a06fb3c",
    "metadata": {},
    "outputs": [
@@ -2483,7 +2483,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "id": "b470dc81-2e7f-4743-9435-ce9071394eea",
    "metadata": {},
    "outputs": [
@@ -2491,17 +2491,17 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 53 ms, sys: 29 ms, total: 82 ms\n",
-      "Wall time: 84.2 ms\n"
+      "CPU times: user 25.9 ms, sys: 15.3 ms, total: 41.3 ms\n",
+      "Wall time: 144 ms\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "\"\\n\\nWhy couldn't the bicycle stand up by itself? Because it was two-tired!\""
+       "\"\\n\\nWhy don't scientists trust atoms?\\n\\nBecause they make up everything.\""
       ]
      },
-     "execution_count": 5,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2512,6 +2512,35 @@
     "llm.invoke(\"Tell me a joke\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1dca39d8-233a-45ba-ad7d-0920dfbc4a50",
+   "metadata": {},
+   "source": [
+    "### Specifying a Time to Live (TTL) for the Cached entries\n",
+    "The Cached documents can be deleted after a specified time automatically by specifying a `ttl` parameter along with the initialization of the Cache."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a3edcc6f-2ccd-45ba-8ca4-f65b5e51b461",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import timedelta\n",
+    "\n",
+    "set_llm_cache(\n",
+    "    CouchbaseCache(\n",
+    "        cluster=cluster,\n",
+    "        bucket_name=BUCKET_NAME,\n",
+    "        scope_name=SCOPE_NAME,\n",
+    "        collection_name=COLLECTION_NAME,\n",
+    "        ttl=timedelta(minutes=5),\n",
+    "    )\n",
+    ")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "43626f33-d184-4260-b641-c9341cef5842",
@@ -2523,7 +2552,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "id": "6b470c03-d7fe-4270-89e1-638251619a53",
    "metadata": {},
    "outputs": [],
@@ -2653,7 +2682,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
    "id": "ae0766c8-ea34-4604-b0dc-cf2bbe8077f4",
    "metadata": {},
    "outputs": [],
@@ -2679,7 +2708,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 11,
    "id": "a2e82743-10ea-4319-b43e-193475ae5449",
    "metadata": {},
    "outputs": [
@@ -2703,7 +2732,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 12,
    "id": "c36f4e29-d872-4334-a1f1-0e6d10c5d9f2",
    "metadata": {},
    "outputs": [
@@ -2725,6 +2754,38 @@
     "print(llm.invoke(\"What is the expected lifespan of a dog?\"))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "f6f674fa-70b5-4cf9-a208-992aad2c3c89",
+   "metadata": {},
+   "source": [
+    "### Specifying a Time to Live (TTL) for the Cached entries\n",
+    "The Cached documents can be deleted after a specified time automatically by specifying a `ttl` parameter along with the initialization of the Cache."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "7e127d0a-5049-47e0-abf4-6424ad7d9fec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import timedelta\n",
+    "\n",
+    "set_llm_cache(\n",
+    "    CouchbaseSemanticCache(\n",
+    "        cluster=cluster,\n",
+    "        embedding=embeddings,\n",
+    "        bucket_name=BUCKET_NAME,\n",
+    "        scope_name=SCOPE_NAME,\n",
+    "        collection_name=COLLECTION_NAME,\n",
+    "        index_name=INDEX_NAME,\n",
+    "        score_threshold=0.8,\n",
+    "        ttl=timedelta(minutes=5),\n",
+    "    )\n",
+    ")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "ae1f5e1c-085e-4998-9f2d-b5867d2c3d5b",
@@ -2802,7 +2863,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,

docs/docs/integrations/llms/sambanova.ipynb

@@ -6,129 +6,11 @@
    "source": [
     "# SambaNova\n",
     "\n",
-    "**[SambaNova](https://sambanova.ai/)'s** [Sambaverse](https://sambaverse.sambanova.ai/) and [Sambastudio](https://sambanova.ai/technology/full-stack-ai-platform) are platforms for running your own open-source models\n",
+    "**[SambaNova](https://sambanova.ai/)'s** [Sambastudio](https://sambanova.ai/technology/full-stack-ai-platform) is a platform for running your own open-source models\n",
     "\n",
     "This example goes over how to use LangChain to interact with SambaNova models"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Sambaverse"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**Sambaverse** allows you to interact with multiple open-source models. You can view the list of available models and interact with them in the [playground](https://sambaverse.sambanova.ai/playground).\n",
-    " **Please note that Sambaverse's free offering is performance-limited.** Companies that are ready to evaluate the production tokens-per-second performance, volume throughput, and 10x lower total cost of ownership (TCO) of SambaNova should [contact us](https://sambaverse.sambanova.ai/contact-us) for a non-limited evaluation instance."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "An API key is required to access Sambaverse models. To get a key, create an account at [sambaverse.sambanova.ai](https://sambaverse.sambanova.ai/)\n",
-    "\n",
-    "The [sseclient-py](https://pypi.org/project/sseclient-py/) package is required to run streaming predictions "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --quiet sseclient-py==1.8.0"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Register your API key as an environment variable:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "sambaverse_api_key = \"<Your sambaverse API key>\"\n",
-    "\n",
-    "# Set the environment variables\n",
-    "os.environ[\"SAMBAVERSE_API_KEY\"] = sambaverse_api_key"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Call Sambaverse models directly from LangChain!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.llms.sambanova import Sambaverse\n",
-    "\n",
-    "llm = Sambaverse(\n",
-    "    sambaverse_model_name=\"Meta/llama-2-7b-chat-hf\",\n",
-    "    streaming=False,\n",
-    "    model_kwargs={\n",
-    "        \"do_sample\": True,\n",
-    "        \"max_tokens_to_generate\": 1000,\n",
-    "        \"temperature\": 0.01,\n",
-    "        \"select_expert\": \"llama-2-7b-chat-hf\",\n",
-    "        \"process_prompt\": False,\n",
-    "        # \"stop_sequences\": '\\\"sequence1\\\",\\\"sequence2\\\"',\n",
-    "        # \"repetition_penalty\":  1.0,\n",
-    "        # \"top_k\": 50,\n",
-    "        # \"top_p\": 1.0\n",
-    "    },\n",
-    ")\n",
-    "\n",
-    "print(llm.invoke(\"Why should I use open source models?\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Streaming response\n",
-    "\n",
-    "from langchain_community.llms.sambanova import Sambaverse\n",
-    "\n",
-    "llm = Sambaverse(\n",
-    "    sambaverse_model_name=\"Meta/llama-2-7b-chat-hf\",\n",
-    "    streaming=True,\n",
-    "    model_kwargs={\n",
-    "        \"do_sample\": True,\n",
-    "        \"max_tokens_to_generate\": 1000,\n",
-    "        \"temperature\": 0.01,\n",
-    "        \"select_expert\": \"llama-2-7b-chat-hf\",\n",
-    "        \"process_prompt\": False,\n",
-    "        # \"stop_sequences\": '\\\"sequence1\\\",\\\"sequence2\\\"',\n",
-    "        # \"repetition_penalty\":  1.0,\n",
-    "        # \"top_k\": 50,\n",
-    "        # \"top_p\": 1.0\n",
-    "    },\n",
-    ")\n",
-    "\n",
-    "for chunk in llm.stream(\"Why should I use open source models?\"):\n",
-    "    print(chunk, end=\"\", flush=True)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},

docs/docs/integrations/memory/couchbase_chat_message_history.ipynb

@@ -1,325 +1,354 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a283d2fd-e26e-4811-a486-d3cf0ecf6749",
-   "metadata": {},
-   "source": [
-    "# Couchbase\n",
-    "> Couchbase is an award-winning distributed NoSQL cloud database that delivers unmatched versatility, performance, scalability, and financial value for all of your cloud, mobile, AI, and edge computing applications. Couchbase embraces AI with coding assistance for developers and vector search for their applications.\n",
-    "\n",
-    "This notebook goes over how to use the `CouchbaseChatMessageHistory` class to store the chat message history in a Couchbase cluster\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ff868a6c-3e17-4c3d-8d32-67b01f4d7bcc",
-   "metadata": {},
-   "source": [
-    "## Set Up Couchbase Cluster\n",
-    "To run this demo, you need a Couchbase Cluster. \n",
-    "\n",
-    "You can work with both [Couchbase Capella](https://www.couchbase.com/products/capella/) and your self-managed Couchbase Server."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "41fa85e7-6968-45e4-a445-de305d80f332",
-   "metadata": {},
-   "source": [
-    "## Install Dependencies\n",
-    "`CouchbaseChatMessageHistory` lives inside the `langchain-couchbase` package. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "b744ca05-b8c6-458c-91df-f50ca2c20b3c",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
-   "source": [
-    "%pip install --upgrade --quiet langchain-couchbase"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "41f29205-6452-493b-ba18-8a3b006bcca4",
-   "metadata": {},
-   "source": [
-    "## Create Couchbase Connection Object\n",
-    "We create a connection to the Couchbase cluster initially and then pass the cluster object to the Vector Store. \n",
-    "\n",
-    "Here, we are connecting using the username and password. You can also connect using any other supported way to your cluster. \n",
-    "\n",
-    "For more information on connecting to the Couchbase cluster, please check the [Python SDK documentation](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html#connect)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f394908e-f5fe-408a-84d7-b97fdebcfa26",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "COUCHBASE_CONNECTION_STRING = (\n",
-    "    \"couchbase://localhost\"  # or \"couchbases://localhost\" if using TLS\n",
-    ")\n",
-    "DB_USERNAME = \"Administrator\"\n",
-    "DB_PASSWORD = \"Password\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "ad4dce21-d80c-465a-b709-fd366ba5ce35",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from datetime import timedelta\n",
-    "\n",
-    "from couchbase.auth import PasswordAuthenticator\n",
-    "from couchbase.cluster import Cluster\n",
-    "from couchbase.options import ClusterOptions\n",
-    "\n",
-    "auth = PasswordAuthenticator(DB_USERNAME, DB_PASSWORD)\n",
-    "options = ClusterOptions(auth)\n",
-    "cluster = Cluster(COUCHBASE_CONNECTION_STRING, options)\n",
-    "\n",
-    "# Wait until the cluster is ready for use.\n",
-    "cluster.wait_until_ready(timedelta(seconds=5))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e3d0210c-e2e6-437a-86f3-7397a1899fef",
-   "metadata": {},
-   "source": [
-    "We will now set the bucket, scope, and collection names in the Couchbase cluster that we want to use for storing the message history.\n",
-    "\n",
-    "Note that the bucket, scope, and collection need to exist before using them to store the message history."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "e8c7f846-a5c4-4465-a40e-4a9a23ac71bd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "BUCKET_NAME = \"langchain-testing\"\n",
-    "SCOPE_NAME = \"_default\"\n",
-    "COLLECTION_NAME = \"conversational_cache\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "283959e1-6af7-4768-9211-5b0facc6ef65",
-   "metadata": {},
-   "source": [
-    "## Usage\n",
-    "In order to store the messages, you need the following:\n",
-    "- Couchbase Cluster object: Valid connection to the Couchbase cluster\n",
-    "- bucket_name: Bucket in cluster to store the chat message history\n",
-    "- scope_name: Scope in bucket to store the message history\n",
-    "- collection_name: Collection in scope to store the message history\n",
-    "- session_id: Unique identifier for the session\n",
-    "\n",
-    "Optionally you can configure the following:\n",
-    "- session_id_key: Field in the chat message documents to store the `session_id`\n",
-    "- message_key: Field in the chat message documents to store the message content\n",
-    "- create_index: Used to specify if the index needs to be created on the collection. By default, an index is created on the `message_key` and the `session_id_key` of the documents"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "43c3b2d5-aae2-44a9-9e9f-f10adf054cfa",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_couchbase.chat_message_histories import CouchbaseChatMessageHistory\n",
-    "\n",
-    "message_history = CouchbaseChatMessageHistory(\n",
-    "    cluster=cluster,\n",
-    "    bucket_name=BUCKET_NAME,\n",
-    "    scope_name=SCOPE_NAME,\n",
-    "    collection_name=COLLECTION_NAME,\n",
-    "    session_id=\"test-session\",\n",
-    ")\n",
-    "\n",
-    "message_history.add_user_message(\"hi!\")\n",
-    "\n",
-    "message_history.add_ai_message(\"how are you doing?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "e7e348ef-79e9-481c-aeef-969ae03dea6a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[HumanMessage(content='hi!'), AIMessage(content='how are you doing?')]"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "message_history.messages"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c8b942a7-93fa-4cd9-8414-d047135c2733",
-   "metadata": {},
-   "source": [
-    "## Chaining\n",
-    "The chat message history class can be used with [LCEL Runnables](https://python.langchain.com/docs/how_to/message_history/)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8a9f0d91-d1d6-481d-8137-ea11229f485a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "946d45aa-5a61-49ae-816b-1c3949c56d9a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\"system\", \"You are a helpful assistant.\"),\n",
-    "        MessagesPlaceholder(variable_name=\"history\"),\n",
-    "        (\"human\", \"{question}\"),\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "# Create the LCEL runnable\n",
-    "chain = prompt | ChatOpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "20dfd838-b549-42ed-b3ba-ac005f7e024c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain_with_history = RunnableWithMessageHistory(\n",
-    "    chain,\n",
-    "    lambda session_id: CouchbaseChatMessageHistory(\n",
-    "        cluster=cluster,\n",
-    "        bucket_name=BUCKET_NAME,\n",
-    "        scope_name=SCOPE_NAME,\n",
-    "        collection_name=COLLECTION_NAME,\n",
-    "        session_id=session_id,\n",
-    "    ),\n",
-    "    input_messages_key=\"question\",\n",
-    "    history_messages_key=\"history\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "17bd09f4-896d-433d-bb9a-369a06e7aa8a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This is where we configure the session id\n",
-    "config = {\"configurable\": {\"session_id\": \"testing\"}}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "4bda1096-2fc2-40d7-a046-0d5d8e3a8f75",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Hello Bob! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 22, 'total_tokens': 32}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-a0f8a29e-ddf4-4e06-a1fe-cf8c325a2b72-0', usage_metadata={'input_tokens': 22, 'output_tokens': 10, 'total_tokens': 32})"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_history.invoke({\"question\": \"Hi! I'm bob\"}, config=config)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "1cfb31da-51bb-4c5f-909a-b7118b0ae08d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Your name is Bob.', response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 43, 'total_tokens': 48}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-f764a9eb-999e-4042-96b6-fe47b7ae4779-0', usage_metadata={'input_tokens': 43, 'output_tokens': 5, 'total_tokens': 48})"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_history.invoke({\"question\": \"Whats my name\"}, config=config)"
-   ]
-  }
- ],
- "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.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
+       "cells": [
+              {
+                     "cell_type": "markdown",
+                     "id": "a283d2fd-e26e-4811-a486-d3cf0ecf6749",
+                     "metadata": {},
+                     "source": [
+                            "# Couchbase\n",
+                            "> Couchbase is an award-winning distributed NoSQL cloud database that delivers unmatched versatility, performance, scalability, and financial value for all of your cloud, mobile, AI, and edge computing applications. Couchbase embraces AI with coding assistance for developers and vector search for their applications.\n",
+                            "\n",
+                            "This notebook goes over how to use the `CouchbaseChatMessageHistory` class to store the chat message history in a Couchbase cluster\n"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "ff868a6c-3e17-4c3d-8d32-67b01f4d7bcc",
+                     "metadata": {},
+                     "source": [
+                            "## Set Up Couchbase Cluster\n",
+                            "To run this demo, you need a Couchbase Cluster. \n",
+                            "\n",
+                            "You can work with both [Couchbase Capella](https://www.couchbase.com/products/capella/) and your self-managed Couchbase Server."
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "41fa85e7-6968-45e4-a445-de305d80f332",
+                     "metadata": {},
+                     "source": [
+                            "## Install Dependencies\n",
+                            "`CouchbaseChatMessageHistory` lives inside the `langchain-couchbase` package. "
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 1,
+                     "id": "b744ca05-b8c6-458c-91df-f50ca2c20b3c",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "name": "stdout",
+                                   "output_type": "stream",
+                                   "text": [
+                                          "Note: you may need to restart the kernel to use updated packages.\n"
+                                   ]
+                            }
+                     ],
+                     "source": [
+                            "%pip install --upgrade --quiet langchain-couchbase"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "41f29205-6452-493b-ba18-8a3b006bcca4",
+                     "metadata": {},
+                     "source": [
+                            "## Create Couchbase Connection Object\n",
+                            "We create a connection to the Couchbase cluster initially and then pass the cluster object to the Vector Store. \n",
+                            "\n",
+                            "Here, we are connecting using the username and password. You can also connect using any other supported way to your cluster. \n",
+                            "\n",
+                            "For more information on connecting to the Couchbase cluster, please check the [Python SDK documentation](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html#connect)."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 2,
+                     "id": "f394908e-f5fe-408a-84d7-b97fdebcfa26",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "COUCHBASE_CONNECTION_STRING = (\n",
+                            "    \"couchbase://localhost\"  # or \"couchbases://localhost\" if using TLS\n",
+                            ")\n",
+                            "DB_USERNAME = \"Administrator\"\n",
+                            "DB_PASSWORD = \"Password\""
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 3,
+                     "id": "ad4dce21-d80c-465a-b709-fd366ba5ce35",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "from datetime import timedelta\n",
+                            "\n",
+                            "from couchbase.auth import PasswordAuthenticator\n",
+                            "from couchbase.cluster import Cluster\n",
+                            "from couchbase.options import ClusterOptions\n",
+                            "\n",
+                            "auth = PasswordAuthenticator(DB_USERNAME, DB_PASSWORD)\n",
+                            "options = ClusterOptions(auth)\n",
+                            "cluster = Cluster(COUCHBASE_CONNECTION_STRING, options)\n",
+                            "\n",
+                            "# Wait until the cluster is ready for use.\n",
+                            "cluster.wait_until_ready(timedelta(seconds=5))"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "e3d0210c-e2e6-437a-86f3-7397a1899fef",
+                     "metadata": {},
+                     "source": [
+                            "We will now set the bucket, scope, and collection names in the Couchbase cluster that we want to use for storing the message history.\n",
+                            "\n",
+                            "Note that the bucket, scope, and collection need to exist before using them to store the message history."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 4,
+                     "id": "e8c7f846-a5c4-4465-a40e-4a9a23ac71bd",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "BUCKET_NAME = \"langchain-testing\"\n",
+                            "SCOPE_NAME = \"_default\"\n",
+                            "COLLECTION_NAME = \"conversational_cache\""
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "283959e1-6af7-4768-9211-5b0facc6ef65",
+                     "metadata": {},
+                     "source": [
+                            "## Usage\n",
+                            "In order to store the messages, you need the following:\n",
+                            "- Couchbase Cluster object: Valid connection to the Couchbase cluster\n",
+                            "- bucket_name: Bucket in cluster to store the chat message history\n",
+                            "- scope_name: Scope in bucket to store the message history\n",
+                            "- collection_name: Collection in scope to store the message history\n",
+                            "- session_id: Unique identifier for the session\n",
+                            "\n",
+                            "Optionally you can configure the following:\n",
+                            "- session_id_key: Field in the chat message documents to store the `session_id`\n",
+                            "- message_key: Field in the chat message documents to store the message content\n",
+                            "- create_index: Used to specify if the index needs to be created on the collection. By default, an index is created on the `message_key` and the `session_id_key` of the documents\n",
+                            "- ttl: Used to specify a time in `timedelta` to live for the documents after which they will get deleted automatically from the storage."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 5,
+                     "id": "43c3b2d5-aae2-44a9-9e9f-f10adf054cfa",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "from langchain_couchbase.chat_message_histories import CouchbaseChatMessageHistory\n",
+                            "\n",
+                            "message_history = CouchbaseChatMessageHistory(\n",
+                            "    cluster=cluster,\n",
+                            "    bucket_name=BUCKET_NAME,\n",
+                            "    scope_name=SCOPE_NAME,\n",
+                            "    collection_name=COLLECTION_NAME,\n",
+                            "    session_id=\"test-session\",\n",
+                            ")\n",
+                            "\n",
+                            "message_history.add_user_message(\"hi!\")\n",
+                            "\n",
+                            "message_history.add_ai_message(\"how are you doing?\")"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 6,
+                     "id": "e7e348ef-79e9-481c-aeef-969ae03dea6a",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "data": {
+                                          "text/plain": [
+                                                 "[HumanMessage(content='hi!'), AIMessage(content='how are you doing?')]"
+                                          ]
+                                   },
+                                   "execution_count": 6,
+                                   "metadata": {},
+                                   "output_type": "execute_result"
+                            }
+                     ],
+                     "source": [
+                            "message_history.messages"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "b993fe69-4462-4cb4-ad0a-eb31a1a4d7d9",
+                     "metadata": {},
+                     "source": [
+                            "## Specifying a Time to Live (TTL) for the Chat Messages\n",
+                            "The stored messages can be deleted after a specified time automatically by specifying a `ttl` parameter along with the initialization of the chat message history store."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 7,
+                     "id": "d32d9302-de97-4319-a484-c83530bab508",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "from langchain_couchbase.chat_message_histories import CouchbaseChatMessageHistory\n",
+                            "\n",
+                            "message_history = CouchbaseChatMessageHistory(\n",
+                            "    cluster=cluster,\n",
+                            "    bucket_name=BUCKET_NAME,\n",
+                            "    scope_name=SCOPE_NAME,\n",
+                            "    collection_name=COLLECTION_NAME,\n",
+                            "    session_id=\"test-session\",\n",
+                            "    ttl=timedelta(hours=24),\n",
+                            ")"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "c8b942a7-93fa-4cd9-8414-d047135c2733",
+                     "metadata": {},
+                     "source": [
+                            "## Chaining\n",
+                            "The chat message history class can be used with [LCEL Runnables](https://python.langchain.com/docs/how_to/message_history/)"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 8,
+                     "id": "8a9f0d91-d1d6-481d-8137-ea11229f485a",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "import getpass\n",
+                            "import os\n",
+                            "\n",
+                            "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+                            "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+                            "from langchain_openai import ChatOpenAI\n",
+                            "\n",
+                            "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 9,
+                     "id": "946d45aa-5a61-49ae-816b-1c3949c56d9a",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "prompt = ChatPromptTemplate.from_messages(\n",
+                            "    [\n",
+                            "        (\"system\", \"You are a helpful assistant.\"),\n",
+                            "        MessagesPlaceholder(variable_name=\"history\"),\n",
+                            "        (\"human\", \"{question}\"),\n",
+                            "    ]\n",
+                            ")\n",
+                            "\n",
+                            "# Create the LCEL runnable\n",
+                            "chain = prompt | ChatOpenAI()"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 10,
+                     "id": "20dfd838-b549-42ed-b3ba-ac005f7e024c",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "chain_with_history = RunnableWithMessageHistory(\n",
+                            "    chain,\n",
+                            "    lambda session_id: CouchbaseChatMessageHistory(\n",
+                            "        cluster=cluster,\n",
+                            "        bucket_name=BUCKET_NAME,\n",
+                            "        scope_name=SCOPE_NAME,\n",
+                            "        collection_name=COLLECTION_NAME,\n",
+                            "        session_id=session_id,\n",
+                            "    ),\n",
+                            "    input_messages_key=\"question\",\n",
+                            "    history_messages_key=\"history\",\n",
+                            ")"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 11,
+                     "id": "17bd09f4-896d-433d-bb9a-369a06e7aa8a",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "# This is where we configure the session id\n",
+                            "config = {\"configurable\": {\"session_id\": \"testing\"}}"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 12,
+                     "id": "4bda1096-2fc2-40d7-a046-0d5d8e3a8f75",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "data": {
+                                          "text/plain": [
+                                                 "AIMessage(content='Hello, Bob! How can I assist you today?', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 22, 'total_tokens': 33}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-62e54e3d-db70-429d-9ee0-e5e8eb2489a1-0', usage_metadata={'input_tokens': 22, 'output_tokens': 11, 'total_tokens': 33})"
+                                          ]
+                                   },
+                                   "execution_count": 12,
+                                   "metadata": {},
+                                   "output_type": "execute_result"
+                            }
+                     ],
+                     "source": [
+                            "chain_with_history.invoke({\"question\": \"Hi! I'm bob\"}, config=config)"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 13,
+                     "id": "1cfb31da-51bb-4c5f-909a-b7118b0ae08d",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "data": {
+                                          "text/plain": [
+                                                 "AIMessage(content='Your name is Bob.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 44, 'total_tokens': 49}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-d84a570a-45f3-4931-814a-078761170bca-0', usage_metadata={'input_tokens': 44, 'output_tokens': 5, 'total_tokens': 49})"
+                                          ]
+                                   },
+                                   "execution_count": 13,
+                                   "metadata": {},
+                                   "output_type": "execute_result"
+                            }
+                     ],
+                     "source": [
+                            "chain_with_history.invoke({\"question\": \"Whats my name\"}, config=config)"
+                     ]
+              }
+       ],
+       "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.10.13"
+              }
+       },
+       "nbformat": 4,
+       "nbformat_minor": 5
+}

docs/docs/versions/migrating_chains/conversation_chain.ipynb

@@ -9,13 +9,13 @@
     "\n",
     "[`ConversationChain`](https://python.langchain.com/api_reference/langchain/chains/langchain.chains.conversation.base.ConversationChain.html) incorporated a memory of previous messages to sustain a stateful conversation.\n",
     "\n",
-    "Some advantages of switching to the LCEL implementation are:\n",
+    "Some advantages of switching to the Langgraph implementation are:\n",
     "\n",
     "- Innate support for threads/separate sessions. To make this work with `ConversationChain`, you'd need to instantiate a separate memory class outside the chain.\n",
     "- More explicit parameters. `ConversationChain` contains a hidden default prompt, which can cause confusion.\n",
     "- Streaming support. `ConversationChain` only supports streaming via callbacks.\n",
     "\n",
-    "`RunnableWithMessageHistory` implements sessions via configuration parameters. It should be instantiated with a callable that returns a [chat message history](https://python.langchain.com/api_reference/core/chat_history/langchain_core.chat_history.BaseChatMessageHistory.html). By default, it expects this function to take a single argument `session_id`."
+    "Langgraph's [checkpointing](https://langchain-ai.github.io/langgraph/how-tos/persistence/) system supports multiple threads or sessions, which can be specified via the `\"thread_id\"` key in its configuration parameters."
    ]
   },
   {
@@ -61,9 +61,9 @@
     {
      "data": {
       "text/plain": [
-       "{'input': 'how are you?',\n",
+       "{'input': \"I'm Bob, how are you?\",\n",
        " 'history': '',\n",
-       " 'response': \"Arr matey, I be doin' well on the high seas, plunderin' and pillagin' as usual. How be ye?\"}"
+       " 'response': \"Arrr matey, I be a pirate sailin' the high seas. What be yer business with me?\"}"
       ]
      },
      "execution_count": 2,
@@ -93,7 +93,30 @@
     "    prompt=prompt,\n",
     ")\n",
     "\n",
-    "chain({\"input\": \"how are you?\"})"
+    "chain({\"input\": \"I'm Bob, how are you?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "53f2c723-178f-470a-8147-54e7cb982211",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'input': 'What is my name?',\n",
+       " 'history': \"Human: I'm Bob, how are you?\\nAI: Arrr matey, I be a pirate sailin' the high seas. What be yer business with me?\",\n",
+       " 'response': 'Your name be Bob, matey.'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain({\"input\": \"What is my name?\"})"
    ]
   },
   {
@@ -103,111 +126,110 @@
    "source": [
     "</details>\n",
     "\n",
-    "## LCEL\n",
+    "## Langgraph\n",
     "\n",
     "<details open>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "666c92a0-b555-4418-a465-6490c1b92570",
+   "execution_count": 4,
+   "id": "a59b910c-0d02-41aa-bc99-441f11989cf8",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "\"Arr, me matey! I be doin' well, sailin' the high seas and searchin' for treasure. How be ye?\""
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "from langchain_core.chat_history import InMemoryChatMessageHistory\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+    "import uuid\n",
+    "\n",
     "from langchain_openai import ChatOpenAI\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, MessagesState, StateGraph\n",
     "\n",
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\"system\", \"You are a pirate. Answer the following questions as best you can.\"),\n",
-    "        (\"placeholder\", \"{chat_history}\"),\n",
-    "        (\"human\", \"{input}\"),\n",
-    "    ]\n",
-    ")\n",
+    "model = ChatOpenAI(model=\"gpt-4o-mini\")\n",
     "\n",
-    "history = InMemoryChatMessageHistory()\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(state_schema=MessagesState)\n",
     "\n",
     "\n",
-    "def get_history():\n",
-    "    return history\n",
+    "# Define the function that calls the model\n",
+    "def call_model(state: MessagesState):\n",
+    "    response = model.invoke(state[\"messages\"])\n",
+    "    return {\"messages\": response}\n",
     "\n",
     "\n",
-    "chain = prompt | ChatOpenAI() | StrOutputParser()\n",
+    "# Define the two nodes we will cycle between\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_node(\"model\", call_model)\n",
     "\n",
-    "wrapped_chain = RunnableWithMessageHistory(\n",
-    "    chain,\n",
-    "    get_history,\n",
-    "    history_messages_key=\"chat_history\",\n",
-    ")\n",
+    "# Add memory\n",
+    "memory = MemorySaver()\n",
+    "app = workflow.compile(checkpointer=memory)\n",
     "\n",
-    "wrapped_chain.invoke({\"input\": \"how are you?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6b386ce6-895e-442c-88f3-7bec0ab9f401",
-   "metadata": {},
-   "source": [
-    "The above example uses the same `history` for all sessions. The example below shows how to use a different chat history for each session."
+    "\n",
+    "# The thread id is a unique key that identifies\n",
+    "# this particular conversation.\n",
+    "# We'll just generate a random uuid here.\n",
+    "thread_id = uuid.uuid4()\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "96152263-98d7-4e06-8c73-d0c0abf3e8e9",
+   "execution_count": 5,
+   "id": "3a9df4bb-e804-4373-9a15-a29dc0371595",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'Ahoy there, me hearty! What can this old pirate do for ye today?'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "I'm Bob, how are you?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Ahoy, Bob! I be feelin' as lively as a ship in full sail! How be ye on this fine day?\n"
+     ]
     }
    ],
    "source": [
-    "from langchain_core.chat_history import BaseChatMessageHistory\n",
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+    "query = \"I'm Bob, how are you?\"\n",
     "\n",
-    "store = {}\n",
+    "input_messages = [\n",
+    "    {\n",
+    "        \"role\": \"system\",\n",
+    "        \"content\": \"You are a pirate. Answer the following questions as best you can.\",\n",
+    "    },\n",
+    "    {\"role\": \"user\", \"content\": query},\n",
+    "]\n",
+    "for event in app.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d3f77e69-fa3d-496c-968c-86371e1e8cf1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "What is my name?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Ye be callin' yerself Bob, I reckon! A fine name for a swashbuckler like yerself!\n"
+     ]
+    }
+   ],
+   "source": [
+    "query = \"What is my name?\"\n",
     "\n",
-    "\n",
-    "def get_session_history(session_id: str) -> BaseChatMessageHistory:\n",
-    "    if session_id not in store:\n",
-    "        store[session_id] = InMemoryChatMessageHistory()\n",
-    "    return store[session_id]\n",
-    "\n",
-    "\n",
-    "chain = prompt | ChatOpenAI() | StrOutputParser()\n",
-    "\n",
-    "wrapped_chain = RunnableWithMessageHistory(\n",
-    "    chain,\n",
-    "    get_session_history,\n",
-    "    history_messages_key=\"chat_history\",\n",
-    ")\n",
-    "\n",
-    "wrapped_chain.invoke(\n",
-    "    {\"input\": \"Hello!\"},\n",
-    "    config={\"configurable\": {\"session_id\": \"abc123\"}},\n",
-    ")"
+    "input_messages = [{\"role\": \"user\", \"content\": query}]\n",
+    "for event in app.stream({\"messages\": input_messages}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
    ]
   },
   {

docs/docs/versions/migrating_memory/conversation_buffer_memory.ipynb

@@ -0,0 +1,554 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ce8457ed-c0b1-4a74-abbd-9d3d2211270f",
+   "metadata": {},
+   "source": [
+    "# Migrating off ConversationBufferMemory or ConversationStringBufferMemory\n",
+    "\n",
+    "[ConversationBufferMemory](https://python.langchain.com/api_reference/langchain/memory/langchain.memory.buffer.ConversationBufferMemory.html)\n",
+    "and [ConversationStringBufferMemory](https://python.langchain.com/api_reference/langchain/memory/langchain.memory.buffer.ConversationStringBufferMemory.html)\n",
+    " were used to keep track of a conversation between a human and an ai asstistant without any additional processing. \n",
+    "\n",
+    "\n",
+    ":::note\n",
+    "The `ConversationStringBufferMemory` is equivalent to `ConversationBufferMemory` but was targeting LLMs that were not chat models.\n",
+    ":::\n",
+    "\n",
+    "The methods for handling conversation history using existing modern primitives are:\n",
+    "\n",
+    "1. Using [LangGraph persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence/) along with appropriate processing of the message history\n",
+    "2. Using LCEL with [RunnableWithMessageHistory](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html#) combined with appropriate processing of the message history.\n",
+    "\n",
+    "Most users will find [LangGraph persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence/) both easier to use and configure than the equivalent LCEL, especially for more complex use cases."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d07f9459-9fb6-4942-99c9-64558aedd7d4",
+   "metadata": {},
+   "source": [
+    "## Set up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b99b47ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install --upgrade --quiet langchain-openai langchain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "717c8673",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from getpass import getpass\n",
+    "\n",
+    "if \"OPENAI_API_KEY\" not in os.environ:\n",
+    "    os.environ[\"OPENAI_API_KEY\"] = getpass()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3621b62-a037-42b8-8faa-59575608bb8b",
+   "metadata": {},
+   "source": [
+    "## Usage with LLMChain / ConversationChain\n",
+    "\n",
+    "This section shows how to migrate off `ConversationBufferMemory` or `ConversationStringBufferMemory` that's used together with either an `LLMChain` or a `ConversationChain`.\n",
+    "\n",
+    "### Legacy\n",
+    "\n",
+    "Below is example usage of `ConversationBufferMemory` with an `LLMChain` or an equivalent `ConversationChain`.\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8b6e1063-cf3a-456a-bf7d-830e5c1d2864",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'text': 'Hello Bob! How can I assist you today?', 'chat_history': [HumanMessage(content='my name is bob', additional_kwargs={}, response_metadata={}), AIMessage(content='Hello Bob! How can I assist you today?', additional_kwargs={}, response_metadata={})]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chains import LLMChain\n",
+    "from langchain.memory import ConversationBufferMemory\n",
+    "from langchain_core.messages import SystemMessage\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    "    MessagesPlaceholder,\n",
+    ")\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "prompt = ChatPromptTemplate(\n",
+    "    [\n",
+    "        MessagesPlaceholder(variable_name=\"chat_history\"),\n",
+    "        HumanMessagePromptTemplate.from_template(\"{text}\"),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "# highlight-start\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\", return_messages=True)\n",
+    "# highlight-end\n",
+    "\n",
+    "legacy_chain = LLMChain(\n",
+    "    llm=ChatOpenAI(),\n",
+    "    prompt=prompt,\n",
+    "    # highlight-next-line\n",
+    "    memory=memory,\n",
+    ")\n",
+    "\n",
+    "legacy_result = legacy_chain.invoke({\"text\": \"my name is bob\"})\n",
+    "print(legacy_result)\n",
+    "\n",
+    "legacy_result = legacy_chain.invoke({\"text\": \"what was my name\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c7fa1618",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Your name is Bob. How can I assist you today, Bob?'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "legacy_result[\"text\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3599774f-b56e-4ba3-876c-624f0270b8ac",
+   "metadata": {},
+   "source": [
+    ":::note\n",
+    "Note that there is no support for separating conversation threads in a single memory object\n",
+    ":::"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cdc3b527-c09e-4c77-9711-c3cc4506cd95",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "### LangGraph\n",
+    "\n",
+    "The example below shows how to use LangGraph to implement a `ConversationChain` or `LLMChain` with `ConversationBufferMemory`.\n",
+    "\n",
+    "This example assumes that you're already somewhat familiar with `LangGraph`. If you're not, then please see the [LangGraph Quickstart Guide](https://langchain-ai.github.io/langgraph/tutorials/introduction/) for more details.\n",
+    "\n",
+    "`LangGraph` offers a lot of additional functionality (e.g., time-travel and interrupts) and will work well for other more complex (and realistic) architectures.\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e591965c-c4d7-4df7-966d-4d14bd46e157",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "hi! I'm bob\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Hello Bob! How can I assist you today?\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "what was my name?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Your name is Bob. How can I help you today, Bob?\n"
+     ]
+    }
+   ],
+   "source": [
+    "import uuid\n",
+    "\n",
+    "from IPython.display import Image, display\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, MessagesState, StateGraph\n",
+    "\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(state_schema=MessagesState)\n",
+    "\n",
+    "# Define a chat model\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "\n",
+    "# Define the function that calls the model\n",
+    "def call_model(state: MessagesState):\n",
+    "    response = model.invoke(state[\"messages\"])\n",
+    "    # We return a list, because this will get added to the existing list\n",
+    "    return {\"messages\": response}\n",
+    "\n",
+    "\n",
+    "# Define the two nodes we will cycle between\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_node(\"model\", call_model)\n",
+    "\n",
+    "\n",
+    "# Adding memory is straight forward in langgraph!\n",
+    "# highlight-next-line\n",
+    "memory = MemorySaver()\n",
+    "\n",
+    "app = workflow.compile(\n",
+    "    # highlight-next-line\n",
+    "    checkpointer=memory\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# The thread id is a unique key that identifies\n",
+    "# this particular conversation.\n",
+    "# We'll just generate a random uuid here.\n",
+    "# This enables a single application to manage conversations among multiple users.\n",
+    "thread_id = uuid.uuid4()\n",
+    "# highlight-next-line\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "\n",
+    "input_message = HumanMessage(content=\"hi! I'm bob\")\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()\n",
+    "\n",
+    "# Here, let's confirm that the AI remembers our name!\n",
+    "input_message = HumanMessage(content=\"what was my name?\")\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "9893029f-43f3-4703-89bf-e0e8fa18aff3",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "### LCEL RunnableWithMessageHistory\n",
+    "\n",
+    "Alternatively, if you have a simple chain, you can wrap the chat model of the chain within a [RunnableWithMessageHistory](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.history.RunnableWithMessageHistory.html).\n",
+    "\n",
+    "Please refer to the following [migration guide](/docs/versions/migrating_chains/conversation_chain/) for more information.\n",
+    "\n",
+    "\n",
+    "## Usasge with a pre-built agent\n",
+    "\n",
+    "This example shows usage of an Agent Executor with a pre-built agent constructed using the [create_tool_calling_agent](https://python.langchain.com/api_reference/langchain/agents/langchain.agents.tool_calling_agent.base.create_tool_calling_agent.html) function.\n",
+    "\n",
+    "If you are using one of the [old LangChain pre-built agents](https://python.langchain.com/v0.1/docs/modules/agents/agent_types/), you should be able\n",
+    "to replace that code with the new [langgraph pre-built agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent/) which leverages\n",
+    "native tool calling capabilities of chat models and will likely work better out of the box.\n",
+    "\n",
+    "### Legacy Usage\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "dc2928de-d7a4-4f87-ab96-59bde9a3829f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'input': 'hi! my name is bob what is my age?', 'chat_history': [HumanMessage(content='hi! my name is bob what is my age?', additional_kwargs={}, response_metadata={}), AIMessage(content='Bob, you are 42 years old.', additional_kwargs={}, response_metadata={})], 'output': 'Bob, you are 42 years old.'}\n",
+      "\n",
+      "{'input': 'do you remember my name?', 'chat_history': [HumanMessage(content='hi! my name is bob what is my age?', additional_kwargs={}, response_metadata={}), AIMessage(content='Bob, you are 42 years old.', additional_kwargs={}, response_metadata={}), HumanMessage(content='do you remember my name?', additional_kwargs={}, response_metadata={}), AIMessage(content='Yes, your name is Bob.', additional_kwargs={}, response_metadata={})], 'output': 'Yes, your name is Bob.'}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain import hub\n",
+    "from langchain.agents import AgentExecutor, create_tool_calling_agent\n",
+    "from langchain.memory import ConversationBufferMemory\n",
+    "from langchain_core.tools import tool\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(temperature=0)\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def get_user_age(name: str) -> str:\n",
+    "    \"\"\"Use this tool to find the user's age.\"\"\"\n",
+    "    # This is a placeholder for the actual implementation\n",
+    "    if \"bob\" in name.lower():\n",
+    "        return \"42 years old\"\n",
+    "    return \"41 years old\"\n",
+    "\n",
+    "\n",
+    "tools = [get_user_age]\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"placeholder\", \"{chat_history}\"),\n",
+    "        (\"human\", \"{input}\"),\n",
+    "        (\"placeholder\", \"{agent_scratchpad}\"),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "# Construct the Tools agent\n",
+    "agent = create_tool_calling_agent(model, tools, prompt)\n",
+    "# Instantiate memory\n",
+    "# highlight-start\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\", return_messages=True)\n",
+    "# highlight-end\n",
+    "\n",
+    "# Create an agent\n",
+    "agent = create_tool_calling_agent(model, tools, prompt)\n",
+    "agent_executor = AgentExecutor(\n",
+    "    agent=agent,\n",
+    "    tools=tools,\n",
+    "    # highlight-next-line\n",
+    "    memory=memory,  # Pass the memory to the executor\n",
+    ")\n",
+    "\n",
+    "# Verify that the agent can use tools\n",
+    "print(agent_executor.invoke({\"input\": \"hi! my name is bob what is my age?\"}))\n",
+    "print()\n",
+    "# Verify that the agent has access to conversation history.\n",
+    "# The agent should be able to answer that the user's name is bob.\n",
+    "print(agent_executor.invoke({\"input\": \"do you remember my name?\"}))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4866ae9-e683-44dc-a77b-da1737d3a645",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "### LangGraph\n",
+    "\n",
+    "You can follow the standard LangChain tutorial for [building an agent](/docs/tutorials/agents/) an in depth explanation of how this works.\n",
+    "\n",
+    "This example is shown here explicitly to make it easier for users to compare the legacy implementation vs. the corresponding langgraph implementation.\n",
+    "\n",
+    "This example shows how to add memory to the [pre-built react agent](https://langchain-ai.github.io/langgraph/reference/prebuilt/#create_react_agent) in langgraph.\n",
+    "\n",
+    "For more details, please see the [how to add memory to the prebuilt ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-memory/) guide in langgraph.\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "bdb29c9b-bc57-4512-9430-c5d5e3f91e3c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "hi! I'm bob. What is my age?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Tool Calls:\n",
+      "  get_user_age (call_oEDwEbIDNdokwqhAV6Azn47c)\n",
+      " Call ID: call_oEDwEbIDNdokwqhAV6Azn47c\n",
+      "  Args:\n",
+      "    name: bob\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: get_user_age\n",
+      "\n",
+      "42 years old\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Bob, you are 42 years old! If you need any more assistance or information, feel free to ask.\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "do you remember my name?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Yes, your name is Bob. If you have any other questions or need assistance, feel free to ask!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import uuid\n",
+    "\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "from langchain_core.tools import tool\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.prebuilt import create_react_agent\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def get_user_age(name: str) -> str:\n",
+    "    \"\"\"Use this tool to find the user's age.\"\"\"\n",
+    "    # This is a placeholder for the actual implementation\n",
+    "    if \"bob\" in name.lower():\n",
+    "        return \"42 years old\"\n",
+    "    return \"41 years old\"\n",
+    "\n",
+    "\n",
+    "# highlight-next-line\n",
+    "memory = MemorySaver()\n",
+    "model = ChatOpenAI()\n",
+    "app = create_react_agent(\n",
+    "    model,\n",
+    "    tools=[get_user_age],\n",
+    "    # highlight-next-line\n",
+    "    checkpointer=memory,\n",
+    ")\n",
+    "\n",
+    "# highlight-start\n",
+    "# The thread id is a unique key that identifies\n",
+    "# this particular conversation.\n",
+    "# We'll just generate a random uuid here.\n",
+    "# This enables a single application to manage conversations among multiple users.\n",
+    "thread_id = uuid.uuid4()\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "# highlight-end\n",
+    "\n",
+    "# Tell the AI that our name is Bob, and ask it to use a tool to confirm\n",
+    "# that it's capable of working like an agent.\n",
+    "input_message = HumanMessage(content=\"hi! I'm bob. What is my age?\")\n",
+    "\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()\n",
+    "\n",
+    "# Confirm that the chat bot has access to previous conversation\n",
+    "# and can respond to the user saying that the user's name is Bob.\n",
+    "input_message = HumanMessage(content=\"do you remember my name?\")\n",
+    "\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "87d14cef-a51e-44be-b376-f31b723caaf8",
+   "metadata": {},
+   "source": [
+    "If we use a different thread ID, it'll start a new conversation and the bot will not know our name!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fe63e424-1111-4f6a-a9c9-0887eb150ab0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "hi! do you remember my name?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Hello! Yes, I remember your name. It's great to see you again! How can I assist you today?\n"
+     ]
+    }
+   ],
+   "source": [
+    "config = {\"configurable\": {\"thread_id\": \"123456789\"}}\n",
+    "\n",
+    "input_message = HumanMessage(content=\"hi! do you remember my name?\")\n",
+    "\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2717810",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "## Next steps\n",
+    "\n",
+    "Explore persistence with LangGraph:\n",
+    "\n",
+    "* [LangGraph quickstart tutorial](https://langchain-ai.github.io/langgraph/tutorials/introduction/)\n",
+    "* [How to add persistence (\"memory\") to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)\n",
+    "* [How to manage conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/)\n",
+    "* [How to add summary of the conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/)\n",
+    "\n",
+    "Add persistence with simple LCEL (favor langgraph for more complex use cases):\n",
+    "\n",
+    "* [How to add message history](/docs/how_to/message_history/)\n",
+    "\n",
+    "Working with message history:\n",
+    "\n",
+    "* [How to trim messages](/docs/how_to/trim_messages)\n",
+    "* [How to filter messages](/docs/how_to/filter_messages/)\n",
+    "* [How to merge message runs](/docs/how_to/merge_message_runs/)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce4c48e1-b613-4aab-bc2b-617c811fad1d",
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/versions/migrating_memory/conversation_buffer_window_memory.ipynb

@@ -0,0 +1,728 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ce8457ed-c0b1-4a74-abbd-9d3d2211270f",
+   "metadata": {},
+   "source": [
+    "# Migrating off ConversationBufferWindowMemory or ConversationTokenBufferMemory\n",
+    "\n",
+    "Follow this guide if you're trying to migrate off one of the old memory classes listed below:\n",
+    "\n",
+    "\n",
+    "| Memory Type                      | Description                                                                                                                                                       |\n",
+    "|----------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n",
+    "| `ConversationBufferWindowMemory` | Keeps the last `n` messages of the conversation. Drops the oldest messages when there are more than `n` messages.                                                                      |\n",
+    "| `ConversationTokenBufferMemory`  | Keeps only the most recent messages in the conversation under the constraint that the total number of tokens in the conversation does not exceed a certain limit. |\n",
+    "\n",
+    "`ConversationBufferWindowMemory` and `ConversationTokenBufferMemory` apply additional processing on top of the raw conversation history to trim the conversation history to a size that fits inside the context window of a chat model. \n",
+    "\n",
+    "This processing functionality can be accomplished using LangChain's built-in [trim_messages](https://python.langchain.com/api_reference/core/messages/langchain_core.messages.utils.trim_messages.html) function."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79935247-acc7-4a05-a387-5d72c9c8c8cb",
+   "metadata": {},
+   "source": [
+    ":::important\n",
+    "\n",
+    "We’ll begin by exploring a straightforward method that involves applying processing logic to the entire conversation history.\n",
+    "\n",
+    "While this approach is easy to implement, it has a downside: as the conversation grows, so does the latency, since the logic is re-applied to all previous exchanges in the conversation at each turn.\n",
+    "\n",
+    "More advanced strategies focus on incrementally updating the conversation history to avoid redundant processing.\n",
+    "\n",
+    "For instance, the langgraph [how-to guide on summarization](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/) demonstrates\n",
+    "how to maintain a running summary of the conversation while discarding older messages, ensuring they aren't re-processed during later turns.\n",
+    ":::"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d07f9459-9fb6-4942-99c9-64558aedd7d4",
+   "metadata": {},
+   "source": [
+    "## Set up"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b99b47ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%%capture --no-stderr\n",
+    "%pip install --upgrade --quiet langchain-openai langchain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7127478f-4413-48be-bfec-d0cd91b8cf70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from getpass import getpass\n",
+    "\n",
+    "if \"OPENAI_API_KEY\" not in os.environ:\n",
+    "    os.environ[\"OPENAI_API_KEY\"] = getpass()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6a7bc93-21a9-44c8-842e-9cc82f1ada7c",
+   "metadata": {},
+   "source": [
+    "## Legacy usage with LLMChain / Conversation Chain\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "371616e1-ca41-4a57-99e0-5fbf7d63f2ad",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'text': 'Nice to meet you, Bob! How can I assist you today?', 'chat_history': []}\n",
+      "{'text': 'Your name is Bob. How can I assist you further, Bob?', 'chat_history': [HumanMessage(content='my name is bob', additional_kwargs={}, response_metadata={}), AIMessage(content='Nice to meet you, Bob! How can I assist you today?', additional_kwargs={}, response_metadata={})]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chains import LLMChain\n",
+    "from langchain.memory import ConversationBufferWindowMemory\n",
+    "from langchain_core.messages import SystemMessage\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    "    MessagesPlaceholder,\n",
+    ")\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "prompt = ChatPromptTemplate(\n",
+    "    [\n",
+    "        SystemMessage(content=\"You are a helpful assistant.\"),\n",
+    "        MessagesPlaceholder(variable_name=\"chat_history\"),\n",
+    "        HumanMessagePromptTemplate.from_template(\"{text}\"),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "# highlight-start\n",
+    "memory = ConversationBufferWindowMemory(memory_key=\"chat_history\", return_messages=True)\n",
+    "# highlight-end\n",
+    "\n",
+    "legacy_chain = LLMChain(\n",
+    "    llm=ChatOpenAI(),\n",
+    "    prompt=prompt,\n",
+    "    # highlight-next-line\n",
+    "    memory=memory,\n",
+    ")\n",
+    "\n",
+    "legacy_result = legacy_chain.invoke({\"text\": \"my name is bob\"})\n",
+    "print(legacy_result)\n",
+    "\n",
+    "legacy_result = legacy_chain.invoke({\"text\": \"what was my name\"})\n",
+    "print(legacy_result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f48cac47-c8b6-444c-8e1b-f7115c0b2d8d",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "## Reimplementing ConversationBufferWindowMemory logic\n",
+    "\n",
+    "Let's first create appropriate logic to process the conversation history, and then we'll see how to integrate it into an application. You can later replace this basic setup with more advanced logic tailored to your specific needs.\n",
+    "\n",
+    "We'll use `trim_messages` to implement logic that keeps the last `n` messages of the conversation. It will drop the oldest messages when the number of messages exceeds `n`.\n",
+    "\n",
+    "In addition, we will also keep the system message if it's present -- when present, it's the first message in a conversation that includes instructions for the chat model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0a92b3f3-0315-46ac-bb28-d07398dd23ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import (\n",
+    "    AIMessage,\n",
+    "    BaseMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage,\n",
+    "    trim_messages,\n",
+    ")\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "messages = [\n",
+    "    SystemMessage(\"you're a good assistant, you always respond with a joke.\"),\n",
+    "    HumanMessage(\"i wonder why it's called langchain\"),\n",
+    "    AIMessage(\n",
+    "        'Well, I guess they thought \"WordRope\" and \"SentenceString\" just didn\\'t have the same ring to it!'\n",
+    "    ),\n",
+    "    HumanMessage(\"and who is harrison chasing anyways\"),\n",
+    "    AIMessage(\n",
+    "        \"Hmmm let me think.\\n\\nWhy, he's probably chasing after the last cup of coffee in the office!\"\n",
+    "    ),\n",
+    "    HumanMessage(\"why is 42 always the answer?\"),\n",
+    "    AIMessage(\n",
+    "        \"Because it’s the only number that’s constantly right, even when it doesn’t add up!\"\n",
+    "    ),\n",
+    "    HumanMessage(\"What did the cow say?\"),\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e7ddf8dc-ea27-43e2-8800-9f7c1d4abdc1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m System Message \u001b[0m================================\n",
+      "\n",
+      "you're a good assistant, you always respond with a joke.\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Hmmm let me think.\n",
+      "\n",
+      "Why, he's probably chasing after the last cup of coffee in the office!\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "why is 42 always the answer?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Because it’s the only number that’s constantly right, even when it doesn’t add up!\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "What did the cow say?\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.messages import trim_messages\n",
+    "\n",
+    "selected_messages = trim_messages(\n",
+    "    messages,\n",
+    "    token_counter=len,  # <-- len will simply count the number of messages rather than tokens\n",
+    "    max_tokens=5,  # <-- allow up to 5 messages.\n",
+    "    strategy=\"last\",\n",
+    "    # The start_on is specified\n",
+    "    # to make sure we do not generate a sequence where\n",
+    "    # a ToolMessage that contains the result of a tool invocation\n",
+    "    # appears before the AIMessage that requested a tool invocation\n",
+    "    # as this will cause some chat models to raise an error.\n",
+    "    start_on=(\"human\", \"ai\"),\n",
+    "    include_system=True,  # <-- Keep the system message\n",
+    "    allow_partial=False,\n",
+    ")\n",
+    "\n",
+    "for msg in selected_messages:\n",
+    "    msg.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18f73819-05e0-41f3-a0e7-a5fd6701d9ef",
+   "metadata": {},
+   "source": [
+    "## Reimplementing ConversationTokenBufferMemory logic\n",
+    "\n",
+    "Here, we'll use `trim_messages` to keeps the system message and the most recent messages in the conversation under the constraint that the total number of tokens in the conversation does not exceed a certain limit. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6442f74b-2c36-48fd-a3d1-c7c5d18c050f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m System Message \u001b[0m================================\n",
+      "\n",
+      "you're a good assistant, you always respond with a joke.\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "why is 42 always the answer?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Because it’s the only number that’s constantly right, even when it doesn’t add up!\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "What did the cow say?\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.messages import trim_messages\n",
+    "\n",
+    "selected_messages = trim_messages(\n",
+    "    messages,\n",
+    "    # Please see API reference for trim_messages for other ways to specify a token counter.\n",
+    "    token_counter=ChatOpenAI(model=\"gpt-4o\"),\n",
+    "    max_tokens=80,  # <-- token limit\n",
+    "    # The start_on is specified\n",
+    "    # to make sure we do not generate a sequence where\n",
+    "    # a ToolMessage that contains the result of a tool invocation\n",
+    "    # appears before the AIMessage that requested a tool invocation\n",
+    "    # as this will cause some chat models to raise an error.\n",
+    "    start_on=(\"human\", \"ai\"),\n",
+    "    strategy=\"last\",\n",
+    "    include_system=True,  # <-- Keep the system message\n",
+    ")\n",
+    "\n",
+    "for msg in selected_messages:\n",
+    "    msg.pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f05d272-2d22-44b7-9fa6-e617a48584b4",
+   "metadata": {},
+   "source": [
+    "## Modern usage with LangGraph\n",
+    "\n",
+    "The example below shows how to use LangGraph to add simple conversation pre-processing logic.\n",
+    "\n",
+    ":::note\n",
+    "\n",
+    "If you want to avoid running the computation on the entire conversation history each time, you can follow\n",
+    "the [how-to guide on summarization](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/) that demonstrates\n",
+    "how to discard older messages, ensuring they aren't re-processed during later turns.\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7d6f79a3-fda7-48fd-9128-bbe4aad84199",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "hi! I'm bob\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Hello Bob! How can I assist you today?\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "what was my name?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Your name is Bob. How can I help you, Bob?\n"
+     ]
+    }
+   ],
+   "source": [
+    "import uuid\n",
+    "\n",
+    "from IPython.display import Image, display\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.graph import START, MessagesState, StateGraph\n",
+    "\n",
+    "# Define a new graph\n",
+    "workflow = StateGraph(state_schema=MessagesState)\n",
+    "\n",
+    "# Define a chat model\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "\n",
+    "# Define the function that calls the model\n",
+    "def call_model(state: MessagesState):\n",
+    "    # highlight-start\n",
+    "    selected_messages = trim_messages(\n",
+    "        state[\"messages\"],\n",
+    "        token_counter=len,  # <-- len will simply count the number of messages rather than tokens\n",
+    "        max_tokens=5,  # <-- allow up to 5 messages.\n",
+    "        strategy=\"last\",\n",
+    "        # The start_on is specified\n",
+    "        # to make sure we do not generate a sequence where\n",
+    "        # a ToolMessage that contains the result of a tool invocation\n",
+    "        # appears before the AIMessage that requested a tool invocation\n",
+    "        # as this will cause some chat models to raise an error.\n",
+    "        start_on=(\"human\", \"ai\"),\n",
+    "        include_system=True,  # <-- Keep the system message\n",
+    "        allow_partial=False,\n",
+    "    )\n",
+    "\n",
+    "    # highlight-end\n",
+    "    response = model.invoke(selected_messages)\n",
+    "    # We return a list, because this will get added to the existing list\n",
+    "    return {\"messages\": response}\n",
+    "\n",
+    "\n",
+    "# Define the two nodes we will cycle between\n",
+    "workflow.add_edge(START, \"model\")\n",
+    "workflow.add_node(\"model\", call_model)\n",
+    "\n",
+    "\n",
+    "# Adding memory is straight forward in langgraph!\n",
+    "# highlight-next-line\n",
+    "memory = MemorySaver()\n",
+    "\n",
+    "app = workflow.compile(\n",
+    "    # highlight-next-line\n",
+    "    checkpointer=memory\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# The thread id is a unique key that identifies\n",
+    "# this particular conversation.\n",
+    "# We'll just generate a random uuid here.\n",
+    "thread_id = uuid.uuid4()\n",
+    "# highlight-next-line\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "input_message = HumanMessage(content=\"hi! I'm bob\")\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()\n",
+    "\n",
+    "# Here, let's confirm that the AI remembers our name!\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "input_message = HumanMessage(content=\"what was my name?\")\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "84229e2e-a578-4b21-840a-814223406402",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "## Usage with a pre-built langgraph agent\n",
+    "\n",
+    "This example shows usage of an Agent Executor with a pre-built agent constructed using the [create_tool_calling_agent](https://api.python.langchain.com/en/latest/agents/langchain.agents.tool_calling_agent.base.create_tool_calling_agent.html) function.\n",
+    "\n",
+    "If you are using one of the [old LangChain pre-built agents](https://python.langchain.com/v0.1/docs/modules/agents/agent_types/), you should be able\n",
+    "to replace that code with the new [langgraph pre-built agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent/) which leverages\n",
+    "native tool calling capabilities of chat models and will likely work better out of the box.\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f671db87-8f01-453e-81fd-4e603140a512",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "hi! I'm bob. What is my age?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Tool Calls:\n",
+      "  get_user_age (call_jsMvoIFv970DhqqLCJDzPKsp)\n",
+      " Call ID: call_jsMvoIFv970DhqqLCJDzPKsp\n",
+      "  Args:\n",
+      "    name: bob\n",
+      "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+      "Name: get_user_age\n",
+      "\n",
+      "42 years old\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Bob, you are 42 years old.\n",
+      "================================\u001b[1m Human Message \u001b[0m=================================\n",
+      "\n",
+      "do you remember my name?\n",
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "\n",
+      "Yes, your name is Bob.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import uuid\n",
+    "\n",
+    "from langchain_core.messages import (\n",
+    "    AIMessage,\n",
+    "    BaseMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage,\n",
+    "    trim_messages,\n",
+    ")\n",
+    "from langchain_core.tools import tool\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "from langgraph.checkpoint.memory import MemorySaver\n",
+    "from langgraph.prebuilt import create_react_agent\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def get_user_age(name: str) -> str:\n",
+    "    \"\"\"Use this tool to find the user's age.\"\"\"\n",
+    "    # This is a placeholder for the actual implementation\n",
+    "    if \"bob\" in name.lower():\n",
+    "        return \"42 years old\"\n",
+    "    return \"41 years old\"\n",
+    "\n",
+    "\n",
+    "memory = MemorySaver()\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "\n",
+    "# highlight-start\n",
+    "def state_modifier(state) -> list[BaseMessage]:\n",
+    "    \"\"\"Given the agent state, return a list of messages for the chat model.\"\"\"\n",
+    "    # We're using the message processor defined above.\n",
+    "    return trim_messages(\n",
+    "        state[\"messages\"],\n",
+    "        token_counter=len,  # <-- len will simply count the number of messages rather than tokens\n",
+    "        max_tokens=5,  # <-- allow up to 5 messages.\n",
+    "        strategy=\"last\",\n",
+    "        # The start_on is specified\n",
+    "        # to make sure we do not generate a sequence where\n",
+    "        # a ToolMessage that contains the result of a tool invocation\n",
+    "        # appears before the AIMessage that requested a tool invocation\n",
+    "        # as this will cause some chat models to raise an error.\n",
+    "        start_on=(\"human\", \"ai\"),\n",
+    "        include_system=True,  # <-- Keep the system message\n",
+    "        allow_partial=False,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "# highlight-end\n",
+    "\n",
+    "app = create_react_agent(\n",
+    "    model,\n",
+    "    tools=[get_user_age],\n",
+    "    checkpointer=memory,\n",
+    "    # highlight-next-line\n",
+    "    state_modifier=state_modifier,\n",
+    ")\n",
+    "\n",
+    "# The thread id is a unique key that identifies\n",
+    "# this particular conversation.\n",
+    "# We'll just generate a random uuid here.\n",
+    "thread_id = uuid.uuid4()\n",
+    "config = {\"configurable\": {\"thread_id\": thread_id}}\n",
+    "\n",
+    "# Tell the AI that our name is Bob, and ask it to use a tool to confirm\n",
+    "# that it's capable of working like an agent.\n",
+    "input_message = HumanMessage(content=\"hi! I'm bob. What is my age?\")\n",
+    "\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()\n",
+    "\n",
+    "# Confirm that the chat bot has access to previous conversation\n",
+    "# and can respond to the user saying that the user's name is Bob.\n",
+    "input_message = HumanMessage(content=\"do you remember my name?\")\n",
+    "\n",
+    "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+    "    event[\"messages\"][-1].pretty_print()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "f4d16e09-1d90-4153-8576-6d3996cb5a6c",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "## LCEL: Add a preprocessing step\n",
+    "\n",
+    "The simplest way to add complex conversation management is by introducing a pre-processing step in front of the chat model and pass the full conversation history to the pre-processing step.\n",
+    "\n",
+    "This approach is conceptually simple and will work in many situations; for example, if using a [RunnableWithMessageHistory](/docs/how_to/message_history/) instead of wrapping the chat model, wrap the chat model with the pre-processor.\n",
+    "\n",
+    "The obvious downside of this approach is that latency starts to increase as the conversation history grows because of two reasons:\n",
+    "\n",
+    "1. As the conversation gets longer, more data may need to be fetched from whatever store your'e using to store the conversation history (if not storing it in memory).\n",
+    "2. The pre-processing logic will end up doing a lot of redundant computation, repeating computation from previous steps of the conversation.\n",
+    "\n",
+    ":::caution\n",
+    "\n",
+    "If you want to use a chat model's tool calling capabilities, remember to bind the tools to the model before adding the history pre-processing step to it!\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "<details open>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "072046bb-3892-4206-8ae5-025e93110dcc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+      "Tool Calls:\n",
+      "  what_did_the_cow_say (call_urHTB5CShhcKz37QiVzNBlIS)\n",
+      " Call ID: call_urHTB5CShhcKz37QiVzNBlIS\n",
+      "  Args:\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.messages import (\n",
+    "    AIMessage,\n",
+    "    BaseMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage,\n",
+    "    trim_messages,\n",
+    ")\n",
+    "from langchain_core.tools import tool\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def what_did_the_cow_say() -> str:\n",
+    "    \"\"\"Check to see what the cow said.\"\"\"\n",
+    "    return \"foo\"\n",
+    "\n",
+    "\n",
+    "# highlight-start\n",
+    "message_processor = trim_messages(  # Returns a Runnable if no messages are provided\n",
+    "    token_counter=len,  # <-- len will simply count the number of messages rather than tokens\n",
+    "    max_tokens=5,  # <-- allow up to 5 messages.\n",
+    "    strategy=\"last\",\n",
+    "    # The start_on is specified\n",
+    "    # to make sure we do not generate a sequence where\n",
+    "    # a ToolMessage that contains the result of a tool invocation\n",
+    "    # appears before the AIMessage that requested a tool invocation\n",
+    "    # as this will cause some chat models to raise an error.\n",
+    "    start_on=(\"human\", \"ai\"),\n",
+    "    include_system=True,  # <-- Keep the system message\n",
+    "    allow_partial=False,\n",
+    ")\n",
+    "# highlight-end\n",
+    "\n",
+    "# Note that we bind tools to the model first!\n",
+    "model_with_tools = model.bind_tools([what_did_the_cow_say])\n",
+    "\n",
+    "# highlight-next-line\n",
+    "model_with_preprocessor = message_processor | model_with_tools\n",
+    "\n",
+    "full_history = [\n",
+    "    SystemMessage(\"you're a good assistant, you always respond with a joke.\"),\n",
+    "    HumanMessage(\"i wonder why it's called langchain\"),\n",
+    "    AIMessage(\n",
+    "        'Well, I guess they thought \"WordRope\" and \"SentenceString\" just didn\\'t have the same ring to it!'\n",
+    "    ),\n",
+    "    HumanMessage(\"and who is harrison chasing anyways\"),\n",
+    "    AIMessage(\n",
+    "        \"Hmmm let me think.\\n\\nWhy, he's probably chasing after the last cup of coffee in the office!\"\n",
+    "    ),\n",
+    "    HumanMessage(\"why is 42 always the answer?\"),\n",
+    "    AIMessage(\n",
+    "        \"Because it’s the only number that’s constantly right, even when it doesn’t add up!\"\n",
+    "    ),\n",
+    "    HumanMessage(\"What did the cow say?\"),\n",
+    "]\n",
+    "\n",
+    "\n",
+    "# We pass it explicity to the model_with_preprocesor for illustrative purposes.\n",
+    "# If you're using `RunnableWithMessageHistory` the history will be automatically\n",
+    "# read from the source the you configure.\n",
+    "model_with_preprocessor.invoke(full_history).pretty_print()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "5da7225a-5e94-4f53-bb0d-86b6b528d150",
+   "metadata": {},
+   "source": [
+    "</details>\n",
+    "\n",
+    "If you need to implement more efficient logic and want to use `RunnableWithMessageHistory` for now the way to achieve this\n",
+    "is to subclass from [BaseChatMessageHistory](https://api.python.langchain.com/en/latest/chat_history/langchain_core.chat_history.BaseChatMessageHistory.html) and\n",
+    "define appropriate logic for `add_messages` (that doesn't simply append the history, but instead re-writes it).\n",
+    "\n",
+    "Unless you have a good reason to implement this solution, you should instead use LangGraph."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2717810",
+   "metadata": {},
+   "source": [
+    "## Next steps\n",
+    "\n",
+    "Explore persistence with LangGraph:\n",
+    "\n",
+    "* [LangGraph quickstart tutorial](https://langchain-ai.github.io/langgraph/tutorials/introduction/)\n",
+    "* [How to add persistence (\"memory\") to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)\n",
+    "* [How to manage conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/)\n",
+    "* [How to add summary of the conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/)\n",
+    "\n",
+    "Add persistence with simple LCEL (favor langgraph for more complex use cases):\n",
+    "\n",
+    "* [How to add message history](/docs/how_to/message_history/)\n",
+    "\n",
+    "Working with message history:\n",
+    "\n",
+    "* [How to trim messages](/docs/how_to/trim_messages)\n",
+    "* [How to filter messages](/docs/how_to/filter_messages/)\n",
+    "* [How to merge message runs](/docs/how_to/merge_message_runs/)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f4adad0b-3e25-47d9-a8e6-6a9c6c616f14",
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/versions/migrating_memory/conversation_summary_memory.ipynb

@@ -0,0 +1,45 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ce8457ed-c0b1-4a74-abbd-9d3d2211270f",
+   "metadata": {},
+   "source": [
+    "# Migrating off ConversationSummaryMemory or ConversationSummaryBufferMemory\n",
+    "\n",
+    "Follow this guide if you're trying to migrate off one of the old memory classes listed below:\n",
+    "\n",
+    "\n",
+    "| Memory Type                          | Description                                                                                                                                          |\n",
+    "|---------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|\n",
+    "| `ConversationSummaryMemory`           | Continually summarizes the conversation history. The summary is updated after each conversation turn. The abstraction returns the summary of the conversation history. |\n",
+    "| `ConversationSummaryBufferMemory`     | Provides a running summary of the conversation together with the most recent messages in the conversation under the constraint that the total number of tokens in the conversation does not exceed a certain limit. |\n",
+    "\n",
+    "Please follow the following [how-to guide on summarization](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/) in LangGraph. \n",
+    "\n",
+    "This guide shows how to maintain a running summary of the conversation while discarding older messages, ensuring they aren't re-processed during later turns."
+   ]
+  }
+ ],
+ "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/versions/migrating_memory/index.mdx

@@ -0,0 +1,118 @@
+---
+sidebar_position: 1
+---
+
+# How to migrate from v0.0 memory
+
+The concept of memory has evolved significantly in LangChain since its initial release.
+
+Broadly speaking, LangChain 0.0.x memory was used to handle three main use cases:
+
+| Use Case                             | Example                                                                                                                           |
+|--------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|
+| Managing conversation history        | Keep only the last `n` turns of the conversation between the user and the AI.                                                     |
+| Extraction of structured information | Extract structured information from the conversation history, such as a list of facts learned about the user.                     |
+| Composite memory implementations     | Combine multiple memory sources, e.g., a list of known facts about the user along with facts learned during a given conversation. |
+
+While the LangChain 0.0.x memory abstractions were useful, they were limited in their capabilities and not well suited for real-world conversational AI applications. These memory abstractions lacked built-in support for multi-user, multi-conversation scenarios, which are essential for practical conversational AI systems.
+
+This guide will help you migrate your usage of memory implementations from LangChain v0.0.x to the persistence implementations of LangGraph.
+
+## Why use LangGraph for memory?
+
+The main advantages of persistence implementation in LangGraph are:
+
+- Built-in support for multi-user, multi-conversation scenarios which is often a requirement for real-world conversational AI applications.
+- Ability to save and resume complex state at any time for error recovery, human-in-the-loop workflows, time travel interactions, and more.
+- Full support for both [LLM](/docs/concepts/#llms) and [chat models](/docs/concepts/#chat-models). In contrast, the v0.0.x memory abstractions were created prior to the existence and widespread adoption of chat model APIs, and so it does not work well with chat models (e.g., fails with tool calling chat models).
+- Offers a high degree of customization and control over the memory implementation, including the ability to use different backends.
+
+## Migrations
+
+:::info Prerequisites
+
+These guides assume some familiarity with the following concepts:
+- [LangGraph](https://langchain-ai.github.io/langgraph/)
+- [v0.0.x Memory](https://python.langchain.com/v0.1/docs/modules/memory/)
+- [How to add persistence ("memory") to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)
+:::
+
+### 1. Managing conversation history
+
+The goal of managing conversation history is to store and retrieve the history in a way that is optimal for a chat model to use.
+
+Often this involves trimming and / or summarizing the conversation history to keep the most relevant parts of the conversation while having the conversation fit inside the context window of the chat model.
+
+Memory classes that fall into this category include:
+
+| Memory Type                       | How to Migrate                                               | Description                                                                                                                                                                                                         |
+|-----------------------------------|:-------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `ConversationBufferMemory`        | [Link to Migration Guide](conversation_buffer_memory)        | A basic memory implementation that simply stores the conversation history.                                                                                                                                          |
+| `ConversationStringBufferMemory`  | [Link to Migration Guide](conversation_buffer_memory)        | A special case of `ConversationBufferMemory` designed for LLMs and no longer relevant.                                                                                                                              |
+| `ConversationBufferWindowMemory`  | [Link to Migration Guide](conversation_buffer_window_memory) | Keeps the last `n` turns of the conversation. Drops the oldest turn when the buffer is full.                                                                                                                        |
+| `ConversationTokenBufferMemory`   | [Link to Migration Guide](conversation_buffer_window_memory) | Keeps only the most recent messages in the conversation under the constraint that the total number of tokens in the conversation does not exceed a certain limit.                                                   |
+| `ConversationSummaryMemory`       | [Link to Migration Guide](conversation_summary_memory)       | Continually summarizes the conversation history. The summary is updated after each conversation turn. The abstraction returns the summary of the conversation history.                                              |
+| `ConversationSummaryBufferMemory` | [Link to Migration Guide](conversation_summary_memory)       | Provides a running summary of the conversation together with the most recent messages in the conversation under the constraint that the total number of tokens in the conversation does not exceed a certain limit. |
+| `VectorStoreRetrieverMemory`      | No migration guide yet                                       | Stores the conversation history in a vector store and retrieves the most relevant parts of past conversation based on the input.                                                                                    |
+
+
+### 2. Extraction of structured information from the conversation history
+
+Memory classes that fall into this category include:
+
+| Memory Type                | Description                                                                                                                                                                                                       |
+|----------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `BaseEntityStore`          | An abstract interface that resembles a key-value store. It was used for storing structured information learned during the conversation. The information had to be represented as a dictionary of key-value pairs. |
+| `ConversationEntityMemory` | Combines the ability to summarize the conversation while extracting structured information from the conversation history.                                                                                         |
+
+And specific backend implementations of abstractions:
+
+| Memory Type               | Description                                                                                              |
+|---------------------------|----------------------------------------------------------------------------------------------------------|
+| `InMemoryEntityStore`     | An implementation of `BaseEntityStore` that stores the information in the literal computer memory (RAM). |
+| `RedisEntityStore`        | A specific implementation of `BaseEntityStore` that uses Redis as the backend.                           |
+| `SQLiteEntityStore`       | A specific implementation of `BaseEntityStore` that uses SQLite as the backend.                          |
+| `UpstashRedisEntityStore` | A specific implementation of `BaseEntityStore` that uses Upstash as the backend.                         |
+
+These abstractions have not received much development since their initial release. The reason
+is that for these abstractions to be useful they typically require a lot of specialization for a particular application, so these
+abstractions are not as widely used as the conversation history management abstractions.
+
+For this reason, there are no migration guides for these abstractions. If you're struggling to migrate an applications
+that relies on these abstractions, please open an issue on the LangChain GitHub repository and we'll try to prioritize providing
+more guidance on how to migrate these abstractions.
+
+The general strategy for extracting structured information from the conversation history is to use a chat model with tool calling capabilities to extract structured information from the conversation history.
+The extracted information can then be saved into an appropriate data structure (e.g., a dictionary), and information from it can be retrieved and added into the prompt as needed.
+
+### 3. Implementations that provide composite logic on top of one or more memory implementations
+
+Memory classes that fall into this category include:
+
+| Memory Type            | Description                                                                                                                    |
+|------------------------|--------------------------------------------------------------------------------------------------------------------------------|
+| `CombinedMemory`       | This abstraction accepted a list of `BaseMemory` and fetched relevant memory information from each of them based on the input. |
+| `SimpleMemory`         | Used to add read-only hard-coded context. Users can simply write this information into the prompt.                             |
+| `ReadOnlySharedMemory` | Provided a read-only view of an existing `BaseMemory` implementation.                                                          |
+
+These implementations did not seem to be used widely or provide significant value. Users should be able
+to re-implement these without too much difficulty in custom code.
+
+## Related Resources
+
+Explore persistence with LangGraph:
+
+* [LangGraph quickstart tutorial](https://langchain-ai.github.io/langgraph/tutorials/introduction/)
+* [How to add persistence ("memory") to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)
+* [How to manage conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/)
+* [How to add summary of the conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/)
+
+Add persistence with simple LCEL (favor langgraph for more complex use cases):
+
+* [How to add message history](https://python.langchain.com/docs/how_to/message_history/)
+
+Working with message history:
+
+* [How to trim messages](https://python.langchain.com/docs/how_to/trim_messages)
+* [How to filter messages](https://python.langchain.com/docs/how_to/filter_messages/)
+* [How to merge message runs](https://python.langchain.com/docs/how_to/merge_message_runs/)

docs/src/css/custom.css

@@ -38,6 +38,9 @@
   --ifm-menu-link-padding-horizontal: 0.5rem;
   --ifm-menu-link-padding-vertical: 0.5rem;
   --doc-sidebar-width: 275px !important;
+
+  /* Code block syntax highlighting */
+  --docusaurus-highlighted-code-line-bg: rgb(176, 227, 199);
 }
 
 /* For readability concerns, you should choose a lighter palette in dark mode. */
@@ -49,6 +52,9 @@
   --ifm-color-primary-light: #29d5b0;
   --ifm-color-primary-lighter: #32d8b4;
   --ifm-color-primary-lightest: #4fddbf;
+
+  /* Code block syntax highlighting */
+  --docusaurus-highlighted-code-line-bg: rgb(14, 73, 60);
 }
 
 nav, h1, h2, h3, h4 {

docs/src/theme/FeatureTables.js

@@ -354,7 +354,7 @@ const FEATURE_TABLES = {
             },
             {
                 name: "Nomic",
-                link: "cohere",
+                link: "nomic",
                 package: "langchain-nomic",
                 apiLink: "https://python.langchain.com/api_reference/nomic/embeddings/langchain_nomic.embeddings.NomicEmbeddings.html"
             },

docs/vercel.json

@@ -26,6 +26,10 @@
     }
   ],
   "redirects": [
+    {
+      "source": "/v0.3/docs/:path(.*/?)*",
+      "destination": "/docs/:path*"
+    },
     {
       "source": "/docs/modules/agents/tools/custom_tools(/?)",
       "destination": "/docs/how_to/custom_tools/"

libs/community/langchain_community/chat_models/zhipuai.py

@@ -204,7 +204,7 @@ def _convert_delta_to_message_chunk(
     role = dct.get("role")
     content = dct.get("content", "")
     additional_kwargs = {}
-    tool_calls = dct.get("tool_call", None)
+    tool_calls = dct.get("tool_calls", None)
     if tool_calls is not None:
         additional_kwargs["tool_calls"] = tool_calls
 

libs/community/langchain_community/document_loaders/__init__.py

@@ -359,6 +359,7 @@ if TYPE_CHECKING:
     )
     from langchain_community.document_loaders.pebblo import (
         PebbloSafeLoader,
+        PebbloTextLoader,
     )
     from langchain_community.document_loaders.polars_dataframe import (
         PolarsDataFrameLoader,
@@ -650,6 +651,7 @@ _module_lookup = {
     "PDFPlumberLoader": "langchain_community.document_loaders.pdf",
     "PagedPDFSplitter": "langchain_community.document_loaders.pdf",
     "PebbloSafeLoader": "langchain_community.document_loaders.pebblo",
+    "PebbloTextLoader": "langchain_community.document_loaders.pebblo",
     "PlaywrightURLLoader": "langchain_community.document_loaders.url_playwright",
     "PolarsDataFrameLoader": "langchain_community.document_loaders.polars_dataframe",
     "PsychicLoader": "langchain_community.document_loaders.psychic",
@@ -855,6 +857,7 @@ __all__ = [
     "PDFPlumberLoader",
     "PagedPDFSplitter",
     "PebbloSafeLoader",
+    "PebbloTextLoader",
     "PlaywrightURLLoader",
     "PolarsDataFrameLoader",
     "PsychicLoader",

libs/community/langchain_community/document_loaders/parsers/pdf.py

@@ -267,6 +267,7 @@ class PyMuPDFParser(BaseBlobParser):
 
     def lazy_parse(self, blob: Blob) -> Iterator[Document]:  # type: ignore[valid-type]
         """Lazily parse the blob."""
+
         import fitz
 
         with blob.as_bytes_io() as file_path:  # type: ignore[attr-defined]
@@ -277,25 +278,49 @@ class PyMuPDFParser(BaseBlobParser):
 
             yield from [
                 Document(
-                    page_content=page.get_text(**self.text_kwargs)
-                    + self._extract_images_from_page(doc, page),
-                    metadata=dict(
-                        {
-                            "source": blob.source,  # type: ignore[attr-defined]
-                            "file_path": blob.source,  # type: ignore[attr-defined]
-                            "page": page.number,
-                            "total_pages": len(doc),
-                        },
-                        **{
-                            k: doc.metadata[k]
-                            for k in doc.metadata
-                            if type(doc.metadata[k]) in [str, int]
-                        },
-                    ),
+                    page_content=self._get_page_content(doc, page, blob),
+                    metadata=self._extract_metadata(doc, page, blob),
                 )
                 for page in doc
             ]
 
+    def _get_page_content(
+        self, doc: fitz.fitz.Document, page: fitz.fitz.Page, blob: Blob
+    ) -> str:
+        """
+        Get the text of the page using PyMuPDF and RapidOCR and issue a warning
+        if it is empty.
+        """
+        content = page.get_text(**self.text_kwargs) + self._extract_images_from_page(
+            doc, page
+        )
+
+        if not content:
+            warnings.warn(
+                f"Warning: Empty content on page "
+                f"{page.number} of document {blob.source}"
+            )
+
+        return content
+
+    def _extract_metadata(
+        self, doc: fitz.fitz.Document, page: fitz.fitz.Page, blob: Blob
+    ) -> dict:
+        """Extract metadata from the document and page."""
+        return dict(
+            {
+                "source": blob.source,  # type: ignore[attr-defined]
+                "file_path": blob.source,  # type: ignore[attr-defined]
+                "page": page.number,
+                "total_pages": len(doc),
+            },
+            **{
+                k: doc.metadata[k]
+                for k in doc.metadata
+                if isinstance(doc.metadata[k], (str, int))
+            },
+        )
+
     def _extract_images_from_page(
         self, doc: fitz.fitz.Document, page: fitz.fitz.Page
     ) -> str:

libs/community/langchain_community/document_loaders/pebblo.py

@@ -4,7 +4,7 @@ import logging
 import os
 import uuid
 from importlib.metadata import version
-from typing import Dict, Iterator, List, Optional
+from typing import Any, Dict, Iterable, Iterator, List, Optional
 
 from langchain_core.documents import Document
 
@@ -271,3 +271,67 @@ class PebbloSafeLoader(BaseLoader):
             doc_metadata["pb_checksum"] = classified_docs.get(doc.pb_id, {}).get(
                 "pb_checksum", None
             )
+
+
+class PebbloTextLoader(BaseLoader):
+    """
+    Loader for text data.
+
+    Since PebbloSafeLoader is a wrapper around document loaders, this loader is
+    used to load text data directly into Documents.
+    """
+
+    def __init__(
+        self,
+        texts: Iterable[str],
+        *,
+        source: Optional[str] = None,
+        ids: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        metadatas: Optional[List[Dict[str, Any]]] = None,
+    ) -> None:
+        """
+        Args:
+            texts: Iterable of text data.
+            source: Source of the text data.
+                Optional. Defaults to None.
+            ids: List of unique identifiers for each text.
+                Optional. Defaults to None.
+            metadata: Metadata for all texts.
+                Optional. Defaults to None.
+            metadatas: List of metadata for each text.
+                Optional. Defaults to None.
+        """
+        self.texts = texts
+        self.source = source
+        self.ids = ids
+        self.metadata = metadata
+        self.metadatas = metadatas
+
+    def lazy_load(self) -> Iterator[Document]:
+        """
+        Lazy load text data into Documents.
+
+        Returns:
+            Iterator of Documents
+        """
+        for i, text in enumerate(self.texts):
+            _id = None
+            metadata = self.metadata or {}
+            if self.metadatas and i < len(self.metadatas) and self.metadatas[i]:
+                metadata.update(self.metadatas[i])
+            if self.ids and i < len(self.ids):
+                _id = self.ids[i]
+            yield Document(id=_id, page_content=text, metadata=metadata)
+
+    def load(self) -> List[Document]:
+        """
+        Load text data into Documents.
+
+        Returns:
+            List of Documents
+        """
+        documents = []
+        for doc in self.lazy_load():
+            documents.append(doc)
+        return documents

libs/community/langchain_community/document_loaders/recursive_url_loader.py

@@ -227,7 +227,7 @@ class RecursiveUrlLoader(BaseLoader):
                 "https://docs.python.org/3.9/",
                 prevent_outside=True,
                 base_url="https://docs.python.org",
-                link_regex=r'<a\s+(?:[^>]*?\s+)?href="([^"]*(?=index)[^"]*)"',
+                link_regex=r'<a\\s+(?:[^>]*?\\s+)?href="([^"]*(?=index)[^"]*)"',
                 exclude_dirs=['https://docs.python.org/3.9/faq']
             )
             docs = loader.load()

libs/community/langchain_community/embeddings/huggingface.py

@@ -396,6 +396,8 @@ class HuggingFaceInferenceAPIEmbeddings(BaseModel, Embeddings):
     additional_headers: Dict[str, str] = {}
     """Pass additional headers to the requests library if needed."""
 
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
     @property
     def _api_url(self) -> str:
         return self.api_url or self._default_api_url

libs/community/langchain_community/embeddings/sambanova.py

@@ -213,7 +213,7 @@ class SambaStudioEmbeddings(BaseModel, Embeddings):
                     )
                 try:
                     if params.get("select_expert"):
-                        embedding = response.json()["predictions"][0]
+                        embedding = response.json()["predictions"]
                     else:
                         embedding = response.json()["predictions"]
                     embeddings.extend(embedding)
@@ -299,7 +299,7 @@ class SambaStudioEmbeddings(BaseModel, Embeddings):
                 )
             try:
                 if params.get("select_expert"):
-                    embedding = response.json()["predictions"][0][0]
+                    embedding = response.json()["predictions"][0]
                 else:
                     embedding = response.json()["predictions"][0]
             except KeyError:

libs/community/langchain_community/graph_vectorstores/__init__.py

@@ -1,6 +1,9 @@
-"""**Graph Vector Store**
+""".. title:: Graph Vector Store
 
-Sometimes embedding models don’t capture all the important relationships between
+Graph Vector Store
+==================
+
+Sometimes embedding models don't capture all the important relationships between
 documents.
 Graph Vector Stores are an extension to both vector stores and retrievers that allow
 documents to be explicitly connected to each other.
@@ -13,11 +16,10 @@ Each document identifies tags that link to and from it.
 For example, a paragraph of text may be linked to URLs based on the anchor tags in
 it's content and linked from the URL(s) it is published at.
 
-Link extractors can be used to extract links from documents.
+`Link extractors <langchain_community.graph_vectorstores.extractors.link_extractor.LinkExtractor>`
+can be used to extract links from documents.
 
-Example:
-
-.. code-block:: python
+Example::
 
     graph_vector_store = CassandraGraphVectorStore()
     link_extractor = HtmlLinkExtractor()
@@ -25,13 +27,18 @@ Example:
     add_links(document, links)
     graph_vector_store.add_document(document)
 
-***********
+.. seealso::
+
+    - :class:`How to use a graph vector store as a retriever <langchain_community.graph_vectorstores.base.GraphVectorStoreRetriever>`
+    - :class:`How to create links between documents <langchain_community.graph_vectorstores.links.Link>`
+    - :class:`How to link Documents on hyperlinks in HTML <langchain_community.graph_vectorstores.extractors.html_link_extractor.HtmlLinkExtractor>`
+    - :class:`How to link Documents on common keywords (using KeyBERT) <langchain_community.graph_vectorstores.extractors.keybert_link_extractor.KeybertLinkExtractor>`
+    - :class:`How to link Documents on common named entities (using GliNER) <langchain_community.graph_vectorstores.extractors.gliner_link_extractor.GLiNERLinkExtractor>`
+
 Get started
-***********
+-----------
 
-We chunk the State of the Union text and split it into documents.
-
-.. code-block:: python
+We chunk the State of the Union text and split it into documents::
 
     from langchain_community.document_loaders import TextLoader
     from langchain_text_splitters import CharacterTextSplitter
@@ -41,14 +48,12 @@ We chunk the State of the Union text and split it into documents.
     documents = text_splitter.split_documents(raw_documents)
 
 Links can be added to documents manually but it's easier to use a
-:class:`~langchain_community.graph_vectorstores.extractors.LinkExtractor`.
+:class:`~langchain_community.graph_vectorstores.extractors.link_extractor.LinkExtractor`.
 Several common link extractors are available and you can build your own.
 For this guide, we'll use the
-:class:`~langchain_community.graph_vectorstores.extractors.KeybertLinkExtractor`
+:class:`~langchain_community.graph_vectorstores.extractors.keybert_link_extractor.KeybertLinkExtractor`
 which uses the KeyBERT model to tag documents with keywords and uses these keywords to
-create links between documents.
-
-.. code-block:: python
+create links between documents::
 
     from langchain_community.graph_vectorstores.extractors import KeybertLinkExtractor
     from langchain_community.graph_vectorstores.links import add_links
@@ -58,15 +63,14 @@ create links between documents.
     for doc in documents:
         add_links(doc, extractor.extract_one(doc))
 
-***********************************************
 Create the graph vector store and add documents
-***********************************************
+-----------------------------------------------
 
 We'll use an Apache Cassandra or Astra DB database as an example.
-We create a :class:`~langchain_community.graph_vectorstores.CassandraGraphVectorStore`
-from the documents and an :class:`~langchain_openai.OpenAIEmbeddings` model.
-
-.. code-block:: python
+We create a
+:class:`~langchain_community.graph_vectorstores.cassandra.CassandraGraphVectorStore`
+from the documents and an :class:`~langchain_openai.embeddings.base.OpenAIEmbeddings`
+model::
 
     import cassio
     from langchain_community.graph_vectorstores import CassandraGraphVectorStore
@@ -80,45 +84,37 @@ from the documents and an :class:`~langchain_openai.OpenAIEmbeddings` model.
         documents=documents,
     )
 
-*****************
+
 Similarity search
-*****************
+-----------------
 
 If we don't traverse the graph, a graph vector store behaves like a regular vector
 store.
 So all methods available in a vector store are also available in a graph vector store.
 The :meth:`~langchain_community.graph_vectorstores.base.GraphVectorStore.similarity_search`
 method returns documents similar to a query without considering
-the links between documents.
-
-.. code-block:: python
+the links between documents::
 
     docs = store.similarity_search(
         "What did the president say about Ketanji Brown Jackson?"
     )
 
-****************
 Traversal search
-****************
+----------------
 
 The :meth:`~langchain_community.graph_vectorstores.base.GraphVectorStore.traversal_search`
 method returns documents similar to a query considering the links
 between documents. It first does a similarity search and then traverses the graph to
-find linked documents.
-
-.. code-block:: python
+find linked documents::
 
     docs = list(
         store.traversal_search("What did the president say about Ketanji Brown Jackson?")
     )
 
-*************
 Async methods
-*************
+-------------
 
-The graph vector store has async versions of the methods prefixed with ``a``.
-
-.. code-block:: python
+The graph vector store has async versions of the methods prefixed with ``a``::
 
     docs = [
         doc
@@ -127,15 +123,12 @@ The graph vector store has async versions of the methods prefixed with ``a``.
         )
     ]
 
-****************************
 Graph vector store retriever
-****************************
+----------------------------
 
 The graph vector store can be converted to a retriever.
 It is similar to the vector store retriever but it also has traversal search methods
-such as ``traversal`` and ``mmr_traversal``.
-
-.. code-block:: python
+such as ``traversal`` and ``mmr_traversal``::
 
     retriever = store.as_retriever(search_type="mmr_traversal")
     docs = retriever.invoke("What did the president say about Ketanji Brown Jackson?")

libs/community/langchain_community/graph_vectorstores/base.py

@@ -1,7 +1,840 @@
-from langchain_core.graph_vectorstores.base import (
-    GraphVectorStore,
-    GraphVectorStoreRetriever,
-    Node,
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import AsyncIterable, Collection, Iterable, Iterator
+from typing import (
+    Any,
+    ClassVar,
+    Optional,
 )
 
-__all__ = ["GraphVectorStore", "GraphVectorStoreRetriever", "Node"]
+from langchain_core._api import beta
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForRetrieverRun,
+    CallbackManagerForRetrieverRun,
+)
+from langchain_core.documents import Document
+from langchain_core.load import Serializable
+from langchain_core.runnables import run_in_executor
+from langchain_core.vectorstores import VectorStore, VectorStoreRetriever
+from pydantic import Field
+
+from langchain_community.graph_vectorstores.links import METADATA_LINKS_KEY, Link
+
+
+def _has_next(iterator: Iterator) -> bool:
+    """Checks if the iterator has more elements.
+    Warning: consumes an element from the iterator"""
+    sentinel = object()
+    return next(iterator, sentinel) is not sentinel
+
+
+@beta()
+class Node(Serializable):
+    """Node in the GraphVectorStore.
+
+    Edges exist from nodes with an outgoing link to nodes with a matching incoming link.
+
+    For instance two nodes `a` and `b` connected over a hyperlink ``https://some-url``
+    would look like:
+
+    .. code-block:: python
+
+        [
+            Node(
+                id="a",
+                text="some text a",
+                links= [
+                    Link(kind="hyperlink", tag="https://some-url", direction="incoming")
+                ],
+            ),
+            Node(
+                id="b",
+                text="some text b",
+                links= [
+                    Link(kind="hyperlink", tag="https://some-url", direction="outgoing")
+                ],
+            )
+        ]
+    """
+
+    id: Optional[str] = None
+    """Unique ID for the node. Will be generated by the GraphVectorStore if not set."""
+    text: str
+    """Text contained by the node."""
+    metadata: dict = Field(default_factory=dict)
+    """Metadata for the node."""
+    links: list[Link] = Field(default_factory=list)
+    """Links associated with the node."""
+
+
+def _texts_to_nodes(
+    texts: Iterable[str],
+    metadatas: Optional[Iterable[dict]],
+    ids: Optional[Iterable[str]],
+) -> Iterator[Node]:
+    metadatas_it = iter(metadatas) if metadatas else None
+    ids_it = iter(ids) if ids else None
+    for text in texts:
+        try:
+            _metadata = next(metadatas_it).copy() if metadatas_it else {}
+        except StopIteration as e:
+            raise ValueError("texts iterable longer than metadatas") from e
+        try:
+            _id = next(ids_it) if ids_it else None
+        except StopIteration as e:
+            raise ValueError("texts iterable longer than ids") from e
+
+        links = _metadata.pop(METADATA_LINKS_KEY, [])
+        if not isinstance(links, list):
+            links = list(links)
+        yield Node(
+            id=_id,
+            metadata=_metadata,
+            text=text,
+            links=links,
+        )
+    if ids_it and _has_next(ids_it):
+        raise ValueError("ids iterable longer than texts")
+    if metadatas_it and _has_next(metadatas_it):
+        raise ValueError("metadatas iterable longer than texts")
+
+
+def _documents_to_nodes(documents: Iterable[Document]) -> Iterator[Node]:
+    for doc in documents:
+        metadata = doc.metadata.copy()
+        links = metadata.pop(METADATA_LINKS_KEY, [])
+        if not isinstance(links, list):
+            links = list(links)
+        yield Node(
+            id=doc.id,
+            metadata=metadata,
+            text=doc.page_content,
+            links=links,
+        )
+
+
+@beta()
+def nodes_to_documents(nodes: Iterable[Node]) -> Iterator[Document]:
+    """Convert nodes to documents.
+
+    Args:
+        nodes: The nodes to convert to documents.
+    Returns:
+        The documents generated from the nodes.
+    """
+    for node in nodes:
+        metadata = node.metadata.copy()
+        metadata[METADATA_LINKS_KEY] = [
+            # Convert the core `Link` (from the node) back to the local `Link`.
+            Link(kind=link.kind, direction=link.direction, tag=link.tag)
+            for link in node.links
+        ]
+
+        yield Document(
+            id=node.id,
+            page_content=node.text,
+            metadata=metadata,
+        )
+
+
+@beta(message="Added in version 0.3.1 of langchain_community. API subject to change.")
+class GraphVectorStore(VectorStore):
+    """A hybrid vector-and-graph graph store.
+
+    Document chunks support vector-similarity search as well as edges linking
+    chunks based on structural and semantic properties.
+
+    .. versionadded:: 0.3.1
+    """
+
+    @abstractmethod
+    def add_nodes(
+        self,
+        nodes: Iterable[Node],
+        **kwargs: Any,
+    ) -> Iterable[str]:
+        """Add nodes to the graph store.
+
+        Args:
+            nodes: the nodes to add.
+        """
+
+    async def aadd_nodes(
+        self,
+        nodes: Iterable[Node],
+        **kwargs: Any,
+    ) -> AsyncIterable[str]:
+        """Add nodes to the graph store.
+
+        Args:
+            nodes: the nodes to add.
+        """
+        iterator = iter(await run_in_executor(None, self.add_nodes, nodes, **kwargs))
+        done = object()
+        while True:
+            doc = await run_in_executor(None, next, iterator, done)
+            if doc is done:
+                break
+            yield doc  # type: ignore[misc]
+
+    def add_texts(
+        self,
+        texts: Iterable[str],
+        metadatas: Optional[Iterable[dict]] = None,
+        *,
+        ids: Optional[Iterable[str]] = None,
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more texts through the embeddings and add to the vectorstore.
+
+        The Links present in the metadata field `links` will be extracted to create
+        the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            store.add_texts(
+                ids=["a", "b"],
+                texts=["some text a", "some text b"],
+                metadatas=[
+                    {
+                        "links": [
+                            Link.incoming(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                    {
+                        "links": [
+                            Link.outgoing(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                ],
+            )
+
+        Args:
+            texts: Iterable of strings to add to the vectorstore.
+            metadatas: Optional list of metadatas associated with the texts.
+                The metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+            ids: Optional list of IDs associated with the texts.
+            **kwargs: vectorstore specific parameters.
+
+        Returns:
+            List of ids from adding the texts into the vectorstore.
+        """
+        nodes = _texts_to_nodes(texts, metadatas, ids)
+        return list(self.add_nodes(nodes, **kwargs))
+
+    async def aadd_texts(
+        self,
+        texts: Iterable[str],
+        metadatas: Optional[Iterable[dict]] = None,
+        *,
+        ids: Optional[Iterable[str]] = None,
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more texts through the embeddings and add to the vectorstore.
+
+        The Links present in the metadata field `links` will be extracted to create
+        the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            await store.aadd_texts(
+                ids=["a", "b"],
+                texts=["some text a", "some text b"],
+                metadatas=[
+                    {
+                        "links": [
+                            Link.incoming(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                    {
+                        "links": [
+                            Link.outgoing(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                ],
+            )
+
+        Args:
+            texts: Iterable of strings to add to the vectorstore.
+            metadatas: Optional list of metadatas associated with the texts.
+                The metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+            ids: Optional list of IDs associated with the texts.
+            **kwargs: vectorstore specific parameters.
+
+        Returns:
+            List of ids from adding the texts into the vectorstore.
+        """
+        nodes = _texts_to_nodes(texts, metadatas, ids)
+        return [_id async for _id in self.aadd_nodes(nodes, **kwargs)]
+
+    def add_documents(
+        self,
+        documents: Iterable[Document],
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more documents through the embeddings and add to the vectorstore.
+
+        The Links present in the document metadata field `links` will be extracted to
+        create the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            store.add_documents(
+                [
+                    Document(
+                        id="a",
+                        page_content="some text a",
+                        metadata={
+                            "links": [
+                                Link.incoming(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                    Document(
+                        id="b",
+                        page_content="some text b",
+                        metadata={
+                            "links": [
+                                Link.outgoing(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                ]
+
+            )
+
+        Args:
+            documents: Documents to add to the vectorstore.
+                The document's metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+
+        Returns:
+            List of IDs of the added texts.
+        """
+        nodes = _documents_to_nodes(documents)
+        return list(self.add_nodes(nodes, **kwargs))
+
+    async def aadd_documents(
+        self,
+        documents: Iterable[Document],
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more documents through the embeddings and add to the vectorstore.
+
+        The Links present in the document metadata field `links` will be extracted to
+        create the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            store.add_documents(
+                [
+                    Document(
+                        id="a",
+                        page_content="some text a",
+                        metadata={
+                            "links": [
+                                Link.incoming(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                    Document(
+                        id="b",
+                        page_content="some text b",
+                        metadata={
+                            "links": [
+                                Link.outgoing(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                ]
+
+            )
+
+        Args:
+            documents: Documents to add to the vectorstore.
+                The document's metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+
+        Returns:
+            List of IDs of the added texts.
+        """
+        nodes = _documents_to_nodes(documents)
+        return [_id async for _id in self.aadd_nodes(nodes, **kwargs)]
+
+    @abstractmethod
+    def traversal_search(
+        self,
+        query: str,
+        *,
+        k: int = 4,
+        depth: int = 1,
+        **kwargs: Any,
+    ) -> Iterable[Document]:
+        """Retrieve documents from traversing this graph store.
+
+        First, `k` nodes are retrieved using a search for each `query` string.
+        Then, additional nodes are discovered up to the given `depth` from those
+        starting nodes.
+
+        Args:
+            query: The query string.
+            k: The number of Documents to return from the initial search.
+                Defaults to 4. Applies to each of the query strings.
+            depth: The maximum depth of edges to traverse. Defaults to 1.
+        Returns:
+            Retrieved documents.
+        """
+
+    async def atraversal_search(
+        self,
+        query: str,
+        *,
+        k: int = 4,
+        depth: int = 1,
+        **kwargs: Any,
+    ) -> AsyncIterable[Document]:
+        """Retrieve documents from traversing this graph store.
+
+        First, `k` nodes are retrieved using a search for each `query` string.
+        Then, additional nodes are discovered up to the given `depth` from those
+        starting nodes.
+
+        Args:
+            query: The query string.
+            k: The number of Documents to return from the initial search.
+                Defaults to 4. Applies to each of the query strings.
+            depth: The maximum depth of edges to traverse. Defaults to 1.
+        Returns:
+            Retrieved documents.
+        """
+        iterator = iter(
+            await run_in_executor(
+                None, self.traversal_search, query, k=k, depth=depth, **kwargs
+            )
+        )
+        done = object()
+        while True:
+            doc = await run_in_executor(None, next, iterator, done)
+            if doc is done:
+                break
+            yield doc  # type: ignore[misc]
+
+    @abstractmethod
+    def mmr_traversal_search(
+        self,
+        query: str,
+        *,
+        k: int = 4,
+        depth: int = 2,
+        fetch_k: int = 100,
+        adjacent_k: int = 10,
+        lambda_mult: float = 0.5,
+        score_threshold: float = float("-inf"),
+        **kwargs: Any,
+    ) -> Iterable[Document]:
+        """Retrieve documents from this graph store using MMR-traversal.
+
+        This strategy first retrieves the top `fetch_k` results by similarity to
+        the question. It then selects the top `k` results based on
+        maximum-marginal relevance using the given `lambda_mult`.
+
+        At each step, it considers the (remaining) documents from `fetch_k` as
+        well as any documents connected by edges to a selected document
+        retrieved based on similarity (a "root").
+
+        Args:
+            query: The query string to search for.
+            k: Number of Documents to return. Defaults to 4.
+            fetch_k: Number of Documents to fetch via similarity.
+                Defaults to 100.
+            adjacent_k: Number of adjacent Documents to fetch.
+                Defaults to 10.
+            depth: Maximum depth of a node (number of edges) from a node
+                retrieved via similarity. Defaults to 2.
+            lambda_mult: Number between 0 and 1 that determines the degree
+                of diversity among the results with 0 corresponding to maximum
+                diversity and 1 to minimum diversity. Defaults to 0.5.
+            score_threshold: Only documents with a score greater than or equal
+                this threshold will be chosen. Defaults to negative infinity.
+        """
+
+    async def ammr_traversal_search(
+        self,
+        query: str,
+        *,
+        k: int = 4,
+        depth: int = 2,
+        fetch_k: int = 100,
+        adjacent_k: int = 10,
+        lambda_mult: float = 0.5,
+        score_threshold: float = float("-inf"),
+        **kwargs: Any,
+    ) -> AsyncIterable[Document]:
+        """Retrieve documents from this graph store using MMR-traversal.
+
+        This strategy first retrieves the top `fetch_k` results by similarity to
+        the question. It then selects the top `k` results based on
+        maximum-marginal relevance using the given `lambda_mult`.
+
+        At each step, it considers the (remaining) documents from `fetch_k` as
+        well as any documents connected by edges to a selected document
+        retrieved based on similarity (a "root").
+
+        Args:
+            query: The query string to search for.
+            k: Number of Documents to return. Defaults to 4.
+            fetch_k: Number of Documents to fetch via similarity.
+                Defaults to 100.
+            adjacent_k: Number of adjacent Documents to fetch.
+                Defaults to 10.
+            depth: Maximum depth of a node (number of edges) from a node
+                retrieved via similarity. Defaults to 2.
+            lambda_mult: Number between 0 and 1 that determines the degree
+                of diversity among the results with 0 corresponding to maximum
+                diversity and 1 to minimum diversity. Defaults to 0.5.
+            score_threshold: Only documents with a score greater than or equal
+                this threshold will be chosen. Defaults to negative infinity.
+        """
+        iterator = iter(
+            await run_in_executor(
+                None,
+                self.mmr_traversal_search,
+                query,
+                k=k,
+                fetch_k=fetch_k,
+                adjacent_k=adjacent_k,
+                depth=depth,
+                lambda_mult=lambda_mult,
+                score_threshold=score_threshold,
+                **kwargs,
+            )
+        )
+        done = object()
+        while True:
+            doc = await run_in_executor(None, next, iterator, done)
+            if doc is done:
+                break
+            yield doc  # type: ignore[misc]
+
+    def similarity_search(
+        self, query: str, k: int = 4, **kwargs: Any
+    ) -> list[Document]:
+        return list(self.traversal_search(query, k=k, depth=0))
+
+    def max_marginal_relevance_search(
+        self,
+        query: str,
+        k: int = 4,
+        fetch_k: int = 20,
+        lambda_mult: float = 0.5,
+        **kwargs: Any,
+    ) -> list[Document]:
+        return list(
+            self.mmr_traversal_search(
+                query, k=k, fetch_k=fetch_k, lambda_mult=lambda_mult, depth=0
+            )
+        )
+
+    async def asimilarity_search(
+        self, query: str, k: int = 4, **kwargs: Any
+    ) -> list[Document]:
+        return [doc async for doc in self.atraversal_search(query, k=k, depth=0)]
+
+    def search(self, query: str, search_type: str, **kwargs: Any) -> list[Document]:
+        if search_type == "similarity":
+            return self.similarity_search(query, **kwargs)
+        elif search_type == "similarity_score_threshold":
+            docs_and_similarities = self.similarity_search_with_relevance_scores(
+                query, **kwargs
+            )
+            return [doc for doc, _ in docs_and_similarities]
+        elif search_type == "mmr":
+            return self.max_marginal_relevance_search(query, **kwargs)
+        elif search_type == "traversal":
+            return list(self.traversal_search(query, **kwargs))
+        elif search_type == "mmr_traversal":
+            return list(self.mmr_traversal_search(query, **kwargs))
+        else:
+            raise ValueError(
+                f"search_type of {search_type} not allowed. Expected "
+                "search_type to be 'similarity', 'similarity_score_threshold', "
+                "'mmr' or 'traversal'."
+            )
+
+    async def asearch(
+        self, query: str, search_type: str, **kwargs: Any
+    ) -> list[Document]:
+        if search_type == "similarity":
+            return await self.asimilarity_search(query, **kwargs)
+        elif search_type == "similarity_score_threshold":
+            docs_and_similarities = await self.asimilarity_search_with_relevance_scores(
+                query, **kwargs
+            )
+            return [doc for doc, _ in docs_and_similarities]
+        elif search_type == "mmr":
+            return await self.amax_marginal_relevance_search(query, **kwargs)
+        elif search_type == "traversal":
+            return [doc async for doc in self.atraversal_search(query, **kwargs)]
+        else:
+            raise ValueError(
+                f"search_type of {search_type} not allowed. Expected "
+                "search_type to be 'similarity', 'similarity_score_threshold', "
+                "'mmr' or 'traversal'."
+            )
+
+    def as_retriever(self, **kwargs: Any) -> GraphVectorStoreRetriever:
+        """Return GraphVectorStoreRetriever initialized from this GraphVectorStore.
+
+        Args:
+            **kwargs: Keyword arguments to pass to the search function.
+                Can include:
+
+                - search_type (Optional[str]): Defines the type of search that
+                  the Retriever should perform.
+                  Can be ``traversal`` (default), ``similarity``, ``mmr``, or
+                  ``similarity_score_threshold``.
+                - search_kwargs (Optional[Dict]): Keyword arguments to pass to the
+                  search function. Can include things like:
+
+                  - k(int): Amount of documents to return (Default: 4).
+                  - depth(int): The maximum depth of edges to traverse (Default: 1).
+                  - score_threshold(float): Minimum relevance threshold
+                    for similarity_score_threshold.
+                  - fetch_k(int): Amount of documents to pass to MMR algorithm
+                    (Default: 20).
+                  - lambda_mult(float): Diversity of results returned by MMR;
+                    1 for minimum diversity and 0 for maximum. (Default: 0.5).
+        Returns:
+            Retriever for this GraphVectorStore.
+
+        Examples:
+
+        .. code-block:: python
+
+            # Retrieve documents traversing edges
+            docsearch.as_retriever(
+                search_type="traversal",
+                search_kwargs={'k': 6, 'depth': 3}
+            )
+
+            # Retrieve more documents with higher diversity
+            # Useful if your dataset has many similar documents
+            docsearch.as_retriever(
+                search_type="mmr",
+                search_kwargs={'k': 6, 'lambda_mult': 0.25}
+            )
+
+            # Fetch more documents for the MMR algorithm to consider
+            # But only return the top 5
+            docsearch.as_retriever(
+                search_type="mmr",
+                search_kwargs={'k': 5, 'fetch_k': 50}
+            )
+
+            # Only retrieve documents that have a relevance score
+            # Above a certain threshold
+            docsearch.as_retriever(
+                search_type="similarity_score_threshold",
+                search_kwargs={'score_threshold': 0.8}
+            )
+
+            # Only get the single most similar document from the dataset
+            docsearch.as_retriever(search_kwargs={'k': 1})
+
+        """
+        return GraphVectorStoreRetriever(vectorstore=self, **kwargs)
+
+
+@beta(message="Added in version 0.3.1 of langchain_community. API subject to change.")
+class GraphVectorStoreRetriever(VectorStoreRetriever):
+    """Retriever for GraphVectorStore.
+
+    A graph vector store retriever is a retriever that uses a graph vector store to
+    retrieve documents.
+    It is similar to a vector store retriever, except that it uses both vector
+    similarity and graph connections to retrieve documents.
+    It uses the search methods implemented by a graph vector store, like traversal
+    search and MMR traversal search, to query the texts in the graph vector store.
+
+    Example::
+
+        store = CassandraGraphVectorStore(...)
+        retriever = store.as_retriever()
+        retriever.invoke("What is ...")
+
+    .. seealso::
+
+        :mod:`How to use a graph vector store <langchain_community.graph_vectorstores>`
+
+    How to use a graph vector store as a retriever
+    ==============================================
+
+    Creating a retriever from a graph vector store
+    ----------------------------------------------
+
+    You can build a retriever from a graph vector store using its
+    :meth:`~langchain_community.graph_vectorstores.base.GraphVectorStore.as_retriever`
+    method.
+
+    First we instantiate a graph vector store.
+    We will use a store backed by Cassandra
+    :class:`~langchain_community.graph_vectorstores.cassandra.CassandraGraphVectorStore`
+    graph vector store::
+
+        from langchain_community.document_loaders import TextLoader
+        from langchain_community.graph_vectorstores import CassandraGraphVectorStore
+        from langchain_community.graph_vectorstores.extractors import (
+            KeybertLinkExtractor,
+            LinkExtractorTransformer,
+        )
+        from langchain_openai import OpenAIEmbeddings
+        from langchain_text_splitters import CharacterTextSplitter
+
+        loader = TextLoader("state_of_the_union.txt")
+        documents = loader.load()
+
+        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+        texts = text_splitter.split_documents(documents)
+
+        pipeline = LinkExtractorTransformer([KeybertLinkExtractor()])
+        pipeline.transform_documents(texts)
+        embeddings = OpenAIEmbeddings()
+        graph_vectorstore = CassandraGraphVectorStore.from_documents(texts, embeddings)
+
+    We can then instantiate a retriever::
+
+        retriever = graph_vectorstore.as_retriever()
+
+    This creates a retriever (specifically a ``GraphVectorStoreRetriever``), which we
+    can use in the usual way::
+
+        docs = retriever.invoke("what did the president say about ketanji brown jackson?")
+
+    Maximum marginal relevance traversal retrieval
+    ----------------------------------------------
+
+    By default, the graph vector store retriever uses similarity search, then expands
+    the retrieved set by following a fixed number of graph edges.
+    If the underlying graph vector store supports maximum marginal relevance traversal,
+    you can specify that as the search type.
+
+    MMR-traversal is a retrieval method combining MMR and graph traversal.
+    The strategy first retrieves the top fetch_k results by similarity to the question.
+    It then iteratively expands the set of fetched documents by following adjacent_k
+    graph edges and selects the top k results based on maximum-marginal relevance using
+    the given ``lambda_mult``::
+
+        retriever = graph_vectorstore.as_retriever(search_type="mmr_traversal")
+
+    Passing search parameters
+    -------------------------
+
+    We can pass parameters to the underlying graph vectorstore's search methods using
+    ``search_kwargs``.
+
+    Specifying graph traversal depth
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    For example, we can set the graph traversal depth to only return documents
+    reachable through a given number of graph edges::
+
+        retriever = graph_vectorstore.as_retriever(search_kwargs={"depth": 3})
+
+    Specifying MMR parameters
+    ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    When using search type ``mmr_traversal``, several parameters of the MMR algorithm
+    can be configured.
+
+    The ``fetch_k`` parameter determines how many documents are fetched using vector
+    similarity and ``adjacent_k`` parameter determines how many documents are fetched
+    using graph edges.
+    The ``lambda_mult`` parameter controls how the MMR re-ranking weights similarity to
+    the query string vs diversity among the retrieved documents as fetched documents
+    are selected for the set of ``k`` final results::
+
+        retriever = graph_vectorstore.as_retriever(
+            search_type="mmr",
+            search_kwargs={"fetch_k": 20, "adjacent_k": 20, "lambda_mult": 0.25},
+        )
+
+    Specifying top k
+    ^^^^^^^^^^^^^^^^
+
+    We can also limit the number of documents ``k`` returned by the retriever.
+
+    Note that if ``depth`` is greater than zero, the retriever may return more documents
+    than is specified by ``k``, since both the original ``k`` documents retrieved using
+    vector similarity and any documents connected via graph edges will be returned::
+
+        retriever = graph_vectorstore.as_retriever(search_kwargs={"k": 1})
+
+    Similarity score threshold retrieval
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    For example, we can set a similarity score threshold and only return documents with
+    a score above that threshold::
+
+        retriever = graph_vectorstore.as_retriever(search_kwargs={"score_threshold": 0.5})
+    """  # noqa: E501
+
+    vectorstore: GraphVectorStore
+    """GraphVectorStore to use for retrieval."""
+    search_type: str = "traversal"
+    """Type of search to perform. Defaults to "traversal"."""
+    allowed_search_types: ClassVar[Collection[str]] = (
+        "similarity",
+        "similarity_score_threshold",
+        "mmr",
+        "traversal",
+        "mmr_traversal",
+    )
+
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> list[Document]:
+        if self.search_type == "traversal":
+            return list(self.vectorstore.traversal_search(query, **self.search_kwargs))
+        elif self.search_type == "mmr_traversal":
+            return list(
+                self.vectorstore.mmr_traversal_search(query, **self.search_kwargs)
+            )
+        else:
+            return super()._get_relevant_documents(query, run_manager=run_manager)
+
+    async def _aget_relevant_documents(
+        self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun
+    ) -> list[Document]:
+        if self.search_type == "traversal":
+            return [
+                doc
+                async for doc in self.vectorstore.atraversal_search(
+                    query, **self.search_kwargs
+                )
+            ]
+        elif self.search_type == "mmr_traversal":
+            return [
+                doc
+                async for doc in self.vectorstore.ammr_traversal_search(
+                    query, **self.search_kwargs
+                )
+            ]
+        else:
+            return await super()._aget_relevant_documents(
+                query, run_manager=run_manager
+            )

libs/community/langchain_community/graph_vectorstores/cassandra.py

@@ -12,12 +12,12 @@ from typing import (
 from langchain_core._api import beta
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
-from langchain_core.graph_vectorstores.base import (
+
+from langchain_community.graph_vectorstores.base import (
     GraphVectorStore,
     Node,
     nodes_to_documents,
 )
-
 from langchain_community.utilities.cassandra import SetupMode
 
 if TYPE_CHECKING:

libs/community/langchain_community/graph_vectorstores/extractors/gliner_link_extractor.py

@@ -2,11 +2,11 @@ from typing import Any, Dict, Iterable, List, Optional, Set, Union
 
 from langchain_core._api import beta
 from langchain_core.documents import Document
-from langchain_core.graph_vectorstores.links import Link
 
 from langchain_community.graph_vectorstores.extractors.link_extractor import (
     LinkExtractor,
 )
+from langchain_community.graph_vectorstores.links import Link
 
 # TypeAlias is not available in Python 3.9, we can't use that or the newer `type`.
 GLiNERInput = Union[str, Document]
@@ -34,7 +34,7 @@ class GLiNERLinkExtractor(LinkExtractor[GLiNERInput]):
     .. seealso::
 
             - :mod:`How to use a graph vector store <langchain_community.graph_vectorstores>`
-            - :class:`How to create links between documents <langchain_core.graph_vectorstores.links.Link>`
+            - :class:`How to create links between documents <langchain_community.graph_vectorstores.links.Link>`
 
     How to link Documents on common named entities
     ==============================================
@@ -59,12 +59,12 @@ class GLiNERLinkExtractor(LinkExtractor[GLiNERInput]):
 
     We can use :meth:`extract_one` on a document to get the links and add the links
     to the document metadata with
-    :meth:`~langchain_core.graph_vectorstores.links.add_links`::
+    :meth:`~langchain_community.graph_vectorstores.links.add_links`::
 
         from langchain_community.document_loaders import TextLoader
         from langchain_community.graph_vectorstores import CassandraGraphVectorStore
         from langchain_community.graph_vectorstores.extractors import GLiNERLinkExtractor
-        from langchain_core.graph_vectorstores.links import add_links
+        from langchain_community.graph_vectorstores.links import add_links
         from langchain_text_splitters import CharacterTextSplitter
 
         loader = TextLoader("state_of_the_union.txt")
@@ -113,7 +113,7 @@ class GLiNERLinkExtractor(LinkExtractor[GLiNERInput]):
 
         {'source': 'state_of_the_union.txt', 'links': [Link(kind='entity:Person', direction='bidir', tag='President Zelenskyy'), Link(kind='entity:Person', direction='bidir', tag='Vladimir Putin')]}
 
-    The documents with named entity links can then be added to a :class:`~langchain_core.graph_vectorstores.base.GraphVectorStore`::
+    The documents with named entity links can then be added to a :class:`~langchain_community.graph_vectorstores.base.GraphVectorStore`::
 
         from langchain_community.graph_vectorstores import CassandraGraphVectorStore
 

libs/community/langchain_community/graph_vectorstores/extractors/hierarchy_link_extractor.py

@@ -2,7 +2,6 @@ from typing import Callable, List, Set
 
 from langchain_core._api import beta
 from langchain_core.documents import Document
-from langchain_core.graph_vectorstores.links import Link
 
 from langchain_community.graph_vectorstores.extractors.link_extractor import (
     LinkExtractor,
@@ -10,6 +9,7 @@ from langchain_community.graph_vectorstores.extractors.link_extractor import (
 from langchain_community.graph_vectorstores.extractors.link_extractor_adapter import (
     LinkExtractorAdapter,
 )
+from langchain_community.graph_vectorstores.links import Link
 
 # TypeAlias is not available in Python 3.9, we can't use that or the newer `type`.
 HierarchyInput = List[str]

libs/community/langchain_community/graph_vectorstores/extractors/html_link_extractor.py

@@ -6,8 +6,8 @@ from urllib.parse import urldefrag, urljoin, urlparse
 
 from langchain_core._api import beta
 from langchain_core.documents import Document
-from langchain_core.graph_vectorstores import Link
 
+from langchain_community.graph_vectorstores import Link
 from langchain_community.graph_vectorstores.extractors.link_extractor import (
     LinkExtractor,
 )
@@ -77,7 +77,7 @@ class HtmlLinkExtractor(LinkExtractor[HtmlInput]):
         .. seealso::
 
             - :mod:`How to use a graph vector store <langchain_community.graph_vectorstores>`
-            - :class:`How to create links between documents <langchain_core.graph_vectorstores.links.Link>`
+            - :class:`How to create links between documents <langchain_community.graph_vectorstores.links.Link>`
 
         How to link Documents on hyperlinks in HTML
         ===========================================
@@ -103,7 +103,7 @@ class HtmlLinkExtractor(LinkExtractor[HtmlInput]):
 
         We can use :meth:`extract_one` on a document to get the links and add the links
         to the document metadata with
-        :meth:`~langchain_core.graph_vectorstores.links.add_links`::
+        :meth:`~langchain_community.graph_vectorstores.links.add_links`::
 
             from langchain_community.document_loaders import AsyncHtmlLoader
             from langchain_community.graph_vectorstores.extractors import (
@@ -148,7 +148,7 @@ class HtmlLinkExtractor(LinkExtractor[HtmlInput]):
 
             from langchain_community.document_loaders import AsyncHtmlLoader
             from langchain_community.graph_vectorstores.extractors import HtmlLinkExtractor
-            from langchain_core.graph_vectorstores.links import add_links
+            from langchain_community.graph_vectorstores.links import add_links
 
             loader = AsyncHtmlLoader(
                 [
@@ -227,7 +227,7 @@ class HtmlLinkExtractor(LinkExtractor[HtmlInput]):
 
             Found link from https://python.langchain.com/v0.2/docs/integrations/providers/astradb/ to https://docs.datastax.com/en/astra/home/astra.html.
 
-        The documents with URL links can then be added to a :class:`~langchain_core.graph_vectorstores.base.GraphVectorStore`::
+        The documents with URL links can then be added to a :class:`~langchain_community.graph_vectorstores.base.GraphVectorStore`::
 
             from langchain_community.graph_vectorstores import CassandraGraphVectorStore
 

libs/community/langchain_community/graph_vectorstores/extractors/keybert_link_extractor.py

@@ -2,11 +2,11 @@ from typing import Any, Dict, Iterable, Optional, Set, Union
 
 from langchain_core._api import beta
 from langchain_core.documents import Document
-from langchain_core.graph_vectorstores.links import Link
 
 from langchain_community.graph_vectorstores.extractors.link_extractor import (
     LinkExtractor,
 )
+from langchain_community.graph_vectorstores.links import Link
 
 KeybertInput = Union[str, Document]
 
@@ -37,7 +37,7 @@ class KeybertLinkExtractor(LinkExtractor[KeybertInput]):
         .. seealso::
 
             - :mod:`How to use a graph vector store <langchain_community.graph_vectorstores>`
-            - :class:`How to create links between documents <langchain_core.graph_vectorstores.links.Link>`
+            - :class:`How to create links between documents <langchain_community.graph_vectorstores.links.Link>`
 
         How to link Documents on common keywords using Keybert
         ======================================================
@@ -62,12 +62,12 @@ class KeybertLinkExtractor(LinkExtractor[KeybertInput]):
 
         We can use :meth:`extract_one` on a document to get the links and add the links
         to the document metadata with
-        :meth:`~langchain_core.graph_vectorstores.links.add_links`::
+        :meth:`~langchain_community.graph_vectorstores.links.add_links`::
 
             from langchain_community.document_loaders import TextLoader
             from langchain_community.graph_vectorstores import CassandraGraphVectorStore
             from langchain_community.graph_vectorstores.extractors import KeybertLinkExtractor
-            from langchain_core.graph_vectorstores.links import add_links
+            from langchain_community.graph_vectorstores.links import add_links
             from langchain_text_splitters import CharacterTextSplitter
 
             loader = TextLoader("state_of_the_union.txt")
@@ -116,7 +116,7 @@ class KeybertLinkExtractor(LinkExtractor[KeybertInput]):
 
             {'source': 'state_of_the_union.txt', 'links': [Link(kind='kw', direction='bidir', tag='ukraine'), Link(kind='kw', direction='bidir', tag='ukrainian'), Link(kind='kw', direction='bidir', tag='putin'), Link(kind='kw', direction='bidir', tag='vladimir'), Link(kind='kw', direction='bidir', tag='russia')]}
 
-        The documents with keyword links can then be added to a :class:`~langchain_core.graph_vectorstores.base.GraphVectorStore`::
+        The documents with keyword links can then be added to a :class:`~langchain_community.graph_vectorstores.base.GraphVectorStore`::
 
             from langchain_community.graph_vectorstores import CassandraGraphVectorStore
 

libs/community/langchain_community/graph_vectorstores/extractors/link_extractor.py

@@ -4,7 +4,8 @@ from abc import ABC, abstractmethod
 from typing import Generic, Iterable, Set, TypeVar
 
 from langchain_core._api import beta
-from langchain_core.graph_vectorstores import Link
+
+from langchain_community.graph_vectorstores import Link
 
 InputT = TypeVar("InputT")
 

libs/community/langchain_community/graph_vectorstores/extractors/link_extractor_adapter.py

@@ -1,8 +1,8 @@
 from typing import Callable, Iterable, Set, TypeVar
 
 from langchain_core._api import beta
-from langchain_core.graph_vectorstores import Link
 
+from langchain_community.graph_vectorstores import Link
 from langchain_community.graph_vectorstores.extractors.link_extractor import (
     LinkExtractor,
 )

libs/community/langchain_community/graph_vectorstores/extractors/link_extractor_transformer.py

@@ -3,11 +3,11 @@ from typing import Any, Sequence
 from langchain_core._api import beta
 from langchain_core.documents import Document
 from langchain_core.documents.transformers import BaseDocumentTransformer
-from langchain_core.graph_vectorstores.links import copy_with_links
 
 from langchain_community.graph_vectorstores.extractors.link_extractor import (
     LinkExtractor,
 )
+from langchain_community.graph_vectorstores.links import copy_with_links
 
 
 @beta()

libs/community/langchain_community/graph_vectorstores/links.py

@@ -1,8 +1,102 @@
-from langchain_core.graph_vectorstores.links import (
-    Link,
-    add_links,
-    copy_with_links,
-    get_links,
-)
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Literal, Union
 
-__all__ = ["Link", "add_links", "get_links", "copy_with_links"]
+from langchain_core._api import beta
+from langchain_core.documents import Document
+
+
+@beta()
+@dataclass(frozen=True)
+class Link:
+    """A link to/from a tag of a given tag.
+
+    Edges exist from nodes with an outgoing link to nodes with a matching incoming link.
+    """
+
+    kind: str
+    """The kind of link. Allows different extractors to use the same tag name without
+    creating collisions between extractors. For example “keyword” vs “url”."""
+    direction: Literal["in", "out", "bidir"]
+    """The direction of the link."""
+    tag: str
+    """The tag of the link."""
+
+    @staticmethod
+    def incoming(kind: str, tag: str) -> "Link":
+        """Create an incoming link."""
+        return Link(kind=kind, direction="in", tag=tag)
+
+    @staticmethod
+    def outgoing(kind: str, tag: str) -> "Link":
+        """Create an outgoing link."""
+        return Link(kind=kind, direction="out", tag=tag)
+
+    @staticmethod
+    def bidir(kind: str, tag: str) -> "Link":
+        """Create a bidirectional link."""
+        return Link(kind=kind, direction="bidir", tag=tag)
+
+
+METADATA_LINKS_KEY = "links"
+
+
+@beta()
+def get_links(doc: Document) -> list[Link]:
+    """Get the links from a document.
+
+    Args:
+        doc: The document to get the link tags from.
+    Returns:
+        The set of link tags from the document.
+    """
+
+    links = doc.metadata.setdefault(METADATA_LINKS_KEY, [])
+    if not isinstance(links, list):
+        # Convert to a list and remember that.
+        links = list(links)
+        doc.metadata[METADATA_LINKS_KEY] = links
+    return links
+
+
+@beta()
+def add_links(doc: Document, *links: Union[Link, Iterable[Link]]) -> None:
+    """Add links to the given metadata.
+
+    Args:
+        doc: The document to add the links to.
+        *links: The links to add to the document.
+    """
+    links_in_metadata = get_links(doc)
+    for link in links:
+        if isinstance(link, Iterable):
+            links_in_metadata.extend(link)
+        else:
+            links_in_metadata.append(link)
+
+
+@beta()
+def copy_with_links(doc: Document, *links: Union[Link, Iterable[Link]]) -> Document:
+    """Return a document with the given links added.
+
+    Args:
+        doc: The document to add the links to.
+        *links: The links to add to the document.
+
+    Returns:
+        A document with a shallow-copy of the metadata with the links added.
+    """
+    new_links = set(get_links(doc))
+    for link in links:
+        if isinstance(link, Iterable):
+            new_links.update(link)
+        else:
+            new_links.add(link)
+
+    return Document(
+        page_content=doc.page_content,
+        metadata={
+            **doc.metadata,
+            METADATA_LINKS_KEY: list(new_links),
+        },
+    )

libs/community/langchain_community/graphs/neo4j_graph.py

@@ -411,7 +411,9 @@ class Neo4jGraph(GraphStore):
         return self.structured_schema
 
     def query(
-        self, query: str, params: dict = {}, retry_on_session_expired: bool = True
+        self,
+        query: str,
+        params: dict = {},
     ) -> List[Dict[str, Any]]:
         """Query Neo4j database.
 
@@ -423,26 +425,44 @@ class Neo4jGraph(GraphStore):
             List[Dict[str, Any]]: The list of dictionaries containing the query results.
         """
         from neo4j import Query
-        from neo4j.exceptions import CypherSyntaxError, SessionExpired
+        from neo4j.exceptions import Neo4jError
 
-        with self._driver.session(database=self._database) as session:
-            try:
-                data = session.run(Query(text=query, timeout=self.timeout), params)
-                json_data = [r.data() for r in data]
-                if self.sanitize:
-                    json_data = [value_sanitize(el) for el in json_data]
-                return json_data
-            except CypherSyntaxError as e:
-                raise ValueError(f"Generated Cypher Statement is not valid\n{e}")
-            except (
-                SessionExpired
-            ) as e:  # Session expired is a transient error that can be retried
-                if retry_on_session_expired:
-                    return self.query(
-                        query, params=params, retry_on_session_expired=False
+        try:
+            data, _, _ = self._driver.execute_query(
+                Query(text=query, timeout=self.timeout),
+                database=self._database,
+                parameters_=params,
+            )
+            json_data = [r.data() for r in data]
+            if self.sanitize:
+                json_data = [value_sanitize(el) for el in json_data]
+            return json_data
+        except Neo4jError as e:
+            if not (
+                (
+                    (  # isCallInTransactionError
+                        e.code == "Neo.DatabaseError.Statement.ExecutionFailed"
+                        or e.code
+                        == "Neo.DatabaseError.Transaction.TransactionStartFailed"
                     )
-                else:
-                    raise e
+                    and "in an implicit transaction" in e.message
+                )
+                or (  # isPeriodicCommitError
+                    e.code == "Neo.ClientError.Statement.SemanticError"
+                    and (
+                        "in an open transaction is not possible" in e.message
+                        or "tried to execute in an explicit transaction" in e.message
+                    )
+                )
+            ):
+                raise
+        # fallback to allow implicit transactions
+        with self._driver.session() as session:
+            data = session.run(Query(text=query, timeout=self.timeout), params)
+            json_data = [r.data() for r in data]
+            if self.sanitize:
+                json_data = [value_sanitize(el) for el in json_data]
+            return json_data
 
     def refresh_schema(self) -> None:
         """

libs/community/langchain_community/llms/__init__.py

@@ -510,12 +510,6 @@ def _import_sagemaker_endpoint() -> Type[BaseLLM]:
     return SagemakerEndpoint
 
 
-def _import_sambaverse() -> Type[BaseLLM]:
-    from langchain_community.llms.sambanova import Sambaverse
-
-    return Sambaverse
-
-
 def _import_sambastudio() -> Type[BaseLLM]:
     from langchain_community.llms.sambanova import SambaStudio
 
@@ -817,8 +811,6 @@ def __getattr__(name: str) -> Any:
         return _import_rwkv()
     elif name == "SagemakerEndpoint":
         return _import_sagemaker_endpoint()
-    elif name == "Sambaverse":
-        return _import_sambaverse()
     elif name == "SambaStudio":
         return _import_sambastudio()
     elif name == "SelfHostedPipeline":
@@ -954,7 +946,6 @@ __all__ = [
     "RWKV",
     "Replicate",
     "SagemakerEndpoint",
-    "Sambaverse",
     "SambaStudio",
     "SelfHostedHuggingFaceLLM",
     "SelfHostedPipeline",
@@ -1051,7 +1042,6 @@ def get_type_to_cls_dict() -> Dict[str, Callable[[], Type[BaseLLM]]]:
         "replicate": _import_replicate,
         "rwkv": _import_rwkv,
         "sagemaker_endpoint": _import_sagemaker_endpoint,
-        "sambaverse": _import_sambaverse,
         "sambastudio": _import_sambastudio,
         "self_hosted": _import_self_hosted,
         "self_hosted_hugging_face": _import_self_hosted_hugging_face,

libs/community/langchain_community/llms/sambanova.py

@@ -9,464 +9,6 @@ from langchain_core.utils import get_from_dict_or_env, pre_init
 from pydantic import ConfigDict
 
 
-class SVEndpointHandler:
-    """
-    SambaNova Systems Interface for Sambaverse endpoint.
-
-    :param str host_url: Base URL of the DaaS API service
-    """
-
-    API_BASE_PATH: str = "/api/predict"
-
-    def __init__(self, host_url: str):
-        """
-        Initialize the SVEndpointHandler.
-
-        :param str host_url: Base URL of the DaaS API service
-        """
-        self.host_url = host_url
-        self.http_session = requests.Session()
-
-    @staticmethod
-    def _process_response(response: requests.Response) -> Dict:
-        """
-        Processes the API response and returns the resulting dict.
-
-        All resulting dicts, regardless of success or failure, will contain the
-        `status_code` key with the API response status code.
-
-        If the API returned an error, the resulting dict will contain the key
-        `detail` with the error message.
-
-        If the API call was successful, the resulting dict will contain the key
-        `data` with the response data.
-
-        :param requests.Response response: the response object to process
-        :return: the response dict
-        :type: dict
-        """
-        result: Dict[str, Any] = {}
-        try:
-            lines_result = response.text.strip().split("\n")
-            text_result = lines_result[-1]
-            if response.status_code == 200 and json.loads(text_result).get("error"):
-                completion = ""
-                for line in lines_result[:-1]:
-                    completion += json.loads(line)["result"]["responses"][0][
-                        "stream_token"
-                    ]
-                text_result = lines_result[-2]
-                result = json.loads(text_result)
-                result["result"]["responses"][0]["completion"] = completion
-            else:
-                result = json.loads(text_result)
-        except Exception as e:
-            result["detail"] = str(e)
-        if "status_code" not in result:
-            result["status_code"] = response.status_code
-        return result
-
-    @staticmethod
-    def _process_streaming_response(
-        response: requests.Response,
-    ) -> Generator[Dict, None, None]:
-        """Process the streaming response"""
-        try:
-            for line in response.iter_lines():
-                chunk = json.loads(line)
-                if "status_code" not in chunk:
-                    chunk["status_code"] = response.status_code
-                if chunk["status_code"] == 200 and chunk.get("error"):
-                    chunk["result"] = {"responses": [{"stream_token": ""}]}
-                    return chunk
-                yield chunk
-        except Exception as e:
-            raise RuntimeError(f"Error processing streaming response: {e}")
-
-    def _get_full_url(self) -> str:
-        """
-        Return the full API URL for a given path.
-        :returns: the full API URL for the sub-path
-        :type: str
-        """
-        return f"{self.host_url}{self.API_BASE_PATH}"
-
-    def nlp_predict(
-        self,
-        key: str,
-        sambaverse_model_name: Optional[str],
-        input: Union[List[str], str],
-        params: Optional[str] = "",
-        stream: bool = False,
-    ) -> Dict:
-        """
-        NLP predict using inline input string.
-
-        :param str project: Project ID in which the endpoint exists
-        :param str endpoint: Endpoint ID
-        :param str key: API Key
-        :param str input_str: Input string
-        :param str params: Input params string
-        :returns: Prediction results
-        :type: dict
-        """
-        if params:
-            data = {"instance": input, "params": json.loads(params)}
-        else:
-            data = {"instance": input}
-        response = self.http_session.post(
-            self._get_full_url(),
-            headers={
-                "key": key,
-                "Content-Type": "application/json",
-                "modelName": sambaverse_model_name,
-            },
-            json=data,
-        )
-        return SVEndpointHandler._process_response(response)
-
-    def nlp_predict_stream(
-        self,
-        key: str,
-        sambaverse_model_name: Optional[str],
-        input: Union[List[str], str],
-        params: Optional[str] = "",
-    ) -> Iterator[Dict]:
-        """
-        NLP predict using inline input string.
-
-        :param str project: Project ID in which the endpoint exists
-        :param str endpoint: Endpoint ID
-        :param str key: API Key
-        :param str input_str: Input string
-        :param str params: Input params string
-        :returns: Prediction results
-        :type: dict
-        """
-        if params:
-            data = {"instance": input, "params": json.loads(params)}
-        else:
-            data = {"instance": input}
-        # Streaming output
-        response = self.http_session.post(
-            self._get_full_url(),
-            headers={
-                "key": key,
-                "Content-Type": "application/json",
-                "modelName": sambaverse_model_name,
-            },
-            json=data,
-            stream=True,
-        )
-        for chunk in SVEndpointHandler._process_streaming_response(response):
-            yield chunk
-
-
-class Sambaverse(LLM):
-    """
-    Sambaverse large language models.
-
-    To use, you should have the environment variable ``SAMBAVERSE_API_KEY``
-    set with your API key.
-
-    get one in https://sambaverse.sambanova.ai
-    read extra documentation in https://docs.sambanova.ai/sambaverse/latest/index.html
-
-
-    Example:
-    .. code-block:: python
-
-        from langchain_community.llms.sambanova  import Sambaverse
-        Sambaverse(
-            sambaverse_url="https://sambaverse.sambanova.ai",
-            sambaverse_api_key="your-sambaverse-api-key",
-            sambaverse_model_name="Meta/llama-2-7b-chat-hf",
-            streaming: = False
-            model_kwargs={
-                "select_expert": "llama-2-7b-chat-hf",
-                "do_sample": False,
-                "max_tokens_to_generate": 100,
-                "temperature": 0.7,
-                "top_p": 1.0,
-                "repetition_penalty": 1.0,
-                "top_k": 50,
-                "process_prompt": False
-            },
-        )
-    """
-
-    sambaverse_url: str = ""
-    """Sambaverse url to use"""
-
-    sambaverse_api_key: str = ""
-    """sambaverse api key"""
-
-    sambaverse_model_name: Optional[str] = None
-    """sambaverse expert model to use"""
-
-    model_kwargs: Optional[dict] = None
-    """Key word arguments to pass to the model."""
-
-    streaming: Optional[bool] = False
-    """Streaming flag to get streamed response."""
-
-    model_config = ConfigDict(
-        extra="forbid",
-    )
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return True
-
-    @pre_init
-    def validate_environment(cls, values: Dict) -> Dict:
-        """Validate that api key exists in environment."""
-        values["sambaverse_url"] = get_from_dict_or_env(
-            values,
-            "sambaverse_url",
-            "SAMBAVERSE_URL",
-            default="https://sambaverse.sambanova.ai",
-        )
-        values["sambaverse_api_key"] = get_from_dict_or_env(
-            values, "sambaverse_api_key", "SAMBAVERSE_API_KEY"
-        )
-        values["sambaverse_model_name"] = get_from_dict_or_env(
-            values, "sambaverse_model_name", "SAMBAVERSE_MODEL_NAME"
-        )
-        return values
-
-    @property
-    def _identifying_params(self) -> Dict[str, Any]:
-        """Get the identifying parameters."""
-        return {**{"model_kwargs": self.model_kwargs}}
-
-    @property
-    def _llm_type(self) -> str:
-        """Return type of llm."""
-        return "Sambaverse LLM"
-
-    def _get_tuning_params(self, stop: Optional[List[str]]) -> str:
-        """
-        Get the tuning parameters to use when calling the LLM.
-
-        Args:
-            stop: Stop words to use when generating. Model output is cut off at the
-                first occurrence of any of the stop substrings.
-
-        Returns:
-            The tuning parameters as a JSON string.
-        """
-        _model_kwargs = self.model_kwargs or {}
-        _kwarg_stop_sequences = _model_kwargs.get("stop_sequences", [])
-        _stop_sequences = stop or _kwarg_stop_sequences
-        if not _kwarg_stop_sequences:
-            _model_kwargs["stop_sequences"] = ",".join(
-                f'"{x}"' for x in _stop_sequences
-            )
-        tuning_params_dict = {
-            k: {"type": type(v).__name__, "value": str(v)}
-            for k, v in (_model_kwargs.items())
-        }
-        _model_kwargs["stop_sequences"] = _kwarg_stop_sequences
-        tuning_params = json.dumps(tuning_params_dict)
-        return tuning_params
-
-    def _handle_nlp_predict(
-        self,
-        sdk: SVEndpointHandler,
-        prompt: Union[List[str], str],
-        tuning_params: str,
-    ) -> str:
-        """
-        Perform an NLP prediction using the Sambaverse endpoint handler.
-
-        Args:
-            sdk: The SVEndpointHandler to use for the prediction.
-            prompt: The prompt to use for the prediction.
-            tuning_params: The tuning parameters to use for the prediction.
-
-        Returns:
-            The prediction result.
-
-        Raises:
-            ValueError: If the prediction fails.
-        """
-        response = sdk.nlp_predict(
-            self.sambaverse_api_key, self.sambaverse_model_name, prompt, tuning_params
-        )
-        if response["status_code"] != 200:
-            error = response.get("error")
-            if error:
-                optional_code = error.get("code")
-                optional_details = error.get("details")
-                optional_message = error.get("message")
-                raise RuntimeError(
-                    f"Sambanova /complete call failed with status code "
-                    f"{response['status_code']}.\n"
-                    f"Message: {optional_message}\n"
-                    f"Details: {optional_details}\n"
-                    f"Code: {optional_code}\n"
-                )
-            else:
-                raise RuntimeError(
-                    f"Sambanova /complete call failed with status code "
-                    f"{response['status_code']}."
-                    f"{response}."
-                )
-        return response["result"]["responses"][0]["completion"]
-
-    def _handle_completion_requests(
-        self, prompt: Union[List[str], str], stop: Optional[List[str]]
-    ) -> str:
-        """
-        Perform a prediction using the Sambaverse endpoint handler.
-
-        Args:
-            prompt: The prompt to use for the prediction.
-            stop: stop sequences.
-
-        Returns:
-            The prediction result.
-
-        Raises:
-            ValueError: If the prediction fails.
-        """
-        ss_endpoint = SVEndpointHandler(self.sambaverse_url)
-        tuning_params = self._get_tuning_params(stop)
-        return self._handle_nlp_predict(ss_endpoint, prompt, tuning_params)
-
-    def _handle_nlp_predict_stream(
-        self, sdk: SVEndpointHandler, prompt: Union[List[str], str], tuning_params: str
-    ) -> Iterator[GenerationChunk]:
-        """
-        Perform a streaming request to the LLM.
-
-        Args:
-            sdk: The SVEndpointHandler to use for the prediction.
-            prompt: The prompt to use for the prediction.
-            tuning_params: The tuning parameters to use for the prediction.
-
-        Returns:
-            An iterator of GenerationChunks.
-        """
-        for chunk in sdk.nlp_predict_stream(
-            self.sambaverse_api_key, self.sambaverse_model_name, prompt, tuning_params
-        ):
-            if chunk["status_code"] != 200:
-                error = chunk.get("error")
-                if error:
-                    optional_code = error.get("code")
-                    optional_details = error.get("details")
-                    optional_message = error.get("message")
-                    raise ValueError(
-                        f"Sambanova /complete call failed with status code "
-                        f"{chunk['status_code']}.\n"
-                        f"Message: {optional_message}\n"
-                        f"Details: {optional_details}\n"
-                        f"Code: {optional_code}\n"
-                    )
-                else:
-                    raise RuntimeError(
-                        f"Sambanova /complete call failed with status code "
-                        f"{chunk['status_code']}."
-                        f"{chunk}."
-                    )
-            text = chunk["result"]["responses"][0]["stream_token"]
-            generated_chunk = GenerationChunk(text=text)
-            yield generated_chunk
-
-    def _stream(
-        self,
-        prompt: Union[List[str], str],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> Iterator[GenerationChunk]:
-        """Stream the Sambaverse's LLM on the given prompt.
-
-        Args:
-            prompt: The prompt to pass into the model.
-            stop: Optional list of stop words to use when generating.
-            run_manager: Callback manager for the run.
-            kwargs: Additional keyword arguments. directly passed
-                to the sambaverse model in API call.
-
-        Returns:
-            An iterator of GenerationChunks.
-        """
-        ss_endpoint = SVEndpointHandler(self.sambaverse_url)
-        tuning_params = self._get_tuning_params(stop)
-        try:
-            if self.streaming:
-                for chunk in self._handle_nlp_predict_stream(
-                    ss_endpoint, prompt, tuning_params
-                ):
-                    if run_manager:
-                        run_manager.on_llm_new_token(chunk.text)
-                    yield chunk
-            else:
-                return
-        except Exception as e:
-            # Handle any errors raised by the inference endpoint
-            raise ValueError(f"Error raised by the inference endpoint: {e}") from e
-
-    def _handle_stream_request(
-        self,
-        prompt: Union[List[str], str],
-        stop: Optional[List[str]],
-        run_manager: Optional[CallbackManagerForLLMRun],
-        kwargs: Dict[str, Any],
-    ) -> str:
-        """
-        Perform a streaming request to the LLM.
-
-        Args:
-            prompt: The prompt to generate from.
-            stop: Stop words to use when generating. Model output is cut off at the
-                first occurrence of any of the stop substrings.
-            run_manager: Callback manager for the run.
-            kwargs: Additional keyword arguments. directly passed
-                to the sambaverse model in API call.
-
-        Returns:
-            The model output as a string.
-        """
-        completion = ""
-        for chunk in self._stream(
-            prompt=prompt, stop=stop, run_manager=run_manager, **kwargs
-        ):
-            completion += chunk.text
-        return completion
-
-    def _call(
-        self,
-        prompt: Union[List[str], str],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> str:
-        """Run the LLM on the given input.
-
-        Args:
-            prompt: The prompt to generate from.
-            stop: Stop words to use when generating. Model output is cut off at the
-                first occurrence of any of the stop substrings.
-            run_manager: Callback manager for the run.
-            kwargs: Additional keyword arguments. directly passed
-                to the sambaverse model in API call.
-
-        Returns:
-            The model output as a string.
-        """
-        try:
-            if self.streaming:
-                return self._handle_stream_request(prompt, stop, run_manager, kwargs)
-            return self._handle_completion_requests(prompt, stop)
-        except Exception as e:
-            # Handle any errors raised by the inference endpoint
-            raise ValueError(f"Error raised by the inference endpoint: {e}") from e
-
-
 class SSEndpointHandler:
     """
     SambaNova Systems Interface for SambaStudio model endpoints.
@@ -975,7 +517,7 @@ class SambaStudio(LLM):
                 first occurrence of any of the stop substrings.
             run_manager: Callback manager for the run.
             kwargs: Additional keyword arguments. directly passed
-                to the sambaverse model in API call.
+                to the sambastudio model in API call.
 
         Returns:
             The model output as a string.

libs/community/langchain_community/tools/databricks/tool.py

@@ -10,7 +10,6 @@ from pydantic import BaseModel, Field, create_model
 from typing_extensions import Self
 
 if TYPE_CHECKING:
-    from databricks.sdk import WorkspaceClient
     from databricks.sdk.service.catalog import FunctionInfo
 
 from pydantic import ConfigDict
@@ -121,7 +120,7 @@ def _get_tool_name(function: "FunctionInfo") -> str:
     return tool_name
 
 
-def _get_default_workspace_client() -> "WorkspaceClient":
+def _get_default_workspace_client() -> Any:
     try:
         from databricks.sdk import WorkspaceClient
     except ImportError as e:
@@ -137,7 +136,7 @@ class UCFunctionToolkit(BaseToolkit):
         description="The ID of a Databricks SQL Warehouse to execute functions."
     )
 
-    workspace_client: "WorkspaceClient" = Field(
+    workspace_client: Any = Field(
         default_factory=_get_default_workspace_client,
         description="Databricks workspace client.",
     )

libs/community/langchain_community/tools/zenguard/tool.py

@@ -69,6 +69,19 @@ class ZenGuardTool(BaseTool):
             )
         return v
 
+    @property
+    def _api_key(self) -> str:
+        if self.zenguard_api_key is None:
+            raise ValueError(
+                "API key is required for the ZenGuardTool. "
+                "Please provide the API key by either:\n"
+                "1. Manually specifying it when initializing the tool: "
+                "ZenGuardTool(zenguard_api_key='your_api_key')\n"
+                "2. Setting it as an environment variable:"
+                f" {self._ZENGUARD_API_KEY_ENV_NAME}"
+            )
+        return self.zenguard_api_key
+
     def _run(
         self,
         prompts: List[str],
@@ -91,7 +104,7 @@ class ZenGuardTool(BaseTool):
             response = requests.post(
                 self._ZENGUARD_API_URL_ROOT + postfix,
                 json=json,
-                headers={"x-api-key": self.zenguard_api_key},
+                headers={"x-api-key": self._api_key},
                 timeout=5,
             )
             response.raise_for_status()

libs/community/langchain_community/utilities/financial_datasets.py

@@ -24,6 +24,18 @@ class FinancialDatasetsAPIWrapper(BaseModel):
             data, "financial_datasets_api_key", "FINANCIAL_DATASETS_API_KEY"
         )
 
+    @property
+    def _api_key(self) -> str:
+        if self.financial_datasets_api_key is None:
+            raise ValueError(
+                "API key is required for the FinancialDatasetsAPIWrapper. "
+                "Please provide the API key by either:\n"
+                "1. Manually specifying it when initializing the wrapper: "
+                "FinancialDatasetsAPIWrapper(financial_datasets_api_key='your_api_key')\n"
+                "2. Setting it as an environment variable: FINANCIAL_DATASETS_API_KEY"
+            )
+        return self.financial_datasets_api_key
+
     def get_income_statements(
         self,
         ticker: str,
@@ -47,7 +59,7 @@ class FinancialDatasetsAPIWrapper(BaseModel):
         )
 
         # Add the api key to the headers
-        headers = {"X-API-KEY": self.financial_datasets_api_key}
+        headers = {"X-API-KEY": self._api_key}
 
         # Execute the request
         response = requests.get(url, headers=headers)
@@ -78,7 +90,7 @@ class FinancialDatasetsAPIWrapper(BaseModel):
         )
 
         # Add the api key to the headers
-        headers = {"X-API-KEY": self.financial_datasets_api_key}
+        headers = {"X-API-KEY": self._api_key}
 
         # Execute the request
         response = requests.get(url, headers=headers)
@@ -110,7 +122,7 @@ class FinancialDatasetsAPIWrapper(BaseModel):
         )
 
         # Add the api key to the headers
-        headers = {"X-API-KEY": self.financial_datasets_api_key}
+        headers = {"X-API-KEY": self._api_key}
 
         # Execute the request
         response = requests.get(url, headers=headers)

libs/community/langchain_community/utilities/github.py

@@ -492,7 +492,7 @@ class GitHubAPIWrapper(BaseModel):
         response_dict: Dict[str, str] = {}
         add_to_dict(response_dict, "title", pull.title)
         add_to_dict(response_dict, "number", str(pr_number))
-        add_to_dict(response_dict, "body", pull.body)
+        add_to_dict(response_dict, "body", pull.body if pull.body else "")
 
         comments: List[str] = []
         page = 0

libs/community/langchain_community/vectorstores/azuresearch.py

@@ -443,6 +443,12 @@ class AzureSearch(VectorStore):
             logger.debug("Nothing to insert, skipping.")
             return []
 
+        # when `keys` are not passed in and there is `ids` in kwargs, use those instead
+        # base class expects `ids` passed in rather than `keys`
+        # https://github.com/langchain-ai/langchain/blob/4cdaca67dc51dba887289f56c6fead3c1a52f97d/libs/core/langchain_core/vectorstores/base.py#L65
+        if (not keys) and ("ids" in kwargs) and (len(kwargs["ids"]) == len(embeddings)):
+            keys = kwargs["ids"]
+
         return self.add_embeddings(zip(texts, embeddings), metadatas, keys=keys)
 
     async def aadd_texts(
@@ -467,6 +473,12 @@ class AzureSearch(VectorStore):
             logger.debug("Nothing to insert, skipping.")
             return []
 
+        # when `keys` are not passed in and there is `ids` in kwargs, use those instead
+        # base class expects `ids` passed in rather than `keys`
+        # https://github.com/langchain-ai/langchain/blob/4cdaca67dc51dba887289f56c6fead3c1a52f97d/libs/core/langchain_core/vectorstores/base.py#L65
+        if (not keys) and ("ids" in kwargs) and (len(kwargs["ids"]) == len(embeddings)):
+            keys = kwargs["ids"]
+
         return await self.aadd_embeddings(zip(texts, embeddings), metadatas, keys=keys)
 
     def add_embeddings(
@@ -483,9 +495,13 @@ class AzureSearch(VectorStore):
         data = []
         for i, (text, embedding) in enumerate(text_embeddings):
             # Use provided key otherwise use default key
-            key = keys[i] if keys else str(uuid.uuid4())
-            # Encoding key for Azure Search valid characters
-            key = base64.urlsafe_b64encode(bytes(key, "utf-8")).decode("ascii")
+            if keys:
+                key = keys[i]
+            else:
+                key = str(uuid.uuid4())
+                # Encoding key for Azure Search valid characters
+                key = base64.urlsafe_b64encode(bytes(key, "utf-8")).decode("ascii")
+
             metadata = metadatas[i] if metadatas else {}
             # Add data to index
             # Additional metadata to fields mapping

libs/community/langchain_community/vectorstores/epsilla.py

@@ -65,10 +65,12 @@ class Epsilla(VectorStore):
                 "Please install pyepsilla package with `pip install pyepsilla`."
             ) from e
 
-        if not isinstance(client, pyepsilla.vectordb.Client):
+        if not isinstance(
+            client, (pyepsilla.vectordb.Client, pyepsilla.cloud.client.Vectordb)
+        ):
             raise TypeError(
-                f"client should be an instance of pyepsilla.vectordb.Client, "
-                f"got {type(client)}"
+                "client should be an instance of pyepsilla.vectordb.Client or "
+                f"pyepsilla.cloud.client.Vectordb, got {type(client)}"
             )
 
         self._client: vectordb.Client = client

libs/community/langchain_community/vectorstores/neo4j_vector.py

@@ -595,11 +595,8 @@ class Neo4jVector(VectorStore):
         query: str,
         *,
         params: Optional[dict] = None,
-        retry_on_session_expired: bool = True,
     ) -> List[Dict[str, Any]]:
-        """
-        This method sends a Cypher query to the connected Neo4j database
-        and returns the results as a list of dictionaries.
+        """Query Neo4j database with retries and exponential backoff.
 
         Args:
             query (str): The Cypher query to execute.
@@ -608,24 +605,38 @@ class Neo4jVector(VectorStore):
         Returns:
             List[Dict[str, Any]]: List of dictionaries containing the query results.
         """
-        from neo4j.exceptions import CypherSyntaxError, SessionExpired
+        from neo4j import Query
+        from neo4j.exceptions import Neo4jError
 
         params = params or {}
-        with self._driver.session(database=self._database) as session:
-            try:
-                data = session.run(query, params)
-                return [r.data() for r in data]
-            except CypherSyntaxError as e:
-                raise ValueError(f"Cypher Statement is not valid\n{e}")
-            except (
-                SessionExpired
-            ) as e:  # Session expired is a transient error that can be retried
-                if retry_on_session_expired:
-                    return self.query(
-                        query, params=params, retry_on_session_expired=False
+        try:
+            data, _, _ = self._driver.execute_query(
+                query, database=self._database, parameters_=params
+            )
+            return [r.data() for r in data]
+        except Neo4jError as e:
+            if not (
+                (
+                    (  # isCallInTransactionError
+                        e.code == "Neo.DatabaseError.Statement.ExecutionFailed"
+                        or e.code
+                        == "Neo.DatabaseError.Transaction.TransactionStartFailed"
                     )
-                else:
-                    raise e
+                    and "in an implicit transaction" in e.message
+                )
+                or (  # isPeriodicCommitError
+                    e.code == "Neo.ClientError.Statement.SemanticError"
+                    and (
+                        "in an open transaction is not possible" in e.message
+                        or "tried to execute in an explicit transaction" in e.message
+                    )
+                )
+            ):
+                raise
+        # Fallback to allow implicit transactions
+        with self._driver.session() as session:
+            data = session.run(Query(text=query), params)
+            return [r.data() for r in data]
 
     def verify_version(self) -> None:
         """

libs/community/poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand.
+# This file is automatically @generated by Poetry 1.5.1 and should not be changed by hand.
 
 [[package]]
 name = "aiohappyeyeballs"
@@ -150,13 +150,13 @@ files = [
 
 [[package]]
 name = "anyio"
-version = "4.4.0"
+version = "4.5.0"
 description = "High level compatibility layer for multiple asynchronous event loop implementations"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"},
-    {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"},
+    {file = "anyio-4.5.0-py3-none-any.whl", hash = "sha256:fdeb095b7cc5a5563175eedd926ec4ae55413bb4be5770c424af0ba46ccb4a78"},
+    {file = "anyio-4.5.0.tar.gz", hash = "sha256:c5a275fe5ca0afd788001f58fca1e69e29ce706d746e317d660e21f70c530ef9"},
 ]
 
 [package.dependencies]
@@ -166,9 +166,9 @@ sniffio = ">=1.1"
 typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"]
-test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"]
-trio = ["trio (>=0.23)"]
+doc = ["Sphinx (>=7.4,<8.0)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"]
+test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.21.0b1)"]
+trio = ["trio (>=0.26.1)"]
 
 [[package]]
 name = "appnope"
@@ -1251,15 +1251,18 @@ zstd = ["zstandard (>=0.18.0)"]
 
 [[package]]
 name = "idna"
-version = "3.8"
+version = "3.10"
 description = "Internationalized Domain Names in Applications (IDNA)"
 optional = false
 python-versions = ">=3.6"
 files = [
-    {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"},
-    {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"},
+    {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"},
+    {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"},
 ]
 
+[package.extras]
+all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"]
+
 [[package]]
 name = "importlib-metadata"
 version = "8.5.0"
@@ -1535,13 +1538,13 @@ notebook = "*"
 
 [[package]]
 name = "jupyter-client"
-version = "8.6.2"
+version = "8.6.3"
 description = "Jupyter protocol implementation and client libraries"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "jupyter_client-8.6.2-py3-none-any.whl", hash = "sha256:50cbc5c66fd1b8f65ecb66bc490ab73217993632809b6e505687de18e9dea39f"},
-    {file = "jupyter_client-8.6.2.tar.gz", hash = "sha256:2bda14d55ee5ba58552a8c53ae43d215ad9868853489213f37da060ced54d8df"},
+    {file = "jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f"},
+    {file = "jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419"},
 ]
 
 [package.dependencies]
@@ -1794,8 +1797,8 @@ langchain-core = "^0.3.0"
 langchain-text-splitters = "^0.3.0"
 langsmith = "^0.1.17"
 numpy = [
-    {version = ">=1,<2", markers = "python_version < \"3.12\""},
-    {version = ">=1.26.0,<2.0.0", markers = "python_version >= \"3.12\""},
+    {version = "^1", markers = "python_version < \"3.12\""},
+    {version = "^1.26.0", markers = "python_version >= \"3.12\""},
 ]
 pydantic = "^2.7.4"
 PyYAML = ">=5.3"
@@ -1809,7 +1812,7 @@ url = "../langchain"
 
 [[package]]
 name = "langchain-core"
-version = "0.3.0"
+version = "0.3.2"
 description = "Building applications with LLMs through composability"
 optional = false
 python-versions = ">=3.9,<4.0"
@@ -1818,11 +1821,11 @@ develop = true
 
 [package.dependencies]
 jsonpatch = "^1.33"
-langsmith = "^0.1.117"
+langsmith = "^0.1.125"
 packaging = ">=23.2,<25"
 pydantic = [
-    {version = ">=2.5.2,<3.0.0", markers = "python_full_version < \"3.12.4\""},
-    {version = ">=2.7.4,<3.0.0", markers = "python_full_version >= \"3.12.4\""},
+    {version = "^2.5.2", markers = "python_full_version < \"3.12.4\""},
+    {version = "^2.7.4", markers = "python_full_version >= \"3.12.4\""},
 ]
 PyYAML = ">=5.3"
 tenacity = "^8.1.0,!=8.4.0"
@@ -1843,7 +1846,7 @@ develop = true
 
 [package.dependencies]
 httpx = "^0.27.0"
-langchain-core = ">=0.3.0.dev1"
+langchain-core = "^0.3.0"
 pytest = ">=7,<9"
 syrupy = "^4"
 
@@ -1869,13 +1872,13 @@ url = "../text-splitters"
 
 [[package]]
 name = "langsmith"
-version = "0.1.120"
+version = "0.1.125"
 description = "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform."
 optional = false
 python-versions = "<4.0,>=3.8.1"
 files = [
-    {file = "langsmith-0.1.120-py3-none-any.whl", hash = "sha256:54d2785e301646c0988e0a69ebe4d976488c87b41928b358cb153b6ddd8db62b"},
-    {file = "langsmith-0.1.120.tar.gz", hash = "sha256:25499ca187b41bd89d784b272b97a8d76f60e0e21bdf20336e8a2aa6a9b23ac9"},
+    {file = "langsmith-0.1.125-py3-none-any.whl", hash = "sha256:74ce8eb2663e1ed20bfcfc88d41e0712879306956c9938d1cdbab7d60458bdca"},
+    {file = "langsmith-0.1.125.tar.gz", hash = "sha256:2c0eb0c3cbf22cff55bf519b8e889041f9a591bcf97af5152c8e130333c5940e"},
 ]
 
 [package.dependencies]
@@ -2574,13 +2577,13 @@ ptyprocess = ">=0.5"
 
 [[package]]
 name = "platformdirs"
-version = "4.3.2"
+version = "4.3.6"
 description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "platformdirs-4.3.2-py3-none-any.whl", hash = "sha256:eb1c8582560b34ed4ba105009a4badf7f6f85768b30126f351328507b2beb617"},
-    {file = "platformdirs-4.3.2.tar.gz", hash = "sha256:9e5e27a08aa095dd127b9f2e764d74254f482fef22b0970773bfba79d091ab8c"},
+    {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"},
+    {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"},
 ]
 
 [package.extras]
@@ -2633,22 +2636,22 @@ wcwidth = "*"
 
 [[package]]
 name = "protobuf"
-version = "5.28.1"
+version = "5.28.2"
 description = ""
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "protobuf-5.28.1-cp310-abi3-win32.whl", hash = "sha256:fc063acaf7a3d9ca13146fefb5b42ac94ab943ec6e978f543cd5637da2d57957"},
-    {file = "protobuf-5.28.1-cp310-abi3-win_amd64.whl", hash = "sha256:4c7f5cb38c640919791c9f74ea80c5b82314c69a8409ea36f2599617d03989af"},
-    {file = "protobuf-5.28.1-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4304e4fceb823d91699e924a1fdf95cde0e066f3b1c28edb665bda762ecde10f"},
-    {file = "protobuf-5.28.1-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:0dfd86d2b5edf03d91ec2a7c15b4e950258150f14f9af5f51c17fa224ee1931f"},
-    {file = "protobuf-5.28.1-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:51f09caab818707ab91cf09cc5c156026599cf05a4520779ccbf53c1b352fb25"},
-    {file = "protobuf-5.28.1-cp38-cp38-win32.whl", hash = "sha256:1b04bde117a10ff9d906841a89ec326686c48ececeb65690f15b8cabe7149495"},
-    {file = "protobuf-5.28.1-cp38-cp38-win_amd64.whl", hash = "sha256:cabfe43044ee319ad6832b2fda332646f9ef1636b0130186a3ae0a52fc264bb4"},
-    {file = "protobuf-5.28.1-cp39-cp39-win32.whl", hash = "sha256:4b4b9a0562a35773ff47a3df823177ab71a1f5eb1ff56d8f842b7432ecfd7fd2"},
-    {file = "protobuf-5.28.1-cp39-cp39-win_amd64.whl", hash = "sha256:f24e5d70e6af8ee9672ff605d5503491635f63d5db2fffb6472be78ba62efd8f"},
-    {file = "protobuf-5.28.1-py3-none-any.whl", hash = "sha256:c529535e5c0effcf417682563719e5d8ac8d2b93de07a56108b4c2d436d7a29a"},
-    {file = "protobuf-5.28.1.tar.gz", hash = "sha256:42597e938f83bb7f3e4b35f03aa45208d49ae8d5bcb4bc10b9fc825e0ab5e423"},
+    {file = "protobuf-5.28.2-cp310-abi3-win32.whl", hash = "sha256:eeea10f3dc0ac7e6b4933d32db20662902b4ab81bf28df12218aa389e9c2102d"},
+    {file = "protobuf-5.28.2-cp310-abi3-win_amd64.whl", hash = "sha256:2c69461a7fcc8e24be697624c09a839976d82ae75062b11a0972e41fd2cd9132"},
+    {file = "protobuf-5.28.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:a8b9403fc70764b08d2f593ce44f1d2920c5077bf7d311fefec999f8c40f78b7"},
+    {file = "protobuf-5.28.2-cp38-abi3-manylinux2014_aarch64.whl", hash = "sha256:35cfcb15f213449af7ff6198d6eb5f739c37d7e4f1c09b5d0641babf2cc0c68f"},
+    {file = "protobuf-5.28.2-cp38-abi3-manylinux2014_x86_64.whl", hash = "sha256:5e8a95246d581eef20471b5d5ba010d55f66740942b95ba9b872d918c459452f"},
+    {file = "protobuf-5.28.2-cp38-cp38-win32.whl", hash = "sha256:87317e9bcda04a32f2ee82089a204d3a2f0d3c8aeed16568c7daf4756e4f1fe0"},
+    {file = "protobuf-5.28.2-cp38-cp38-win_amd64.whl", hash = "sha256:c0ea0123dac3399a2eeb1a1443d82b7afc9ff40241433296769f7da42d142ec3"},
+    {file = "protobuf-5.28.2-cp39-cp39-win32.whl", hash = "sha256:ca53faf29896c526863366a52a8f4d88e69cd04ec9571ed6082fa117fac3ab36"},
+    {file = "protobuf-5.28.2-cp39-cp39-win_amd64.whl", hash = "sha256:8ddc60bf374785fb7cb12510b267f59067fa10087325b8e1855b898a0d81d276"},
+    {file = "protobuf-5.28.2-py3-none-any.whl", hash = "sha256:52235802093bd8a2811abbe8bf0ab9c5f54cca0a751fdd3f6ac2a21438bffece"},
+    {file = "protobuf-5.28.2.tar.gz", hash = "sha256:59379674ff119717404f7454647913787034f03fe7049cbef1d74a97bb4593f0"},
 ]
 
 [[package]]
@@ -2718,18 +2721,18 @@ files = [
 
 [[package]]
 name = "pydantic"
-version = "2.9.1"
+version = "2.9.2"
 description = "Data validation using Python type hints"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic-2.9.1-py3-none-any.whl", hash = "sha256:7aff4db5fdf3cf573d4b3c30926a510a10e19a0774d38fc4967f78beb6deb612"},
-    {file = "pydantic-2.9.1.tar.gz", hash = "sha256:1363c7d975c7036df0db2b4a61f2e062fbc0aa5ab5f2772e0ffc7191a4f4bce2"},
+    {file = "pydantic-2.9.2-py3-none-any.whl", hash = "sha256:f048cec7b26778210e28a0459867920654d48e5e62db0958433636cde4254f12"},
+    {file = "pydantic-2.9.2.tar.gz", hash = "sha256:d155cef71265d1e9807ed1c32b4c8deec042a44a50a4188b25ac67ecd81a9c0f"},
 ]
 
 [package.dependencies]
 annotated-types = ">=0.6.0"
-pydantic-core = "2.23.3"
+pydantic-core = "2.23.4"
 typing-extensions = [
     {version = ">=4.6.1", markers = "python_version < \"3.13\""},
     {version = ">=4.12.2", markers = "python_version >= \"3.13\""},
@@ -2741,100 +2744,100 @@ timezone = ["tzdata"]
 
 [[package]]
 name = "pydantic-core"
-version = "2.23.3"
+version = "2.23.4"
 description = "Core functionality for Pydantic validation and serialization"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "pydantic_core-2.23.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7f10a5d1b9281392f1bf507d16ac720e78285dfd635b05737c3911637601bae6"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3c09a7885dd33ee8c65266e5aa7fb7e2f23d49d8043f089989726391dd7350c5"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6470b5a1ec4d1c2e9afe928c6cb37eb33381cab99292a708b8cb9aa89e62429b"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9172d2088e27d9a185ea0a6c8cebe227a9139fd90295221d7d495944d2367700"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86fc6c762ca7ac8fbbdff80d61b2c59fb6b7d144aa46e2d54d9e1b7b0e780e01"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f0cb80fd5c2df4898693aa841425ea1727b1b6d2167448253077d2a49003e0ed"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03667cec5daf43ac4995cefa8aaf58f99de036204a37b889c24a80927b629cec"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:047531242f8e9c2db733599f1c612925de095e93c9cc0e599e96cf536aaf56ba"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:5499798317fff7f25dbef9347f4451b91ac2a4330c6669821c8202fd354c7bee"},
-    {file = "pydantic_core-2.23.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bbb5e45eab7624440516ee3722a3044b83fff4c0372efe183fd6ba678ff681fe"},
-    {file = "pydantic_core-2.23.3-cp310-none-win32.whl", hash = "sha256:8b5b3ed73abb147704a6e9f556d8c5cb078f8c095be4588e669d315e0d11893b"},
-    {file = "pydantic_core-2.23.3-cp310-none-win_amd64.whl", hash = "sha256:2b603cde285322758a0279995b5796d64b63060bfbe214b50a3ca23b5cee3e83"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:c889fd87e1f1bbeb877c2ee56b63bb297de4636661cc9bbfcf4b34e5e925bc27"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ea85bda3189fb27503af4c45273735bcde3dd31c1ab17d11f37b04877859ef45"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a7f7f72f721223f33d3dc98a791666ebc6a91fa023ce63733709f4894a7dc611"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b2b55b0448e9da68f56b696f313949cda1039e8ec7b5d294285335b53104b61"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c24574c7e92e2c56379706b9a3f07c1e0c7f2f87a41b6ee86653100c4ce343e5"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2b05e6ccbee333a8f4b8f4d7c244fdb7a979e90977ad9c51ea31261e2085ce0"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2c409ce1c219c091e47cb03feb3c4ed8c2b8e004efc940da0166aaee8f9d6c8"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d965e8b325f443ed3196db890d85dfebbb09f7384486a77461347f4adb1fa7f8"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f56af3a420fb1ffaf43ece3ea09c2d27c444e7c40dcb7c6e7cf57aae764f2b48"},
-    {file = "pydantic_core-2.23.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:5b01a078dd4f9a52494370af21aa52964e0a96d4862ac64ff7cea06e0f12d2c5"},
-    {file = "pydantic_core-2.23.3-cp311-none-win32.whl", hash = "sha256:560e32f0df04ac69b3dd818f71339983f6d1f70eb99d4d1f8e9705fb6c34a5c1"},
-    {file = "pydantic_core-2.23.3-cp311-none-win_amd64.whl", hash = "sha256:c744fa100fdea0d000d8bcddee95213d2de2e95b9c12be083370b2072333a0fa"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e0ec50663feedf64d21bad0809f5857bac1ce91deded203efc4a84b31b2e4305"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:db6e6afcb95edbe6b357786684b71008499836e91f2a4a1e55b840955b341dbb"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98ccd69edcf49f0875d86942f4418a4e83eb3047f20eb897bffa62a5d419c8fa"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a678c1ac5c5ec5685af0133262103defb427114e62eafeda12f1357a12140162"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01491d8b4d8db9f3391d93b0df60701e644ff0894352947f31fff3e52bd5c801"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fcf31facf2796a2d3b7fe338fe8640aa0166e4e55b4cb108dbfd1058049bf4cb"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7200fd561fb3be06827340da066df4311d0b6b8eb0c2116a110be5245dceb326"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:dc1636770a809dee2bd44dd74b89cc80eb41172bcad8af75dd0bc182c2666d4c"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:67a5def279309f2e23014b608c4150b0c2d323bd7bccd27ff07b001c12c2415c"},
-    {file = "pydantic_core-2.23.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:748bdf985014c6dd3e1e4cc3db90f1c3ecc7246ff5a3cd4ddab20c768b2f1dab"},
-    {file = "pydantic_core-2.23.3-cp312-none-win32.whl", hash = "sha256:255ec6dcb899c115f1e2a64bc9ebc24cc0e3ab097775755244f77360d1f3c06c"},
-    {file = "pydantic_core-2.23.3-cp312-none-win_amd64.whl", hash = "sha256:40b8441be16c1e940abebed83cd006ddb9e3737a279e339dbd6d31578b802f7b"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6daaf5b1ba1369a22c8b050b643250e3e5efc6a78366d323294aee54953a4d5f"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d015e63b985a78a3d4ccffd3bdf22b7c20b3bbd4b8227809b3e8e75bc37f9cb2"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3fc572d9b5b5cfe13f8e8a6e26271d5d13f80173724b738557a8c7f3a8a3791"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f6bd91345b5163ee7448bee201ed7dd601ca24f43f439109b0212e296eb5b423"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc379c73fd66606628b866f661e8785088afe2adaba78e6bbe80796baf708a63"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fbdce4b47592f9e296e19ac31667daed8753c8367ebb34b9a9bd89dacaa299c9"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc3cf31edf405a161a0adad83246568647c54404739b614b1ff43dad2b02e6d5"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8e22b477bf90db71c156f89a55bfe4d25177b81fce4aa09294d9e805eec13855"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:0a0137ddf462575d9bce863c4c95bac3493ba8e22f8c28ca94634b4a1d3e2bb4"},
-    {file = "pydantic_core-2.23.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:203171e48946c3164fe7691fc349c79241ff8f28306abd4cad5f4f75ed80bc8d"},
-    {file = "pydantic_core-2.23.3-cp313-none-win32.whl", hash = "sha256:76bdab0de4acb3f119c2a4bff740e0c7dc2e6de7692774620f7452ce11ca76c8"},
-    {file = "pydantic_core-2.23.3-cp313-none-win_amd64.whl", hash = "sha256:37ba321ac2a46100c578a92e9a6aa33afe9ec99ffa084424291d84e456f490c1"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d063c6b9fed7d992bcbebfc9133f4c24b7a7f215d6b102f3e082b1117cddb72c"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6cb968da9a0746a0cf521b2b5ef25fc5a0bee9b9a1a8214e0a1cfaea5be7e8a4"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edbefe079a520c5984e30e1f1f29325054b59534729c25b874a16a5048028d16"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cbaaf2ef20d282659093913da9d402108203f7cb5955020bd8d1ae5a2325d1c4"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fb539d7e5dc4aac345846f290cf504d2fd3c1be26ac4e8b5e4c2b688069ff4cf"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7e6f33503c5495059148cc486867e1d24ca35df5fc064686e631e314d959ad5b"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04b07490bc2f6f2717b10c3969e1b830f5720b632f8ae2f3b8b1542394c47a8e"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:03795b9e8a5d7fda05f3873efc3f59105e2dcff14231680296b87b80bb327295"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:c483dab0f14b8d3f0df0c6c18d70b21b086f74c87ab03c59250dbf6d3c89baba"},
-    {file = "pydantic_core-2.23.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8b2682038e255e94baf2c473dca914a7460069171ff5cdd4080be18ab8a7fd6e"},
-    {file = "pydantic_core-2.23.3-cp38-none-win32.whl", hash = "sha256:f4a57db8966b3a1d1a350012839c6a0099f0898c56512dfade8a1fe5fb278710"},
-    {file = "pydantic_core-2.23.3-cp38-none-win_amd64.whl", hash = "sha256:13dd45ba2561603681a2676ca56006d6dee94493f03d5cadc055d2055615c3ea"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:82da2f4703894134a9f000e24965df73cc103e31e8c31906cc1ee89fde72cbd8"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dd9be0a42de08f4b58a3cc73a123f124f65c24698b95a54c1543065baca8cf0e"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89b731f25c80830c76fdb13705c68fef6a2b6dc494402987c7ea9584fe189f5d"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c6de1ec30c4bb94f3a69c9f5f2182baeda5b809f806676675e9ef6b8dc936f28"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bb68b41c3fa64587412b104294b9cbb027509dc2f6958446c502638d481525ef"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1c3980f2843de5184656aab58698011b42763ccba11c4a8c35936c8dd6c7068c"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94f85614f2cba13f62c3c6481716e4adeae48e1eaa7e8bac379b9d177d93947a"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:510b7fb0a86dc8f10a8bb43bd2f97beb63cffad1203071dc434dac26453955cd"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:1eba2f7ce3e30ee2170410e2171867ea73dbd692433b81a93758ab2de6c64835"},
-    {file = "pydantic_core-2.23.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4b259fd8409ab84b4041b7b3f24dcc41e4696f180b775961ca8142b5b21d0e70"},
-    {file = "pydantic_core-2.23.3-cp39-none-win32.whl", hash = "sha256:40d9bd259538dba2f40963286009bf7caf18b5112b19d2b55b09c14dde6db6a7"},
-    {file = "pydantic_core-2.23.3-cp39-none-win_amd64.whl", hash = "sha256:5a8cd3074a98ee70173a8633ad3c10e00dcb991ecec57263aacb4095c5efb958"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f399e8657c67313476a121a6944311fab377085ca7f490648c9af97fc732732d"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:6b5547d098c76e1694ba85f05b595720d7c60d342f24d5aad32c3049131fa5c4"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0dda0290a6f608504882d9f7650975b4651ff91c85673341789a476b1159f211"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:65b6e5da855e9c55a0c67f4db8a492bf13d8d3316a59999cfbaf98cc6e401961"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:09e926397f392059ce0afdcac920df29d9c833256354d0c55f1584b0b70cf07e"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:87cfa0ed6b8c5bd6ae8b66de941cece179281239d482f363814d2b986b79cedc"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e61328920154b6a44d98cabcb709f10e8b74276bc709c9a513a8c37a18786cc4"},
-    {file = "pydantic_core-2.23.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ce3317d155628301d649fe5e16a99528d5680af4ec7aa70b90b8dacd2d725c9b"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e89513f014c6be0d17b00a9a7c81b1c426f4eb9224b15433f3d98c1a071f8433"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:4f62c1c953d7ee375df5eb2e44ad50ce2f5aff931723b398b8bc6f0ac159791a"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2718443bc671c7ac331de4eef9b673063b10af32a0bb385019ad61dcf2cc8f6c"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0d90e08b2727c5d01af1b5ef4121d2f0c99fbee692c762f4d9d0409c9da6541"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2b676583fc459c64146debea14ba3af54e540b61762dfc0613dc4e98c3f66eeb"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:50e4661f3337977740fdbfbae084ae5693e505ca2b3130a6d4eb0f2281dc43b8"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:68f4cf373f0de6abfe599a38307f4417c1c867ca381c03df27c873a9069cda25"},
-    {file = "pydantic_core-2.23.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:59d52cf01854cb26c46958552a21acb10dd78a52aa34c86f284e66b209db8cab"},
-    {file = "pydantic_core-2.23.3.tar.gz", hash = "sha256:3cb0f65d8b4121c1b015c60104a685feb929a29d7cf204387c7f2688c7974690"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:b10bd51f823d891193d4717448fab065733958bdb6a6b351967bd349d48d5c9b"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4fc714bdbfb534f94034efaa6eadd74e5b93c8fa6315565a222f7b6f42ca1166"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63e46b3169866bd62849936de036f901a9356e36376079b05efa83caeaa02ceb"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed1a53de42fbe34853ba90513cea21673481cd81ed1be739f7f2efb931b24916"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cfdd16ab5e59fc31b5e906d1a3f666571abc367598e3e02c83403acabc092e07"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255a8ef062cbf6674450e668482456abac99a5583bbafb73f9ad469540a3a232"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a7cd62e831afe623fbb7aabbb4fe583212115b3ef38a9f6b71869ba644624a2"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f09e2ff1f17c2b51f2bc76d1cc33da96298f0a036a137f5440ab3ec5360b624f"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e38e63e6f3d1cec5a27e0afe90a085af8b6806ee208b33030e65b6516353f1a3"},
+    {file = "pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0dbd8dbed2085ed23b5c04afa29d8fd2771674223135dc9bc937f3c09284d071"},
+    {file = "pydantic_core-2.23.4-cp310-none-win32.whl", hash = "sha256:6531b7ca5f951d663c339002e91aaebda765ec7d61b7d1e3991051906ddde119"},
+    {file = "pydantic_core-2.23.4-cp310-none-win_amd64.whl", hash = "sha256:7c9129eb40958b3d4500fa2467e6a83356b3b61bfff1b414c7361d9220f9ae8f"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:77733e3892bb0a7fa797826361ce8a9184d25c8dffaec60b7ffe928153680ba8"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b84d168f6c48fabd1f2027a3d1bdfe62f92cade1fb273a5d68e621da0e44e6d"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df49e7a0861a8c36d089c1ed57d308623d60416dab2647a4a17fe050ba85de0e"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ff02b6d461a6de369f07ec15e465a88895f3223eb75073ffea56b84d9331f607"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:996a38a83508c54c78a5f41456b0103c30508fed9abcad0a59b876d7398f25fd"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d97683ddee4723ae8c95d1eddac7c192e8c552da0c73a925a89fa8649bf13eea"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:216f9b2d7713eb98cb83c80b9c794de1f6b7e3145eef40400c62e86cee5f4e1e"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6f783e0ec4803c787bcea93e13e9932edab72068f68ecffdf86a99fd5918878b"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d0776dea117cf5272382634bd2a5c1b6eb16767c223c6a5317cd3e2a757c61a0"},
+    {file = "pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d5f7a395a8cf1621939692dba2a6b6a830efa6b3cee787d82c7de1ad2930de64"},
+    {file = "pydantic_core-2.23.4-cp311-none-win32.whl", hash = "sha256:74b9127ffea03643e998e0c5ad9bd3811d3dac8c676e47db17b0ee7c3c3bf35f"},
+    {file = "pydantic_core-2.23.4-cp311-none-win_amd64.whl", hash = "sha256:98d134c954828488b153d88ba1f34e14259284f256180ce659e8d83e9c05eaa3"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f3e0da4ebaef65158d4dfd7d3678aad692f7666877df0002b8a522cdf088f231"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f69a8e0b033b747bb3e36a44e7732f0c99f7edd5cea723d45bc0d6e95377ffee"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:723314c1d51722ab28bfcd5240d858512ffd3116449c557a1336cbe3919beb87"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb2802e667b7051a1bebbfe93684841cc9351004e2badbd6411bf357ab8d5ac8"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d18ca8148bebe1b0a382a27a8ee60350091a6ddaf475fa05ef50dc35b5df6327"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33e3d65a85a2a4a0dc3b092b938a4062b1a05f3a9abde65ea93b233bca0e03f2"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:128585782e5bfa515c590ccee4b727fb76925dd04a98864182b22e89a4e6ed36"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:68665f4c17edcceecc112dfed5dbe6f92261fb9d6054b47d01bf6371a6196126"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:20152074317d9bed6b7a95ade3b7d6054845d70584216160860425f4fbd5ee9e"},
+    {file = "pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9261d3ce84fa1d38ed649c3638feefeae23d32ba9182963e465d58d62203bd24"},
+    {file = "pydantic_core-2.23.4-cp312-none-win32.whl", hash = "sha256:4ba762ed58e8d68657fc1281e9bb72e1c3e79cc5d464be146e260c541ec12d84"},
+    {file = "pydantic_core-2.23.4-cp312-none-win_amd64.whl", hash = "sha256:97df63000f4fea395b2824da80e169731088656d1818a11b95f3b173747b6cd9"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7530e201d10d7d14abce4fb54cfe5b94a0aefc87da539d0346a484ead376c3cc"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:df933278128ea1cd77772673c73954e53a1c95a4fdf41eef97c2b779271bd0bd"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cb3da3fd1b6a5d0279a01877713dbda118a2a4fc6f0d821a57da2e464793f05"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c6dcb030aefb668a2b7009c85b27f90e51e6a3b4d5c9bc4c57631292015b0d"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:696dd8d674d6ce621ab9d45b205df149399e4bb9aa34102c970b721554828510"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2971bb5ffe72cc0f555c13e19b23c85b654dd2a8f7ab493c262071377bfce9f6"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8394d940e5d400d04cad4f75c0598665cbb81aecefaca82ca85bd28264af7f9b"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0dff76e0602ca7d4cdaacc1ac4c005e0ce0dcfe095d5b5259163a80d3a10d327"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7d32706badfe136888bdea71c0def994644e09fff0bfe47441deaed8e96fdbc6"},
+    {file = "pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ed541d70698978a20eb63d8c5d72f2cc6d7079d9d90f6b50bad07826f1320f5f"},
+    {file = "pydantic_core-2.23.4-cp313-none-win32.whl", hash = "sha256:3d5639516376dce1940ea36edf408c554475369f5da2abd45d44621cb616f769"},
+    {file = "pydantic_core-2.23.4-cp313-none-win_amd64.whl", hash = "sha256:5a1504ad17ba4210df3a045132a7baeeba5a200e930f57512ee02909fc5c4cb5"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:d4488a93b071c04dc20f5cecc3631fc78b9789dd72483ba15d423b5b3689b555"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:81965a16b675b35e1d09dd14df53f190f9129c0202356ed44ab2728b1c905658"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ffa2ebd4c8530079140dd2d7f794a9d9a73cbb8e9d59ffe24c63436efa8f271"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:61817945f2fe7d166e75fbfb28004034b48e44878177fc54d81688e7b85a3665"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:29d2c342c4bc01b88402d60189f3df065fb0dda3654744d5a165a5288a657368"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5e11661ce0fd30a6790e8bcdf263b9ec5988e95e63cf901972107efc49218b13"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d18368b137c6295db49ce7218b1a9ba15c5bc254c96d7c9f9e924a9bc7825ad"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ec4e55f79b1c4ffb2eecd8a0cfba9955a2588497d96851f4c8f99aa4a1d39b12"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:374a5e5049eda9e0a44c696c7ade3ff355f06b1fe0bb945ea3cac2bc336478a2"},
+    {file = "pydantic_core-2.23.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5c364564d17da23db1106787675fc7af45f2f7b58b4173bfdd105564e132e6fb"},
+    {file = "pydantic_core-2.23.4-cp38-none-win32.whl", hash = "sha256:d7a80d21d613eec45e3d41eb22f8f94ddc758a6c4720842dc74c0581f54993d6"},
+    {file = "pydantic_core-2.23.4-cp38-none-win_amd64.whl", hash = "sha256:5f5ff8d839f4566a474a969508fe1c5e59c31c80d9e140566f9a37bba7b8d556"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:a4fa4fc04dff799089689f4fd502ce7d59de529fc2f40a2c8836886c03e0175a"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0a7df63886be5e270da67e0966cf4afbae86069501d35c8c1b3b6c168f42cb36"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dcedcd19a557e182628afa1d553c3895a9f825b936415d0dbd3cd0bbcfd29b4b"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f54b118ce5de9ac21c363d9b3caa6c800341e8c47a508787e5868c6b79c9323"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86d2f57d3e1379a9525c5ab067b27dbb8a0642fb5d454e17a9ac434f9ce523e3"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:de6d1d1b9e5101508cb37ab0d972357cac5235f5c6533d1071964c47139257df"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1278e0d324f6908e872730c9102b0112477a7f7cf88b308e4fc36ce1bdb6d58c"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9a6b5099eeec78827553827f4c6b8615978bb4b6a88e5d9b93eddf8bb6790f55"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:e55541f756f9b3ee346b840103f32779c695a19826a4c442b7954550a0972040"},
+    {file = "pydantic_core-2.23.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a5c7ba8ffb6d6f8f2ab08743be203654bb1aaa8c9dcb09f82ddd34eadb695605"},
+    {file = "pydantic_core-2.23.4-cp39-none-win32.whl", hash = "sha256:37b0fe330e4a58d3c58b24d91d1eb102aeec675a3db4c292ec3928ecd892a9a6"},
+    {file = "pydantic_core-2.23.4-cp39-none-win_amd64.whl", hash = "sha256:1498bec4c05c9c787bde9125cfdcc63a41004ff167f495063191b863399b1a29"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f455ee30a9d61d3e1a15abd5068827773d6e4dc513e795f380cdd59932c782d5"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1e90d2e3bd2c3863d48525d297cd143fe541be8bbf6f579504b9712cb6b643ec"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e203fdf807ac7e12ab59ca2bfcabb38c7cf0b33c41efeb00f8e5da1d86af480"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e08277a400de01bc72436a0ccd02bdf596631411f592ad985dcee21445bd0068"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f220b0eea5965dec25480b6333c788fb72ce5f9129e8759ef876a1d805d00801"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d06b0c8da4f16d1d1e352134427cb194a0a6e19ad5db9161bf32b2113409e728"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:ba1a0996f6c2773bd83e63f18914c1de3c9dd26d55f4ac302a7efe93fb8e7433"},
+    {file = "pydantic_core-2.23.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:9a5bce9d23aac8f0cf0836ecfc033896aa8443b501c58d0602dbfd5bd5b37753"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:78ddaaa81421a29574a682b3179d4cf9e6d405a09b99d93ddcf7e5239c742e21"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:883a91b5dd7d26492ff2f04f40fbb652de40fcc0afe07e8129e8ae779c2110eb"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88ad334a15b32a791ea935af224b9de1bf99bcd62fabf745d5f3442199d86d59"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:233710f069d251feb12a56da21e14cca67994eab08362207785cf8c598e74577"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:19442362866a753485ba5e4be408964644dd6a09123d9416c54cd49171f50744"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:624e278a7d29b6445e4e813af92af37820fafb6dcc55c012c834f9e26f9aaaef"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f5ef8f42bec47f21d07668a043f077d507e5bf4e668d5c6dfe6aaba89de1a5b8"},
+    {file = "pydantic_core-2.23.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:aea443fffa9fbe3af1a9ba721a87f926fe548d32cab71d188a6ede77d0ff244e"},
+    {file = "pydantic_core-2.23.4.tar.gz", hash = "sha256:2584f7cf844ac4d970fba483a717dbe10c1c1c96a969bf65d61ffe94df1b2863"},
 ]
 
 [package.dependencies]
@@ -3582,64 +3585,64 @@ files = [
 
 [[package]]
 name = "sqlalchemy"
-version = "2.0.34"
+version = "2.0.35"
 description = "Database Abstraction Library"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:95d0b2cf8791ab5fb9e3aa3d9a79a0d5d51f55b6357eecf532a120ba3b5524db"},
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:243f92596f4fd4c8bd30ab8e8dd5965afe226363d75cab2468f2c707f64cd83b"},
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ea54f7300553af0a2a7235e9b85f4204e1fc21848f917a3213b0e0818de9a24"},
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:173f5f122d2e1bff8fbd9f7811b7942bead1f5e9f371cdf9e670b327e6703ebd"},
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:196958cde924a00488e3e83ff917be3b73cd4ed8352bbc0f2989333176d1c54d"},
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bd90c221ed4e60ac9d476db967f436cfcecbd4ef744537c0f2d5291439848768"},
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-win32.whl", hash = "sha256:3166dfff2d16fe9be3241ee60ece6fcb01cf8e74dd7c5e0b64f8e19fab44911b"},
-    {file = "SQLAlchemy-2.0.34-cp310-cp310-win_amd64.whl", hash = "sha256:6831a78bbd3c40f909b3e5233f87341f12d0b34a58f14115c9e94b4cdaf726d3"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7db3db284a0edaebe87f8f6642c2b2c27ed85c3e70064b84d1c9e4ec06d5d84"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:430093fce0efc7941d911d34f75a70084f12f6ca5c15d19595c18753edb7c33b"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79cb400c360c7c210097b147c16a9e4c14688a6402445ac848f296ade6283bbc"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb1b30f31a36c7f3fee848391ff77eebdd3af5750bf95fbf9b8b5323edfdb4ec"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fddde2368e777ea2a4891a3fb4341e910a056be0bb15303bf1b92f073b80c02"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80bd73ea335203b125cf1d8e50fef06be709619eb6ab9e7b891ea34b5baa2287"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-win32.whl", hash = "sha256:6daeb8382d0df526372abd9cb795c992e18eed25ef2c43afe518c73f8cccb721"},
-    {file = "SQLAlchemy-2.0.34-cp311-cp311-win_amd64.whl", hash = "sha256:5bc08e75ed11693ecb648b7a0a4ed80da6d10845e44be0c98c03f2f880b68ff4"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:53e68b091492c8ed2bd0141e00ad3089bcc6bf0e6ec4142ad6505b4afe64163e"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bcd18441a49499bf5528deaa9dee1f5c01ca491fc2791b13604e8f972877f812"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:165bbe0b376541092bf49542bd9827b048357f4623486096fc9aaa6d4e7c59a2"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3330415cd387d2b88600e8e26b510d0370db9b7eaf984354a43e19c40df2e2b"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:97b850f73f8abbffb66ccbab6e55a195a0eb655e5dc74624d15cff4bfb35bd74"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee4c6917857fd6121ed84f56d1dc78eb1d0e87f845ab5a568aba73e78adf83"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-win32.whl", hash = "sha256:fbb034f565ecbe6c530dff948239377ba859420d146d5f62f0271407ffb8c580"},
-    {file = "SQLAlchemy-2.0.34-cp312-cp312-win_amd64.whl", hash = "sha256:707c8f44931a4facd4149b52b75b80544a8d824162602b8cd2fe788207307f9a"},
-    {file = "SQLAlchemy-2.0.34-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:24af3dc43568f3780b7e1e57c49b41d98b2d940c1fd2e62d65d3928b6f95f021"},
-    {file = "SQLAlchemy-2.0.34-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e60ed6ef0a35c6b76b7640fe452d0e47acc832ccbb8475de549a5cc5f90c2c06"},
-    {file = "SQLAlchemy-2.0.34-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:413c85cd0177c23e32dee6898c67a5f49296640041d98fddb2c40888fe4daa2e"},
-    {file = "SQLAlchemy-2.0.34-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:25691f4adfb9d5e796fd48bf1432272f95f4bbe5f89c475a788f31232ea6afba"},
-    {file = "SQLAlchemy-2.0.34-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:526ce723265643dbc4c7efb54f56648cc30e7abe20f387d763364b3ce7506c82"},
-    {file = "SQLAlchemy-2.0.34-cp37-cp37m-win32.whl", hash = "sha256:13be2cc683b76977a700948411a94c67ad8faf542fa7da2a4b167f2244781cf3"},
-    {file = "SQLAlchemy-2.0.34-cp37-cp37m-win_amd64.whl", hash = "sha256:e54ef33ea80d464c3dcfe881eb00ad5921b60f8115ea1a30d781653edc2fd6a2"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:43f28005141165edd11fbbf1541c920bd29e167b8bbc1fb410d4fe2269c1667a"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b68094b165a9e930aedef90725a8fcfafe9ef95370cbb54abc0464062dbf808f"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a1e03db964e9d32f112bae36f0cc1dcd1988d096cfd75d6a588a3c3def9ab2b"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:203d46bddeaa7982f9c3cc693e5bc93db476ab5de9d4b4640d5c99ff219bee8c"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ae92bebca3b1e6bd203494e5ef919a60fb6dfe4d9a47ed2453211d3bd451b9f5"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:9661268415f450c95f72f0ac1217cc6f10256f860eed85c2ae32e75b60278ad8"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-win32.whl", hash = "sha256:895184dfef8708e15f7516bd930bda7e50ead069280d2ce09ba11781b630a434"},
-    {file = "SQLAlchemy-2.0.34-cp38-cp38-win_amd64.whl", hash = "sha256:6e7cde3a2221aa89247944cafb1b26616380e30c63e37ed19ff0bba5e968688d"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:dbcdf987f3aceef9763b6d7b1fd3e4ee210ddd26cac421d78b3c206d07b2700b"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ce119fc4ce0d64124d37f66a6f2a584fddc3c5001755f8a49f1ca0a177ef9796"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a17d8fac6df9835d8e2b4c5523666e7051d0897a93756518a1fe101c7f47f2f0"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ebc11c54c6ecdd07bb4efbfa1554538982f5432dfb8456958b6d46b9f834bb7"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2e6965346fc1491a566e019a4a1d3dfc081ce7ac1a736536367ca305da6472a8"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:220574e78ad986aea8e81ac68821e47ea9202b7e44f251b7ed8c66d9ae3f4278"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-win32.whl", hash = "sha256:b75b00083e7fe6621ce13cfce9d4469c4774e55e8e9d38c305b37f13cf1e874c"},
-    {file = "SQLAlchemy-2.0.34-cp39-cp39-win_amd64.whl", hash = "sha256:c29d03e0adf3cc1a8c3ec62d176824972ae29b67a66cbb18daff3062acc6faa8"},
-    {file = "SQLAlchemy-2.0.34-py3-none-any.whl", hash = "sha256:7286c353ee6475613d8beff83167374006c6b3e3f0e6491bfe8ca610eb1dec0f"},
-    {file = "sqlalchemy-2.0.34.tar.gz", hash = "sha256:10d8f36990dd929690666679b0f42235c159a7051534adb135728ee52828dd22"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:67219632be22f14750f0d1c70e62f204ba69d28f62fd6432ba05ab295853de9b"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4668bd8faf7e5b71c0319407b608f278f279668f358857dbfd10ef1954ac9f90"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb8bea573863762bbf45d1e13f87c2d2fd32cee2dbd50d050f83f87429c9e1ea"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f552023710d4b93d8fb29a91fadf97de89c5926c6bd758897875435f2a939f33"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:016b2e665f778f13d3c438651dd4de244214b527a275e0acf1d44c05bc6026a9"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7befc148de64b6060937231cbff8d01ccf0bfd75aa26383ffdf8d82b12ec04ff"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-win32.whl", hash = "sha256:22b83aed390e3099584b839b93f80a0f4a95ee7f48270c97c90acd40ee646f0b"},
+    {file = "SQLAlchemy-2.0.35-cp310-cp310-win_amd64.whl", hash = "sha256:a29762cd3d116585278ffb2e5b8cc311fb095ea278b96feef28d0b423154858e"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e21f66748ab725ade40fa7af8ec8b5019c68ab00b929f6643e1b1af461eddb60"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8a6219108a15fc6d24de499d0d515c7235c617b2540d97116b663dade1a54d62"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:042622a5306c23b972192283f4e22372da3b8ddf5f7aac1cc5d9c9b222ab3ff6"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:627dee0c280eea91aed87b20a1f849e9ae2fe719d52cbf847c0e0ea34464b3f7"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4fdcd72a789c1c31ed242fd8c1bcd9ea186a98ee8e5408a50e610edfef980d71"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:89b64cd8898a3a6f642db4eb7b26d1b28a497d4022eccd7717ca066823e9fb01"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-win32.whl", hash = "sha256:6a93c5a0dfe8d34951e8a6f499a9479ffb9258123551fa007fc708ae2ac2bc5e"},
+    {file = "SQLAlchemy-2.0.35-cp311-cp311-win_amd64.whl", hash = "sha256:c68fe3fcde03920c46697585620135b4ecfdfc1ed23e75cc2c2ae9f8502c10b8"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:eb60b026d8ad0c97917cb81d3662d0b39b8ff1335e3fabb24984c6acd0c900a2"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6921ee01caf375363be5e9ae70d08ce7ca9d7e0e8983183080211a062d299468"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8cdf1a0dbe5ced887a9b127da4ffd7354e9c1a3b9bb330dce84df6b70ccb3a8d"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93a71c8601e823236ac0e5d087e4f397874a421017b3318fd92c0b14acf2b6db"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e04b622bb8a88f10e439084486f2f6349bf4d50605ac3e445869c7ea5cf0fa8c"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1b56961e2d31389aaadf4906d453859f35302b4eb818d34a26fab72596076bb8"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-win32.whl", hash = "sha256:0f9f3f9a3763b9c4deb8c5d09c4cc52ffe49f9876af41cc1b2ad0138878453cf"},
+    {file = "SQLAlchemy-2.0.35-cp312-cp312-win_amd64.whl", hash = "sha256:25b0f63e7fcc2a6290cb5f7f5b4fc4047843504983a28856ce9b35d8f7de03cc"},
+    {file = "SQLAlchemy-2.0.35-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:f021d334f2ca692523aaf7bbf7592ceff70c8594fad853416a81d66b35e3abf9"},
+    {file = "SQLAlchemy-2.0.35-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05c3f58cf91683102f2f0265c0db3bd3892e9eedabe059720492dbaa4f922da1"},
+    {file = "SQLAlchemy-2.0.35-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:032d979ce77a6c2432653322ba4cbeabf5a6837f704d16fa38b5a05d8e21fa00"},
+    {file = "SQLAlchemy-2.0.35-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:2e795c2f7d7249b75bb5f479b432a51b59041580d20599d4e112b5f2046437a3"},
+    {file = "SQLAlchemy-2.0.35-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:cc32b2990fc34380ec2f6195f33a76b6cdaa9eecf09f0c9404b74fc120aef36f"},
+    {file = "SQLAlchemy-2.0.35-cp37-cp37m-win32.whl", hash = "sha256:9509c4123491d0e63fb5e16199e09f8e262066e58903e84615c301dde8fa2e87"},
+    {file = "SQLAlchemy-2.0.35-cp37-cp37m-win_amd64.whl", hash = "sha256:3655af10ebcc0f1e4e06c5900bb33e080d6a1fa4228f502121f28a3b1753cde5"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4c31943b61ed8fdd63dfd12ccc919f2bf95eefca133767db6fbbd15da62078ec"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a62dd5d7cc8626a3634208df458c5fe4f21200d96a74d122c83bc2015b333bc1"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0630774b0977804fba4b6bbea6852ab56c14965a2b0c7fc7282c5f7d90a1ae72"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d625eddf7efeba2abfd9c014a22c0f6b3796e0ffb48f5d5ab106568ef01ff5a"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ada603db10bb865bbe591939de854faf2c60f43c9b763e90f653224138f910d9"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:c41411e192f8d3ea39ea70e0fae48762cd11a2244e03751a98bd3c0ca9a4e936"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-win32.whl", hash = "sha256:d299797d75cd747e7797b1b41817111406b8b10a4f88b6e8fe5b5e59598b43b0"},
+    {file = "SQLAlchemy-2.0.35-cp38-cp38-win_amd64.whl", hash = "sha256:0375a141e1c0878103eb3d719eb6d5aa444b490c96f3fedab8471c7f6ffe70ee"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ccae5de2a0140d8be6838c331604f91d6fafd0735dbdcee1ac78fc8fbaba76b4"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2a275a806f73e849e1c309ac11108ea1a14cd7058577aba962cd7190e27c9e3c"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:732e026240cdd1c1b2e3ac515c7a23820430ed94292ce33806a95869c46bd139"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:890da8cd1941fa3dab28c5bac3b9da8502e7e366f895b3b8e500896f12f94d11"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c0d8326269dbf944b9201911b0d9f3dc524d64779a07518199a58384c3d37a44"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b76d63495b0508ab9fc23f8152bac63205d2a704cd009a2b0722f4c8e0cba8e0"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-win32.whl", hash = "sha256:69683e02e8a9de37f17985905a5eca18ad651bf592314b4d3d799029797d0eb3"},
+    {file = "SQLAlchemy-2.0.35-cp39-cp39-win_amd64.whl", hash = "sha256:aee110e4ef3c528f3abbc3c2018c121e708938adeeff9006428dd7c8555e9b3f"},
+    {file = "SQLAlchemy-2.0.35-py3-none-any.whl", hash = "sha256:2ab3f0336c0387662ce6221ad30ab3a5e6499aab01b9790879b6578fd9b8faa1"},
+    {file = "sqlalchemy-2.0.35.tar.gz", hash = "sha256:e11d7ea4d24f0a262bccf9a7cd6284c976c5369dac21db237cff59586045ab9f"},
 ]
 
 [package.dependencies]
-greenlet = {version = "!=0.4.17", markers = "python_version < \"3.13\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\")"}
+greenlet = {version = "!=0.4.17", markers = "python_version < \"3.13\" and (platform_machine == \"win32\" or platform_machine == \"WIN32\" or platform_machine == \"AMD64\" or platform_machine == \"amd64\" or platform_machine == \"x86_64\" or platform_machine == \"ppc64le\" or platform_machine == \"aarch64\")"}
 typing-extensions = ">=4.6.0"
 
 [package.extras]
@@ -3838,13 +3841,13 @@ files = [
 
 [[package]]
 name = "types-protobuf"
-version = "5.27.0.20240907"
+version = "5.27.0.20240920"
 description = "Typing stubs for protobuf"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "types-protobuf-5.27.0.20240907.tar.gz", hash = "sha256:bb6f90f66b18d4d1c75667b6586334b0573a6fcee5eb0142a7348a765a7cbadc"},
-    {file = "types_protobuf-5.27.0.20240907-py3-none-any.whl", hash = "sha256:5443270534cc8072909ef7ad9e1421ccff924ca658749a6396c0c43d64c32676"},
+    {file = "types-protobuf-5.27.0.20240920.tar.gz", hash = "sha256:992d695315d11eb2d25e806122c9e1fd9fec282e96104f0a0cb9226cd5d90293"},
+    {file = "types_protobuf-5.27.0.20240920-py3-none-any.whl", hash = "sha256:c04140bd3c761a55f4e661372b24a6f508169e0815f2b73da33f34b447ed7a8d"},
 ]
 
 [[package]]
@@ -3886,13 +3889,13 @@ files = [
 
 [[package]]
 name = "types-pyyaml"
-version = "6.0.12.20240808"
+version = "6.0.12.20240917"
 description = "Typing stubs for PyYAML"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "types-PyYAML-6.0.12.20240808.tar.gz", hash = "sha256:b8f76ddbd7f65440a8bda5526a9607e4c7a322dc2f8e1a8c405644f9a6f4b9af"},
-    {file = "types_PyYAML-6.0.12.20240808-py3-none-any.whl", hash = "sha256:deda34c5c655265fc517b546c902aa6eed2ef8d3e921e4765fe606fe2afe8d35"},
+    {file = "types-PyYAML-6.0.12.20240917.tar.gz", hash = "sha256:d1405a86f9576682234ef83bcb4e6fff7c9305c8b1fbad5e0bcd4f7dbdc9c587"},
+    {file = "types_PyYAML-6.0.12.20240917-py3-none-any.whl", hash = "sha256:392b267f1c0fe6022952462bf5d6523f31e37f6cea49b14cee7ad634b6301570"},
 ]
 
 [[package]]
@@ -3924,29 +3927,15 @@ files = [
 [package.dependencies]
 types-urllib3 = "*"
 
-[[package]]
-name = "types-requests"
-version = "2.32.0.20240907"
-description = "Typing stubs for requests"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "types-requests-2.32.0.20240907.tar.gz", hash = "sha256:ff33935f061b5e81ec87997e91050f7b4af4f82027a7a7a9d9aaea04a963fdf8"},
-    {file = "types_requests-2.32.0.20240907-py3-none-any.whl", hash = "sha256:1d1e79faeaf9d42def77f3c304893dea17a97cae98168ac69f3cb465516ee8da"},
-]
-
-[package.dependencies]
-urllib3 = ">=2"
-
 [[package]]
 name = "types-setuptools"
-version = "74.1.0.20240907"
+version = "75.1.0.20240917"
 description = "Typing stubs for setuptools"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "types-setuptools-74.1.0.20240907.tar.gz", hash = "sha256:0abdb082552ca966c1e5fc244e4853adc62971f6cd724fb1d8a3713b580e5a65"},
-    {file = "types_setuptools-74.1.0.20240907-py3-none-any.whl", hash = "sha256:15b38c8e63ca34f42f6063ff4b1dd662ea20086166d5ad6a102e670a52574120"},
+    {file = "types-setuptools-75.1.0.20240917.tar.gz", hash = "sha256:12f12a165e7ed383f31def705e5c0fa1c26215dd466b0af34bd042f7d5331f55"},
+    {file = "types_setuptools-75.1.0.20240917-py3-none-any.whl", hash = "sha256:06f78307e68d1bbde6938072c57b81cf8a99bc84bd6dc7e4c5014730b097dc0c"},
 ]
 
 [[package]]
@@ -4038,23 +4027,6 @@ brotli = ["brotli (==1.0.9)", "brotli (>=1.0.9)", "brotlicffi (>=0.8.0)", "brotl
 secure = ["certifi", "cryptography (>=1.3.4)", "idna (>=2.0.0)", "ipaddress", "pyOpenSSL (>=0.14)", "urllib3-secure-extra"]
 socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
 
-[[package]]
-name = "urllib3"
-version = "2.2.3"
-description = "HTTP library with thread-safe connection pooling, file post, and more."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac"},
-    {file = "urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9"},
-]
-
-[package.extras]
-brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
-h2 = ["h2 (>=4,<5)"]
-socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
-zstd = ["zstandard (>=0.18.0)"]
-
 [[package]]
 name = "vcrpy"
 version = "6.0.1"
@@ -4386,4 +4358,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.0"
 python-versions = ">=3.9,<4.0"
-content-hash = "ee964a118892539749a10eeb2e7e8ce5570cf84faf02ea226fa2af865dc14135"
+content-hash = "d4ddaa606dc1af15b47b534482210ad687c8b96c816cb7ab13fa77d184514435"

libs/community/pyproject.toml

@@ -42,7 +42,7 @@ aiohttp = "^3.8.3"
 tenacity = "^8.1.0,!=8.4.0"
 dataclasses-json = ">= 0.5.7, < 0.7"
 pydantic-settings = "^2.4.0"
-langsmith = "^0.1.112"
+langsmith = "^0.1.125"
 
 [[tool.poetry.dependencies.numpy]]
 version = "^1"

libs/community/scripts/check_pydantic.sh

@@ -20,7 +20,7 @@ count=$(git grep -E '(@root_validator)|(@validator)|(@field_validator)|(@pre_ini
 # PRs that increase the current count will not be accepted.
 # PRs that decrease update the code in the repository
 # and allow decreasing the count of are welcome!
-current_count=129
+current_count=128
 
 if [ "$count" -gt "$current_count" ]; then
   echo "The PR seems to be introducing new usage of @root_validator and/or @field_validator."

libs/community/tests/integration_tests/document_loaders/test_pdf.py

@@ -1,4 +1,3 @@
-import re
 from pathlib import Path
 from typing import Sequence, Union
 
@@ -11,7 +10,6 @@ from langchain_community.document_loaders import (
     PDFMinerPDFasHTMLLoader,
     PyMuPDFLoader,
     PyPDFium2Loader,
-    PyPDFLoader,
     UnstructuredPDFLoader,
 )
 
@@ -86,37 +84,6 @@ def test_pdfminer_pdf_as_html_loader() -> None:
     assert len(docs) == 1
 
 
-def test_pypdf_loader() -> None:
-    """Test PyPDFLoader."""
-    file_path = Path(__file__).parent.parent / "examples/hello.pdf"
-    loader = PyPDFLoader(str(file_path))
-    docs = loader.load()
-
-    assert len(docs) == 1
-
-    file_path = Path(__file__).parent.parent / "examples/layout-parser-paper.pdf"
-    loader = PyPDFLoader(str(file_path))
-
-    docs = loader.load()
-    assert len(docs) == 16
-
-
-def test_pypdf_loader_with_layout() -> None:
-    """Test PyPDFLoader with layout mode."""
-    file_path = Path(__file__).parent.parent / "examples/layout-parser-paper.pdf"
-    loader = PyPDFLoader(str(file_path), extraction_mode="layout")
-
-    docs = loader.load()
-    first_page = docs[0].page_content
-
-    expected = (
-        Path(__file__).parent.parent / "examples/layout-parser-paper-page-1.txt"
-    ).read_text(encoding="utf-8")
-    cleaned_first_page = re.sub(r"\x00", "", first_page)
-    cleaned_expected = re.sub(r"\x00", "", expected)
-    assert cleaned_first_page == cleaned_expected
-
-
 def test_pypdfium2_loader() -> None:
     """Test PyPDFium2Loader."""
     file_path = Path(__file__).parent.parent / "examples/hello.pdf"

libs/community/tests/integration_tests/graph_vectorstores/extractors/test_gliner_link_extractor.py

@@ -1,7 +1,7 @@
 import pytest
-from langchain_core.graph_vectorstores.links import Link
 
 from langchain_community.graph_vectorstores.extractors import GLiNERLinkExtractor
+from langchain_community.graph_vectorstores.links import Link
 
 PAGE_1 = """
 Cristiano Ronaldo dos Santos Aveiro (Portuguese pronunciation: [kɾiʃ'tjɐnu

libs/community/tests/integration_tests/graph_vectorstores/extractors/test_keybert_link_extractor.py

@@ -1,7 +1,7 @@
 import pytest
-from langchain_core.graph_vectorstores.links import Link
 
 from langchain_community.graph_vectorstores.extractors import KeybertLinkExtractor
+from langchain_community.graph_vectorstores.links import Link
 
 PAGE_1 = """
 Supervised learning is the machine learning task of learning a function that

libs/community/tests/integration_tests/graph_vectorstores/test_cassandra.py

@@ -4,9 +4,9 @@ from typing import Iterable, List, Optional, Type
 
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
-from langchain_core.graph_vectorstores.links import METADATA_LINKS_KEY, Link
 
 from langchain_community.graph_vectorstores import CassandraGraphVectorStore
+from langchain_community.graph_vectorstores.links import METADATA_LINKS_KEY, Link
 
 CASSANDRA_DEFAULT_KEYSPACE = "graph_test_keyspace"
 

libs/community/tests/integration_tests/llms/test_sambanova.py

@@ -1,28 +1,17 @@
 """Test sambanova API wrapper.
 
-In order to run this test, you need to have an sambaverse api key,
-and a sambaverse base url, project id, endpoint id, and api key.
-You'll then need to set SAMBAVERSE_API_KEY, SAMBASTUDIO_BASE_URL,
+In order to run this test, you need to have a sambastudio base url,
+project id, endpoint id, and api key.
+You'll then need to set SAMBASTUDIO_BASE_URL, SAMBASTUDIO_BASE_URI
 SAMBASTUDIO_PROJECT_ID, SAMBASTUDIO_ENDPOINT_ID, and SAMBASTUDIO_API_KEY
 environment variables.
 """
 
-from langchain_community.llms.sambanova import SambaStudio, Sambaverse
-
-
-def test_sambaverse_call() -> None:
-    """Test simple non-streaming call to sambaverse."""
-    llm = Sambaverse(
-        sambaverse_model_name="Meta/llama-2-7b-chat-hf",
-        model_kwargs={"select_expert": "llama-2-7b-chat-hf"},
-    )
-    output = llm.invoke("What is LangChain")
-    assert output
-    assert isinstance(output, str)
+from langchain_community.llms.sambanova import SambaStudio
 
 
 def test_sambastudio_call() -> None:
-    """Test simple non-streaming call to sambaverse."""
+    """Test simple non-streaming call to sambastudio."""
     llm = SambaStudio()
     output = llm.invoke("What is LangChain")
     assert output

libs/community/tests/unit_tests/document_loaders/test_imports.py

@@ -55,6 +55,7 @@ EXPECTED_ALL = [
     "DedocFileLoader",
     "DedocPDFLoader",
     "PebbloSafeLoader",
+    "PebbloTextLoader",
     "DiffbotLoader",
     "DirectoryLoader",
     "DiscordChatLoader",

libs/community/tests/unit_tests/document_loaders/test_pdf.py

@@ -0,0 +1,62 @@
+import re
+from pathlib import Path
+
+import pytest
+
+from langchain_community.document_loaders import PyPDFLoader
+
+path_to_simple_pdf = (
+    Path(__file__).parent.parent.parent / "integration_tests/examples/hello.pdf"
+)
+path_to_layout_pdf = (
+    Path(__file__).parent.parent
+    / "document_loaders/sample_documents/layout-parser-paper.pdf"
+)
+path_to_layout_pdf_txt = (
+    Path(__file__).parent.parent.parent
+    / "integration_tests/examples/layout-parser-paper-page-1.txt"
+)
+
+
+@pytest.mark.requires("pypdf")
+def test_pypdf_loader() -> None:
+    """Test PyPDFLoader."""
+    loader = PyPDFLoader(str(path_to_simple_pdf))
+    docs = loader.load()
+
+    assert len(docs) == 1
+
+    loader = PyPDFLoader(str(path_to_layout_pdf))
+
+    docs = loader.load()
+    assert len(docs) == 16
+    for page, doc in enumerate(docs):
+        assert doc.metadata["page"] == page
+        assert doc.metadata["source"].endswith("layout-parser-paper.pdf")
+        assert len(doc.page_content) > 10
+
+    first_page = docs[0].page_content
+    for expected in ["LayoutParser", "A Unified Toolkit"]:
+        assert expected in first_page
+
+
+@pytest.mark.requires("pypdf")
+def test_pypdf_loader_with_layout() -> None:
+    """Test PyPDFLoader with layout mode."""
+    loader = PyPDFLoader(str(path_to_layout_pdf), extraction_mode="layout")
+
+    docs = loader.load()
+    assert len(docs) == 16
+    for page, doc in enumerate(docs):
+        assert doc.metadata["page"] == page
+        assert doc.metadata["source"].endswith("layout-parser-paper.pdf")
+        assert len(doc.page_content) > 10
+
+    first_page = docs[0].page_content
+    for expected in ["LayoutParser", "A Unified Toolkit"]:
+        assert expected in first_page
+
+    expected = path_to_layout_pdf_txt.read_text(encoding="utf-8")
+    cleaned_first_page = re.sub(r"\x00", "", first_page)
+    cleaned_expected = re.sub(r"\x00", "", expected)
+    assert cleaned_first_page == cleaned_expected

libs/community/tests/unit_tests/document_loaders/test_pebblo.py

@@ -25,6 +25,11 @@ def test_pebblo_import() -> None:
     from langchain_community.document_loaders import PebbloSafeLoader  # noqa: F401
 
 
+def test_pebblo_text_loader_import() -> None:
+    """Test that the Pebblo text loader can be imported."""
+    from langchain_community.document_loaders import PebbloTextLoader  # noqa: F401
+
+
 def test_empty_filebased_loader(mocker: MockerFixture) -> None:
     """Test basic file based csv loader."""
     # Setup
@@ -146,3 +151,42 @@ def test_pebblo_safe_loader_api_key() -> None:
     # Assert
     assert loader.pb_client.api_key == api_key
     assert loader.pb_client.classifier_location == "local"
+
+
+def test_pebblo_text_loader(mocker: MockerFixture) -> None:
+    """
+    Test loading in-memory text with PebbloTextLoader and PebbloSafeLoader.
+    """
+    # Setup
+    from langchain_community.document_loaders import PebbloSafeLoader, PebbloTextLoader
+
+    mocker.patch.multiple(
+        "requests",
+        get=MockResponse(json_data={"data": ""}, status_code=200),
+        post=MockResponse(json_data={"data": ""}, status_code=200),
+    )
+
+    text = "This is a test text."
+    source = "fake_source"
+    expected_docs = [
+        Document(
+            metadata={
+                "full_path": source,
+                "pb_checksum": None,
+            },
+            page_content=text,
+        ),
+    ]
+
+    # Exercise
+    texts = [text]
+    loader = PebbloSafeLoader(
+        PebbloTextLoader(texts, source=source),
+        "dummy_app_name",
+        "dummy_owner",
+        "dummy_description",
+    )
+    result = loader.load()
+
+    # Assert
+    assert result == expected_docs

libs/community/tests/unit_tests/document_loaders/test_web_base.py

@@ -1,3 +1,7 @@
+from textwrap import dedent
+from typing import Any
+from unittest.mock import MagicMock, patch
+
 import pytest as pytest
 
 from langchain_community.document_loaders.web_base import WebBaseLoader
@@ -19,3 +23,62 @@ class TestWebBaseLoader:
         assert web_base_loader.web_paths == ["https://www.example.com"]
         web_base_loader = WebBaseLoader(web_path="https://www.example.com")
         assert web_base_loader.web_paths == ["https://www.example.com"]
+
+
+@pytest.mark.requires("bs4")
+@patch("langchain_community.document_loaders.web_base.requests.Session.get")
+def test_lazy_load(mock_get: Any) -> None:
+    import bs4
+
+    mock_response = MagicMock()
+    mock_response.text = "<html><body><p>Test content</p></body></html>"
+    mock_get.return_value = mock_response
+
+    loader = WebBaseLoader(web_paths=["https://www.example.com"])
+    results = list(loader.lazy_load())
+    mock_get.assert_called_with("https://www.example.com")
+    assert len(results) == 1
+    assert results[0].page_content == "Test content"
+
+    # Test bs4 kwargs
+    mock_html = dedent("""
+        <html>
+        <body>
+            <p>Test content</p>
+            <div class="special-class">This is a div with a special class</div>
+        </body>
+        </html>
+        """)
+    mock_response = MagicMock()
+    mock_response.text = mock_html
+    mock_get.return_value = mock_response
+
+    loader = WebBaseLoader(
+        web_paths=["https://www.example.com"],
+        bs_kwargs={"parse_only": bs4.SoupStrainer(class_="special-class")},
+    )
+    results = list(loader.lazy_load())
+    assert len(results) == 1
+    assert results[0].page_content == "This is a div with a special class"
+
+
+@pytest.mark.requires("bs4")
+@patch("aiohttp.ClientSession.get")
+def test_aload(mock_get: Any) -> None:
+    async def mock_text() -> str:
+        return "<html><body><p>Test content</p></body></html>"
+
+    mock_response = MagicMock()
+    mock_response.text = mock_text
+    mock_get.return_value.__aenter__.return_value = mock_response
+
+    loader = WebBaseLoader(
+        web_paths=["https://www.example.com"],
+        header_template={"User-Agent": "test-user-agent"},
+    )
+    results = loader.aload()
+    assert len(results) == 1
+    assert results[0].page_content == "Test content"
+    mock_get.assert_called_with(
+        "https://www.example.com", headers={"User-Agent": "test-user-agent"}, cookies={}
+    )

libs/community/tests/unit_tests/graph_vectorstores/extractors/test_hierarchy_link_extractor.py

@@ -1,6 +1,5 @@
-from langchain_core.graph_vectorstores.links import Link
-
 from langchain_community.graph_vectorstores.extractors import HierarchyLinkExtractor
+from langchain_community.graph_vectorstores.links import Link
 
 PATH_1 = ["Root", "H1", "h2"]
 

libs/community/tests/unit_tests/graph_vectorstores/extractors/test_html_link_extractor.py

@@ -1,6 +1,6 @@
 import pytest
-from langchain_core.graph_vectorstores import Link
 
+from langchain_community.graph_vectorstores import Link
 from langchain_community.graph_vectorstores.extractors import (
     HtmlInput,
     HtmlLinkExtractor,

libs/community/tests/unit_tests/graph_vectorstores/extractors/test_link_extractor_transformer.py

@@ -1,12 +1,12 @@
 from typing import Set
 
 from langchain_core.documents import Document
-from langchain_core.graph_vectorstores.links import Link, get_links
 
 from langchain_community.graph_vectorstores.extractors import (
     LinkExtractor,
     LinkExtractorTransformer,
 )
+from langchain_community.graph_vectorstores.links import Link, get_links
 
 TEXT1 = "Text1"
 TEXT2 = "Text2"

libs/community/tests/unit_tests/llms/test_imports.py

@@ -77,7 +77,6 @@ EXPECT_ALL = [
     "RWKV",
     "Replicate",
     "SagemakerEndpoint",
-    "Sambaverse",
     "SambaStudio",
     "SelfHostedHuggingFaceLLM",
     "SelfHostedPipeline",

libs/community/tests/unit_tests/test_graph_vectorstores.py

@@ -1,12 +1,12 @@
 import pytest
-
 from langchain_core.documents import Document
-from langchain_core.graph_vectorstores.base import (
+
+from langchain_community.graph_vectorstores.base import (
     Node,
     _documents_to_nodes,
     _texts_to_nodes,
 )
-from langchain_core.graph_vectorstores.links import Link
+from langchain_community.graph_vectorstores.links import Link
 
 
 def test_texts_to_nodes() -> None:

libs/community/tests/unit_tests/vectorstores/test_azure_search.py

@@ -190,3 +190,40 @@ def test_additional_search_options() -> None:
         )
         assert vector_store.client is not None
         assert vector_store.client._api_version == "test"
+
+
+@pytest.mark.requires("azure.search.documents")
+def test_ids_used_correctly() -> None:
+    """Check whether vector store uses the document ids when provided with them."""
+    from azure.search.documents import SearchClient
+    from azure.search.documents.indexes import SearchIndexClient
+    from langchain_core.documents import Document
+
+    class Response:
+        def __init__(self) -> None:
+            self.succeeded: bool = True
+
+    def mock_upload_documents(self, documents: List[object]) -> List[Response]:  # type: ignore[no-untyped-def]
+        # assume all documents uploaded successfuly
+        response = [Response() for _ in documents]
+        return response
+
+    documents = [
+        Document(
+            page_content="page zero Lorem Ipsum",
+            metadata={"source": "document.pdf", "page": 0, "id": "ID-document-1"},
+        ),
+        Document(
+            page_content="page one Lorem Ipsum",
+            metadata={"source": "document.pdf", "page": 1, "id": "ID-document-2"},
+        ),
+    ]
+    ids_provided = [i.metadata.get("id") for i in documents]
+
+    with patch.object(
+        SearchClient, "upload_documents", mock_upload_documents
+    ), patch.object(SearchIndexClient, "get_index", mock_default_index):
+        vector_store = create_vector_store()
+        ids_used_at_upload = vector_store.add_documents(documents, ids=ids_provided)
+        assert len(ids_provided) == len(ids_used_at_upload)
+        assert ids_provided == ids_used_at_upload

libs/core/langchain_core/_api/beta_decorator.py

@@ -155,7 +155,7 @@ def beta(
             _name = _name or obj.fget.__qualname__
             old_doc = obj.__doc__
 
-            class _beta_property(property):
+            class _BetaProperty(property):
                 """A beta property."""
 
                 def __init__(self, fget=None, fset=None, fdel=None, doc=None):
@@ -186,7 +186,7 @@ def beta(
 
             def finalize(wrapper: Callable[..., Any], new_doc: str) -> Any:
                 """Finalize the property."""
-                return _beta_property(
+                return _BetaProperty(
                     fget=obj.fget, fset=obj.fset, fdel=obj.fdel, doc=new_doc
                 )
 

libs/core/langchain_core/_api/deprecation.py

@@ -264,7 +264,7 @@ def deprecated(
             _name = _name or cast(Union[type, Callable], obj.fget).__qualname__
             old_doc = obj.__doc__
 
-            class _deprecated_property(property):
+            class _DeprecatedProperty(property):
                 """A deprecated property."""
 
                 def __init__(self, fget=None, fset=None, fdel=None, doc=None):  # type: ignore[no-untyped-def]
@@ -297,7 +297,7 @@ def deprecated(
                 """Finalize the property."""
                 return cast(
                     T,
-                    _deprecated_property(
+                    _DeprecatedProperty(
                         fget=obj.fget, fset=obj.fset, fdel=obj.fdel, doc=new_doc
                     ),
                 )

libs/core/langchain_core/exceptions.py

@@ -3,7 +3,7 @@
 from typing import Any, Optional
 
 
-class LangChainException(Exception):
+class LangChainException(Exception):  # noqa: N818
     """General LangChain exception."""
 
 
@@ -11,7 +11,7 @@ class TracerException(LangChainException):
     """Base class for exceptions in tracers module."""
 
 
-class OutputParserException(ValueError, LangChainException):
+class OutputParserException(ValueError, LangChainException):  # noqa: N818
     """Exception that output parsers should raise to signify a parsing error.
 
     This exists to differentiate parsing errors from other code or execution errors

libs/core/langchain_core/graph_vectorstores/__init__.py

@@ -1,15 +0,0 @@
-from langchain_core.graph_vectorstores.base import (
-    GraphVectorStore,
-    GraphVectorStoreRetriever,
-    Node,
-)
-from langchain_core.graph_vectorstores.links import (
-    Link,
-)
-
-__all__ = [
-    "GraphVectorStore",
-    "GraphVectorStoreRetriever",
-    "Node",
-    "Link",
-]

libs/core/langchain_core/graph_vectorstores/base.py

@@ -1,708 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from collections.abc import AsyncIterable, Collection, Iterable, Iterator
-from typing import (
-    Any,
-    ClassVar,
-    Optional,
-)
-
-from pydantic import Field
-
-from langchain_core._api import beta
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForRetrieverRun,
-    CallbackManagerForRetrieverRun,
-)
-from langchain_core.documents import Document
-from langchain_core.graph_vectorstores.links import METADATA_LINKS_KEY, Link
-from langchain_core.load import Serializable
-from langchain_core.runnables import run_in_executor
-from langchain_core.vectorstores import VectorStore, VectorStoreRetriever
-
-
-def _has_next(iterator: Iterator) -> bool:
-    """Checks if the iterator has more elements.
-    Warning: consumes an element from the iterator"""
-    sentinel = object()
-    return next(iterator, sentinel) is not sentinel
-
-
-@beta()
-class Node(Serializable):
-    """Node in the GraphVectorStore.
-
-    Edges exist from nodes with an outgoing link to nodes with a matching incoming link.
-
-    For instance two nodes `a` and `b` connected over a hyperlink ``https://some-url``
-    would look like:
-
-    .. code-block:: python
-
-        [
-            Node(
-                id="a",
-                text="some text a",
-                links= [
-                    Link(kind="hyperlink", tag="https://some-url", direction="incoming")
-                ],
-            ),
-            Node(
-                id="b",
-                text="some text b",
-                links= [
-                    Link(kind="hyperlink", tag="https://some-url", direction="outgoing")
-                ],
-            )
-        ]
-    """
-
-    id: Optional[str] = None
-    """Unique ID for the node. Will be generated by the GraphVectorStore if not set."""
-    text: str
-    """Text contained by the node."""
-    metadata: dict = Field(default_factory=dict)
-    """Metadata for the node."""
-    links: list[Link] = Field(default_factory=list)
-    """Links associated with the node."""
-
-
-def _texts_to_nodes(
-    texts: Iterable[str],
-    metadatas: Optional[Iterable[dict]],
-    ids: Optional[Iterable[str]],
-) -> Iterator[Node]:
-    metadatas_it = iter(metadatas) if metadatas else None
-    ids_it = iter(ids) if ids else None
-    for text in texts:
-        try:
-            _metadata = next(metadatas_it).copy() if metadatas_it else {}
-        except StopIteration as e:
-            raise ValueError("texts iterable longer than metadatas") from e
-        try:
-            _id = next(ids_it) if ids_it else None
-        except StopIteration as e:
-            raise ValueError("texts iterable longer than ids") from e
-
-        links = _metadata.pop(METADATA_LINKS_KEY, [])
-        if not isinstance(links, list):
-            links = list(links)
-        yield Node(
-            id=_id,
-            metadata=_metadata,
-            text=text,
-            links=links,
-        )
-    if ids_it and _has_next(ids_it):
-        raise ValueError("ids iterable longer than texts")
-    if metadatas_it and _has_next(metadatas_it):
-        raise ValueError("metadatas iterable longer than texts")
-
-
-def _documents_to_nodes(documents: Iterable[Document]) -> Iterator[Node]:
-    for doc in documents:
-        metadata = doc.metadata.copy()
-        links = metadata.pop(METADATA_LINKS_KEY, [])
-        if not isinstance(links, list):
-            links = list(links)
-        yield Node(
-            id=doc.id,
-            metadata=metadata,
-            text=doc.page_content,
-            links=links,
-        )
-
-
-@beta()
-def nodes_to_documents(nodes: Iterable[Node]) -> Iterator[Document]:
-    """Convert nodes to documents.
-
-    Args:
-        nodes: The nodes to convert to documents.
-    Returns:
-        The documents generated from the nodes.
-    """
-    for node in nodes:
-        metadata = node.metadata.copy()
-        metadata[METADATA_LINKS_KEY] = [
-            # Convert the core `Link` (from the node) back to the local `Link`.
-            Link(kind=link.kind, direction=link.direction, tag=link.tag)
-            for link in node.links
-        ]
-
-        yield Document(
-            id=node.id,
-            page_content=node.text,
-            metadata=metadata,
-        )
-
-
-@beta(message="Added in version 0.2.14 of langchain_core. API subject to change.")
-class GraphVectorStore(VectorStore):
-    """A hybrid vector-and-graph graph store.
-
-    Document chunks support vector-similarity search as well as edges linking
-    chunks based on structural and semantic properties.
-
-    .. versionadded:: 0.2.14
-    """
-
-    @abstractmethod
-    def add_nodes(
-        self,
-        nodes: Iterable[Node],
-        **kwargs: Any,
-    ) -> Iterable[str]:
-        """Add nodes to the graph store.
-
-        Args:
-            nodes: the nodes to add.
-        """
-
-    async def aadd_nodes(
-        self,
-        nodes: Iterable[Node],
-        **kwargs: Any,
-    ) -> AsyncIterable[str]:
-        """Add nodes to the graph store.
-
-        Args:
-            nodes: the nodes to add.
-        """
-        iterator = iter(await run_in_executor(None, self.add_nodes, nodes, **kwargs))
-        done = object()
-        while True:
-            doc = await run_in_executor(None, next, iterator, done)
-            if doc is done:
-                break
-            yield doc  # type: ignore[misc]
-
-    def add_texts(
-        self,
-        texts: Iterable[str],
-        metadatas: Optional[Iterable[dict]] = None,
-        *,
-        ids: Optional[Iterable[str]] = None,
-        **kwargs: Any,
-    ) -> list[str]:
-        """Run more texts through the embeddings and add to the vectorstore.
-
-        The Links present in the metadata field `links` will be extracted to create
-        the `Node` links.
-
-        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
-        function call would look like:
-
-        .. code-block:: python
-
-            store.add_texts(
-                ids=["a", "b"],
-                texts=["some text a", "some text b"],
-                metadatas=[
-                    {
-                        "links": [
-                            Link.incoming(kind="hyperlink", tag="https://some-url")
-                        ]
-                    },
-                    {
-                        "links": [
-                            Link.outgoing(kind="hyperlink", tag="https://some-url")
-                        ]
-                    },
-                ],
-            )
-
-        Args:
-            texts: Iterable of strings to add to the vectorstore.
-            metadatas: Optional list of metadatas associated with the texts.
-                The metadata key `links` shall be an iterable of
-                :py:class:`~langchain_core.graph_vectorstores.links.Link`.
-            **kwargs: vectorstore specific parameters.
-
-        Returns:
-            List of ids from adding the texts into the vectorstore.
-        """
-        nodes = _texts_to_nodes(texts, metadatas, ids)
-        return list(self.add_nodes(nodes, **kwargs))
-
-    async def aadd_texts(
-        self,
-        texts: Iterable[str],
-        metadatas: Optional[Iterable[dict]] = None,
-        *,
-        ids: Optional[Iterable[str]] = None,
-        **kwargs: Any,
-    ) -> list[str]:
-        """Run more texts through the embeddings and add to the vectorstore.
-
-        The Links present in the metadata field `links` will be extracted to create
-        the `Node` links.
-
-        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
-        function call would look like:
-
-        .. code-block:: python
-
-            await store.aadd_texts(
-                ids=["a", "b"],
-                texts=["some text a", "some text b"],
-                metadatas=[
-                    {
-                        "links": [
-                            Link.incoming(kind="hyperlink", tag="https://some-url")
-                        ]
-                    },
-                    {
-                        "links": [
-                            Link.outgoing(kind="hyperlink", tag="https://some-url")
-                        ]
-                    },
-                ],
-            )
-
-        Args:
-            texts: Iterable of strings to add to the vectorstore.
-            metadatas: Optional list of metadatas associated with the texts.
-                The metadata key `links` shall be an iterable of
-                :py:class:`~langchain_core.graph_vectorstores.links.Link`.
-            **kwargs: vectorstore specific parameters.
-
-        Returns:
-            List of ids from adding the texts into the vectorstore.
-        """
-        nodes = _texts_to_nodes(texts, metadatas, ids)
-        return [_id async for _id in self.aadd_nodes(nodes, **kwargs)]
-
-    def add_documents(
-        self,
-        documents: Iterable[Document],
-        **kwargs: Any,
-    ) -> list[str]:
-        """Run more documents through the embeddings and add to the vectorstore.
-
-        The Links present in the document metadata field `links` will be extracted to
-        create the `Node` links.
-
-        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
-        function call would look like:
-
-        .. code-block:: python
-
-            store.add_documents(
-                [
-                    Document(
-                        id="a",
-                        page_content="some text a",
-                        metadata={
-                            "links": [
-                                Link.incoming(kind="hyperlink", tag="http://some-url")
-                            ]
-                        }
-                    ),
-                    Document(
-                        id="b",
-                        page_content="some text b",
-                        metadata={
-                            "links": [
-                                Link.outgoing(kind="hyperlink", tag="http://some-url")
-                            ]
-                        }
-                    ),
-                ]
-
-            )
-
-        Args:
-            documents: Documents to add to the vectorstore.
-                The document's metadata key `links` shall be an iterable of
-                :py:class:`~langchain_core.graph_vectorstores.links.Link`.
-
-        Returns:
-            List of IDs of the added texts.
-        """
-        nodes = _documents_to_nodes(documents)
-        return list(self.add_nodes(nodes, **kwargs))
-
-    async def aadd_documents(
-        self,
-        documents: Iterable[Document],
-        **kwargs: Any,
-    ) -> list[str]:
-        """Run more documents through the embeddings and add to the vectorstore.
-
-        The Links present in the document metadata field `links` will be extracted to
-        create the `Node` links.
-
-        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
-        function call would look like:
-
-        .. code-block:: python
-
-            store.add_documents(
-                [
-                    Document(
-                        id="a",
-                        page_content="some text a",
-                        metadata={
-                            "links": [
-                                Link.incoming(kind="hyperlink", tag="http://some-url")
-                            ]
-                        }
-                    ),
-                    Document(
-                        id="b",
-                        page_content="some text b",
-                        metadata={
-                            "links": [
-                                Link.outgoing(kind="hyperlink", tag="http://some-url")
-                            ]
-                        }
-                    ),
-                ]
-
-            )
-
-        Args:
-            documents: Documents to add to the vectorstore.
-                The document's metadata key `links` shall be an iterable of
-                :py:class:`~langchain_core.graph_vectorstores.links.Link`.
-
-        Returns:
-            List of IDs of the added texts.
-        """
-        nodes = _documents_to_nodes(documents)
-        return [_id async for _id in self.aadd_nodes(nodes, **kwargs)]
-
-    @abstractmethod
-    def traversal_search(
-        self,
-        query: str,
-        *,
-        k: int = 4,
-        depth: int = 1,
-        **kwargs: Any,
-    ) -> Iterable[Document]:
-        """Retrieve documents from traversing this graph store.
-
-        First, `k` nodes are retrieved using a search for each `query` string.
-        Then, additional nodes are discovered up to the given `depth` from those
-        starting nodes.
-
-        Args:
-            query: The query string.
-            k: The number of Documents to return from the initial search.
-                Defaults to 4. Applies to each of the query strings.
-            depth: The maximum depth of edges to traverse. Defaults to 1.
-        Returns:
-            Retrieved documents.
-        """
-
-    async def atraversal_search(
-        self,
-        query: str,
-        *,
-        k: int = 4,
-        depth: int = 1,
-        **kwargs: Any,
-    ) -> AsyncIterable[Document]:
-        """Retrieve documents from traversing this graph store.
-
-        First, `k` nodes are retrieved using a search for each `query` string.
-        Then, additional nodes are discovered up to the given `depth` from those
-        starting nodes.
-
-        Args:
-            query: The query string.
-            k: The number of Documents to return from the initial search.
-                Defaults to 4. Applies to each of the query strings.
-            depth: The maximum depth of edges to traverse. Defaults to 1.
-        Returns:
-            Retrieved documents.
-        """
-        iterator = iter(
-            await run_in_executor(
-                None, self.traversal_search, query, k=k, depth=depth, **kwargs
-            )
-        )
-        done = object()
-        while True:
-            doc = await run_in_executor(None, next, iterator, done)
-            if doc is done:
-                break
-            yield doc  # type: ignore[misc]
-
-    @abstractmethod
-    def mmr_traversal_search(
-        self,
-        query: str,
-        *,
-        k: int = 4,
-        depth: int = 2,
-        fetch_k: int = 100,
-        adjacent_k: int = 10,
-        lambda_mult: float = 0.5,
-        score_threshold: float = float("-inf"),
-        **kwargs: Any,
-    ) -> Iterable[Document]:
-        """Retrieve documents from this graph store using MMR-traversal.
-
-        This strategy first retrieves the top `fetch_k` results by similarity to
-        the question. It then selects the top `k` results based on
-        maximum-marginal relevance using the given `lambda_mult`.
-
-        At each step, it considers the (remaining) documents from `fetch_k` as
-        well as any documents connected by edges to a selected document
-        retrieved based on similarity (a "root").
-
-        Args:
-            query: The query string to search for.
-            k: Number of Documents to return. Defaults to 4.
-            fetch_k: Number of Documents to fetch via similarity.
-                Defaults to 100.
-            adjacent_k: Number of adjacent Documents to fetch.
-                Defaults to 10.
-            depth: Maximum depth of a node (number of edges) from a node
-                retrieved via similarity. Defaults to 2.
-            lambda_mult: Number between 0 and 1 that determines the degree
-                of diversity among the results with 0 corresponding to maximum
-                diversity and 1 to minimum diversity. Defaults to 0.5.
-            score_threshold: Only documents with a score greater than or equal
-                this threshold will be chosen. Defaults to negative infinity.
-        """
-
-    async def ammr_traversal_search(
-        self,
-        query: str,
-        *,
-        k: int = 4,
-        depth: int = 2,
-        fetch_k: int = 100,
-        adjacent_k: int = 10,
-        lambda_mult: float = 0.5,
-        score_threshold: float = float("-inf"),
-        **kwargs: Any,
-    ) -> AsyncIterable[Document]:
-        """Retrieve documents from this graph store using MMR-traversal.
-
-        This strategy first retrieves the top `fetch_k` results by similarity to
-        the question. It then selects the top `k` results based on
-        maximum-marginal relevance using the given `lambda_mult`.
-
-        At each step, it considers the (remaining) documents from `fetch_k` as
-        well as any documents connected by edges to a selected document
-        retrieved based on similarity (a "root").
-
-        Args:
-            query: The query string to search for.
-            k: Number of Documents to return. Defaults to 4.
-            fetch_k: Number of Documents to fetch via similarity.
-                Defaults to 100.
-            adjacent_k: Number of adjacent Documents to fetch.
-                Defaults to 10.
-            depth: Maximum depth of a node (number of edges) from a node
-                retrieved via similarity. Defaults to 2.
-            lambda_mult: Number between 0 and 1 that determines the degree
-                of diversity among the results with 0 corresponding to maximum
-                diversity and 1 to minimum diversity. Defaults to 0.5.
-            score_threshold: Only documents with a score greater than or equal
-                this threshold will be chosen. Defaults to negative infinity.
-        """
-        iterator = iter(
-            await run_in_executor(
-                None,
-                self.mmr_traversal_search,
-                query,
-                k=k,
-                fetch_k=fetch_k,
-                adjacent_k=adjacent_k,
-                depth=depth,
-                lambda_mult=lambda_mult,
-                score_threshold=score_threshold,
-                **kwargs,
-            )
-        )
-        done = object()
-        while True:
-            doc = await run_in_executor(None, next, iterator, done)
-            if doc is done:
-                break
-            yield doc  # type: ignore[misc]
-
-    def similarity_search(
-        self, query: str, k: int = 4, **kwargs: Any
-    ) -> list[Document]:
-        return list(self.traversal_search(query, k=k, depth=0))
-
-    def max_marginal_relevance_search(
-        self,
-        query: str,
-        k: int = 4,
-        fetch_k: int = 20,
-        lambda_mult: float = 0.5,
-        **kwargs: Any,
-    ) -> list[Document]:
-        return list(
-            self.mmr_traversal_search(
-                query, k=k, fetch_k=fetch_k, lambda_mult=lambda_mult, depth=0
-            )
-        )
-
-    async def asimilarity_search(
-        self, query: str, k: int = 4, **kwargs: Any
-    ) -> list[Document]:
-        return [doc async for doc in self.atraversal_search(query, k=k, depth=0)]
-
-    def search(self, query: str, search_type: str, **kwargs: Any) -> list[Document]:
-        if search_type == "similarity":
-            return self.similarity_search(query, **kwargs)
-        elif search_type == "similarity_score_threshold":
-            docs_and_similarities = self.similarity_search_with_relevance_scores(
-                query, **kwargs
-            )
-            return [doc for doc, _ in docs_and_similarities]
-        elif search_type == "mmr":
-            return self.max_marginal_relevance_search(query, **kwargs)
-        elif search_type == "traversal":
-            return list(self.traversal_search(query, **kwargs))
-        elif search_type == "mmr_traversal":
-            return list(self.mmr_traversal_search(query, **kwargs))
-        else:
-            raise ValueError(
-                f"search_type of {search_type} not allowed. Expected "
-                "search_type to be 'similarity', 'similarity_score_threshold', "
-                "'mmr' or 'traversal'."
-            )
-
-    async def asearch(
-        self, query: str, search_type: str, **kwargs: Any
-    ) -> list[Document]:
-        if search_type == "similarity":
-            return await self.asimilarity_search(query, **kwargs)
-        elif search_type == "similarity_score_threshold":
-            docs_and_similarities = await self.asimilarity_search_with_relevance_scores(
-                query, **kwargs
-            )
-            return [doc for doc, _ in docs_and_similarities]
-        elif search_type == "mmr":
-            return await self.amax_marginal_relevance_search(query, **kwargs)
-        elif search_type == "traversal":
-            return [doc async for doc in self.atraversal_search(query, **kwargs)]
-        else:
-            raise ValueError(
-                f"search_type of {search_type} not allowed. Expected "
-                "search_type to be 'similarity', 'similarity_score_threshold', "
-                "'mmr' or 'traversal'."
-            )
-
-    def as_retriever(self, **kwargs: Any) -> GraphVectorStoreRetriever:
-        """Return GraphVectorStoreRetriever initialized from this GraphVectorStore.
-
-        Args:
-            **kwargs: Keyword arguments to pass to the search function.
-                Can include:
-
-                - search_type (Optional[str]): Defines the type of search that
-                  the Retriever should perform.
-                  Can be ``traversal`` (default), ``similarity``, ``mmr``, or
-                  ``similarity_score_threshold``.
-                - search_kwargs (Optional[Dict]): Keyword arguments to pass to the
-                  search function. Can include things like:
-
-                  - k(int): Amount of documents to return (Default: 4).
-                  - depth(int): The maximum depth of edges to traverse (Default: 1).
-                  - score_threshold(float): Minimum relevance threshold
-                    for similarity_score_threshold.
-                  - fetch_k(int): Amount of documents to pass to MMR algorithm
-                    (Default: 20).
-                  - lambda_mult(float): Diversity of results returned by MMR;
-                    1 for minimum diversity and 0 for maximum. (Default: 0.5).
-        Returns:
-            Retriever for this GraphVectorStore.
-
-        Examples:
-
-        .. code-block:: python
-
-            # Retrieve documents traversing edges
-            docsearch.as_retriever(
-                search_type="traversal",
-                search_kwargs={'k': 6, 'depth': 3}
-            )
-
-            # Retrieve more documents with higher diversity
-            # Useful if your dataset has many similar documents
-            docsearch.as_retriever(
-                search_type="mmr",
-                search_kwargs={'k': 6, 'lambda_mult': 0.25}
-            )
-
-            # Fetch more documents for the MMR algorithm to consider
-            # But only return the top 5
-            docsearch.as_retriever(
-                search_type="mmr",
-                search_kwargs={'k': 5, 'fetch_k': 50}
-            )
-
-            # Only retrieve documents that have a relevance score
-            # Above a certain threshold
-            docsearch.as_retriever(
-                search_type="similarity_score_threshold",
-                search_kwargs={'score_threshold': 0.8}
-            )
-
-            # Only get the single most similar document from the dataset
-            docsearch.as_retriever(search_kwargs={'k': 1})
-
-        """
-        return GraphVectorStoreRetriever(vectorstore=self, **kwargs)
-
-
-class GraphVectorStoreRetriever(VectorStoreRetriever):
-    """Retriever class for GraphVectorStore."""
-
-    vectorstore: GraphVectorStore
-    """GraphVectorStore to use for retrieval."""
-    search_type: str = "traversal"
-    """Type of search to perform. Defaults to "traversal"."""
-    allowed_search_types: ClassVar[Collection[str]] = (
-        "similarity",
-        "similarity_score_threshold",
-        "mmr",
-        "traversal",
-        "mmr_traversal",
-    )
-
-    def _get_relevant_documents(
-        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
-    ) -> list[Document]:
-        if self.search_type == "traversal":
-            return list(self.vectorstore.traversal_search(query, **self.search_kwargs))
-        elif self.search_type == "mmr_traversal":
-            return list(
-                self.vectorstore.mmr_traversal_search(query, **self.search_kwargs)
-            )
-        else:
-            return super()._get_relevant_documents(query, run_manager=run_manager)
-
-    async def _aget_relevant_documents(
-        self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun
-    ) -> list[Document]:
-        if self.search_type == "traversal":
-            return [
-                doc
-                async for doc in self.vectorstore.atraversal_search(
-                    query, **self.search_kwargs
-                )
-            ]
-        elif self.search_type == "mmr_traversal":
-            return [
-                doc
-                async for doc in self.vectorstore.ammr_traversal_search(
-                    query, **self.search_kwargs
-                )
-            ]
-        else:
-            return await super()._aget_relevant_documents(
-                query, run_manager=run_manager
-            )

libs/core/langchain_core/graph_vectorstores/links.py

@@ -1,102 +0,0 @@
-from collections.abc import Iterable
-from dataclasses import dataclass
-from typing import Literal, Union
-
-from langchain_core._api import beta
-from langchain_core.documents import Document
-
-
-@beta()
-@dataclass(frozen=True)
-class Link:
-    """A link to/from a tag of a given tag.
-
-    Edges exist from nodes with an outgoing link to nodes with a matching incoming link.
-    """
-
-    kind: str
-    """The kind of link. Allows different extractors to use the same tag name without
-    creating collisions between extractors. For example “keyword” vs “url”."""
-    direction: Literal["in", "out", "bidir"]
-    """The direction of the link."""
-    tag: str
-    """The tag of the link."""
-
-    @staticmethod
-    def incoming(kind: str, tag: str) -> "Link":
-        """Create an incoming link."""
-        return Link(kind=kind, direction="in", tag=tag)
-
-    @staticmethod
-    def outgoing(kind: str, tag: str) -> "Link":
-        """Create an outgoing link."""
-        return Link(kind=kind, direction="out", tag=tag)
-
-    @staticmethod
-    def bidir(kind: str, tag: str) -> "Link":
-        """Create a bidirectional link."""
-        return Link(kind=kind, direction="bidir", tag=tag)
-
-
-METADATA_LINKS_KEY = "links"
-
-
-@beta()
-def get_links(doc: Document) -> list[Link]:
-    """Get the links from a document.
-
-    Args:
-        doc: The document to get the link tags from.
-    Returns:
-        The set of link tags from the document.
-    """
-
-    links = doc.metadata.setdefault(METADATA_LINKS_KEY, [])
-    if not isinstance(links, list):
-        # Convert to a list and remember that.
-        links = list(links)
-        doc.metadata[METADATA_LINKS_KEY] = links
-    return links
-
-
-@beta()
-def add_links(doc: Document, *links: Union[Link, Iterable[Link]]) -> None:
-    """Add links to the given metadata.
-
-    Args:
-        doc: The document to add the links to.
-        *links: The links to add to the document.
-    """
-    links_in_metadata = get_links(doc)
-    for link in links:
-        if isinstance(link, Iterable):
-            links_in_metadata.extend(link)
-        else:
-            links_in_metadata.append(link)
-
-
-@beta()
-def copy_with_links(doc: Document, *links: Union[Link, Iterable[Link]]) -> Document:
-    """Return a document with the given links added.
-
-    Args:
-        doc: The document to add the links to.
-        *links: The links to add to the document.
-
-    Returns:
-        A document with a shallow-copy of the metadata with the links added.
-    """
-    new_links = set(get_links(doc))
-    for link in links:
-        if isinstance(link, Iterable):
-            new_links.update(link)
-        else:
-            new_links.add(link)
-
-    return Document(
-        page_content=doc.page_content,
-        metadata={
-            **doc.metadata,
-            METADATA_LINKS_KEY: list(new_links),
-        },
-    )

libs/core/langchain_core/language_models/base.py

@@ -14,7 +14,7 @@ from typing import (
 )
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
-from typing_extensions import TypeAlias, TypedDict
+from typing_extensions import TypeAlias, TypedDict, override
 
 from langchain_core._api import deprecated
 from langchain_core.messages import (
@@ -143,6 +143,7 @@ class BaseLanguageModel(
             return verbose
 
     @property
+    @override
     def InputType(self) -> TypeAlias:
         """Get the input type for this runnable."""
         from langchain_core.prompt_values import (

libs/core/langchain_core/language_models/chat_models.py

@@ -26,6 +26,7 @@ from pydantic import (
     Field,
     model_validator,
 )
+from typing_extensions import override
 
 from langchain_core._api import deprecated
 from langchain_core.caches import BaseCache
@@ -251,6 +252,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessage], ABC):
     # --- Runnable methods ---
 
     @property
+    @override
     def OutputType(self) -> Any:
         """Get the output type for this runnable."""
         return AnyMessage

libs/core/langchain_core/language_models/llms.py

@@ -31,6 +31,7 @@ from tenacity import (
     stop_after_attempt,
     wait_exponential,
 )
+from typing_extensions import override
 
 from langchain_core._api import deprecated
 from langchain_core.caches import BaseCache
@@ -318,6 +319,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     # --- Runnable methods ---
 
     @property
+    @override
     def OutputType(self) -> type[str]:
         """Get the input type for this runnable."""
         return str

libs/core/langchain_core/load/load.py

@@ -19,6 +19,17 @@ DEFAULT_NAMESPACES = [
     "langchain_anthropic",
     "langchain_groq",
     "langchain_google_genai",
+    "langchain_aws",
+    "langchain_openai",
+    "langchain_google_vertexai",
+    "langchain_mistralai",
+    "langchain_fireworks",
+]
+# Namespaces for which only deserializing via the SERIALIZABLE_MAPPING is allowed.
+# Load by path is not allowed.
+DISALLOW_LOAD_FROM_PATH = [
+    "langchain_community",
+    "langchain",
 ]
 
 ALL_SERIALIZABLE_MAPPINGS = {
@@ -103,40 +114,31 @@ class Reviver:
             and value.get("id", None) is not None
         ):
             [*namespace, name] = value["id"]
+            mapping_key = tuple(value["id"])
 
             if namespace[0] not in self.valid_namespaces:
                 raise ValueError(f"Invalid namespace: {value}")
-
-            # The root namespace "langchain" is not a valid identifier.
-            if len(namespace) == 1 and namespace[0] == "langchain":
+            # The root namespace ["langchain"] is not a valid identifier.
+            elif namespace == ["langchain"]:
                 raise ValueError(f"Invalid namespace: {value}")
-
-            # If namespace is in known namespaces, try to use mapping
-            key = tuple(namespace + [name])
-            if namespace[0] in DEFAULT_NAMESPACES:
-                # Get the importable path
-                if key not in self.import_mappings:
-                    raise ValueError(
-                        "Trying to deserialize something that cannot "
-                        "be deserialized in current version of langchain-core: "
-                        f"{key}"
-                    )
-                import_path = self.import_mappings[key]
+            # Has explicit import path.
+            elif mapping_key in self.import_mappings:
+                import_path = self.import_mappings[mapping_key]
                 # Split into module and name
-                import_dir, import_obj = import_path[:-1], import_path[-1]
+                import_dir, name = import_path[:-1], import_path[-1]
                 # Import module
                 mod = importlib.import_module(".".join(import_dir))
-                # Import class
-                cls = getattr(mod, import_obj)
-            # Otherwise, load by path
+            elif namespace[0] in DISALLOW_LOAD_FROM_PATH:
+                raise ValueError(
+                    "Trying to deserialize something that cannot "
+                    "be deserialized in current version of langchain-core: "
+                    f"{mapping_key}."
+                )
+            # Otherwise, treat namespace as path.
             else:
-                if key in self.additional_import_mappings:
-                    import_path = self.import_mappings[key]
-                    mod = importlib.import_module(".".join(import_path[:-1]))
-                    name = import_path[-1]
-                else:
-                    mod = importlib.import_module(".".join(namespace))
-                cls = getattr(mod, name)
+                mod = importlib.import_module(".".join(namespace))
+
+            cls = getattr(mod, name)
 
             # The class must be a subclass of Serializable.
             if not issubclass(cls, Serializable):

libs/core/langchain_core/load/mapping.py

@@ -1026,4 +1026,24 @@ _JS_SERIALIZABLE_MAPPING: dict[tuple[str, ...], tuple[str, ...]] = {
         "image",
         "ImagePromptTemplate",
     ),
+    ("langchain", "chat_models", "bedrock", "ChatBedrock"): (
+        "langchain_aws",
+        "chat_models",
+        "ChatBedrock",
+    ),
+    ("langchain", "chat_models", "google_genai", "ChatGoogleGenerativeAI"): (
+        "langchain_google_genai",
+        "chat_models",
+        "ChatGoogleGenerativeAI",
+    ),
+    ("langchain", "chat_models", "groq", "ChatGroq"): (
+        "langchain_groq",
+        "chat_models",
+        "ChatGroq",
+    ),
+    ("langchain", "chat_models", "bedrock", "BedrockChat"): (
+        "langchain_aws",
+        "chat_models",
+        "ChatBedrock",
+    ),
 }

libs/core/langchain_core/memory.py

@@ -1,11 +1,8 @@
 """**Memory** maintains Chain state, incorporating context from past runs.
 
-**Class hierarchy for Memory:**
-
-.. code-block::
-
-    BaseMemory --> <name>Memory --> <name>Memory  # Examples: BaseChatMemory -> MotorheadMemory
+This module contains memory abstractions from LangChain v0.0.x.
 
+These abstractions are now deprecated and will be removed in LangChain v1.0.0.
 """  # noqa: E501
 
 from __future__ import annotations
@@ -15,10 +12,19 @@ from typing import Any
 
 from pydantic import ConfigDict
 
+from langchain_core._api import deprecated
 from langchain_core.load.serializable import Serializable
 from langchain_core.runnables import run_in_executor
 
 
+@deprecated(
+    since="0.3.3",
+    removal="1.0.0",
+    message=(
+        "Please see the migration guide at: "
+        "https://python.langchain.com/docs/versions/migrating_memory/"
+    ),
+)
 class BaseMemory(Serializable, ABC):
     """Abstract base class for memory in Chains.
 

libs/core/langchain_core/output_parsers/base.py

@@ -10,6 +10,8 @@ from typing import (
     Union,
 )
 
+from typing_extensions import override
+
 from langchain_core.language_models import LanguageModelOutput
 from langchain_core.messages import AnyMessage, BaseMessage
 from langchain_core.outputs import ChatGeneration, Generation
@@ -63,11 +65,13 @@ class BaseGenerationOutputParser(
     """Base class to parse the output of an LLM call."""
 
     @property
+    @override
     def InputType(self) -> Any:
         """Return the input type for the parser."""
         return Union[str, AnyMessage]
 
     @property
+    @override
     def OutputType(self) -> type[T]:
         """Return the output type for the parser."""
         # even though mypy complains this isn't valid,
@@ -148,11 +152,13 @@ class BaseOutputParser(
     """  # noqa: E501
 
     @property
+    @override
     def InputType(self) -> Any:
         """Return the input type for the parser."""
         return Union[str, AnyMessage]
 
     @property
+    @override
     def OutputType(self) -> type[T]:
         """Return the output type for the parser.
 

libs/core/langchain_core/output_parsers/pydantic.py

@@ -3,6 +3,7 @@ from typing import Annotated, Generic, Optional
 
 import pydantic
 from pydantic import SkipValidation
+from typing_extensions import override
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.output_parsers import JsonOutputParser
@@ -107,6 +108,7 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
         return "pydantic"
 
     @property
+    @override
     def OutputType(self) -> type[TBaseModel]:
         """Return the pydantic model."""
         return self.pydantic_object

libs/core/langchain_core/output_parsers/xml.py

@@ -1,6 +1,6 @@
 import re
 import xml
-import xml.etree.ElementTree as ET
+import xml.etree.ElementTree as ET  # noqa: N817
 from collections.abc import AsyncIterator, Iterator
 from typing import Any, Literal, Optional, Union
 from xml.etree.ElementTree import TreeBuilder
@@ -46,14 +46,14 @@ class _StreamingParser:
         """
         if parser == "defusedxml":
             try:
-                from defusedxml import ElementTree as DET  # type: ignore
+                import defusedxml  # type: ignore
             except ImportError as e:
                 raise ImportError(
                     "defusedxml is not installed. "
                     "Please install it to use the defusedxml parser."
                     "You can install it with `pip install defusedxml` "
                 ) from e
-            _parser = DET.DefusedXMLParser(target=TreeBuilder())
+            _parser = defusedxml.ElementTree.DefusedXMLParser(target=TreeBuilder())
         else:
             _parser = None
         self.pull_parser = ET.XMLPullParser(["start", "end"], _parser=_parser)
@@ -189,7 +189,7 @@ class XMLOutputParser(BaseTransformOutputParser):
         # likely if you're reading this you can move them to the top of the file
         if self.parser == "defusedxml":
             try:
-                from defusedxml import ElementTree as DET  # type: ignore
+                from defusedxml import ElementTree  # type: ignore
             except ImportError as e:
                 raise ImportError(
                     "defusedxml is not installed. "
@@ -197,9 +197,9 @@ class XMLOutputParser(BaseTransformOutputParser):
                     "You can install it with `pip install defusedxml`"
                     "See https://github.com/tiran/defusedxml for more details"
                 ) from e
-            _ET = DET  # Use the defusedxml parser
+            _et = ElementTree  # Use the defusedxml parser
         else:
-            _ET = ET  # Use the standard library parser
+            _et = ET  # Use the standard library parser
 
         match = re.search(r"```(xml)?(.*)```", text, re.DOTALL)
         if match is not None:
@@ -211,10 +211,9 @@ class XMLOutputParser(BaseTransformOutputParser):
 
         text = text.strip()
         try:
-            root = ET.fromstring(text)
+            root = _et.fromstring(text)
             return self._root_to_dict(root)
-
-        except ET.ParseError as e:
+        except _et.ParseError as e:
             msg = f"Failed to parse XML format from completion {text}. Got: {e}"
             raise OutputParserException(msg, llm_output=text) from e
 

libs/core/langchain_core/prompts/base.py

@@ -18,7 +18,7 @@ from typing import (
 
 import yaml
 from pydantic import BaseModel, ConfigDict, Field, model_validator
-from typing_extensions import Self
+from typing_extensions import Self, override
 
 from langchain_core.load import dumpd
 from langchain_core.output_parsers.base import BaseOutputParser
@@ -107,6 +107,7 @@ class BasePromptTemplate(
         return dumpd(self)
 
     @property
+    @override
     def OutputType(self) -> Any:
         """Return the output type of the prompt."""
         return Union[StringPromptValue, ChatPromptValueConcrete]

libs/core/langchain_core/prompts/string.py

@@ -17,7 +17,7 @@ from langchain_core.utils.formatting import formatter
 from langchain_core.utils.interactive_env import is_interactive_env
 
 
-def jinja2_formatter(template: str, **kwargs: Any) -> str:
+def jinja2_formatter(template: str, /, **kwargs: Any) -> str:
     """Format a template using jinja2.
 
     *Security warning*:
@@ -99,7 +99,7 @@ def _get_jinja2_variables_from_template(template: str) -> set[str]:
     return variables
 
 
-def mustache_formatter(template: str, **kwargs: Any) -> str:
+def mustache_formatter(template: str, /, **kwargs: Any) -> str:
     """Format a template using mustache.
 
     Args:

libs/core/langchain_core/runnables/base.py

@@ -36,7 +36,7 @@ from typing import (
 )
 
 from pydantic import BaseModel, ConfigDict, Field, RootModel
-from typing_extensions import Literal, get_args
+from typing_extensions import Literal, get_args, override
 
 from langchain_core._api import beta_decorator
 from langchain_core.load.serializable import (
@@ -272,7 +272,7 @@ class Runnable(Generic[Input, Output], ABC):
             return name_
 
     @property
-    def InputType(self) -> type[Input]:
+    def InputType(self) -> type[Input]:  # noqa: N802
         """The type of input this Runnable accepts specified as a type annotation."""
         # First loop through all parent classes and if any of them is
         # a pydantic model, we will pick up the generic parameterization
@@ -297,7 +297,7 @@ class Runnable(Generic[Input, Output], ABC):
         )
 
     @property
-    def OutputType(self) -> type[Output]:
+    def OutputType(self) -> type[Output]:  # noqa: N802
         """The type of output this Runnable produces specified as a type annotation."""
         # First loop through bases -- this will help generic
         # any pydantic models.
@@ -2811,11 +2811,13 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     )
 
     @property
+    @override
     def InputType(self) -> type[Input]:
         """The type of the input to the Runnable."""
         return self.first.InputType
 
     @property
+    @override
     def OutputType(self) -> type[Output]:
         """The type of the output of the Runnable."""
         return self.last.OutputType
@@ -3564,6 +3566,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
         return super().get_name(suffix, name=name)
 
     @property
+    @override
     def InputType(self) -> Any:
         """The type of the input to the Runnable."""
         for step in self.steps__.values():
@@ -4057,6 +4060,7 @@ class RunnableGenerator(Runnable[Input, Output]):
             self.name = "RunnableGenerator"
 
     @property
+    @override
     def InputType(self) -> Any:
         func = getattr(self, "_transform", None) or self._atransform
         try:
@@ -4097,6 +4101,7 @@ class RunnableGenerator(Runnable[Input, Output]):
         )
 
     @property
+    @override
     def OutputType(self) -> Any:
         func = getattr(self, "_transform", None) or self._atransform
         try:
@@ -4346,6 +4351,7 @@ class RunnableLambda(Runnable[Input, Output]):
             pass
 
     @property
+    @override
     def InputType(self) -> Any:
         """The type of the input to this Runnable."""
         func = getattr(self, "func", None) or self.afunc
@@ -4405,6 +4411,7 @@ class RunnableLambda(Runnable[Input, Output]):
         return super().get_input_schema(config)
 
     @property
+    @override
     def OutputType(self) -> Any:
         """The type of the output of this Runnable as a type annotation.
 
@@ -4958,6 +4965,7 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
     )
 
     @property
+    @override
     def InputType(self) -> Any:
         return list[self.bound.InputType]  # type: ignore[name-defined]
 
@@ -4981,6 +4989,7 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
         )
 
     @property
+    @override
     def OutputType(self) -> type[list[Output]]:
         return list[self.bound.OutputType]  # type: ignore[name-defined]
 
@@ -5274,6 +5283,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):
         return self.bound.get_name(suffix, name=name)
 
     @property
+    @override
     def InputType(self) -> type[Input]:
         return (
             cast(type[Input], self.custom_input_type)
@@ -5282,6 +5292,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):
         )
 
     @property
+    @override
     def OutputType(self) -> type[Output]:
         return (
             cast(type[Output], self.custom_output_type)

libs/core/langchain_core/runnables/config.py

@@ -8,15 +8,7 @@ from concurrent.futures import Executor, Future, ThreadPoolExecutor
 from contextlib import contextmanager
 from contextvars import ContextVar, copy_context
 from functools import partial
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union, cast
 
 from typing_extensions import ParamSpec, TypedDict
 
@@ -131,17 +123,29 @@ def _set_config_context(config: RunnableConfig) -> None:
     Args:
         config (RunnableConfig): The config to set.
     """
-    from langsmith import (
-        RunTree,  # type: ignore
-        run_helpers,  # type: ignore
-    )
+    from langchain_core.tracers.langchain import LangChainTracer
 
     var_child_runnable_config.set(config)
-    if hasattr(RunTree, "from_runnable_config"):
-        # import _set_tracing_context, get_tracing_context
-        rt = RunTree.from_runnable_config(dict(config))
-        tc = run_helpers.get_tracing_context()
-        run_helpers._set_tracing_context({**tc, "parent": rt})
+    if (
+        (callbacks := config.get("callbacks"))
+        and (
+            parent_run_id := getattr(callbacks, "parent_run_id", None)
+        )  # Is callback manager
+        and (
+            tracer := next(
+                (
+                    handler
+                    for handler in getattr(callbacks, "handlers", [])
+                    if isinstance(handler, LangChainTracer)
+                ),
+                None,
+            )
+        )
+    ):
+        if run := tracer.run_map.get(str(parent_run_id)):
+            from langsmith.run_helpers import _set_tracing_context
+
+            _set_tracing_context({"parent": run})
 
 
 def ensure_config(config: Optional[RunnableConfig] = None) -> RunnableConfig:

libs/core/langchain_core/runnables/configurable.py

@@ -16,6 +16,7 @@ from typing import (
 from weakref import WeakValueDictionary
 
 from pydantic import BaseModel, ConfigDict
+from typing_extensions import override
 
 from langchain_core.runnables.base import Runnable, RunnableSerializable
 from langchain_core.runnables.config import (
@@ -68,10 +69,12 @@ class DynamicRunnable(RunnableSerializable[Input, Output]):
         return ["langchain", "schema", "runnable"]
 
     @property
+    @override
     def InputType(self) -> type[Input]:
         return self.default.InputType
 
     @property
+    @override
     def OutputType(self) -> type[Output]:
         return self.default.OutputType
 

libs/core/langchain_core/runnables/fallbacks.py

@@ -13,6 +13,7 @@ from typing import (
 )
 
 from pydantic import BaseModel, ConfigDict
+from typing_extensions import override
 
 from langchain_core.runnables.base import Runnable, RunnableSerializable
 from langchain_core.runnables.config import (
@@ -106,10 +107,12 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     )
 
     @property
+    @override
     def InputType(self) -> type[Input]:
         return self.runnable.InputType
 
     @property
+    @override
     def OutputType(self) -> type[Output]:
         return self.runnable.OutputType
 

libs/core/langchain_core/runnables/graph_ascii.py

@@ -246,27 +246,27 @@ def draw_ascii(vertices: Mapping[str, str], edges: Sequence[LangEdge]) -> str:
 
     # NOTE: coordinates might me negative, so we need to shift
     # everything to the positive plane before we actually draw it.
-    Xs = []
-    Ys = []
+    xlist = []
+    ylist = []
 
     sug = _build_sugiyama_layout(vertices, edges)
 
     for vertex in sug.g.sV:
         # NOTE: moving boxes w/2 to the left
-        Xs.append(vertex.view.xy[0] - vertex.view.w / 2.0)
-        Xs.append(vertex.view.xy[0] + vertex.view.w / 2.0)
-        Ys.append(vertex.view.xy[1])
-        Ys.append(vertex.view.xy[1] + vertex.view.h)
+        xlist.append(vertex.view.xy[0] - vertex.view.w / 2.0)
+        xlist.append(vertex.view.xy[0] + vertex.view.w / 2.0)
+        ylist.append(vertex.view.xy[1])
+        ylist.append(vertex.view.xy[1] + vertex.view.h)
 
     for edge in sug.g.sE:
         for x, y in edge.view._pts:
-            Xs.append(x)
-            Ys.append(y)
+            xlist.append(x)
+            ylist.append(y)
 
-    minx = min(Xs)
-    miny = min(Ys)
-    maxx = max(Xs)
-    maxy = max(Ys)
+    minx = min(xlist)
+    miny = min(ylist)
+    maxx = max(xlist)
+    maxy = max(ylist)
 
     canvas_cols = int(math.ceil(math.ceil(maxx) - math.floor(minx))) + 1
     canvas_lines = int(round(maxy - miny))

libs/core/langchain_core/runnables/history.py

@@ -12,6 +12,7 @@ from typing import (
 )
 
 from pydantic import BaseModel
+from typing_extensions import override
 
 from langchain_core.chat_history import BaseChatMessageHistory
 from langchain_core.load.load import load
@@ -396,6 +397,7 @@ class RunnableWithMessageHistory(RunnableBindingBase):
         )
 
     @property
+    @override
     def OutputType(self) -> type[Output]:
         output_type = self._history_chain.OutputType
         return output_type

libs/core/langchain_core/runnables/passthrough.py

@@ -16,6 +16,7 @@ from typing import (
 )
 
 from pydantic import BaseModel, RootModel
+from typing_extensions import override
 
 from langchain_core.runnables.base import (
     Other,
@@ -193,10 +194,12 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
         return ["langchain", "schema", "runnable"]
 
     @property
+    @override
     def InputType(self) -> Any:
         return self.input_type or Any
 
     @property
+    @override
     def OutputType(self) -> Any:
         return self.input_type or Any
 

libs/core/langchain_core/runnables/utils.py

@@ -28,7 +28,7 @@ from typing import (
     Union,
 )
 
-from typing_extensions import TypeGuard
+from typing_extensions import TypeGuard, override
 
 from langchain_core.runnables.schema import StreamEvent
 
@@ -135,6 +135,7 @@ class IsLocalDict(ast.NodeVisitor):
         self.name = name
         self.keys = keys
 
+    @override
     def visit_Subscript(self, node: ast.Subscript) -> Any:
         """Visit a subscript node.
 
@@ -154,6 +155,7 @@ class IsLocalDict(ast.NodeVisitor):
             # we've found a subscript access on the name we're looking for
             self.keys.add(node.slice.value)
 
+    @override
     def visit_Call(self, node: ast.Call) -> Any:
         """Visit a call node.
 
@@ -182,6 +184,7 @@ class IsFunctionArgDict(ast.NodeVisitor):
     def __init__(self) -> None:
         self.keys: set[str] = set()
 
+    @override
     def visit_Lambda(self, node: ast.Lambda) -> Any:
         """Visit a lambda function.
 
@@ -196,6 +199,7 @@ class IsFunctionArgDict(ast.NodeVisitor):
         input_arg_name = node.args.args[0].arg
         IsLocalDict(input_arg_name, self.keys).visit(node.body)
 
+    @override
     def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
         """Visit a function definition.
 
@@ -210,6 +214,7 @@ class IsFunctionArgDict(ast.NodeVisitor):
         input_arg_name = node.args.args[0].arg
         IsLocalDict(input_arg_name, self.keys).visit(node)
 
+    @override
     def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:
         """Visit an async function definition.
 
@@ -232,6 +237,7 @@ class NonLocals(ast.NodeVisitor):
         self.loads: set[str] = set()
         self.stores: set[str] = set()
 
+    @override
     def visit_Name(self, node: ast.Name) -> Any:
         """Visit a name node.
 
@@ -246,6 +252,7 @@ class NonLocals(ast.NodeVisitor):
         elif isinstance(node.ctx, ast.Store):
             self.stores.add(node.id)
 
+    @override
     def visit_Attribute(self, node: ast.Attribute) -> Any:
         """Visit an attribute node.
 
@@ -272,6 +279,7 @@ class FunctionNonLocals(ast.NodeVisitor):
     def __init__(self) -> None:
         self.nonlocals: set[str] = set()
 
+    @override
     def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
         """Visit a function definition.
 
@@ -285,6 +293,7 @@ class FunctionNonLocals(ast.NodeVisitor):
         visitor.visit(node)
         self.nonlocals.update(visitor.loads - visitor.stores)
 
+    @override
     def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:
         """Visit an async function definition.
 
@@ -298,6 +307,7 @@ class FunctionNonLocals(ast.NodeVisitor):
         visitor.visit(node)
         self.nonlocals.update(visitor.loads - visitor.stores)
 
+    @override
     def visit_Lambda(self, node: ast.Lambda) -> Any:
         """Visit a lambda function.
 
@@ -320,6 +330,7 @@ class GetLambdaSource(ast.NodeVisitor):
         self.source: Optional[str] = None
         self.count = 0
 
+    @override
     def visit_Lambda(self, node: ast.Lambda) -> Any:
         """Visit a lambda function.
 

libs/core/langchain_core/tools/base.py

@@ -311,7 +311,7 @@ def create_schema_from_function(
     )
 
 
-class ToolException(Exception):
+class ToolException(Exception):  # noqa: N818
     """Optional exception that tool throws when execution error occurs.
 
     When this exception is thrown, the agent will not stop working,

libs/core/langchain_core/tracers/event_stream.py

@@ -994,6 +994,10 @@ async def _astream_events_implementation_v2(
                     del event["data"]["input"]
 
             yield event
+    except asyncio.CancelledError as exc:
+        # Cancel the task if it's still running
+        task.cancel(exc.args[0] if exc.args else None)
+        raise
     finally:
         # Cancel the task if it's still running
         task.cancel()

libs/core/langchain_core/tracers/langchain.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import copy
 import logging
 import warnings
 from concurrent.futures import ThreadPoolExecutor
@@ -10,6 +11,7 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 from uuid import UUID
 
 from langsmith import Client
+from langsmith import run_trees as rt
 from langsmith import utils as ls_utils
 from pydantic import PydanticDeprecationWarning
 from tenacity import (
@@ -21,6 +23,7 @@ from tenacity import (
 
 from langchain_core.env import get_runtime_environment
 from langchain_core.load import dumpd
+from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
 from langchain_core.tracers.base import BaseTracer
 from langchain_core.tracers.schemas import Run
 
@@ -29,7 +32,6 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 _LOGGED = set()
-_CLIENT: Optional[Client] = None
 _EXECUTOR: Optional[ThreadPoolExecutor] = None
 
 
@@ -49,17 +51,13 @@ def log_error_once(method: str, exception: Exception) -> None:
 
 def wait_for_all_tracers() -> None:
     """Wait for all tracers to finish."""
-    global _CLIENT
-    if _CLIENT is not None and _CLIENT.tracing_queue is not None:
-        _CLIENT.tracing_queue.join()
+    if rt._CLIENT is not None and rt._CLIENT.tracing_queue is not None:
+        rt._CLIENT.tracing_queue.join()
 
 
 def get_client() -> Client:
     """Get the client."""
-    global _CLIENT
-    if _CLIENT is None:
-        _CLIENT = Client()
-    return _CLIENT
+    return rt.get_cached_client()
 
 
 def _get_executor() -> ThreadPoolExecutor:
@@ -112,6 +110,19 @@ class LangChainTracer(BaseTracer):
         self.tags = tags or []
         self.latest_run: Optional[Run] = None
 
+    def _start_trace(self, run: Run) -> None:
+        if self.project_name:
+            run.session_name = self.project_name
+        if self.tags is not None:
+            if run.tags:
+                run.tags = sorted(set(run.tags + self.tags))
+            else:
+                run.tags = self.tags.copy()
+
+        super()._start_trace(run)
+        if run._client is None:
+            run._client = self.client
+
     def on_chat_model_start(
         self,
         serialized: dict[str, Any],
@@ -163,8 +174,7 @@ class LangChainTracer(BaseTracer):
         # run.model_copy
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", category=PydanticDeprecationWarning)
-
-            run_ = run.copy()
+            run_ = copy.copy(run)
         run_.reference_example_id = self.example_id
         self.latest_run = run_
 
@@ -231,6 +241,26 @@ class LangChainTracer(BaseTracer):
             run.reference_example_id = self.example_id
         self._persist_run_single(run)
 
+    def _llm_run_with_token_event(
+        self,
+        token: str,
+        run_id: UUID,
+        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Run:
+        """
+        Append token event to LLM run and return the run.
+        """
+        return super()._llm_run_with_token_event(
+            # Drop the chunk; we don't need to save it
+            token,
+            run_id,
+            chunk=None,
+            parent_run_id=parent_run_id,
+            **kwargs,
+        )
+
     def _on_chat_model_start(self, run: Run) -> None:
         """Persist an LLM run."""
         if run.parent_run_id is None:

libs/core/langchain_core/tracers/langchain_v1.py

@@ -9,7 +9,7 @@ def get_headers(*args: Any, **kwargs: Any) -> Any:
     )
 
 
-def LangChainTracerV1(*args: Any, **kwargs: Any) -> Any:
+def LangChainTracerV1(*args: Any, **kwargs: Any) -> Any:  # noqa: N802
     """Throw an error because this has been replaced by LangChainTracer."""
     raise RuntimeError(
         "LangChainTracerV1 is no longer supported. Please use LangChainTracer instead."

libs/core/langchain_core/tracers/schemas.py

@@ -7,18 +7,17 @@ import warnings
 from typing import Any, Optional
 from uuid import UUID
 
-from langsmith.schemas import RunBase as BaseRunV2
+from langsmith import RunTree
 from langsmith.schemas import RunTypeEnum as RunTypeEnumDep
 from pydantic import PydanticDeprecationWarning
 from pydantic.v1 import BaseModel as BaseModelV1
 from pydantic.v1 import Field as FieldV1
-from pydantic.v1 import root_validator
 
 from langchain_core._api import deprecated
 
 
 @deprecated("0.1.0", alternative="Use string instead.", removal="1.0")
-def RunTypeEnum() -> type[RunTypeEnumDep]:
+def RunTypeEnum() -> type[RunTypeEnumDep]:  # noqa: N802
     """RunTypeEnum."""
     warnings.warn(
         "RunTypeEnum is deprecated. Please directly use a string instead"
@@ -115,37 +114,7 @@ class ToolRun(BaseRun):
 # Begin V2 API Schemas
 
 
-class Run(BaseRunV2):
-    """Run schema for the V2 API in the Tracer.
-
-    Parameters:
-        child_runs: The child runs.
-        tags: The tags. Default is an empty list.
-        events: The events. Default is an empty list.
-        trace_id: The trace ID. Default is None.
-        dotted_order: The dotted order.
-    """
-
-    child_runs: list[Run] = FieldV1(default_factory=list)
-    tags: Optional[list[str]] = FieldV1(default_factory=list)
-    events: list[dict[str, Any]] = FieldV1(default_factory=list)
-    trace_id: Optional[UUID] = None
-    dotted_order: Optional[str] = None
-
-    @root_validator(pre=True)
-    def assign_name(cls, values: dict) -> dict:
-        """Assign name to the run."""
-        if values.get("name") is None and values["serialized"] is not None:
-            if "name" in values["serialized"]:
-                values["name"] = values["serialized"]["name"]
-            elif "id" in values["serialized"]:
-                values["name"] = values["serialized"]["id"][-1]
-        if values.get("name") is None:
-            values["name"] = "Unnamed"
-        if values.get("events") is None:
-            values["events"] = []
-        return values
-
+Run = RunTree  # For backwards compatibility
 
 # TODO: Update once langsmith moves to Pydantic V2 and we can swap Run.model_rebuild
 # for Run.update_forward_refs
@@ -154,7 +123,6 @@ with warnings.catch_warnings():
 
     ChainRun.update_forward_refs()
     ToolRun.update_forward_refs()
-    Run.update_forward_refs()
 
 __all__ = [
     "BaseRun",

libs/core/langchain_core/utils/aiter.py

@@ -235,7 +235,7 @@ class Tee(Generic[T]):
 atee = Tee
 
 
-class aclosing(AbstractAsyncContextManager):
+class aclosing(AbstractAsyncContextManager):  # noqa: N801
     """Async context manager for safely finalizing an asynchronously cleaned-up
     resource such as an async generator, calling its ``aclose()`` method.