revamp memory

- **Description:** The Github error prompt is confused because of JWT
enctrypt to somebody not familiar with Github connection method. This PR
is to add some useful error prompt to help users troubleshooting.
- **Issue:**
https://github.com/langchain-ai/langchain/issues/14550#issuecomment-1867445049
  - **Dependencies:** None,
  - **Twitter handle:** None

.github/CONTRIBUTING.md

@@ -42,4 +42,4 @@ we do not want these to get in the way of getting good code into the codebase.
 
 ### Contributor Documentation
 
-To learn about how to contribute, please follow the [guides here](https://python.langchain.com/docs/contributing/)
+To learn about how to contribute, please follow the [guides here](https://python.langchain.com/docs/contributing/)

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,20 +1,20 @@
 <!-- Thank you for contributing to LangChain!
 
+Please title your PR "<package>: <description>", where <package> is whichever of langchain, community, core, experimental, etc. is being modified.
+
 Replace this entire comment with:
   - **Description:** a description of the change, 
-  - **Issue:** the issue # it fixes (if applicable),
+  - **Issue:** the issue # it fixes if applicable,
   - **Dependencies:** any dependencies required for this change,
-  - **Tag maintainer:** for a quicker response, tag the relevant maintainer (see below),
   - **Twitter handle:** we announce bigger features on Twitter. If your PR gets announced, and you'd like a mention, we'll gladly shout you out!
 
-Please make sure your PR is passing linting and testing before submitting. Run `make format`, `make lint` and `make test` to check this locally.
+Please make sure your PR is passing linting and testing before submitting. Run `make format`, `make lint` and `make test` from the root of the package you've modified to check this locally.
 
-See contribution guidelines for more information on how to write/run tests, lint, etc: 
-https://python.langchain.com/docs/contributing/
+See contribution guidelines for more information on how to write/run tests, lint, etc: https://python.langchain.com/docs/contributing/
 
 If you're adding a new integration, please include:
   1. a test for the integration, preferably unit tests that do not rely on network access,
-  2. an example notebook showing its use. It lives in `docs/extras` directory.
+  2. an example notebook showing its use. It lives in `docs/docs/integrations` directory.
 
 If no one reviews your PR within a few days, please @-mention one of @baskaryan, @eyurtsev, @hwchase17.
  -->

.readthedocs.yaml

@@ -13,8 +13,8 @@ build:
       - python -mvirtualenv $READTHEDOCS_VIRTUALENV_PATH
       - python -m pip install --upgrade --no-cache-dir pip setuptools
       - python -m pip install --upgrade --no-cache-dir sphinx readthedocs-sphinx-ext
-      - python -m pip install --exists-action=w --no-cache-dir -r docs/api_reference/requirements.txt
       - python -m pip install ./libs/partners/*
+      - python -m pip install --exists-action=w --no-cache-dir -r docs/api_reference/requirements.txt
       - python docs/api_reference/create_api_rst.py
       - cat docs/api_reference/conf.py
       - python -m sphinx -T -E -b html -d _build/doctrees -c docs/api_reference docs/api_reference $READTHEDOCS_OUTPUT/html -j auto

README.md

@@ -95,7 +95,7 @@ Agents involve an LLM making decisions about which Actions to take, taking that
 Please see [here](https://python.langchain.com) for full documentation, which includes:
 
 - [Getting started](https://python.langchain.com/docs/get_started/introduction): installation, setting up the environment, simple examples
-- Overview of the [interfaces](https://python.langchain.com/docs/expression_language/), [modules](https://python.langchain.com/docs/modules/) and [integrations](https://python.langchain.com/docs/integrations/providers)
+- Overview of the [interfaces](https://python.langchain.com/docs/expression_language/), [modules](https://python.langchain.com/docs/modules/), and [integrations](https://python.langchain.com/docs/integrations/providers)
 - [Use case](https://python.langchain.com/docs/use_cases/qa_structured/sql) walkthroughs and best practice [guides](https://python.langchain.com/docs/guides/adapters/openai)
 - [LangSmith](https://python.langchain.com/docs/langsmith/), [LangServe](https://python.langchain.com/docs/langserve), and [LangChain Template](https://python.langchain.com/docs/templates/) overviews
 - [Reference](https://api.python.langchain.com): full API docs

cookbook/Multi_modal_RAG.ipynb

@@ -46,7 +46,7 @@
     "\n",
     "---\n",
     "\n",
-    "A seperate cookbook highlights `Option 1` [here](https://github.com/langchain-ai/langchain/blob/master/cookbook/multi_modal_RAG_chroma.ipynb).\n",
+    "A separate cookbook highlights `Option 1` [here](https://github.com/langchain-ai/langchain/blob/master/cookbook/multi_modal_RAG_chroma.ipynb).\n",
     "\n",
     "And option `Option 2` is appropriate for cases when a multi-modal LLM cannot be used for answer synthesis (e.g., cost, etc).\n",
     "\n",

docs/docs/additional_resources/tutorials.mdx

@@ -6,7 +6,12 @@ Below are links to tutorials and courses on LangChain. For written guides on com
 
 ---------------------
 
-### [LangChain on Wikipedia](https://en.wikipedia.org/wiki/LangChain)
+### [LangChain](https://en.wikipedia.org/wiki/LangChain) on Wikipedia
+
+### Books
+
+#### ⛓[Generative AI with LangChain](https://www.amazon.com/Generative-AI-LangChain-language-ChatGPT/dp/1835083463/ref=sr_1_1?crid=1GMOMH0G7GLR&keywords=generative+ai+with+langchain&qid=1703247181&sprefix=%2Caps%2C298&sr=8-1) by [Ben Auffrath](https://www.amazon.com/stores/Ben-Auffarth/author/B08JQKSZ7D?ref=ap_rdr&store_ref=ap_rdr&isDramIntegrated=true&shoppingPortalEnabled=true), ©️ 2023 Packt Publishing
+
 
 ### DeepLearning.AI courses
  by [Harrison Chase](https://en.wikipedia.org/wiki/LangChain) and [Andrew Ng](https://en.wikipedia.org/wiki/Andrew_Ng)

docs/docs/contributing/index.mdx

@@ -14,7 +14,7 @@ There are many ways to contribute to LangChain. Here are some common ways people
 
 - [**Documentation**](./documentation): Help improve our docs, including this one!
 - [**Code**](./code): Help us write code, fix bugs, or improve our infrastructure.
-- [**Integrations**](./integration): Help us integrate with your favorite vendors and tools.
+- [**Integrations**](./integrations): Help us integrate with your favorite vendors and tools.
 
 ### 🚩GitHub Issues
 

docs/docs/expression_language/cookbook/sql_db.ipynb

@@ -152,8 +152,7 @@
    "outputs": [],
    "source": [
     "full_chain = (\n",
-    "    RunnablePassthrough.assign(query=sql_response)\n",
-    "    | RunnablePassthrough.assign(\n",
+    "    RunnablePassthrough.assign(query=sql_response).assign(\n",
     "        schema=get_schema,\n",
     "        response=lambda x: db.run(x[\"query\"]),\n",
     "    )\n",

docs/docs/get_started/quickstart.mdx

@@ -154,7 +154,7 @@ chat_model.invoke(messages)
 <details> <summary>Go deeper</summary>
 
 `LLM.invoke` and `ChatModel.invoke` actually both support as input any of `Union[str, List[BaseMessage], PromptValue]`.
-`PromptValue` is an object that defines it's own custom logic for returning it's inputs either as a string or as messages.
+`PromptValue` is an object that defines its own custom logic for returning its inputs either as a string or as messages.
 `LLM`s have logic for coercing any of these into a string, and `ChatModel`s have logic for coercing any of these to messages.
 The fact that `LLM` and `ChatModel` accept the same inputs means that you can directly swap them for one another in most chains without breaking anything,
 though it's of course important to think about how inputs are being coerced and how that may affect model performance.
@@ -166,7 +166,7 @@ To dive deeper on models head to the [Language models](/docs/modules/model_io/mo
 
 Most LLM applications do not pass user input directly into an LLM. Usually they will add the user input to a larger piece of text, called a prompt template, that provides additional context on the specific task at hand.
 
-In the previous example, the text we passed to the model contained instructions to generate a company name. For our application, it would be great if the user only had to provide the description of a company/product, without having to worry about giving the model instructions.
+In the previous example, the text we passed to the model contained instructions to generate a company name. For our application, it would be great if the user only had to provide the description of a company/product without worrying about giving the model instructions.
 
 PromptTemplates help with exactly this!
 They bundle up all the logic for going from user input into a fully formatted prompt.
@@ -220,8 +220,8 @@ ChatPromptTemplates can also be constructed in other ways - see the [section on
 
 ### Output parsers
 
-`OutputParsers` convert the raw output of a language model into a format that can be used downstream.
-There are few main types of `OutputParser`s, including:
+`OutputParser`s convert the raw output of a language model into a format that can be used downstream.
+There are a few main types of `OutputParser`s, including:
 
 - Convert text from `LLM` into structured information (e.g. JSON)
 - Convert a `ChatMessage` into just a string

docs/docs/integrations/chat/alibaba_cloud_pai_eas.ipynb

@@ -5,7 +5,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "sidebar_label: AliCloud PAI EAS\n",
+    "sidebar_label: Alibaba Cloud PAI EAS\n",
     "---"
    ]
   },
@@ -13,23 +13,29 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# PaiEasChatEndpoint\n",
-    "Machine Learning Platform for AI of Alibaba Cloud is a machine learning or deep learning engineering platform intended for enterprises and developers. It provides easy-to-use, cost-effective, high-performance, and easy-to-scale plug-ins that can be applied to various industry scenarios. With over 140 built-in optimization algorithms, Machine Learning Platform for AI provides whole-process AI engineering capabilities including data labeling (PAI-iTAG), model building (PAI-Designer and PAI-DSW), model training (PAI-DLC), compilation optimization, and inference deployment (PAI-EAS). PAI-EAS supports different types of hardware resources, including CPUs and GPUs, and features high throughput and low latency. It allows you to deploy large-scale complex models with a few clicks and perform elastic scale-ins and scale-outs in real time. It also provides a comprehensive O&M and monitoring system."
+    "# Alibaba Cloud PAI EAS\n",
+    "\n",
+    ">[Alibaba Cloud PAI (Platform for AI)](https://www.alibabacloud.com/help/en/pai/?spm=a2c63.p38356.0.0.c26a426ckrxUwZ) is a lightweight and cost-efficient machine learning platform that uses cloud-native technologies. It provides you with an end-to-end modelling service. It accelerates model training based on tens of billions of features and hundreds of billions of samples in more than 100 scenarios.\n",
+    "\n",
+    ">[Machine Learning Platform for AI of Alibaba Cloud](https://www.alibabacloud.com/help/en/machine-learning-platform-for-ai/latest/what-is-machine-learning-pai) is a machine learning or deep learning engineering platform intended for enterprises and developers. It provides easy-to-use, cost-effective, high-performance, and easy-to-scale plug-ins that can be applied to various industry scenarios. With over 140 built-in optimization algorithms, `Machine Learning Platform for AI` provides whole-process AI engineering capabilities including data labelling (`PAI-iTAG`), model building (`PAI-Designer` and `PAI-DSW`), model training (`PAI-DLC`), compilation optimization, and inference deployment (`PAI-EAS`).\n",
+    ">\n",
+    ">`PAI-EAS` supports different types of hardware resources, including CPUs and GPUs, and features high throughput and low latency. It allows you to deploy large-scale complex models with a few clicks and perform elastic scale-ins and scale-outs in real-time. It also provides a comprehensive O&M and monitoring system."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Setup Eas Service\n",
+    "## Setup EAS Service\n",
     "\n",
-    "One who want to use eas llms must set up eas service first. When the eas service is launched, eas_service_rul and eas_service token can be got. Users can refer to https://www.alibabacloud.com/help/en/pai/user-guide/service-deployment/ for more information. Try to set environment variables to init eas service url and token:\n",
+    "Set up environment variables to init EAS service URL and token.\n",
+    "Use [this document](https://www.alibabacloud.com/help/en/pai/user-guide/service-deployment/) for more information.\n",
     "\n",
-    "```base\n",
+    "```bash\n",
     "export EAS_SERVICE_URL=XXX\n",
     "export EAS_SERVICE_TOKEN=XXX\n",
     "```\n",
-    "or run as follow codes:"
+    "Another option is to use this code:"
    ]
   },
   {
@@ -56,7 +62,8 @@
    "metadata": {},
    "source": [
     "## Run Chat Model\n",
-    "You can use the default settings to call eas service as follows:"
+    "\n",
+    "You can use the default settings to call EAS service as follows:"
    ]
   },
   {
@@ -73,7 +80,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Or, call eas service with new inference params:"
+    "Or, call EAS service with new inference params:"
    ]
   },
   {
@@ -108,7 +115,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -122,10 +129,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  },
-  "orig_nbformat": 4
+   "version": "3.10.12"
+  }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

docs/docs/integrations/chat/huggingface.ipynb

@@ -0,0 +1,456 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Hugging Face Chat Wrapper\n",
+    "\n",
+    "This notebook shows how to get started using Hugging Face LLM's as chat models.\n",
+    "\n",
+    "In particular, we will:\n",
+    "1. Utilize the [HuggingFaceTextGenInference](https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/llms/huggingface_text_gen_inference.py), [HuggingFaceEndpoint](https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/llms/huggingface_endpoint.py), or [HuggingFaceHub](https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/llms/huggingface_hub.py) integrations to instantiate an `LLM`.\n",
+    "2. Utilize the `ChatHuggingFace` class to enable any of these LLMs to interface with LangChain's [Chat Messages](https://python.langchain.com/docs/modules/model_io/chat/#messages) abstraction.\n",
+    "3. Demonstrate how to use an open-source LLM to power an `ChatAgent` pipeline\n",
+    "\n",
+    "\n",
+    "> Note: To get started, you'll need to have a [Hugging Face Access Token](https://huggingface.co/docs/hub/security-tokens) saved as an environment variable: `HUGGINGFACEHUB_API_TOKEN`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "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.1 is available.\n",
+      "You should consider upgrading via the '/Users/jacoblee/langchain/langchain/libs/langchain/.venv/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"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install -q text-generation transformers google-search-results numexpr langchainhub sentencepiece jinja2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Instantiate an LLM\n",
+    "\n",
+    "There are three LLM options to choose from."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `HuggingFaceTextGenInference`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/jacoblee/langchain/langchain/libs/langchain/.venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "from langchain_community.llms import HuggingFaceTextGenInference\n",
+    "\n",
+    "ENDPOINT_URL = \"<YOUR_ENDPOINT_URL_HERE>\"\n",
+    "HF_TOKEN = os.getenv(\"HUGGINGFACEHUB_API_TOKEN\")\n",
+    "\n",
+    "llm = HuggingFaceTextGenInference(\n",
+    "    inference_server_url=ENDPOINT_URL,\n",
+    "    max_new_tokens=512,\n",
+    "    top_k=50,\n",
+    "    temperature=0.1,\n",
+    "    repetition_penalty=1.03,\n",
+    "    server_kwargs={\n",
+    "        \"headers\": {\n",
+    "            \"Authorization\": f\"Bearer {HF_TOKEN}\",\n",
+    "            \"Content-Type\": \"application/json\",\n",
+    "        }\n",
+    "    },\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `HuggingFaceEndpoint`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.llms import HuggingFaceEndpoint\n",
+    "\n",
+    "ENDPOINT_URL = \"<YOUR_ENDPOINT_URL_HERE>\"\n",
+    "llm = HuggingFaceEndpoint(\n",
+    "    endpoint_url=ENDPOINT_URL,\n",
+    "    task=\"text-generation\",\n",
+    "    model_kwargs={\n",
+    "        \"max_new_tokens\": 512,\n",
+    "        \"top_k\": 50,\n",
+    "        \"temperature\": 0.1,\n",
+    "        \"repetition_penalty\": 1.03,\n",
+    "    },\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `HuggingFaceHub`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/jacoblee/langchain/langchain/libs/langchain/.venv/lib/python3.10/site-packages/huggingface_hub/utils/_deprecation.py:127: FutureWarning: '__init__' (from 'huggingface_hub.inference_api') is deprecated and will be removed from version '1.0'. `InferenceApi` client is deprecated in favor of the more feature-complete `InferenceClient`. Check out this guide to learn how to convert your script to use it: https://huggingface.co/docs/huggingface_hub/guides/inference#legacy-inferenceapi-client.\n",
+      "  warnings.warn(warning_message, FutureWarning)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_community.llms import HuggingFaceHub\n",
+    "\n",
+    "llm = HuggingFaceHub(\n",
+    "    repo_id=\"HuggingFaceH4/zephyr-7b-beta\",\n",
+    "    task=\"text-generation\",\n",
+    "    model_kwargs={\n",
+    "        \"max_new_tokens\": 512,\n",
+    "        \"top_k\": 30,\n",
+    "        \"temperature\": 0.1,\n",
+    "        \"repetition_penalty\": 1.03,\n",
+    "    },\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Instantiate the `ChatHuggingFace` to apply chat templates"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Instantiate the chat model and some messages to pass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING! repo_id is not default parameter.\n",
+      "                    repo_id was transferred to model_kwargs.\n",
+      "                    Please confirm that repo_id is what you intended.\n",
+      "WARNING! task is not default parameter.\n",
+      "                    task was transferred to model_kwargs.\n",
+      "                    Please confirm that task is what you intended.\n",
+      "WARNING! huggingfacehub_api_token is not default parameter.\n",
+      "                    huggingfacehub_api_token was transferred to model_kwargs.\n",
+      "                    Please confirm that huggingfacehub_api_token is what you intended.\n",
+      "None of PyTorch, TensorFlow >= 2.0, or Flax have been found. Models won't be available and only tokenizers, configuration and file/data utilities can be used.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.schema import (\n",
+    "    HumanMessage,\n",
+    "    SystemMessage,\n",
+    ")\n",
+    "from langchain_community.chat_models.huggingface import ChatHuggingFace\n",
+    "\n",
+    "messages = [\n",
+    "    SystemMessage(content=\"You're a helpful assistant\"),\n",
+    "    HumanMessage(\n",
+    "        content=\"What happens when an unstoppable force meets an immovable object?\"\n",
+    "    ),\n",
+    "]\n",
+    "\n",
+    "chat_model = ChatHuggingFace(llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Inspect which model and corresponding chat template is being used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'HuggingFaceH4/zephyr-7b-beta'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chat_model.model_id"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Inspect how the chat messages are formatted for the LLM call."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"<|system|>\\nYou're a helpful assistant</s>\\n<|user|>\\nWhat happens when an unstoppable force meets an immovable object?</s>\\n<|assistant|>\\n\""
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chat_model._to_chat_prompt(messages)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Call the model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "According to a popular philosophical paradox, when an unstoppable force meets an immovable object, it is impossible to determine which one will prevail because both are defined as being completely unyielding and unmovable. The paradox suggests that the very concepts of \"unstoppable force\" and \"immovable object\" are inherently contradictory, and therefore, it is illogical to imagine a scenario where they would meet and interact. However, in practical terms, it is highly unlikely for such a scenario to occur in the real world, as the concepts of \"unstoppable force\" and \"immovable object\" are often used metaphorically to describe hypothetical situations or abstract concepts, rather than physical objects or forces.\n"
+     ]
+    }
+   ],
+   "source": [
+    "res = chat_model.invoke(messages)\n",
+    "print(res.content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Take it for a spin as an agent!\n",
+    "\n",
+    "Here we'll test out `Zephyr-7B-beta` as a zero-shot ReAct Agent. The example below is taken from [here](https://python.langchain.com/docs/modules/agents/agent_types/react#using-chat-models).\n",
+    "\n",
+    "> Note: To run this section, you'll need to have a [SerpAPI Token](https://serpapi.com/) saved as an environment variable: `SERPAPI_API_KEY`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import hub\n",
+    "from langchain.agents import AgentExecutor, load_tools\n",
+    "from langchain.agents.format_scratchpad import format_log_to_str\n",
+    "from langchain.agents.output_parsers import (\n",
+    "    ReActJsonSingleInputOutputParser,\n",
+    ")\n",
+    "from langchain.tools.render import render_text_description\n",
+    "from langchain.utilities import SerpAPIWrapper"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Configure the agent with a `react-json` style prompt and access to a search engine and calculator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# setup tools\n",
+    "tools = load_tools([\"serpapi\", \"llm-math\"], llm=llm)\n",
+    "\n",
+    "# setup ReAct style prompt\n",
+    "prompt = hub.pull(\"hwchase17/react-json\")\n",
+    "prompt = prompt.partial(\n",
+    "    tools=render_text_description(tools),\n",
+    "    tool_names=\", \".join([t.name for t in tools]),\n",
+    ")\n",
+    "\n",
+    "# define the agent\n",
+    "chat_model_with_stop = chat_model.bind(stop=[\"\\nObservation\"])\n",
+    "agent = (\n",
+    "    {\n",
+    "        \"input\": lambda x: x[\"input\"],\n",
+    "        \"agent_scratchpad\": lambda x: format_log_to_str(x[\"intermediate_steps\"]),\n",
+    "    }\n",
+    "    | prompt\n",
+    "    | chat_model_with_stop\n",
+    "    | ReActJsonSingleInputOutputParser()\n",
+    ")\n",
+    "\n",
+    "# instantiate AgentExecutor\n",
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mQuestion: Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\n",
+      "\n",
+      "Thought: I need to use the Search tool to find out who Leo DiCaprio's current girlfriend is. Then, I can use the Calculator tool to raise her current age to the power of 0.43.\n",
+      "\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"Search\",\n",
+      "  \"action_input\": \"leo dicaprio girlfriend\"\n",
+      "}\n",
+      "```\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3mLeonardo DiCaprio may have found The One in Vittoria Ceretti. “They are in love,” a source exclusively reveals in the latest issue of Us Weekly. “Leo was clearly very proud to be showing Vittoria off and letting everyone see how happy they are together.”\u001b[0m\u001b[32;1m\u001b[1;3mNow that we know Leo DiCaprio's current girlfriend is Vittoria Ceretti, let's find out her current age.\n",
+      "\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"Search\",\n",
+      "  \"action_input\": \"vittoria ceretti age\"\n",
+      "}\n",
+      "```\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3m25 years\u001b[0m\u001b[32;1m\u001b[1;3mNow that we know Vittoria Ceretti's current age is 25, let's use the Calculator tool to raise it to the power of 0.43.\n",
+      "\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"Calculator\",\n",
+      "  \"action_input\": \"25^0.43\"\n",
+      "}\n",
+      "```\n",
+      "\u001b[0m\u001b[33;1m\u001b[1;3mAnswer: 3.991298452658078\u001b[0m\u001b[32;1m\u001b[1;3mFinal Answer: Vittoria Ceretti, Leo DiCaprio's current girlfriend, when raised to the power of 0.43 is approximately 4.0 rounded to two decimal places. Her current age is 25 years old.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'input': \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\",\n",
+       " 'output': \"Vittoria Ceretti, Leo DiCaprio's current girlfriend, when raised to the power of 0.43 is approximately 4.0 rounded to two decimal places. Her current age is 25 years old.\"}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke(\n",
+    "    {\n",
+    "        \"input\": \"Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?\"\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Wahoo! Our open-source 7b parameter Zephyr model was able to:\n",
+    "\n",
+    "1. Plan out a series of actions: `I need to use the Search tool to find out who Leo DiCaprio's current girlfriend is. Then, I can use the Calculator tool to raise her current age to the power of 0.43.`\n",
+    "2. Then execute a search using the SerpAPI tool to find who Leo DiCaprio's current girlfriend is\n",
+    "3. Execute another search to find her age\n",
+    "4. And finally use a calculator tool to calculate her age raised to the power of 0.43\n",
+    "\n",
+    "It's exciting to see how far open-source LLM's can go as general purpose reasoning agents. Give it a try yourself!"
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/docs/integrations/document_loaders/azure_document_intelligence.ipynb

@@ -5,7 +5,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Azure Document Intelligence"
+    "# Azure AI Document Intelligence"
    ]
   },
   {
@@ -13,7 +13,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Azure Document Intelligence (formerly known as Azure Forms Recognizer) is machine-learning \n",
+    "Azure AI Document Intelligence (formerly known as Azure Form Recognizer) is machine-learning \n",
     "based service that extracts text (including handwriting), tables or key-value-pairs from\n",
     "scanned documents or images.\n",
     "\n",
@@ -21,7 +21,7 @@
     "\n",
     "Document Intelligence supports PDF, JPEG, PNG, BMP, or TIFF.\n",
     "\n",
-    "Further documentation is available at https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/?view=doc-intel-3.1.0.\n"
+    "Further documentation is available at https://aka.ms/doc-intelligence.\n"
    ]
   },
   {
@@ -30,7 +30,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install langchain azure-ai-formrecognizer -q"
+    "%pip install langchain langchain-community azure-ai-documentintelligence -q"
    ]
   },
   {
@@ -46,23 +46,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The first example uses a local file which will be sent to Azure Document Intelligence.\n",
-    "\n",
-    "First, an instance of a DocumentAnalysisClient is created with endpoint and key for the Azure service.    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from azure.ai.formrecognizer import DocumentAnalysisClient\n",
-    "from azure.core.credentials import AzureKeyCredential\n",
-    "\n",
-    "document_analysis_client = DocumentAnalysisClient(\n",
-    "    endpoint=\"<service_endpoint>\", credential=AzureKeyCredential(\"<service_key>\")\n",
-    ")"
+    "The first example uses a local file which will be sent to Azure AI Document Intelligence."
    ]
   },
   {
@@ -75,15 +59,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.document_loaders.pdf import DocumentIntelligenceLoader\n",
+    "from langchain_community.document_loaders import AzureAIDocumentIntelligenceLoader\n",
     "\n",
-    "loader = DocumentIntelligenceLoader(\n",
-    "    \"<Local_filename>\", client=document_analysis_client, model=\"<model_name>\"\n",
-    ")  # e.g. prebuilt-document\n",
+    "file_path = \"<filepath>\"\n",
+    "endpoint = \"<endpoint>\"\n",
+    "key = \"<key>\"\n",
+    "loader = AzureAIDocumentIntelligenceLoader(\n",
+    "    api_endpoint=endpoint, api_key=key, file_path=file_path, api_model=\"prebuilt-layout\"\n",
+    ")\n",
     "\n",
     "documents = loader.load()"
    ]
@@ -93,25 +80,45 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The output contains each page of the source document as a LangChain document: "
+    "The default output contains one LangChain document with markdown format content: "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='...', metadata={'source': '...', 'page': 1})]"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
+   "source": [
+    "documents"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example 2\n",
+    "The input file can also be URL path."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "url_path = \"<url>\"\n",
+    "loader = AzureAIDocumentIntelligenceLoader(\n",
+    "    api_endpoint=endpoint, api_key=key, url_path=url_path, api_model=\"prebuilt-layout\"\n",
+    ")\n",
+    "\n",
+    "documents = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "documents"
    ]
@@ -124,8 +131,16 @@
    "name": "python3"
   },
   "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
    "name": "python",
-   "version": "3.9.5"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
   },
   "vscode": {
    "interpreter": {

docs/docs/integrations/document_loaders/youtube_transcript.ipynb

@@ -43,7 +43,7 @@
    "outputs": [],
    "source": [
     "loader = YoutubeLoader.from_youtube_url(\n",
-    "    \"https://www.youtube.com/watch?v=QsYGlZkevEg\", add_video_info=True\n",
+    "    \"https://www.youtube.com/watch?v=QsYGlZkevEg\", add_video_info=False\n",
     ")"
    ]
   },

docs/docs/integrations/document_transformers/doctran_extract_properties.ipynb

@@ -202,7 +202,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "extracted_document = await property_extractor.atransform_documents(\n",
+    "extracted_document = property_extractor.transform_documents(\n",
     "    documents, properties=properties\n",
     ")"
    ]
@@ -224,10 +224,9 @@
       "      \"Jane Smith\",\n",
       "      \"Michael Johnson\",\n",
       "      \"Sarah Thompson\",\n",
-      "      \"David Rodriguez\",\n",
-      "      \"Jason Fan\"\n",
+      "      \"David Rodriguez\"\n",
       "    ],\n",
-      "    \"eli5\": \"This is an email from the CEO, Jason Fan, giving updates about different areas in the company. He talks about new security measures and praises John Doe for his work. He also mentions new hires and praises Jane Smith for her work in customer service. The CEO reminds everyone about the upcoming benefits enrollment and says to contact Michael Johnson with any questions. He talks about the marketing team's work and praises Sarah Thompson for increasing their social media followers. There's also a product launch event on July 15th. Lastly, he talks about the research and development projects and praises David Rodriguez for his work. There's a brainstorming session on July 10th.\"\n",
+      "    \"eli5\": \"This email provides important updates and discussions on various topics. It mentions the implementation of security and privacy measures, HR updates and employee benefits, marketing initiatives and campaigns, and research and development projects. It recognizes the contributions of John Doe, Jane Smith, Michael Johnson, Sarah Thompson, and David Rodriguez. It also reminds everyone to adhere to data protection policies, enroll in the employee benefits program, attend the upcoming product launch event, and share ideas for new projects during the R&D brainstorming session.\"\n",
       "  }\n",
       "}\n"
      ]
@@ -261,7 +260,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/docs/integrations/document_transformers/doctran_interrogate_document.ipynb

@@ -158,7 +158,7 @@
    "source": [
     "documents = [Document(page_content=sample_text)]\n",
     "qa_transformer = DoctranQATransformer()\n",
-    "transformed_document = await qa_transformer.atransform_documents(documents)"
+    "transformed_document = qa_transformer.transform_documents(documents)"
    ]
   },
   {
@@ -185,44 +185,40 @@
       "      \"answer\": \"The purpose of this document is to provide important updates and discuss various topics that require the team's attention.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"Who is responsible for enhancing the network security?\",\n",
-      "      \"answer\": \"John Doe from the IT department is responsible for enhancing the network security.\"\n",
+      "      \"question\": \"What should be done if someone comes across potential security risks or incidents?\",\n",
+      "      \"answer\": \"If someone comes across potential security risks or incidents, they should report them immediately to the dedicated team at security@example.com.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"Where should potential security risks or incidents be reported?\",\n",
-      "      \"answer\": \"Potential security risks or incidents should be reported to the dedicated team at security@example.com.\"\n",
+      "      \"question\": \"Who is commended for enhancing network security?\",\n",
+      "      \"answer\": \"John Doe from the IT department is commended for enhancing network security.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"Who has been recognized for outstanding performance in customer service?\",\n",
-      "      \"answer\": \"Jane Smith has been recognized for her outstanding performance in customer service.\"\n",
+      "      \"question\": \"Who should be contacted for assistance with employee benefits?\",\n",
+      "      \"answer\": \"For assistance with employee benefits, HR representative Michael Johnson should be contacted. His phone number is 418-492-3850, and his email is michael.johnson@example.com.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"When is the open enrollment period for the employee benefits program?\",\n",
-      "      \"answer\": \"The document does not specify the exact dates for the open enrollment period for the employee benefits program, but it mentions that it is fast approaching.\"\n",
+      "      \"question\": \"Who has made significant contributions to their respective departments?\",\n",
+      "      \"answer\": \"Several new team members have made significant contributions to their respective departments.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"Who should be contacted for questions or assistance regarding the employee benefits program?\",\n",
-      "      \"answer\": \"For questions or assistance regarding the employee benefits program, the HR representative, Michael Johnson, should be contacted.\"\n",
+      "      \"question\": \"Who is recognized for outstanding performance in customer service?\",\n",
+      "      \"answer\": \"Jane Smith is recognized for outstanding performance in customer service.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"Who has been acknowledged for managing the company's social media platforms?\",\n",
-      "      \"answer\": \"Sarah Thompson has been acknowledged for managing the company's social media platforms.\"\n",
+      "      \"question\": \"Who has successfully increased the follower base on social media?\",\n",
+      "      \"answer\": \"Sarah Thompson has successfully increased the follower base on social media.\"\n",
       "    },\n",
       "    {\n",
       "      \"question\": \"When is the upcoming product launch event?\",\n",
       "      \"answer\": \"The upcoming product launch event is on July 15th.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"Who has been recognized for their contributions to the development of the company's technology?\",\n",
-      "      \"answer\": \"David Rodriguez has been recognized for his contributions to the development of the company's technology.\"\n",
+      "      \"question\": \"Who is acknowledged for their exceptional work as project lead?\",\n",
+      "      \"answer\": \"David Rodriguez is acknowledged for his exceptional work as project lead.\"\n",
       "    },\n",
       "    {\n",
-      "      \"question\": \"When is the monthly R&D brainstorming session?\",\n",
+      "      \"question\": \"When is the monthly R&D brainstorming session scheduled?\",\n",
       "      \"answer\": \"The monthly R&D brainstorming session is scheduled for July 10th.\"\n",
-      "    },\n",
-      "    {\n",
-      "      \"question\": \"Who should be contacted for questions or concerns regarding the topics discussed in the document?\",\n",
-      "      \"answer\": \"For questions or concerns regarding the topics discussed in the document, Jason Fan, the Cofounder & CEO, should be contacted.\"\n",
       "    }\n",
       "  ]\n",
       "}\n"
@@ -230,16 +226,9 @@
     }
    ],
    "source": [
-    "transformed_document = await qa_transformer.atransform_documents(documents)\n",
+    "transformed_document = qa_transformer.transform_documents(documents)\n",
     "print(json.dumps(transformed_document[0].metadata, indent=2))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -258,7 +247,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/docs/integrations/document_transformers/doctran_translate_document.ipynb

@@ -34,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -125,51 +125,49 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
-    "translated_document = await qa_translator.atransform_documents(documents)"
+    "translated_document = qa_translator.transform_documents(documents)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[Generado con ChatGPT]\n",
+      "Documento Confidencial - Solo para Uso Interno\n",
       "\n",
-      "Documento confidencial - Solo para uso interno\n",
+      "Fecha: 1 de Julio de 2023\n",
       "\n",
-      "Fecha: 1 de julio de 2023\n",
+      "Asunto: Actualizaciones y Discusiones sobre Varios Temas\n",
       "\n",
-      "Asunto: Actualizaciones y discusiones sobre varios temas\n",
-      "\n",
-      "Estimado equipo,\n",
+      "Estimado Equipo,\n",
       "\n",
       "Espero que este correo electrónico les encuentre bien. En este documento, me gustaría proporcionarles algunas actualizaciones importantes y discutir varios temas que requieren nuestra atención. Por favor, traten la información contenida aquí como altamente confidencial.\n",
       "\n",
-      "Medidas de seguridad y privacidad\n",
-      "Como parte de nuestro compromiso continuo para garantizar la seguridad y privacidad de los datos de nuestros clientes, hemos implementado medidas robustas en todos nuestros sistemas. Nos gustaría elogiar a John Doe (correo electrónico: john.doe@example.com) del departamento de TI por su diligente trabajo en mejorar nuestra seguridad de red. En adelante, recordamos amablemente a todos que se adhieran estrictamente a nuestras políticas y directrices de protección de datos. Además, si se encuentran con cualquier riesgo de seguridad o incidente potencial, por favor repórtelo inmediatamente a nuestro equipo dedicado en security@example.com.\n",
+      "Medidas de Seguridad y Privacidad\n",
+      "Como parte de nuestro compromiso continuo de garantizar la seguridad y privacidad de los datos de nuestros clientes, hemos implementado medidas sólidas en todos nuestros sistemas. Nos gustaría elogiar a John Doe (correo electrónico: john.doe@example.com) del departamento de TI por su diligente trabajo en mejorar nuestra seguridad de red. En el futuro, recordamos amablemente a todos que se adhieran estrictamente a nuestras políticas y pautas de protección de datos. Además, si encuentran algún riesgo o incidente de seguridad potencial, por favor, repórtelo de inmediato a nuestro equipo dedicado en security@example.com.\n",
       "\n",
-      "Actualizaciones de RRHH y beneficios para empleados\n",
-      "Recientemente, dimos la bienvenida a varios nuevos miembros del equipo que han hecho contribuciones significativas a sus respectivos departamentos. Me gustaría reconocer a Jane Smith (SSN: 049-45-5928) por su sobresaliente rendimiento en el servicio al cliente. Jane ha recibido constantemente comentarios positivos de nuestros clientes. Además, recuerden que el período de inscripción abierta para nuestro programa de beneficios para empleados se acerca rápidamente. Si tienen alguna pregunta o necesitan asistencia, por favor contacten a nuestro representante de RRHH, Michael Johnson (teléfono: 418-492-3850, correo electrónico: michael.johnson@example.com).\n",
+      "Actualizaciones de Recursos Humanos y Beneficios para Empleados\n",
+      "Recientemente, dimos la bienvenida a varios nuevos miembros del equipo que han realizado contribuciones significativas en sus respectivos departamentos. Me gustaría reconocer a Jane Smith (SSN: 049-45-5928) por su destacado desempeño en servicio al cliente. Jane ha recibido consistentemente comentarios positivos de nuestros clientes. Además, recuerden que el período de inscripción abierta para nuestro programa de beneficios para empleados se acerca rápidamente. Si tienen alguna pregunta o necesitan ayuda, por favor, contacten a nuestro representante de Recursos Humanos, Michael Johnson (teléfono: 418-492-3850, correo electrónico: michael.johnson@example.com).\n",
       "\n",
-      "Iniciativas y campañas de marketing\n",
-      "Nuestro equipo de marketing ha estado trabajando activamente en el desarrollo de nuevas estrategias para aumentar la conciencia de marca y fomentar la participación del cliente. Nos gustaría agradecer a Sarah Thompson (teléfono: 415-555-1234) por sus excepcionales esfuerzos en la gestión de nuestras plataformas de redes sociales. Sarah ha aumentado con éxito nuestra base de seguidores en un 20% solo en el último mes. Además, por favor marquen sus calendarios para el próximo evento de lanzamiento de producto el 15 de julio. Animamos a todos los miembros del equipo a asistir y apoyar este emocionante hito para nuestra empresa.\n",
+      "Iniciativas y Campañas de Marketing\n",
+      "Nuestro equipo de marketing ha estado trabajando activamente en el desarrollo de nuevas estrategias para aumentar el conocimiento de nuestra marca y fomentar la participación de los clientes. Nos gustaría agradecer a Sarah Thompson (teléfono: 415-555-1234) por sus esfuerzos excepcionales en la gestión de nuestras plataformas de redes sociales. Sarah ha logrado aumentar nuestra base de seguidores en un 20% solo en el último mes. Además, marquen sus calendarios para el próximo evento de lanzamiento de productos el 15 de Julio. Animamos a todos los miembros del equipo a asistir y apoyar este emocionante hito para nuestra empresa.\n",
       "\n",
-      "Proyectos de investigación y desarrollo\n",
-      "En nuestra búsqueda de la innovación, nuestro departamento de investigación y desarrollo ha estado trabajando incansablemente en varios proyectos. Me gustaría reconocer el excepcional trabajo de David Rodríguez (correo electrónico: david.rodriguez@example.com) en su papel de líder de proyecto. Las contribuciones de David al desarrollo de nuestra tecnología de vanguardia han sido fundamentales. Además, nos gustaría recordar a todos que compartan sus ideas y sugerencias para posibles nuevos proyectos durante nuestra sesión de lluvia de ideas de I+D mensual, programada para el 10 de julio.\n",
+      "Proyectos de Investigación y Desarrollo\n",
+      "En nuestra búsqueda de la innovación, nuestro departamento de investigación y desarrollo ha estado trabajando incansablemente en varios proyectos. Me gustaría reconocer el trabajo excepcional de David Rodriguez (correo electrónico: david.rodriguez@example.com) en su papel de líder de proyecto. Las contribuciones de David al desarrollo de nuestra tecnología de vanguardia han sido fundamentales. Además, nos gustaría recordar a todos que compartan sus ideas y sugerencias para posibles nuevos proyectos durante nuestra sesión mensual de lluvia de ideas de I+D, programada para el 10 de Julio.\n",
       "\n",
-      "Por favor, traten la información de este documento con la máxima confidencialidad y asegúrense de que no se comparte con personas no autorizadas. Si tienen alguna pregunta o inquietud sobre los temas discutidos, no duden en ponerse en contacto conmigo directamente.\n",
+      "Por favor, traten la información de este documento con la máxima confidencialidad y asegúrense de no compartirla con personas no autorizadas. Si tienen alguna pregunta o inquietud sobre los temas discutidos, por favor, no duden en comunicarse directamente conmigo.\n",
       "\n",
-      "Gracias por su atención, y sigamos trabajando juntos para alcanzar nuestros objetivos.\n",
+      "Gracias por su atención y sigamos trabajando juntos para alcanzar nuestros objetivos.\n",
       "\n",
-      "Saludos cordiales,\n",
+      "Atentamente,\n",
       "\n",
       "Jason Fan\n",
       "Cofundador y CEO\n",
@@ -199,7 +197,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/docs/integrations/llms/baseten.ipynb

@@ -7,9 +7,9 @@
    "source": [
     "# Baseten\n",
     "\n",
-    "[Baseten](https://baseten.co) provides all the infrastructure you need to deploy and serve ML models performantly, scalably, and cost-efficiently.\n",
+    "[Baseten](https://baseten.co) is a [Provider](https://python.langchain.com/docs/integrations/providers/baseten) in the LangChain ecosystem that implements the LLMs component.\n",
     "\n",
-    "This example demonstrates using Langchain with models deployed on Baseten."
+    "This example demonstrates using an LLM — Mistral 7B hosted on Baseten — with LangChain."
    ]
   },
   {
@@ -19,29 +19,16 @@
    "source": [
     "# Setup\n",
     "\n",
-    "To run this notebook, you'll need a [Baseten account](https://baseten.co) and an [API key](https://docs.baseten.co/settings/api-keys).\n",
+    "To run this example, you'll need:\n",
     "\n",
-    "You'll also need to install the Baseten Python package:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install baseten"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import baseten\n",
+    "* A [Baseten account](https://baseten.co)\n",
+    "* An [API key](https://docs.baseten.co/observability/api-keys)\n",
     "\n",
-    "baseten.login(\"YOUR_API_KEY\")"
+    "Export your API key to your as an environment variable called `BASETEN_API_KEY`.\n",
+    "\n",
+    "```sh\n",
+    "export BASETEN_API_KEY=\"paste_your_api_key_here\"\n",
+    "```"
    ]
   },
   {
@@ -53,9 +40,9 @@
     "\n",
     "First, you'll need to deploy a model to Baseten.\n",
     "\n",
-    "You can deploy foundation models like WizardLM and Alpaca with one click from the [Baseten model library](https://app.baseten.co/explore/) or if you have your own model, [deploy it with this tutorial](https://docs.baseten.co/deploying-models/deploy).\n",
+    "You can deploy foundation models like Mistral and Llama 2 with one click from the [Baseten model library](https://app.baseten.co/explore/) or if you have your own model, [deploy it with Truss](https://truss.baseten.co/welcome).\n",
     "\n",
-    "In this example, we'll work with WizardLM. [Deploy WizardLM here](https://app.baseten.co/explore/llama) and follow along with the deployed [model's version ID](https://docs.baseten.co/managing-models/manage)."
+    "In this example, we'll work with Mistral 7B. [Deploy Mistral 7B here](https://app.baseten.co/explore/mistral_7b_instruct) and follow along with the deployed model's ID, found in the model dashboard."
    ]
   },
   {
@@ -64,7 +51,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.llms import Baseten"
+    "from langchain_community.llms import Baseten"
    ]
   },
   {
@@ -74,7 +61,7 @@
    "outputs": [],
    "source": [
     "# Load the model\n",
-    "wizardlm = Baseten(model=\"MODEL_VERSION_ID\", verbose=True)"
+    "mistral = Baseten(model=\"MODEL_ID\", deployment=\"production\")"
    ]
   },
   {
@@ -84,8 +71,7 @@
    "outputs": [],
    "source": [
     "# Prompt the model\n",
-    "\n",
-    "wizardlm(\"What is the difference between a Wizard and a Sorcerer?\")"
+    "mistral(\"What is the Mistral wind?\")"
    ]
   },
   {
@@ -97,7 +83,7 @@
     "\n",
     "We can chain together multiple calls to one or multiple models, which is the whole point of Langchain!\n",
     "\n",
-    "This example uses WizardLM to plan a meal with an entree, three sides, and an alcoholic and non-alcoholic beverage pairing."
+    "For example, we can replace GPT with Mistral in this [demo of terminal emulation](https://python.langchain.com/docs/modules/agents/how_to/chatgpt_clone)."
    ]
   },
   {
@@ -106,24 +92,37 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains import LLMChain, SimpleSequentialChain\n",
-    "from langchain.prompts import PromptTemplate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Build the first link in the chain\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.memory import ConversationBufferWindowMemory\n",
+    "from langchain.prompts import PromptTemplate\n",
     "\n",
-    "prompt = PromptTemplate(\n",
-    "    input_variables=[\"cuisine\"],\n",
-    "    template=\"Name a complex entree for a {cuisine} dinner. Respond with just the name of a single dish.\",\n",
+    "template = \"\"\"Assistant is a large language model trained by OpenAI.\n",
+    "\n",
+    "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+    "\n",
+    "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+    "\n",
+    "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+    "\n",
+    "{history}\n",
+    "Human: {human_input}\n",
+    "Assistant:\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(input_variables=[\"history\", \"human_input\"], template=template)\n",
+    "\n",
+    "\n",
+    "chatgpt_chain = LLMChain(\n",
+    "    llm=mistral,\n",
+    "    llm_kwargs={\"max_length\": 4096},\n",
+    "    prompt=prompt,\n",
+    "    verbose=True,\n",
+    "    memory=ConversationBufferWindowMemory(k=2),\n",
     ")\n",
     "\n",
-    "link_one = LLMChain(llm=wizardlm, prompt=prompt)"
+    "output = chatgpt_chain.predict(\n",
+    "    human_input=\"I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply with the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\"\n",
+    ")\n",
+    "print(output)"
    ]
   },
   {
@@ -132,14 +131,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Build the second link in the chain\n",
-    "\n",
-    "prompt = PromptTemplate(\n",
-    "    input_variables=[\"entree\"],\n",
-    "    template=\"What are three sides that would go with {entree}. Respond with only a list of the sides.\",\n",
-    ")\n",
-    "\n",
-    "link_two = LLMChain(llm=wizardlm, prompt=prompt)"
+    "output = chatgpt_chain.predict(human_input=\"ls ~\")\n",
+    "print(output)"
    ]
   },
   {
@@ -148,14 +141,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Build the third link in the chain\n",
-    "\n",
-    "prompt = PromptTemplate(\n",
-    "    input_variables=[\"sides\"],\n",
-    "    template=\"What is one alcoholic and one non-alcoholic beverage that would go well with this list of sides: {sides}. Respond with only the names of the beverages.\",\n",
-    ")\n",
-    "\n",
-    "link_three = LLMChain(llm=wizardlm, prompt=prompt)"
+    "output = chatgpt_chain.predict(human_input=\"cd ~\")\n",
+    "print(output)"
    ]
   },
   {
@@ -164,12 +151,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Run the full chain!\n",
-    "\n",
-    "menu_maker = SimpleSequentialChain(\n",
-    "    chains=[link_one, link_two, link_three], verbose=True\n",
+    "output = chatgpt_chain.predict(\n",
+    "    human_input=\"\"\"echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py && python3 run.py\"\"\"\n",
     ")\n",
-    "menu_maker.run(\"South Indian\")"
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see from the final example, which outputs a number that may or may not be correct, the model is only approximating likely terminal output, not actually executing provided commands. Still, the example demonstrates Mistral's ample context window, code generation capabilities, and ability to stay on-topic even in conversational sequences."
    ]
   }
  ],

docs/docs/integrations/llms/google_vertex_ai_palm.ipynb

@@ -539,6 +539,35 @@
     "print(output2.content)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can also use the public image URL:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image_message = {\n",
+    "    \"type\": \"image_url\",\n",
+    "    \"image_url\": {\n",
+    "        \"url\": \"https://python.langchain.com/assets/images/cell-18-output-1-0c7fb8b94ff032d51bfe1880d8370104.png\",\n",
+    "    },\n",
+    "}\n",
+    "text_message = {\n",
+    "    \"type\": \"text\",\n",
+    "    \"text\": \"What is shown in this image?\",\n",
+    "}\n",
+    "message = HumanMessage(content=[text_message, image_message])\n",
+    "\n",
+    "output = llm([message])\n",
+    "print(output.content)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {

docs/docs/integrations/llms/llm_caching.ipynb

@@ -287,7 +287,7 @@
     {
      "data": {
       "text/plain": [
-       "'\\n\\nTwo guys stole a calendar. They got six months each.'"
+       "'\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side!'"
       ]
      },
      "execution_count": 50,
@@ -297,7 +297,7 @@
    ],
    "source": [
     "%%time\n",
-    "# The first time, it is not yet in cache, so it should take longer\n",
+    "# The second time it is, so it goes faster\n",
     "llm(\"Tell me a joke\")"
    ]
   },

docs/docs/integrations/llms/oci_model_deployment_endpoint.ipynb

@@ -0,0 +1,131 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# OCI Data Science Model Deployment Endpoint\n",
+    "\n",
+    "[OCI Data Science](https://docs.oracle.com/en-us/iaas/data-science/using/home.htm) is a fully managed and serverless platform for data science teams to build, train, and manage machine learning models in the Oracle Cloud Infrastructure.\n",
+    "\n",
+    "This notebooks goes over how to use an LLM hosted on a [OCI Data Science Model Deployment](https://docs.oracle.com/en-us/iaas/data-science/using/model-dep-about.htm).\n",
+    "\n",
+    "To authenticate, [oracle-ads](https://accelerated-data-science.readthedocs.io/en/latest/user_guide/cli/authentication.html) has been used to automatically load credentials for invoking endpoint."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip3 install oracle-ads"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prerequisite\n",
+    "\n",
+    "### Deploy model\n",
+    "Check [Oracle GitHub samples repository](https://github.com/oracle-samples/oci-data-science-ai-samples/tree/main/model-deployment/containers/llama2) on how to deploy your llm on OCI Data Science Model deployment.\n",
+    "\n",
+    "### Policies\n",
+    "Make sure to have the required [policies](https://docs.oracle.com/en-us/iaas/data-science/using/model-dep-policies-auth.htm#model_dep_policies_auth__predict-endpoint) to access the OCI Data Science Model Deployment endpoint.\n",
+    "\n",
+    "## Set up\n",
+    "\n",
+    "### vLLM\n",
+    "After having deployed model, you have to set up following required parameters of the `OCIModelDeploymentVLLM` call:\n",
+    "\n",
+    "- **`endpoint`**: The model HTTP endpoint from the deployed model, e.g. `https://<MD_OCID>/predict`. \n",
+    "- **`model`**: The location of the model.\n",
+    "\n",
+    "### Text generation inference (TGI)\n",
+    "You have to set up following required parameters of the `OCIModelDeploymentTGI` call:\n",
+    "\n",
+    "- **`endpoint`**: The model HTTP endpoint from the deployed model, e.g. `https://<MD_OCID>/predict`. \n",
+    "\n",
+    "### Authentication\n",
+    "\n",
+    "You can set authentication through either ads or environment variables. When you are working in OCI Data Science Notebook Session, you can leverage resource principal to access other OCI resources. Check out [here](https://accelerated-data-science.readthedocs.io/en/latest/user_guide/cli/authentication.html) to see more options. \n",
+    "\n",
+    "## Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ads\n",
+    "from langchain_community.llms import OCIModelDeploymentVLLM\n",
+    "\n",
+    "# Set authentication through ads\n",
+    "# Use resource principal are operating within a\n",
+    "# OCI service that has resource principal based\n",
+    "# authentication configured\n",
+    "ads.set_auth(\"resource_principal\")\n",
+    "\n",
+    "# Create an instance of OCI Model Deployment Endpoint\n",
+    "# Replace the endpoint uri and model name with your own\n",
+    "llm = OCIModelDeploymentVLLM(endpoint=\"https://<MD_OCID>/predict\", model=\"model_name\")\n",
+    "\n",
+    "# Run the LLM\n",
+    "llm.invoke(\"Who is the first president of United States?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "from langchain_community.llms import OCIModelDeploymentTGI\n",
+    "\n",
+    "# Set authentication through environment variables\n",
+    "# Use API Key setup when you are working from a local\n",
+    "# workstation or on platform which does not support\n",
+    "# resource principals.\n",
+    "os.environ[\"OCI_IAM_TYPE\"] = \"api_key\"\n",
+    "os.environ[\"OCI_CONFIG_PROFILE\"] = \"default\"\n",
+    "os.environ[\"OCI_CONFIG_LOCATION\"] = \"~/.oci\"\n",
+    "\n",
+    "# Set endpoint through environment variables\n",
+    "# Replace the endpoint uri with your own\n",
+    "os.environ[\"OCI_LLM_ENDPOINT\"] = \"https://<MD_OCID>/predict\"\n",
+    "\n",
+    "# Create an instance of OCI Model Deployment Endpoint\n",
+    "llm = OCIModelDeploymentTGI()\n",
+    "\n",
+    "# Run the LLM\n",
+    "llm.invoke(\"Who is the first president of United States?\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "langchain",
+   "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.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/integrations/platforms/anthropic.mdx

@@ -163,3 +163,11 @@ This outputs:
 ```
 
 We can see that we detect that the user is trying to use the special tokens, and so we don't do any formatting.
+
+## `ChatAnthropicMessages` (Beta)
+
+`ChatAnthropicMessages` uses the beta release of Anthropic's new Messages API.
+
+You can use it from the `langchain-anthropic` package, which you can install with `pip install langchain-anthropic`.
+
+For more information, see the [ChatAnthropicMessages docs](../chat/anthropic#chatanthropicmessages)

docs/docs/integrations/providers/alibaba_cloud.mdx

@@ -0,0 +1,35 @@
+# Alibaba Cloud
+
+>[Alibaba Group Holding Limited (Wikipedia)](https://en.wikipedia.org/wiki/Alibaba_Group), or `Alibaba`
+> (Chinese: 阿里巴巴), is a Chinese multinational technology company specializing in e-commerce, retail, 
+> Internet, and technology.
+> 
+> [Alibaba Cloud (Wikipedia)](https://en.wikipedia.org/wiki/Alibaba_Cloud), also known as `Aliyun`
+> (Chinese: 阿里云; pinyin: Ālǐyún; lit. 'Ali Cloud'), is a cloud computing company, a subsidiary 
+> of `Alibaba Group`. `Alibaba Cloud` provides cloud computing services to online businesses and 
+> Alibaba's own e-commerce ecosystem.
+ 
+ 
+## Chat Model
+
+See [installation instructions and a usage example](/docs/integrations/chat/alibaba_cloud_pai_eas).
+
+```python
+from langchain.chat_models import PaiEasChatEndpoint
+```
+
+## Vectorstore
+
+See [installation instructions and a usage example](/docs/integrations/vectorstores/alibabacloud_opensearch).
+
+```python
+from langchain.vectorstores import AlibabaCloudOpenSearch, AlibabaCloudOpenSearchSettings
+```
+
+## Document Loader
+
+See [installation instructions and a usage example](/docs/integrations/document_loaders/alibaba_cloud_maxcompute).
+
+```python
+from langchain.document_loaders import MaxComputeLoader
+```

docs/docs/integrations/providers/alibabacloud_opensearch.md

@@ -1,30 +0,0 @@
-# Alibaba Cloud Opensearch
-
-[Alibaba Cloud Opensearch](https://www.alibabacloud.com/product/opensearch) OpenSearch is a one-stop platform to develop intelligent search services. OpenSearch was built based on the large-scale distributed search engine developed by Alibaba. OpenSearch serves more than 500 business cases in Alibaba Group and thousands of Alibaba Cloud customers. OpenSearch helps develop search services in different search scenarios, including e-commerce, O2O, multimedia, the content industry, communities and forums, and big data query in enterprises.
-
-OpenSearch helps you develop high quality, maintenance-free, and high performance intelligent search services to provide your users with high search efficiency and accuracy.
-
-OpenSearch provides the vector search feature. In specific scenarios,especially in question retrieval and image search scenarios, you can use the vector search feature together with the multimodal search feature to improve the accuracy of search results.
-
-## Purchase an instance and configure it
-
-- Purchase OpenSearch Vector Search Edition from [Alibaba Cloud](https://opensearch.console.aliyun.com) and configure the instance according to the help [documentation](https://help.aliyun.com/document_detail/463198.html?spm=a2c4g.465092.0.0.2cd15002hdwavO).
-  
-## Alibaba Cloud Opensearch Vector Store Wrappers
-supported functions:
-- `add_texts`
-- `add_documents`
-- `from_texts`
-- `from_documents`
-- `similarity_search`
-- `asimilarity_search`
-- `similarity_search_by_vector`
-- `asimilarity_search_by_vector`
-- `similarity_search_with_relevance_scores`
-- `delete_doc_by_texts`
-
-
-For a more detailed walk through of the Alibaba Cloud OpenSearch wrapper, see [this notebook](/docs/integrations/vectorstores/alibabacloud_opensearch)
-
-If you encounter any problems during use, please feel free to contact [xingshaomin.xsm@alibaba-inc.com](xingshaomin.xsm@alibaba-inc.com) , and we will do our best to provide you with assistance and support.
-

docs/docs/integrations/providers/baseten.md

@@ -1,25 +1,71 @@
 # Baseten
 
-Learn how to use LangChain with models deployed on Baseten.
+[Baseten](https://baseten.co) provides all the infrastructure you need to deploy and serve ML models performantly, scalably, and cost-efficiently.
 
-## Installation and setup
+As a model inference platform, Baseten is a `Provider` in the LangChain ecosystem. The Baseten integration currently implements a single `Component`, LLMs, but more are planned!
 
-- Create a [Baseten](https://baseten.co) account and [API key](https://docs.baseten.co/settings/api-keys).
-- Install the Baseten Python client with `pip install baseten`
-- Use your API key to authenticate with `baseten login`
+Baseten lets you run both open source models like Llama 2 or Mistral and run proprietary or fine-tuned models on dedicated GPUs. If you're used to a provider like OpenAI, using Baseten has a few differences:
 
-## Invoking a model
+* Rather than paying per token, you pay per minute of GPU used.
+* Every model on Baseten uses [Truss](https://truss.baseten.co/welcome), our open-source model packaging framework, for maximum customizability.
+* While we have some [OpenAI ChatCompletions-compatible models](https://docs.baseten.co/api-reference/openai), you can define your own I/O spec with Truss.
 
-Baseten integrates with LangChain through the LLM module, which provides a standardized and interoperable interface for models that are deployed on your Baseten workspace.
+You can learn more about Baseten in [our docs](https://docs.baseten.co/) or read on for LangChain-specific info.
 
-You can deploy foundation models like WizardLM and Alpaca with one click from the [Baseten model library](https://app.baseten.co/explore/) or if you have your own model, [deploy it with this tutorial](https://docs.baseten.co/deploying-models/deploy).
+## Setup: LangChain + Baseten
 
-In this example, we'll work with WizardLM. [Deploy WizardLM here](https://app.baseten.co/explore/wizardlm) and follow along with the deployed [model's version ID](https://docs.baseten.co/managing-models/manage).
+You'll need two things to use Baseten models with LangChain:
+
+- A [Baseten account](https://baseten.co)
+- An [API key](https://docs.baseten.co/observability/api-keys)
+
+Export your API key to your as an environment variable called `BASETEN_API_KEY`.
+
+```sh
+export BASETEN_API_KEY="paste_your_api_key_here"
+```
+
+## Component guide: LLMs
+
+Baseten integrates with LangChain through the [LLM component](https://python.langchain.com/docs/integrations/llms/baseten), which provides a standardized and interoperable interface for models that are deployed on your Baseten workspace.
+
+You can deploy foundation models like Mistral and Llama 2 with one click from the [Baseten model library](https://app.baseten.co/explore/) or if you have your own model, [deploy it with Truss](https://truss.baseten.co/welcome).
+
+In this example, we'll work with Mistral 7B. [Deploy Mistral 7B here](https://app.baseten.co/explore/mistral_7b_instruct) and follow along with the deployed model's ID, found in the model dashboard.
+
+To use this module, you must:
+
+* Export your Baseten API key as the environment variable BASETEN_API_KEY
+* Get the model ID for your model from your Baseten dashboard
+* Identify the model deployment ("production" for all model library models)
+
+[Learn more](https://docs.baseten.co/deploy/lifecycle) about model IDs and deployments.
+
+Production deployment (standard for model library models)
 
 ```python
-from langchain.llms import Baseten
+from langchain_community.llms import Baseten
 
-wizardlm = Baseten(model="MODEL_VERSION_ID", verbose=True)
-
-wizardlm("What is the difference between a Wizard and a Sorcerer?")
+mistral = Baseten(model="MODEL_ID", deployment="production")
+mistral("What is the Mistral wind?")
 ```
+
+Development deployment
+
+```python
+from langchain_community.llms import Baseten
+
+mistral = Baseten(model="MODEL_ID", deployment="development")
+mistral("What is the Mistral wind?")
+```
+
+Other published deployment
+
+```python
+from langchain_community.llms import Baseten
+
+mistral = Baseten(model="MODEL_ID", deployment="DEPLOYMENT_ID")
+mistral("What is the Mistral wind?")
+```
+
+Streaming LLM output, chat completions, embeddings models, and more are all supported on the Baseten platform and coming soon to our LangChain integration. Contact us at [support@baseten.co](mailto:support@baseten.co) with any questions about using Baseten with LangChain.

docs/docs/integrations/providers/vectara/index.mdx

@@ -1,14 +1,13 @@
 # Vectara
 
->[Vectara](https://docs.vectara.com/docs/) is a GenAI platform for developers. It provides a simple API to build Grounded Generation
->(aka Retrieval-augmented-generation or RAG) applications.
+>[Vectara](https://vectara.com/) is the trusted GenAI platform for developers. It provides a simple API to build GenAI applications
+> for semantic search or RAG (Retreieval augmented generation).
 
 **Vectara Overview:**
-- `Vectara` is developer-first API platform for building GenAI applications
+- `Vectara` is developer-first API platform for building trusted GenAI applications. 
 - To use Vectara - first [sign up](https://vectara.com/integrations/langchain) and create an account. Then create a corpus and an API key for indexing and searching.
 - You can use Vectara's [indexing API](https://docs.vectara.com/docs/indexing-apis/indexing) to add documents into Vectara's index
 - You can use Vectara's [Search API](https://docs.vectara.com/docs/search-apis/search) to query Vectara's index (which also supports Hybrid search implicitly).
-- You can use Vectara's integration with LangChain as a Vector store or using the Retriever abstraction.
 
 ## Installation and Setup
 
@@ -21,7 +20,7 @@ Once you have these, you can provide them as arguments to the Vectara vectorstor
 - export `VECTARA_API_KEY`="your-vectara-api-key"
 
 
-## Vector Store
+## Vectara as a Vector Store
 
 There exists a wrapper around the Vectara platform, allowing you to use it as a vectorstore, whether for semantic search or example selection.
 
@@ -59,18 +58,35 @@ To query the vectorstore, you can use the `similarity_search` method (or `simila
 ```python
 results = vectara.similarity_score("what is LangChain?")
 ```
+The results are returned as a list of relevant documents, and a relevance score of each document.
 
-`similarity_search_with_score` also supports the following additional arguments:
+In this case, we used the default retrieval parameters, but you can also specify the following additional arguments in `similarity_search` or `similarity_search_with_score`:
 - `k`: number of results to return (defaults to 5)
 - `lambda_val`: the [lexical matching](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching) factor for hybrid search (defaults to 0.025)
 - `filter`: a [filter](https://docs.vectara.com/docs/common-use-cases/filtering-by-metadata/filter-overview) to apply to the results (default None)
 - `n_sentence_context`: number of sentences to include before/after the actual matching segment when returning results. This defaults to 2.
+- `mmr_config`: can be used to specify MMR mode in the query.
+   - `is_enabled`: True or False
+   - `mmr_k`: number of results to use for MMR reranking
+   - `diversity_bias`: 0 = no diversity, 1 = full diversity. This is the lambda parameter in the MMR formula and is in the range 0...1
 
-The results are returned as a list of relevant documents, and a relevance score of each document.
+## Vectara for Retrieval Augmented Generation (RAG)
+
+Vectara provides a full RAG pipeline, including generative summarization. 
+To use this pipeline, you can specify the `summary_config` argument in `similarity_search` or `similarity_search_with_score` as follows:
+
+- `summary_config`: can be used to request an LLM summary in RAG
+   - `is_enabled`: True or False
+   - `max_results`: number of results to use for summary generation
+   - `response_lang`: language of the response summary, in ISO 639-2 format (e.g. 'en', 'fr', 'de', etc)
+
+## Example Notebooks
+
+For a more detailed examples of using Vectara, see the following examples:
+* [this notebook](/docs/integrations/vectorstores/vectara.html) shows how to use Vectara as a vectorstore for semantic search
+* [this notebook](/docs/integrations/providers/vectara/vectara_chat.html) shows how to build a chatbot with Langchain and Vectara
+* [this notebook](/docs/integrations/providers/vectara/vectara_summary.html) shows how to use the full Vectara RAG pipeline, including generative summarization
+* [this notebook](/docs/integrations/retrievers/self_query/vectara_self_query.html) shows the self-query capability with Vectara.
 
 
-For a more detailed examples of using the Vectara wrapper, see one of these two sample notebooks:
-* [Chat Over Documents with Vectara](./vectara_chat.html)
-* [Vectara Text Generation](./vectara_text_generation.html)
-
 

docs/docs/integrations/providers/vectara/vectara_chat.ipynb

@@ -7,12 +7,51 @@
    "source": [
     "# Chat Over Documents with Vectara\n",
     "\n",
-    "This notebook is based on the [chat_vector_db](https://github.com/langchain-ai/langchain/blob/master/docs/modules/chains/index_examples/chat_vector_db) notebook, but using Vectara as the vector database."
+    "This notebook is based on the [chat_vector_db](https://github.com/hwchase17/langchain/blob/master/docs/modules/chains/index_examples/chat_vector_db.html) notebook, but using Vectara as the vector database."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56372c5b",
+   "metadata": {},
+   "source": [
+    "# Setup\n",
+    "\n",
+    "You will need a Vectara account to use Vectara with LangChain. To get started, use the following steps:\n",
+    "1. [Sign up](https://www.vectara.com/integrations/langchain) for a Vectara account if you don't already have one. Once you have completed your sign up you will have a Vectara customer ID. You can find your customer ID by clicking on your name, on the top-right of the Vectara console window.\n",
+    "2. Within your account you can create one or more corpora. Each corpus represents an area that stores text data upon ingest from input documents. To create a corpus, use the **\"Create Corpus\"** button. You then provide a name to your corpus as well as a description. Optionally you can define filtering attributes and apply some advanced options. If you click on your created corpus, you can see its name and corpus ID right on the top.\n",
+    "3. Next you'll need to create API keys to access the corpus. Click on the **\"Authorization\"** tab in the corpus view and then the **\"Create API Key\"** button. Give your key a name, and choose whether you want query only or query+index for your key. Click \"Create\" and you now have an active API key. Keep this key confidential. \n",
+    "\n",
+    "To use LangChain with Vectara, you'll need to have these three values: customer ID, corpus ID and api_key.\n",
+    "You can provide those to LangChain in two ways:\n",
+    "\n",
+    "1. Include in your environment these three variables: `VECTARA_CUSTOMER_ID`, `VECTARA_CORPUS_ID` and `VECTARA_API_KEY`.\n",
+    "\n",
+    "> For example, you can set these variables using os.environ and getpass as follows:\n",
+    "\n",
+    "```python\n",
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "os.environ[\"VECTARA_CUSTOMER_ID\"] = getpass.getpass(\"Vectara Customer ID:\")\n",
+    "os.environ[\"VECTARA_CORPUS_ID\"] = getpass.getpass(\"Vectara Corpus ID:\")\n",
+    "os.environ[\"VECTARA_API_KEY\"] = getpass.getpass(\"Vectara API Key:\")\n",
+    "```\n",
+    "\n",
+    "2. Add them to the Vectara vectorstore constructor:\n",
+    "\n",
+    "```python\n",
+    "vectorstore = Vectara(\n",
+    "                vectara_customer_id=vectara_customer_id,\n",
+    "                vectara_corpus_id=vectara_corpus_id,\n",
+    "                vectara_api_key=vectara_api_key\n",
+    "            )\n",
+    "```"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "70c4e529",
    "metadata": {
     "tags": []
@@ -36,7 +75,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "01c46e92",
    "metadata": {
     "tags": []
@@ -45,7 +84,7 @@
    "source": [
     "from langchain.document_loaders import TextLoader\n",
     "\n",
-    "loader = TextLoader(\"../../../modules/state_of_the_union.txt\")\n",
+    "loader = TextLoader(\"state_of_the_union.txt\")\n",
     "documents = loader.load()"
    ]
   },
@@ -54,19 +93,19 @@
    "id": "239475d2",
    "metadata": {},
    "source": [
-    "We now split the documents, create embeddings for them, and put them in a vectorstore. This allows us to do semantic search over them."
+    "Since we're using Vectara, there's no need to chunk the documents, as that is done automatically in the Vectara platform backend. We just use `from_document()` to upload the text loaded from the file, and directly ingest it into Vectara:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "a8930cf7",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "vectorstore = Vectara.from_documents(documents, embedding=None)"
+    "vectara = Vectara.from_documents(documents, embedding=None)"
    ]
   },
   {
@@ -79,7 +118,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "af803fee",
    "metadata": {},
    "outputs": [],
@@ -94,42 +133,71 @@
    "id": "3c96b118",
    "metadata": {},
    "source": [
-    "We now initialize the `ConversationalRetrievalChain`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "7b4110f3",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "openai_api_key = os.environ[\"OPENAI_API_KEY\"]\n",
-    "llm = OpenAI(openai_api_key=openai_api_key, temperature=0)\n",
-    "retriever = vectorstore.as_retriever(lambda_val=0.025, k=5, filter=None)\n",
-    "d = retriever.get_relevant_documents(\n",
-    "    \"What did the president say about Ketanji Brown Jackson\"\n",
-    ")\n",
-    "\n",
-    "qa = ConversationalRetrievalChain.from_llm(llm, retriever, memory=memory)"
+    "We now initialize the `ConversationalRetrievalChain`:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "e8ce4fe9",
-   "metadata": {},
-   "outputs": [],
+   "id": "7b4110f3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[Document(page_content='Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '29486', 'len': '97'}), Document(page_content='Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '1083', 'len': '117'}), Document(page_content='All told, we created 369,000 new manufacturing jobs in America just last year. Powered by people I’ve met like JoJo Burgess, from generations of union steelworkers from Pittsburgh, who’s here with us tonight. As Ohio Senator Sherrod Brown says, “It’s time to bury the label “Rust Belt.” It’s time. \\n\\nBut with all the bright spots in our economy, record job growth and higher wages, too many families are struggling to keep up with the bills. Inflation is robbing them of the gains they might otherwise feel.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '14257', 'len': '77'}), Document(page_content='This is personal to me and Jill, to Kamala, and to so many of you. Cancer is the #2 cause of death in America–second only to heart disease. Last month, I announced our plan to supercharge  \\nthe Cancer Moonshot that President Obama asked me to lead six years ago. Our goal is to cut the cancer death rate by at least 50% over the next 25 years, turn more cancers from death sentences into treatable diseases. More support for patients and families.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '36196', 'len': '122'}), Document(page_content='Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '664', 'len': '68'}), Document(page_content='I understand. \\n\\nI remember when my Dad had to leave our home in Scranton, Pennsylvania to find work. I grew up in a family where if the price of food went up, you felt it. That’s why one of the first things I did as President was fight to pass the American Rescue Plan. Because people were hurting. We needed to act, and we did.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '8042', 'len': '97'}), Document(page_content='He rejected repeated efforts at diplomacy. He thought the West and NATO wouldn’t respond. And he thought he could divide us at home. We were ready.  Here is what we did. We prepared extensively and carefully.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '2100', 'len': '42'}), Document(page_content='He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. He met the Ukrainian people. From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. Groups of citizens blocking tanks with their bodies.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '788', 'len': '28'}), Document(page_content='Putin’s latest attack on Ukraine was premeditated and unprovoked. He rejected repeated efforts at diplomacy. He thought the West and NATO wouldn’t respond. And he thought he could divide us at home. We were ready.  Here is what we did.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '2053', 'len': '46'}), Document(page_content='A unity agenda for the nation. We can do this. \\n\\nMy fellow Americans—tonight , we have gathered in a sacred space—the citadel of our democracy. In this Capitol, generation after generation, Americans have debated great questions amid great strife, and have done great things. We have fought for freedom, expanded liberty, defeated totalitarianism and terror. And built the strongest, freest, and most prosperous nation the world has ever known.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '36968', 'len': '131'})]\n"
+     ]
+    }
+   ],
    "source": [
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "result = qa({\"question\": query})"
+    "openai_api_key = os.environ[\"OPENAI_API_KEY\"]\n",
+    "llm = OpenAI(openai_api_key=openai_api_key, temperature=0)\n",
+    "retriever = vectara.as_retriever()\n",
+    "d = retriever.get_relevant_documents(\n",
+    "    \"What did the president say about Ketanji Brown Jackson\", k=2\n",
+    ")\n",
+    "print(d)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
+   "id": "44ed803e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bot = ConversationalRetrievalChain.from_llm(\n",
+    "    llm, retriever, memory=memory, verbose=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b6deb16",
+   "metadata": {},
+   "source": [
+    "And can have a multi-turn conversation with out new bot:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e8ce4fe9",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "result = bot({\"question\": query})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
    "id": "4c79862b",
    "metadata": {},
    "outputs": [
@@ -139,7 +207,7 @@
        "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and a former top litigator in private practice, and that she will continue Justice Breyer's legacy of excellence.\""
       ]
      },
-     "execution_count": 7,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -150,28 +218,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "id": "c697d9d1",
    "metadata": {},
    "outputs": [],
    "source": [
-    "query = \"Did he mention who she succeeded\"\n",
-    "result = qa({\"question\": query})"
+    "query = \"Did he mention who she suceeded\"\n",
+    "result = bot({\"question\": query})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 11,
    "id": "ba0678f3",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "' Ketanji Brown Jackson succeeded Justice Breyer.'"
+       "' Ketanji Brown Jackson succeeded Justice Breyer on the United States Supreme Court.'"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -192,15 +260,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 12,
    "id": "1b41a10b-bf68-4689-8f00-9aed7675e2ab",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "qa = ConversationalRetrievalChain.from_llm(\n",
-    "    OpenAI(temperature=0), vectorstore.as_retriever()\n",
+    "bot = ConversationalRetrievalChain.from_llm(\n",
+    "    OpenAI(temperature=0), vectara.as_retriever()\n",
     ")"
    ]
   },
@@ -214,7 +282,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 13,
    "id": "bc672290-8a8b-4828-a90c-f1bbdd6b3920",
    "metadata": {
     "tags": []
@@ -223,12 +291,12 @@
    "source": [
     "chat_history = []\n",
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+    "result = bot({\"question\": query, \"chat_history\": chat_history})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 14,
    "id": "6b62d758-c069-4062-88f0-21e7ea4710bf",
    "metadata": {
     "tags": []
@@ -240,7 +308,7 @@
        "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and a former top litigator in private practice, and that she will continue Justice Breyer's legacy of excellence.\""
       ]
      },
-     "execution_count": 12,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -259,7 +327,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 15,
    "id": "9c95460b-7116-4155-a9d2-c0fb027ee592",
    "metadata": {
     "tags": []
@@ -267,13 +335,13 @@
    "outputs": [],
    "source": [
     "chat_history = [(query, result[\"answer\"])]\n",
-    "query = \"Did he mention who she succeeded\"\n",
-    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+    "query = \"Did he mention who she suceeded\"\n",
+    "result = bot({\"question\": query, \"chat_history\": chat_history})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 16,
    "id": "698ac00c-cadc-407f-9423-226b2d9258d0",
    "metadata": {
     "tags": []
@@ -282,10 +350,10 @@
     {
      "data": {
       "text/plain": [
-       "' Ketanji Brown Jackson succeeded Justice Breyer.'"
+       "' Ketanji Brown Jackson succeeded Justice Breyer on the United States Supreme Court.'"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -305,21 +373,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 17,
    "id": "562769c6",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "qa = ConversationalRetrievalChain.from_llm(\n",
-    "    llm, vectorstore.as_retriever(), return_source_documents=True\n",
+    "bot = ConversationalRetrievalChain.from_llm(\n",
+    "    llm, vectara.as_retriever(), return_source_documents=True\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 18,
    "id": "ea478300",
    "metadata": {
     "tags": []
@@ -328,12 +396,12 @@
    "source": [
     "chat_history = []\n",
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+    "result = bot({\"question\": query, \"chat_history\": chat_history})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 19,
    "id": "4cb75b4e",
    "metadata": {
     "tags": []
@@ -342,10 +410,10 @@
     {
      "data": {
       "text/plain": [
-       "Document(page_content='Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice.', metadata={'source': '../../../modules/state_of_the_union.txt'})"
+       "Document(page_content='Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '29486', 'len': '97'})"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -356,74 +424,16 @@
   },
   {
    "cell_type": "markdown",
-   "id": "669ede2f-d69f-4960-8468-8a768ce1a55f",
+   "id": "99b96dae",
    "metadata": {},
    "source": [
-    "## ConversationalRetrievalChain with `search_distance`\n",
-    "If you are using a vector store that supports filtering by search distance, you can add a threshold value parameter."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "f4f32c6f-8e49-44af-9116-8830b1fcc5f2",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "vectordbkwargs = {\"search_distance\": 0.9}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "1e251775-31e7-4679-b744-d4a57937f93a",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "qa = ConversationalRetrievalChain.from_llm(\n",
-    "    OpenAI(temperature=0), vectorstore.as_retriever(), return_source_documents=True\n",
-    ")\n",
-    "chat_history = []\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "result = qa(\n",
-    "    {\"question\": query, \"chat_history\": chat_history, \"vectordbkwargs\": vectordbkwargs}\n",
-    ")"
+    "## ConversationalRetrievalChain with `map_reduce`\n",
+    "LangChain supports different types of ways to combine document chains with the ConversationalRetrievalChain chain."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 20,
-   "id": "24ebdaec",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " The president said that Ketanji Brown Jackson is one of the nation's top legal minds and a former top litigator in private practice, and that she will continue Justice Breyer's legacy of excellence.\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(result[\"answer\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "99b96dae",
-   "metadata": {},
-   "source": [
-    "## ConversationalRetrievalChain with `map_reduce`\n",
-    "We can also use different types of combine document chains with the ConversationalRetrievalChain chain."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
    "id": "e53a9d66",
    "metadata": {
     "tags": []
@@ -437,7 +447,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 21,
    "id": "bf205e35",
    "metadata": {
     "tags": []
@@ -448,7 +458,7 @@
     "doc_chain = load_qa_chain(llm, chain_type=\"map_reduce\")\n",
     "\n",
     "chain = ConversationalRetrievalChain(\n",
-    "    retriever=vectorstore.as_retriever(),\n",
+    "    retriever=vectara.as_retriever(),\n",
     "    question_generator=question_generator,\n",
     "    combine_docs_chain=doc_chain,\n",
     ")"
@@ -456,7 +466,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 22,
    "id": "78155887",
    "metadata": {
     "tags": []
@@ -470,7 +480,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 23,
    "id": "e54b5fa2",
    "metadata": {
     "tags": []
@@ -482,7 +492,7 @@
        "\" The president said that he nominated Circuit Court of Appeals Judge Ketanji Brown Jackson, who is one of the nation's top legal minds and a former top litigator in private practice.\""
       ]
      },
-     "execution_count": 24,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -503,7 +513,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 24,
    "id": "d1058fd2",
    "metadata": {
     "tags": []
@@ -515,7 +525,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 25,
    "id": "a6594482",
    "metadata": {
     "tags": []
@@ -526,7 +536,7 @@
     "doc_chain = load_qa_with_sources_chain(llm, chain_type=\"map_reduce\")\n",
     "\n",
     "chain = ConversationalRetrievalChain(\n",
-    "    retriever=vectorstore.as_retriever(),\n",
+    "    retriever=vectara.as_retriever(),\n",
     "    question_generator=question_generator,\n",
     "    combine_docs_chain=doc_chain,\n",
     ")"
@@ -534,9 +544,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 26,
    "id": "e2badd21",
    "metadata": {
+    "scrolled": false,
     "tags": []
    },
    "outputs": [],
@@ -548,7 +559,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 27,
    "id": "edb31fe5",
    "metadata": {
     "tags": []
@@ -557,10 +568,10 @@
     {
      "data": {
       "text/plain": [
-       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and a former top litigator in private practice.\\nSOURCES: ../../../modules/state_of_the_union.txt\""
+       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and a former top litigator in private practice.\\nSOURCES: langchain\""
       ]
      },
-     "execution_count": 28,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -581,7 +592,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 28,
    "id": "2efacec3-2690-4b05-8de3-a32fd2ac3911",
    "metadata": {
     "tags": []
@@ -609,8 +620,8 @@
     "question_generator = LLMChain(llm=llm, prompt=CONDENSE_QUESTION_PROMPT)\n",
     "doc_chain = load_qa_chain(streaming_llm, chain_type=\"stuff\", prompt=QA_PROMPT)\n",
     "\n",
-    "qa = ConversationalRetrievalChain(\n",
-    "    retriever=vectorstore.as_retriever(),\n",
+    "bot = ConversationalRetrievalChain(\n",
+    "    retriever=vectara.as_retriever(),\n",
     "    combine_docs_chain=doc_chain,\n",
     "    question_generator=question_generator,\n",
     ")"
@@ -618,7 +629,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 29,
    "id": "fd6d43f4-7428-44a4-81bc-26fe88a98762",
    "metadata": {
     "tags": []
@@ -635,12 +646,12 @@
    "source": [
     "chat_history = []\n",
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+    "result = bot({\"question\": query, \"chat_history\": chat_history})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 30,
    "id": "5ab38978-f3e8-4fa7-808c-c79dec48379a",
    "metadata": {
     "tags": []
@@ -650,14 +661,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " Justice Breyer"
+      " Ketanji Brown Jackson succeeded Justice Breyer on the United States Supreme Court."
      ]
     }
    ],
    "source": [
     "chat_history = [(query, result[\"answer\"])]\n",
-    "query = \"Did he mention who she succeeded\"\n",
-    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+    "query = \"Did he mention who she suceeded\"\n",
+    "result = bot({\"question\": query, \"chat_history\": chat_history})"
    ]
   },
   {
@@ -671,7 +682,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 31,
    "id": "a7ba9d8c",
    "metadata": {
     "tags": []
@@ -685,14 +696,14 @@
     "    return \"\\n\".join(res)\n",
     "\n",
     "\n",
-    "qa = ConversationalRetrievalChain.from_llm(\n",
-    "    llm, vectorstore.as_retriever(), get_chat_history=get_chat_history\n",
+    "bot = ConversationalRetrievalChain.from_llm(\n",
+    "    llm, vectara.as_retriever(), get_chat_history=get_chat_history\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 32,
    "id": "a3e33c0d",
    "metadata": {
     "tags": []
@@ -701,12 +712,12 @@
    "source": [
     "chat_history = []\n",
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+    "result = bot({\"question\": query, \"chat_history\": chat_history})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 33,
    "id": "936dc62f",
    "metadata": {
     "tags": []
@@ -718,7 +729,7 @@
        "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and a former top litigator in private practice, and that she will continue Justice Breyer's legacy of excellence.\""
       ]
      },
-     "execution_count": 34,
+     "execution_count": 33,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -726,14 +737,6 @@
    "source": [
     "result[\"answer\"]"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b8c26901",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

docs/docs/integrations/providers/vectara/vectara_summary.ipynb

@@ -0,0 +1,304 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "559f8e0e",
+   "metadata": {},
+   "source": [
+    "# Vectara\n",
+    "\n",
+    ">[Vectara](https://vectara.com/) is the trusted GenAI platform that provides an easy-to-use API for document indexing and querying. \n",
+    "\n",
+    "Vectara provides an end-to-end managed service for Retrieval Augmented Generation or [RAG](https://vectara.com/grounded-generation/), which includes:\n",
+    "1. A way to extract text from document files and chunk them into sentences.\n",
+    "2. The state-of-the-art [Boomerang](https://vectara.com/how-boomerang-takes-retrieval-augmented-generation-to-the-next-level-via-grounded-generation/) embeddings model. Each text chunk is encoded into a vector embedding using Boomerang, and stored in the Vectara internal knowledge (vector+text) store\n",
+    "3. A query service that automatically encodes the query into embedding, and retrieves the most relevant text segments (including support for [Hybrid Search](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching) and [MMR](https://vectara.com/get-diverse-results-and-comprehensive-summaries-with-vectaras-mmr-reranker/))\n",
+    "4. An option to create [generative summary](https://docs.vectara.com/docs/learn/grounded-generation/grounded-generation-overview), based on the retrieved documents, including citations.\n",
+    "\n",
+    "See the [Vectara API documentation](https://docs.vectara.com/docs/) for more information on how to use the API.\n",
+    "\n",
+    "This notebook shows how to use functionality related to the `Vectara`'s integration with langchain.\n",
+    "Specificaly we will demonstrate how to use chaining with [LangChain's Expression Language](https://python.langchain.com/docs/expression_language/) and using Vectara's integrated summarization capability."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e97dcf11",
+   "metadata": {},
+   "source": [
+    "# Setup\n",
+    "\n",
+    "You will need a Vectara account to use Vectara with LangChain. To get started, use the following steps:\n",
+    "1. [Sign up](https://www.vectara.com/integrations/langchain) for a Vectara account if you don't already have one. Once you have completed your sign up you will have a Vectara customer ID. You can find your customer ID by clicking on your name, on the top-right of the Vectara console window.\n",
+    "2. Within your account you can create one or more corpora. Each corpus represents an area that stores text data upon ingest from input documents. To create a corpus, use the **\"Create Corpus\"** button. You then provide a name to your corpus as well as a description. Optionally you can define filtering attributes and apply some advanced options. If you click on your created corpus, you can see its name and corpus ID right on the top.\n",
+    "3. Next you'll need to create API keys to access the corpus. Click on the **\"Authorization\"** tab in the corpus view and then the **\"Create API Key\"** button. Give your key a name, and choose whether you want query only or query+index for your key. Click \"Create\" and you now have an active API key. Keep this key confidential. \n",
+    "\n",
+    "To use LangChain with Vectara, you'll need to have these three values: customer ID, corpus ID and api_key.\n",
+    "You can provide those to LangChain in two ways:\n",
+    "\n",
+    "1. Include in your environment these three variables: `VECTARA_CUSTOMER_ID`, `VECTARA_CORPUS_ID` and `VECTARA_API_KEY`.\n",
+    "\n",
+    "> For example, you can set these variables using os.environ and getpass as follows:\n",
+    "\n",
+    "```python\n",
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "os.environ[\"VECTARA_CUSTOMER_ID\"] = getpass.getpass(\"Vectara Customer ID:\")\n",
+    "os.environ[\"VECTARA_CORPUS_ID\"] = getpass.getpass(\"Vectara Corpus ID:\")\n",
+    "os.environ[\"VECTARA_API_KEY\"] = getpass.getpass(\"Vectara API Key:\")\n",
+    "```\n",
+    "\n",
+    "2. Add them to the Vectara vectorstore constructor:\n",
+    "\n",
+    "```python\n",
+    "vectorstore = Vectara(\n",
+    "                vectara_customer_id=vectara_customer_id,\n",
+    "                vectara_corpus_id=vectara_corpus_id,\n",
+    "                vectara_api_key=vectara_api_key\n",
+    "            )\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "aac7a9a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import FakeEmbeddings\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnableLambda, RunnablePassthrough\n",
+    "from langchain.vectorstores import Vectara"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "875ffb7e",
+   "metadata": {},
+   "source": [
+    "First we load the state-of-the-union text into Vectara. Note that we use the `from_files` interface which does not require any local processing or chunking - Vectara receives the file content and performs all the necessary pre-processing, chunking and embedding of the file into its knowledge store."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "be0a4973",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vectara = Vectara.from_files([\"state_of_the_union.txt\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22a6b953",
+   "metadata": {},
+   "source": [
+    "We now create a Vectara retriever and specify that:\n",
+    "* It should return only the 3 top Document matches\n",
+    "* For summary, it should use the top 5 results and respond in English"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "19cd2f86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "summary_config = {\"is_enabled\": True, \"max_results\": 5, \"response_lang\": \"eng\"}\n",
+    "retriever = vectara.as_retriever(\n",
+    "    search_kwargs={\"k\": 3, \"summary_config\": summary_config}\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c49284ed",
+   "metadata": {},
+   "source": [
+    "When using summarization with Vectara, the retriever responds with a list of `Document` objects:\n",
+    "1. The first `k` documents are the ones that match the query (as we are used to with a standard vector store)\n",
+    "2. With summary enabled, an additional `Document` object is apended, which includes the summary text. This Document has the metadata field `summary` set as True.\n",
+    "\n",
+    "Let's define two utility functions to split those out:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e5100654",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_sources(documents):\n",
+    "    return documents[:-1]\n",
+    "\n",
+    "\n",
+    "def get_summary(documents):\n",
+    "    return documents[-1].page_content\n",
+    "\n",
+    "\n",
+    "query_str = \"what did Biden say?\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2a74368",
+   "metadata": {},
+   "source": [
+    "Now we can try a summary response for the query:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ee4759c4",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The returned results did not contain sufficient information to be summarized into a useful answer for your query. Please try a different search or restate your query differently.'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(retriever | get_summary).invoke(query_str)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd7c4593",
+   "metadata": {},
+   "source": [
+    "And if we would like to see the sources retrieved from Vectara that were used in this summary (the citations):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0eb66034",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='When they came home, many of the world’s fittest and best trained warriors were never the same. Dizziness. \\n\\nA cancer that would put them in a flag-draped coffin. I know. \\n\\nOne of those soldiers was my son Major Beau Biden. We don’t know for sure if a burn pit was the cause of his brain cancer, or the diseases of so many of our troops. But I’m committed to finding out everything we can.', metadata={'lang': 'eng', 'section': '1', 'offset': '34652', 'len': '60', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'}),\n",
+       " Document(page_content='The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs. We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains. And tonight I am announcing that we will join our allies in closing off American air space to all Russian flights – further isolating Russia – and adding an additional squeeze –on their economy. The Ruble has lost 30% of its value.', metadata={'lang': 'eng', 'section': '1', 'offset': '3807', 'len': '42', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'}),\n",
+       " Document(page_content='He rejected repeated efforts at diplomacy. He thought the West and NATO wouldn’t respond. And he thought he could divide us at home. We were ready.  Here is what we did. We prepared extensively and carefully.', metadata={'lang': 'eng', 'section': '1', 'offset': '2100', 'len': '42', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'})]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(retriever | get_sources).invoke(query_str)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8f16bf8d",
+   "metadata": {},
+   "source": [
+    "Vectara's \"RAG as a service\" does a lot of the heavy lifting in creating question answering or chatbot chains. The integration with LangChain provides the option to use additional capabilities such as query pre-processing  like `SelfQueryRetriever` or `MultiQueryRetriever`. Let's look at an example of using the [MultiQueryRetriever](https://python.langchain.com/docs/modules/data_connection/retrievers/MultiQueryRetriever).\n",
+    "\n",
+    "Since MQR uses an LLM we have to set that up - here we choose `ChatOpenAI`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e14325b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"President Biden has made several notable quotes and comments. He expressed a commitment to investigate the potential impact of burn pits on soldiers' health, referencing his son's brain cancer [1]. He emphasized the importance of unity among Americans, urging us to see each other as fellow citizens rather than enemies [2]. Biden also highlighted the need for schools to use funds from the American Rescue Plan to hire teachers and address learning loss, while encouraging community involvement in supporting education [3].\""
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.retrievers.multi_query import MultiQueryRetriever\n",
+    "\n",
+    "llm = ChatOpenAI(temperature=0)\n",
+    "mqr = MultiQueryRetriever.from_llm(retriever=retriever, llm=llm)\n",
+    "\n",
+    "(mqr | get_summary).invoke(query_str)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fa14f923",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='When they came home, many of the world’s fittest and best trained warriors were never the same. Dizziness. \\n\\nA cancer that would put them in a flag-draped coffin. I know. \\n\\nOne of those soldiers was my son Major Beau Biden. We don’t know for sure if a burn pit was the cause of his brain cancer, or the diseases of so many of our troops. But I’m committed to finding out everything we can.', metadata={'lang': 'eng', 'section': '1', 'offset': '34652', 'len': '60', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'}),\n",
+       " Document(page_content='The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs. We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains. And tonight I am announcing that we will join our allies in closing off American air space to all Russian flights – further isolating Russia – and adding an additional squeeze –on their economy. The Ruble has lost 30% of its value.', metadata={'lang': 'eng', 'section': '1', 'offset': '3807', 'len': '42', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'}),\n",
+       " Document(page_content='And, if Congress provides the funds we need, we’ll have new stockpiles of tests, masks, and pills ready if needed. I cannot promise a new variant won’t come. But I can promise you we’ll do everything within our power to be ready if it does. Third – we can end the shutdown of schools and businesses. We have the tools we need.', metadata={'lang': 'eng', 'section': '1', 'offset': '24753', 'len': '82', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'}),\n",
+       " Document(page_content='The returned results did not contain sufficient information to be summarized into a useful answer for your query. Please try a different search or restate your query differently.', metadata={'summary': True}),\n",
+       " Document(page_content='Danielle says Heath was a fighter to the very end. He didn’t know how to stop fighting, and neither did she. Through her pain she found purpose to demand we do better. Tonight, Danielle—we are. The VA is pioneering new ways of linking toxic exposures to diseases, already helping more veterans get benefits.', metadata={'lang': 'eng', 'section': '1', 'offset': '35502', 'len': '58', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'}),\n",
+       " Document(page_content='Let’s stop seeing each other as enemies, and start seeing each other for who we really are: Fellow Americans. We can’t change how divided we’ve been. But we can change how we move forward—on COVID-19 and other issues we must face together. I recently visited the New York City Police Department days after the funerals of Officer Wilbert Mora and his partner, Officer Jason Rivera. They were responding to a 9-1-1 call when a man shot and killed them with a stolen gun.', metadata={'lang': 'eng', 'section': '1', 'offset': '26312', 'len': '89', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'}),\n",
+       " Document(page_content='The American Rescue Plan gave schools money to hire teachers and help students make up for lost learning. I urge every parent to make sure your school does just that. And we can all play a part—sign up to be a tutor or a mentor. Children were also struggling before the pandemic. Bullying, violence, trauma, and the harms of social media.', metadata={'lang': 'eng', 'section': '1', 'offset': '33227', 'len': '61', 'X-TIKA:Parsed-By': 'org.apache.tika.parser.csv.TextAndCSVParser', 'Content-Encoding': 'UTF-8', 'Content-Type': 'text/plain; charset=UTF-8', 'source': 'vectara'})]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(mqr | get_sources).invoke(query_str)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16853820",
+   "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.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/integrations/providers/vectara/vectara_text_generation.ipynb

@@ -1,199 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Vectara Text Generation\n",
-    "\n",
-    "This notebook is based on [text generation](https://github.com/langchain-ai/langchain/blob/master/docs/modules/chains/index_examples/vector_db_text_generation.ipynb) notebook and adapted to Vectara."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Prepare Data\n",
-    "\n",
-    "First, we prepare the data. For this example, we fetch a documentation site that consists of markdown files hosted on Github and split them into small enough Documents."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import pathlib\n",
-    "import subprocess\n",
-    "import tempfile\n",
-    "\n",
-    "from langchain.docstore.document import Document\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.vectorstores import Vectara"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Cloning into '.'...\n"
-     ]
-    }
-   ],
-   "source": [
-    "def get_github_docs(repo_owner, repo_name):\n",
-    "    with tempfile.TemporaryDirectory() as d:\n",
-    "        subprocess.check_call(\n",
-    "            f\"git clone --depth 1 https://github.com/{repo_owner}/{repo_name}.git .\",\n",
-    "            cwd=d,\n",
-    "            shell=True,\n",
-    "        )\n",
-    "        git_sha = (\n",
-    "            subprocess.check_output(\"git rev-parse HEAD\", shell=True, cwd=d)\n",
-    "            .decode(\"utf-8\")\n",
-    "            .strip()\n",
-    "        )\n",
-    "        repo_path = pathlib.Path(d)\n",
-    "        markdown_files = list(repo_path.glob(\"*/*.md\")) + list(\n",
-    "            repo_path.glob(\"*/*.mdx\")\n",
-    "        )\n",
-    "        for markdown_file in markdown_files:\n",
-    "            with open(markdown_file, \"r\") as f:\n",
-    "                relative_path = markdown_file.relative_to(repo_path)\n",
-    "                github_url = f\"https://github.com/{repo_owner}/{repo_name}/blob/{git_sha}/{relative_path}\"\n",
-    "                yield Document(page_content=f.read(), metadata={\"source\": github_url})\n",
-    "\n",
-    "\n",
-    "sources = get_github_docs(\"yirenlu92\", \"deno-manual-forked\")\n",
-    "\n",
-    "source_chunks = []\n",
-    "splitter = CharacterTextSplitter(separator=\" \", chunk_size=1024, chunk_overlap=0)\n",
-    "for source in sources:\n",
-    "    for chunk in splitter.split_text(source.page_content):\n",
-    "        source_chunks.append(chunk)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Set Up Vector DB\n",
-    "\n",
-    "Now that we have the documentation content in chunks, let's put all this information in a vector index for easy retrieval."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "search_index = Vectara.from_texts(source_chunks, embedding=None)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Set Up LLM Chain with Custom Prompt\n",
-    "\n",
-    "Next, let's set up a simple LLM chain but give it a custom prompt for blog post generation. Note that the custom prompt is parameterized and takes two inputs: `context`, which will be the documents fetched from the vector search, and `topic`, which is given by the user."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains import LLMChain\n",
-    "\n",
-    "prompt_template = \"\"\"Use the context below to write a 400 word blog post about the topic below:\n",
-    "    Context: {context}\n",
-    "    Topic: {topic}\n",
-    "    Blog post:\"\"\"\n",
-    "\n",
-    "PROMPT = PromptTemplate(template=prompt_template, input_variables=[\"context\", \"topic\"])\n",
-    "\n",
-    "llm = OpenAI(openai_api_key=os.environ[\"OPENAI_API_KEY\"], temperature=0)\n",
-    "\n",
-    "chain = LLMChain(llm=llm, prompt=PROMPT)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Generate Text\n",
-    "\n",
-    "Finally, we write a function to apply our inputs to the chain. The function takes an input parameter `topic`. We find the documents in the vector index that correspond to that `topic`, and use them as additional context in our simple LLM chain."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def generate_blog_post(topic):\n",
-    "    docs = search_index.similarity_search(topic, k=4)\n",
-    "    inputs = [{\"context\": doc.page_content, \"topic\": topic} for doc in docs]\n",
-    "    print(chain.apply(inputs))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[{'text': '\\n\\nWhen it comes to running Deno CLI tasks, environment variables can be a powerful tool for customizing the behavior of your tasks. With the Deno Task Definition interface, you can easily configure environment variables to be set when executing your tasks.\\n\\nThe Deno Task Definition interface is configured in a `tasks.json` within your workspace. It includes a `env` field, which allows you to specify any environment variables that should be set when executing the task. For example, if you wanted to set the `NODE_ENV` environment variable to `production` when running a Deno task, you could add the following to your `tasks.json`:\\n\\n```json\\n{\\n \"version\": \"2.0.0\",\\n \"tasks\": [\\n {\\n \"type\": \"deno\",\\n \"command\": \"run\",\\n \"args\": [\\n \"mod.ts\"\\n ],\\n \"env\": {\\n \"NODE_ENV\": \"production\"\\n },\\n \"problemMatcher\": [\\n \"$deno\"\\n ],\\n \"label\": \"deno: run\"\\n }\\n ]\\n}\\n```\\n\\nThe Deno language server and this extension also'}, {'text': '\\n\\nEnvironment variables are a great way to store and access data in your applications. They are especially useful when you need to store sensitive information such as API keys, passwords, and other credentials.\\n\\nDeno.env is a library that provides getter and setter methods for environment variables. This makes it easy to store and retrieve data from environment variables. For example, you can use the setter method to set a variable like this:\\n\\n```ts\\nDeno.env.set(\"FIREBASE_API_KEY\", \"examplekey123\");\\nDeno.env.set(\"FIREBASE_AUTH_DOMAIN\", \"firebasedomain.com\");\\n```\\n\\nAnd then you can use the getter method to retrieve the data like this:\\n\\n```ts\\nconsole.log(Deno.env.get(\"FIREBASE_API_KEY\")); // examplekey123\\nconsole.log(Deno.env.get(\"FIREBASE_AUTH_DOMAIN\")); // firebasedomain.com\\n```\\n\\nYou can also store environment variables in a `.env` file and retrieve them using `dotenv` in the standard'}, {'text': '\\n\\nEnvironment variables are a powerful tool for developers, allowing them to store and access data without hard-coding it into their applications. Deno, the secure JavaScript and TypeScript runtime, offers built-in support for environment variables with the `Deno.env` API.\\n\\nUsing `Deno.env` is simple. It has getter and setter methods that allow you to easily set and retrieve environment variables. For example, you can set the `FIREBASE_API_KEY` and `FIREBASE_AUTH_DOMAIN` environment variables like this:\\n\\n```ts\\nDeno.env.set(\"FIREBASE_API_KEY\", \"examplekey123\");\\nDeno.env.set(\"FIREBASE_AUTH_DOMAIN\", \"firebasedomain.com\");\\n```\\n\\nAnd then you can retrieve them like this:\\n\\n```ts\\nconsole.log(Deno.env.get(\"FIREBASE_API_KEY\")); // examplekey123\\nconsole.log(Deno.env.get(\"FIREBASE_AUTH_DOMAIN\")); // firebasedomain.com\\n```'}, {'text': '\\n\\nEnvironment variables are an important part of any programming language, and Deno is no exception. Environment variables are used to store information about the environment in which a program is running, such as the operating system, user preferences, and other settings. In Deno, environment variables are used to set up proxies, control the output of colors, and more.\\n\\nThe `NO_PROXY` environment variable is a de facto standard in Deno that indicates which hosts should bypass the proxy set in other environment variables. This is useful for developers who want to access certain resources without having to go through a proxy. For more information on this standard, you can check out the website no-color.org.\\n\\nThe `Deno.noColor` environment variable is another important environment variable in Deno. This variable is used to control the output of colors in the Deno terminal. By setting this variable to true, you can disable the output of colors in the terminal. This can be useful for developers who want to focus on the output of their code without being distracted by the colors.\\n\\nFinally, the `Deno.env` environment variable is used to access the environment variables set in the Deno runtime. This variable is useful for developers who want'}]\n"
-     ]
-    }
-   ],
-   "source": [
-    "generate_blog_post(\"environment variables\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

docs/docs/integrations/retrievers/self_query/vectara_self_query.ipynb

@@ -5,12 +5,19 @@
    "id": "13afcae7",
    "metadata": {},
    "source": [
-    "# Vectara\n",
+    "# Vectara self-querying \n",
     "\n",
-    ">[Vectara](https://docs.vectara.com/docs/) is a GenAI platform for developers. It provides a simple API to build Grounded Generation\n",
-    ">(aka Retrieval-augmented-generation or RAG) applications.\n",
+    ">[Vectara](https://vectara.com/) is the trusted GenAI platform that provides an easy-to-use API for document indexing and querying. \n",
     "\n",
-    "In the notebook, we'll demo the `SelfQueryRetriever` wrapped around a Vectara vector store. "
+    "Vectara provides an end-to-end managed service for Retrieval Augmented Generation or [RAG](https://vectara.com/grounded-generation/), which includes:\n",
+    "1. A way to extract text from document files and chunk them into sentences.\n",
+    "2. The state-of-the-art [Boomerang](https://vectara.com/how-boomerang-takes-retrieval-augmented-generation-to-the-next-level-via-grounded-generation/) embeddings model. Each text chunk is encoded into a vector embedding using Boomerang, and stored in the Vectara internal knowledge (vector+text) store\n",
+    "3. A query service that automatically encodes the query into embedding, and retrieves the most relevant text segments (including support for [Hybrid Search](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching) and [MMR](https://vectara.com/get-diverse-results-and-comprehensive-summaries-with-vectaras-mmr-reranker/))\n",
+    "4. An option to create [generative summary](https://docs.vectara.com/docs/learn/grounded-generation/grounded-generation-overview), based on the retrieved documents, including citations.\n",
+    "\n",
+    "See the [Vectara API documentation](https://docs.vectara.com/docs/) for more information on how to use the API.\n",
+    "\n",
+    "This notebook shows how to use `SelfQueryRetriever` with Vectara."
    ]
   },
   {
@@ -75,11 +82,14 @@
    },
    "outputs": [],
    "source": [
+    "from langchain.chains import ConversationalRetrievalChain\n",
     "from langchain.chains.query_constructor.base import AttributeInfo\n",
+    "from langchain.document_loaders import TextLoader\n",
     "from langchain.embeddings import FakeEmbeddings\n",
     "from langchain.llms import OpenAI\n",
     "from langchain.retrievers.self_query.base import SelfQueryRetriever\n",
     "from langchain.schema import Document\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain.vectorstores import Vectara"
    ]
   },
@@ -197,29 +207,15 @@
    "id": "38a126e9",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ofer/dev/langchain/libs/langchain/langchain/chains/llm.py:278: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query='dinosaur' filter=None limit=None\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
        "[Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'lang': 'eng', 'offset': '0', 'len': '66', 'year': '1993', 'rating': '7.7', 'genre': 'science fiction', 'source': 'langchain'}),\n",
        " Document(page_content='Toys come alive and have a blast doing so', metadata={'lang': 'eng', 'offset': '0', 'len': '41', 'year': '1995', 'genre': 'animated', 'source': 'langchain'}),\n",
-       " Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'lang': 'eng', 'offset': '0', 'len': '60', 'year': '1979', 'rating': '9.9', 'director': 'Andrei Tarkovsky', 'genre': 'science fiction', 'source': 'langchain'}),\n",
+       " Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'lang': 'eng', 'offset': '0', 'len': '116', 'year': '2006', 'director': 'Satoshi Kon', 'rating': '8.6', 'source': 'langchain'}),\n",
        " Document(page_content='Leo DiCaprio gets lost in a dream within a dream within a dream within a ...', metadata={'lang': 'eng', 'offset': '0', 'len': '76', 'year': '2010', 'director': 'Christopher Nolan', 'rating': '8.2', 'source': 'langchain'}),\n",
-       " Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'lang': 'eng', 'offset': '0', 'len': '116', 'year': '2006', 'director': 'Satoshi Kon', 'rating': '8.6', 'source': 'langchain'})]"
+       " Document(page_content='A bunch of normal-sized women are supremely wholesome and some men pine after them', metadata={'lang': 'eng', 'offset': '0', 'len': '82', 'year': '2019', 'director': 'Greta Gerwig', 'rating': '8.3', 'source': 'langchain'}),\n",
+       " Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'lang': 'eng', 'offset': '0', 'len': '60', 'year': '1979', 'rating': '9.9', 'director': 'Andrei Tarkovsky', 'genre': 'science fiction', 'source': 'langchain'})]"
       ]
      },
      "execution_count": 5,
@@ -238,18 +234,11 @@
    "id": "fc3f1e6e",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query=' ' filter=Comparison(comparator=<Comparator.GT: 'gt'>, attribute='rating', value=8.5) limit=None\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "[Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'lang': 'eng', 'offset': '0', 'len': '60', 'year': '1979', 'rating': '9.9', 'director': 'Andrei Tarkovsky', 'genre': 'science fiction', 'source': 'langchain'}),\n",
-       " Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'lang': 'eng', 'offset': '0', 'len': '116', 'year': '2006', 'director': 'Satoshi Kon', 'rating': '8.6', 'source': 'langchain'})]"
+       "[Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'lang': 'eng', 'offset': '0', 'len': '116', 'year': '2006', 'director': 'Satoshi Kon', 'rating': '8.6', 'source': 'langchain'}),\n",
+       " Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'lang': 'eng', 'offset': '0', 'len': '60', 'year': '1979', 'rating': '9.9', 'director': 'Andrei Tarkovsky', 'genre': 'science fiction', 'source': 'langchain'})]"
       ]
      },
      "execution_count": 6,
@@ -268,13 +257,6 @@
    "id": "b19d4da0",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query='women' filter=Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='director', value='Greta Gerwig') limit=None\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
@@ -297,13 +279,6 @@
    "id": "f900e40e",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query=' ' filter=Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.GTE: 'gte'>, attribute='rating', value=8.5), Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='genre', value='science fiction')]) limit=None\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
@@ -328,13 +303,6 @@
    "id": "12a51522",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query='toys' filter=Operation(operator=<Operator.AND: 'and'>, arguments=[Comparison(comparator=<Comparator.GT: 'gt'>, attribute='year', value=1990), Comparison(comparator=<Comparator.LT: 'lt'>, attribute='year', value=2005), Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='genre', value='animated')]) limit=None\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
@@ -392,13 +360,6 @@
     "tags": []
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query='dinosaur' filter=None limit=2\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
@@ -433,7 +394,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

docs/docs/integrations/text_embedding/together.ipynb

@@ -42,7 +42,7 @@
     "\n",
     "Make sure to set the following environment variables:\n",
     "\n",
-    "- TODO: fill out relevant environment variables or secrets\n",
+    "- `TOGETHER_API_KEY`\n",
     "\n",
     "## Usage"
    ]

docs/docs/integrations/toolkits/steam.ipynb

@@ -25,7 +25,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install python-steam-api, decouple"
+    "!pip install python-steam-api python-decouple"
    ]
   },
   {

docs/docs/integrations/vectorstores/alibabacloud_opensearch.ipynb

@@ -8,20 +8,53 @@
     "\n",
     ">[Alibaba Cloud Opensearch](https://www.alibabacloud.com/product/opensearch) is a one-stop platform to develop intelligent search services. `OpenSearch` was built on the large-scale distributed search engine developed by `Alibaba`. `OpenSearch` serves more than 500 business cases in Alibaba Group and thousands of Alibaba Cloud customers. `OpenSearch` helps develop search services in different search scenarios, including e-commerce, O2O, multimedia, the content industry, communities and forums, and big data query in enterprises.\n",
     "\n",
-    ">`OpenSearch` helps you develop high quality, maintenance-free, and high performance intelligent search services to provide your users with high search efficiency and accuracy.\n",
+    ">`OpenSearch` helps you develop high-quality, maintenance-free, and high-performance intelligent search services to provide your users with high search efficiency and accuracy.\n",
     "\n",
     ">`OpenSearch` provides the vector search feature. In specific scenarios, especially test question search and image search scenarios, you can use the vector search feature together with the multimodal search feature to improve the accuracy of search results.\n",
     "\n",
-    "This notebook shows how to use functionality related to the `Alibaba Cloud OpenSearch Vector Search Edition`.\n",
-    "To run, you should have an [OpenSearch Vector Search Edition](https://opensearch.console.aliyun.com) instance up and running:\n",
+    "This notebook shows how to use functionality related to the `Alibaba Cloud OpenSearch Vector Search Edition`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up\n",
     "\n",
-    "Read the [help document](https://www.alibabacloud.com/help/en/opensearch/latest/vector-search) to quickly familiarize and configure OpenSearch Vector Search Edition instance."
+    "\n",
+    "### Purchase an instance and configure it\n",
+    "\n",
+    "Purchase OpenSearch Vector Search Edition from [Alibaba Cloud](https://opensearch.console.aliyun.com) and configure the instance according to the help [documentation](https://help.aliyun.com/document_detail/463198.html?spm=a2c4g.465092.0.0.2cd15002hdwavO).\n",
+    "\n",
+    "To run, you should have an [OpenSearch Vector Search Edition](https://opensearch.console.aliyun.com) instance up and running.\n",
+    "\n",
+    "  \n",
+    "### Alibaba Cloud OpenSearch Vector Store class\n",
+    "                                                                                                                `AlibabaCloudOpenSearch` class supports functions:\n",
+    "- `add_texts`\n",
+    "- `add_documents`\n",
+    "- `from_texts`\n",
+    "- `from_documents`\n",
+    "- `similarity_search`\n",
+    "- `asimilarity_search`\n",
+    "- `similarity_search_by_vector`\n",
+    "- `asimilarity_search_by_vector`\n",
+    "- `similarity_search_with_relevance_scores`\n",
+    "- `delete_doc_by_texts`\n",
+    "\n",
+    "\n",
+    "Read the [help document](https://www.alibabacloud.com/help/en/opensearch/latest/vector-search) to quickly familiarize and configure OpenSearch Vector Search Edition instance.\n",
+    "\n",
+    "If you encounter any problems during use, please feel free to contact [xingshaomin.xsm@alibaba-inc.com](xingshaomin.xsm@alibaba-inc.com), and we will do our best to provide you with assistance and support."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
    },
    "source": [
     "After the instance is up and running, follow these steps to split documents, get embeddings, connect to the alibaba cloud opensearch instance, index documents, and perform vector retrieval."
@@ -30,7 +63,10 @@
   {
    "cell_type": "markdown",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
    },
    "source": [
     "We need to install the following Python packages first."
@@ -48,7 +84,10 @@
   {
    "cell_type": "markdown",
    "metadata": {
-    "collapsed": false
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
    },
    "source": [
     "We want to use `OpenAIEmbeddings` so we have to get the OpenAI API Key."
@@ -59,6 +98,9 @@
    "execution_count": null,
    "metadata": {
     "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
     "pycharm": {
      "name": "#%%\n"
     }
@@ -71,6 +113,13 @@
     "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -359,9 +408,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
+}

docs/docs/integrations/vectorstores/vectara.ipynb

@@ -7,16 +7,17 @@
    "source": [
     "# Vectara\n",
     "\n",
-    ">[Vectara](https://vectara.com/) is a API platform for building GenAI applications. It provides an easy-to-use API for document indexing and querying that is managed by Vectara and is optimized for performance and accuracy. \n",
-    "See the [Vectara API documentation ](https://docs.vectara.com/docs/) for more information on how to use the API.\n",
+    ">[Vectara](https://vectara.com/) is the trusted GenAI platform that provides an easy-to-use API for document indexing and querying. \n",
     "\n",
-    "This notebook shows how to use functionality related to the `Vectara`'s integration with langchain.\n",
-    "Note that unlike many other integrations in this category, Vectara provides an end-to-end managed service for [Grounded Generation](https://vectara.com/grounded-generation/) (aka retrieval augmented generation), which includes:\n",
+    "Vectara provides an end-to-end managed service for Retrieval Augmented Generation or [RAG](https://vectara.com/grounded-generation/), which includes:\n",
     "1. A way to extract text from document files and chunk them into sentences.\n",
-    "2. Its own embeddings model and vector store - each text segment is encoded into a vector embedding and stored in the Vectara internal vector store\n",
-    "3. A query service that automatically encodes the query into embedding, and retrieves the most relevant text segments (including support for [Hybrid Search](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching))\n",
+    "2. The state-of-the-art [Boomerang](https://vectara.com/how-boomerang-takes-retrieval-augmented-generation-to-the-next-level-via-grounded-generation/) embeddings model. Each text chunk is encoded into a vector embedding using Boomerang, and stored in the Vectara internal knowledge (vector+text) store\n",
+    "3. A query service that automatically encodes the query into embedding, and retrieves the most relevant text segments (including support for [Hybrid Search](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching) and [MMR](https://vectara.com/get-diverse-results-and-comprehensive-summaries-with-vectaras-mmr-reranker/))\n",
+    "4. An option to create [generative summary](https://docs.vectara.com/docs/learn/grounded-generation/grounded-generation-overview), based on the retrieved documents, including citations.\n",
     "\n",
-    "All of these are supported in this LangChain integration."
+    "See the [Vectara API documentation](https://docs.vectara.com/docs/) for more information on how to use the API.\n",
+    "\n",
+    "This notebook shows how to use the basic retrieval functionality, when utilizing Vectara just as a Vector Store (without summarization), incuding: `similarity_search` and `similarity_search_with_score` as well as using the LangChain `as_retriever` functionality."
    ]
   },
   {
@@ -26,8 +27,8 @@
    "source": [
     "# Setup\n",
     "\n",
-    "You will need a Vectara account to use Vectara with LangChain. To get started, use the following steps (see our [quickstart](https://docs.vectara.com/docs/quickstart) guide):\n",
-    "1. [Sign up](https://vectara.com/integrations/langchain) for a Vectara account if you don't already have one. Once you have completed your sign up you will have a Vectara customer ID. You can find your customer ID by clicking on your name, on the top-right of the Vectara console window.\n",
+    "You will need a Vectara account to use Vectara with LangChain. To get started, use the following steps:\n",
+    "1. [Sign up](https://www.vectara.com/integrations/langchain) for a Vectara account if you don't already have one. Once you have completed your sign up you will have a Vectara customer ID. You can find your customer ID by clicking on your name, on the top-right of the Vectara console window.\n",
     "2. Within your account you can create one or more corpora. Each corpus represents an area that stores text data upon ingest from input documents. To create a corpus, use the **\"Create Corpus\"** button. You then provide a name to your corpus as well as a description. Optionally you can define filtering attributes and apply some advanced options. If you click on your created corpus, you can see its name and corpus ID right on the top.\n",
     "3. Next you'll need to create API keys to access the corpus. Click on the **\"Authorization\"** tab in the corpus view and then the **\"Create API Key\"** button. Give your key a name, and choose whether you want query only or query+index for your key. Click \"Create\" and you now have an active API key. Keep this key confidential. \n",
     "\n",
@@ -47,7 +48,7 @@
     "os.environ[\"VECTARA_API_KEY\"] = getpass.getpass(\"Vectara API Key:\")\n",
     "```\n",
     "\n",
-    "1. Provide them as arguments when creating the Vectara vectorstore object:\n",
+    "2. Add them to the Vectara vectorstore constructor:\n",
     "\n",
     "```python\n",
     "vectorstore = Vectara(\n",
@@ -65,44 +66,31 @@
    "source": [
     "## Connecting to Vectara from LangChain\n",
     "\n",
-    "In this example, we assume that you've created an account and a corpus, and added your VECTARA_CUSTOMER_ID, VECTARA_CORPUS_ID and VECTARA_API_KEY (created with permissions for both indexing and query) as environment variables.\n",
-    "\n",
-    "The corpus has 3 fields defined as metadata for filtering:\n",
-    "\n",
-    "* url: a string field containing the source URL of the document (where relevant)\n",
-    "* speech: a string field containing the name of the speech\n",
-    "* author: the name of the author\n",
-    "\n",
-    "Let's start by ingesting 3 documents into the corpus:\n",
-    "1. The State of the Union speech from 2022, available in the LangChain repository as a text file\n",
-    "2. The \"I have a dream\" speech by Dr. Kind\n",
-    "3. The \"We shall Fight on the Beaches\" speech by Winston Churchil"
+    "To get started, let's ingest the documents using the from_documents() method.\n",
+    "We assume here that you've added your VECTARA_CUSTOMER_ID, VECTARA_CORPUS_ID and query+indexing VECTARA_API_KEY as environment variables."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "04a1f1a0",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains.query_constructor.base import AttributeInfo\n",
     "from langchain.document_loaders import TextLoader\n",
-    "from langchain.embeddings import FakeEmbeddings\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.retrievers.self_query.base import SelfQueryRetriever\n",
+    "from langchain.embeddings.fake import FakeEmbeddings\n",
     "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain.vectorstores import Vectara"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "be0a4973",
    "metadata": {},
    "outputs": [],
    "source": [
-    "loader = TextLoader(\"../../modules/state_of_the_union.txt\")\n",
+    "loader = TextLoader(\"state_of_the_union.txt\")\n",
     "documents = loader.load()\n",
     "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
     "docs = text_splitter.split_documents(documents)"
@@ -110,7 +98,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "8429667e",
    "metadata": {
     "ExecuteTime": {
@@ -124,7 +112,7 @@
     "vectara = Vectara.from_documents(\n",
     "    docs,\n",
     "    embedding=FakeEmbeddings(size=768),\n",
-    "    doc_metadata={\"speech\": \"state-of-the-union\", \"author\": \"Biden\"},\n",
+    "    doc_metadata={\"speech\": \"state-of-the-union\"},\n",
     ")"
    ]
   },
@@ -144,7 +132,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "85ef3468",
    "metadata": {},
    "outputs": [],
@@ -156,16 +144,14 @@
     "    [\n",
     "        \"https://www.gilderlehrman.org/sites/default/files/inline-pdfs/king.dreamspeech.excerpts.pdf\",\n",
     "        \"I-have-a-dream\",\n",
-    "        \"Dr. King\",\n",
     "    ],\n",
     "    [\n",
     "        \"https://www.parkwayschools.net/cms/lib/MO01931486/Centricity/Domain/1578/Churchill_Beaches_Speech.pdf\",\n",
     "        \"we shall fight on the beaches\",\n",
-    "        \"Churchil\",\n",
     "    ],\n",
     "]\n",
     "files_list = []\n",
-    "for url, _, _ in urls:\n",
+    "for url, _ in urls:\n",
     "    name = tempfile.NamedTemporaryFile().name\n",
     "    urllib.request.urlretrieve(url, name)\n",
     "    files_list.append(name)\n",
@@ -173,9 +159,7 @@
     "docsearch: Vectara = Vectara.from_files(\n",
     "    files=files_list,\n",
     "    embedding=FakeEmbeddings(size=768),\n",
-    "    metadatas=[\n",
-    "        {\"url\": url, \"speech\": title, \"author\": author} for url, title, author in urls\n",
-    "    ],\n",
+    "    metadatas=[{\"url\": url, \"speech\": title} for url, title in urls],\n",
     ")"
    ]
   },
@@ -196,7 +180,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "a8c513ab",
    "metadata": {
     "ExecuteTime": {
@@ -213,6 +197,36 @@
     ")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "53324492",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '596', 'len': '97', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.”', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '141', 'len': '117', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='As Ohio Senator Sherrod Brown says, “It’s time to bury the label “Rust Belt.”', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '0', 'len': '77', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='Last month, I announced our plan to supercharge  \\nthe Cancer Moonshot that President Obama asked me to lead six years ago.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '0', 'len': '122', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='He thought he could roll into Ukraine and the world would roll over.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '664', 'len': '68', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='That’s why one of the first things I did as President was fight to pass the American Rescue Plan.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '314', 'len': '97', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='And he thought he could divide us at home.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '160', 'len': '42', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='He met the Ukrainian people.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '788', 'len': '28', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='He thought the West and NATO wouldn’t respond.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '113', 'len': '46', 'speech': 'state-of-the-union'}),\n",
+       " Document(page_content='In this Capitol, generation after generation, Americans have debated great questions amid great strife, and have done great things.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '772', 'len': '131', 'speech': 'state-of-the-union'})]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "found_docs"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -284,7 +298,7 @@
      "text": [
       "Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice.\n",
       "\n",
-      "Score: 0.8299499\n"
+      "Score: 0.74179757\n"
      ]
     }
    ],
@@ -330,14 +344,14 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "id": "3e22949f",
+   "id": "29f465e5",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "With this threshold of 0.2 we have 5 documents\n"
+      "With this threshold of 0.2 we have 10 documents\n"
      ]
     }
    ],
@@ -354,17 +368,104 @@
   },
   {
    "cell_type": "markdown",
-   "id": "691a82d6",
+   "id": "471112c0",
    "metadata": {},
    "source": [
-    "## Vectara as a Retriever\n",
+    "MMR is an important retrieval capability for many applications, whereby search results feeding your GenAI application are reranked to improve diversity of results. \n",
     "\n",
-    "Vectara, as all the other LangChain vectorstores, is most often used as a LangChain Retriever:"
+    "Let's see how that works with Vectara:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 12,
+   "id": "5d597e91",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Economic assistance.\n",
+      "\n",
+      "Grow the workforce. Build the economy from the bottom up  \n",
+      "and the middle out, not from the top down.\n",
+      "\n",
+      "When we invest in our workers, when we build the economy from the bottom up and the middle out together, we can do something we haven’t done in a long time: build a better America.\n",
+      "\n",
+      "Our economy grew at a rate of 5.7% last year, the strongest growth in nearly 40 years, the first step in bringing fundamental change to an economy that hasn’t worked for the working people of this nation for too long.\n",
+      "\n",
+      "Economists call it “increasing the productive capacity of our economy.”\n"
+     ]
+    }
+   ],
+   "source": [
+    "query = \"state of the economy\"\n",
+    "found_docs = vectara.similarity_search(\n",
+    "    query,\n",
+    "    n_sentence_context=0,\n",
+    "    filter=\"doc.speech = 'state-of-the-union'\",\n",
+    "    k=5,\n",
+    "    mmr_config={\"is_enabled\": True, \"mmr_k\": 50, \"diversity_bias\": 0.0},\n",
+    ")\n",
+    "print(\"\\n\\n\".join([x.page_content for x in found_docs]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "be2b2326",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Economic assistance.\n",
+      "\n",
+      "The Russian stock market has lost 40% of its value and trading remains suspended.\n",
+      "\n",
+      "But that trickle-down theory led to weaker economic growth, lower wages, bigger deficits, and the widest gap between those at the top and everyone else in nearly a century.\n",
+      "\n",
+      "In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections.\n",
+      "\n",
+      "The federal government spends about $600 Billion a year to keep the country safe and secure.\n"
+     ]
+    }
+   ],
+   "source": [
+    "query = \"state of the economy\"\n",
+    "found_docs = vectara.similarity_search(\n",
+    "    query,\n",
+    "    n_sentence_context=0,\n",
+    "    filter=\"doc.speech = 'state-of-the-union'\",\n",
+    "    k=5,\n",
+    "    mmr_config={\"is_enabled\": True, \"mmr_k\": 50, \"diversity_bias\": 1.0},\n",
+    ")\n",
+    "print(\"\\n\\n\".join([x.page_content for x in found_docs]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10c1427e",
+   "metadata": {},
+   "source": [
+    "As you can see, in the first example diversity_bias was set to 0.0 (equivalent to diversity reranking disabled), which resulted in a the top-5 most relevant documents. With diversity_bias=1.0 we maximize diversity and as you can see the resulting top documents are much more diverse in their semantic meanings."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "691a82d6",
+   "metadata": {},
+   "source": [
+    "## Vectara as a Retriever\n",
+    "\n",
+    "Finally let's see how to use Vectara with the `as_retriever()` interface:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
    "id": "9427195f",
    "metadata": {
     "ExecuteTime": {
@@ -376,10 +477,10 @@
     {
      "data": {
       "text/plain": [
-       "VectaraRetriever(tags=['Vectara'], metadata=None, vectorstore=<langchain.vectorstores.vectara.Vectara object at 0x13b15e9b0>, search_type='similarity', search_kwargs={'lambda_val': 0.025, 'k': 5, 'filter': '', 'n_sentence_context': '2'})"
+       "VectorStoreRetriever(tags=['Vectara'], vectorstore=<langchain.vectorstores.vectara.Vectara object at 0x109a3c760>)"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -391,22 +492,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 15,
    "id": "f3c70c31",
    "metadata": {
     "ExecuteTime": {
      "end_time": "2023-04-04T10:51:26.495652Z",
      "start_time": "2023-04-04T10:51:26.046407Z"
-    }
+    },
+    "scrolled": false
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Document(page_content='Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '596', 'len': '97', 'speech': 'state-of-the-union', 'author': 'Biden'})"
+       "Document(page_content='Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '596', 'len': '97', 'speech': 'state-of-the-union'})"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -416,118 +518,10 @@
     "retriever.get_relevant_documents(query)[0]"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "e944c26a",
-   "metadata": {},
-   "source": [
-    "## Using Vectara as a SelfQuery Retriever"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "8be674de",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "metadata_field_info = [\n",
-    "    AttributeInfo(\n",
-    "        name=\"speech\",\n",
-    "        description=\"what name of the speech\",\n",
-    "        type=\"string or list[string]\",\n",
-    "    ),\n",
-    "    AttributeInfo(\n",
-    "        name=\"author\",\n",
-    "        description=\"author of the speech\",\n",
-    "        type=\"string or list[string]\",\n",
-    "    ),\n",
-    "]\n",
-    "document_content_description = \"the text of the speech\"\n",
-    "\n",
-    "vectordb = Vectara()\n",
-    "llm = OpenAI(temperature=0)\n",
-    "retriever = SelfQueryRetriever.from_llm(\n",
-    "    llm, vectara, document_content_description, metadata_field_info, verbose=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "f8938999",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/ofer/dev/langchain/libs/langchain/langchain/chains/llm.py:278: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query='freedom' filter=Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='author', value='Biden') limit=None\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='Well I know this nation. We will meet the test. To protect freedom and liberty, to expand fairness and opportunity. We will save democracy. As hard as these times have been, I am more optimistic about America today than I have been my whole life.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '346', 'len': '67', 'speech': 'state-of-the-union', 'author': 'Biden'}),\n",
-       " Document(page_content='To our fellow Ukrainian Americans who forge a deep bond that connects our two nations we stand with you. Putin may circle Kyiv with tanks, but he will never gain the hearts and souls of the Ukrainian people. He will never extinguish their love of freedom. He will never weaken the resolve of the free world. We meet tonight in an America that has lived through two of the hardest years this nation has ever faced.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '740', 'len': '47', 'speech': 'state-of-the-union', 'author': 'Biden'}),\n",
-       " Document(page_content='But most importantly as Americans. With a duty to one another to the American people to the Constitution. And with an unwavering resolve that freedom will always triumph over tyranny. Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '413', 'len': '77', 'speech': 'state-of-the-union', 'author': 'Biden'}),\n",
-       " Document(page_content='We can do this. \\n\\nMy fellow Americans—tonight , we have gathered in a sacred space—the citadel of our democracy. In this Capitol, generation after generation, Americans have debated great questions amid great strife, and have done great things. We have fought for freedom, expanded liberty, defeated totalitarianism and terror. And built the strongest, freest, and most prosperous nation the world has ever known. Now is the hour. \\n\\nOur moment of responsibility.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '906', 'len': '82', 'speech': 'state-of-the-union', 'author': 'Biden'}),\n",
-       " Document(page_content='In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections. We cannot let this happen. Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections.', metadata={'source': 'langchain', 'lang': 'eng', 'offset': '0', 'len': '63', 'speech': 'state-of-the-union', 'author': 'Biden'})]"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "retriever.get_relevant_documents(\"what did Biden say about the freedom?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "a97037fb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "query='freedom' filter=Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='author', value='Dr. King') limit=None\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='And if America is to be a great nation, this must become true. So\\nlet freedom ring from the prodigious hilltops of New Hampshire. Let freedom ring from the mighty\\nmountains of New York. Let freedom ring from the heightening Alleghenies of Pennsylvania. Let\\nfreedom ring from the snowcapped Rockies of Colorado.', metadata={'lang': 'eng', 'section': '3', 'offset': '1534', 'len': '55', 'CreationDate': '1424880481', 'Producer': 'Adobe PDF Library 10.0', 'Author': 'Sasha Rolon-Pereira', 'Title': 'Martin Luther King Jr.pdf', 'Creator': 'Acrobat PDFMaker 10.1 for Word', 'ModDate': '1424880524', 'url': 'https://www.gilderlehrman.org/sites/default/files/inline-pdfs/king.dreamspeech.excerpts.pdf', 'speech': 'I-have-a-dream', 'author': 'Dr. King', 'title': 'Martin Luther King Jr.pdf'}),\n",
-       " Document(page_content='And if America is to be a great nation, this must become true. So\\nlet freedom ring from the prodigious hilltops of New Hampshire. Let freedom ring from the mighty\\nmountains of New York. Let freedom ring from the heightening Alleghenies of Pennsylvania. Let\\nfreedom ring from the snowcapped Rockies of Colorado.', metadata={'lang': 'eng', 'section': '3', 'offset': '1534', 'len': '55', 'CreationDate': '1424880481', 'Producer': 'Adobe PDF Library 10.0', 'Author': 'Sasha Rolon-Pereira', 'Title': 'Martin Luther King Jr.pdf', 'Creator': 'Acrobat PDFMaker 10.1 for Word', 'ModDate': '1424880524', 'url': 'https://www.gilderlehrman.org/sites/default/files/inline-pdfs/king.dreamspeech.excerpts.pdf', 'speech': 'I-have-a-dream', 'author': 'Dr. King', 'title': 'Martin Luther King Jr.pdf'}),\n",
-       " Document(page_content='Let freedom ring from the curvaceous slopes of\\nCalifornia. But not only that. Let freedom ring from Stone Mountain of Georgia. Let freedom ring from Lookout\\nMountain of Tennessee. Let freedom ring from every hill and molehill of Mississippi, from every\\nmountain side. Let freedom ring . . .\\nWhen we allow freedom to ring—when we let it ring from every city and every hamlet, from every state\\nand every city, we will be able to speed up that day when all of God’s children, black men and white\\nmen, Jews and Gentiles, Protestants and Catholics, will be able to join hands and sing in the words of the\\nold Negro spiritual, “Free at last, Free at last, Great God a-mighty, We are free at last.”', metadata={'lang': 'eng', 'section': '3', 'offset': '1842', 'len': '52', 'CreationDate': '1424880481', 'Producer': 'Adobe PDF Library 10.0', 'Author': 'Sasha Rolon-Pereira', 'Title': 'Martin Luther King Jr.pdf', 'Creator': 'Acrobat PDFMaker 10.1 for Word', 'ModDate': '1424880524', 'url': 'https://www.gilderlehrman.org/sites/default/files/inline-pdfs/king.dreamspeech.excerpts.pdf', 'speech': 'I-have-a-dream', 'author': 'Dr. King', 'title': 'Martin Luther King Jr.pdf'}),\n",
-       " Document(page_content='Let freedom ring from the curvaceous slopes of\\nCalifornia. But not only that. Let freedom ring from Stone Mountain of Georgia. Let freedom ring from Lookout\\nMountain of Tennessee. Let freedom ring from every hill and molehill of Mississippi, from every\\nmountain side. Let freedom ring . . .\\nWhen we allow freedom to ring—when we let it ring from every city and every hamlet, from every state\\nand every city, we will be able to speed up that day when all of God’s children, black men and white\\nmen, Jews and Gentiles, Protestants and Catholics, will be able to join hands and sing in the words of the\\nold Negro spiritual, “Free at last, Free at last, Great God a-mighty, We are free at last.”', metadata={'lang': 'eng', 'section': '3', 'offset': '1842', 'len': '52', 'CreationDate': '1424880481', 'Producer': 'Adobe PDF Library 10.0', 'Author': 'Sasha Rolon-Pereira', 'Title': 'Martin Luther King Jr.pdf', 'Creator': 'Acrobat PDFMaker 10.1 for Word', 'ModDate': '1424880524', 'url': 'https://www.gilderlehrman.org/sites/default/files/inline-pdfs/king.dreamspeech.excerpts.pdf', 'speech': 'I-have-a-dream', 'author': 'Dr. King', 'title': 'Martin Luther King Jr.pdf'}),\n",
-       " Document(page_content='Let freedom ring from the mighty\\nmountains of New York. Let freedom ring from the heightening Alleghenies of Pennsylvania. Let\\nfreedom ring from the snowcapped Rockies of Colorado. Let freedom ring from the curvaceous slopes of\\nCalifornia. But not only that. Let freedom ring from Stone Mountain of Georgia.', metadata={'lang': 'eng', 'section': '3', 'offset': '1657', 'len': '57', 'CreationDate': '1424880481', 'Producer': 'Adobe PDF Library 10.0', 'Author': 'Sasha Rolon-Pereira', 'Title': 'Martin Luther King Jr.pdf', 'Creator': 'Acrobat PDFMaker 10.1 for Word', 'ModDate': '1424880524', 'url': 'https://www.gilderlehrman.org/sites/default/files/inline-pdfs/king.dreamspeech.excerpts.pdf', 'speech': 'I-have-a-dream', 'author': 'Dr. King', 'title': 'Martin Luther King Jr.pdf'})]"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "retriever.get_relevant_documents(\"what did Dr. King say about the freedom?\")"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "f6d17e90",
+   "id": "2300e785",
    "metadata": {},
    "outputs": [],
    "source": []

docs/docs/langsmith/index.md

@@ -17,6 +17,6 @@ check out the [LangSmith Cookbook](https://github.com/langchain-ai/langsmith-coo
 - Leveraging user feedback in your JS application ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/feedback-examples/nextjs/README.md)).
 - Building an automated feedback pipeline ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/feedback-examples/algorithmic-feedback/algorithmic_feedback.ipynb)).
 - How to evaluate and audit your RAG workflows ([link](https://github.com/langchain-ai/langsmith-cookbook/tree/main/testing-examples/qa-correctness)).
-- How to fine-tune a LLM on real usage data ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/fine-tuning-examples/export-to-openai/fine-tuning-on-chat-runs.ipynb)).
+- How to fine-tune an LLM on real usage data ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/fine-tuning-examples/export-to-openai/fine-tuning-on-chat-runs.ipynb)).
 - How to use the [LangChain Hub](https://smith.langchain.com/hub) to version your prompts ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/hub-examples/retrieval-qa-chain/retrieval-qa.ipynb))
 

docs/docs/modules/agents/agent_types/xml_agent.ipynb

@@ -177,7 +177,7 @@
     {
      "data": {
       "text/plain": [
-       "{'question': 'whats the weather in New york?',\n",
+       "{'question': 'what's the weather in New york?',\n",
        " 'output': '\\nThe weather in New York is 32 degrees.\\n'}"
       ]
      },
@@ -187,7 +187,7 @@
     }
    ],
    "source": [
-    "agent_executor.invoke({\"question\": \"whats the weather in New york?\"})"
+    "agent_executor.invoke({\"question\": \"what's the weather in New york?\"})"
    ]
   },
   {
@@ -258,7 +258,7 @@
     {
      "data": {
       "text/plain": [
-       "{'input': 'whats the weather in New york?',\n",
+       "{'input': 'what's the weather in New york?',\n",
        " 'output': 'The weather in New York is 32 degrees'}"
       ]
      },
@@ -268,7 +268,7 @@
     }
    ],
    "source": [
-    "agent_executor.invoke({\"input\": \"whats the weather in New york?\"})"
+    "agent_executor.invoke({\"input\": \"what's the weather in New york?\"})"
    ]
   },
   {

docs/docs/modules/memory.ipynb

@@ -0,0 +1,258 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "39402c5b",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 3\n",
+    "sidebar_class_name: hidden\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52b96a57",
+   "metadata": {},
+   "source": [
+    "\n",
+    "# Chat Memory\n",
+    "\n",
+    "Most LLM applications have a conversational interface. An essential component of a conversation is being able to refer to information introduced earlier in the conversation.\n",
+    "\n",
+    "We call this ability to store information about past interactions \"chat memory\".\n",
+    "\n",
+    "A chain will interact with its memory system twice in a given run.\n",
+    "1. AFTER receiving the initial user inputs but BEFORE executing the core logic, a chain will READ from its memory system and augment the user inputs.\n",
+    "2. AFTER executing the core logic but BEFORE returning the answer, a chain will WRITE the inputs and outputs of the current run to memory, so that they can be referred to in future runs.\n",
+    "\n",
+    "![memory-diagram](/img/memory_diagram.png)\n",
+    "\n",
+    "\n",
+    "## [Chat message storage](docs/integrations/memory/)\n",
+    "\n",
+    "Underlying any memory is a history of all chat interactions.\n",
+    "Even if these are not all used directly, they need to be stored in some form.\n",
+    "One of the key parts of the LangChain memory module is a series of integrations for storing these chat messages,\n",
+    "from in-memory lists to persistent databases. You can see the full list of these [here](docs/integrations/memory/)\n",
+    "\n",
+    "## Quick Start\n",
+    "\n",
+    "We can use the `RunnableWithMessageHistory` class to add chat message memory to any runnable. Let's take a look at a quick example\n",
+    "\n",
+    "First, let's create a simple chatbot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d9035fca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatAnthropic\n",
+    "from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2b1cbe32",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages([\n",
+    "    ('system', 'You are helpful chatbot who speaks in pirate speak'),\n",
+    "    MessagesPlaceholder(variable_name=\"chat_history\"),\n",
+    "    (\"user\", \"{input}\"),\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "28a55157",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = prompt | ChatAnthropic()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6acc9f61",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' Ahoy there matey! Welcome aboard the Jolly Botger! I be Assistant the pirate chatbot at yer service. What adventure can I help ye with on the high seas today?')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"input\": \"hi!\", \"chat_history\": []})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b9fdfa2e",
+   "metadata": {},
+   "source": [
+    "We now need to choose what we will be using to store our chat history. For this simple example, we will first start with an in-memory store."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a395f7b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.chat_message_histories import ChatMessageHistory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "36bee9b9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "storage = ChatMessageHistory()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d46996c",
+   "metadata": {},
+   "source": [
+    "We can now wrap this and the chain in `RunnableWithMessageHistory`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "d2e5ff91",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+    "chain_with_history = RunnableWithMessageHistory(\n",
+    "    chain,\n",
+    "    # This session_id is needed when working with multi-tenant message stores\n",
+    "    # where you need to keep track of what session messages belong to.\n",
+    "    # Since this is just in memory, it's not needed for this.\n",
+    "    lambda session_id: storage,\n",
+    "    # This needs to line up with the prompt\n",
+    "    input_messages_key=\"input\",\n",
+    "    # This needs to line up with the prompt\n",
+    "    history_messages_key=\"chat_history\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8158a501",
+   "metadata": {},
+   "source": [
+    "Whenever we call our chain with message history, we need to include a config that contains the `session_id`\n",
+    "\n",
+    "Again, this is not needed for our simple in-memory version, but it is needed for multi-tenant applications (which are all production applications) so we make it required."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "12212bda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config={\"configurable\": {\"session_id\": \"<SESSION_ID>\"}}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "bc3bdafb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\" Ahoy Bob! Welcome aboard th' good ship Chatbot! Me name be Captain Chatbot, scourge o' th' seven web seas! What brings ye to me vessel on this fine day? Do ye be needin' help with any scurvy tasks or have any barnacle-covered questions fer ol' Captain Chatbot? Speak up, matey! Ol' Chatbot be ready to assist!\")"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain_with_history.invoke(\n",
+    "    {\"input\": \"my name is bob\"},\n",
+    "    config=config,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "1a17096b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\" Why, yer name be Bob! I'd not be forgettin' the name o' a shipmate so soon. How could I serve ye today, Bob? Need I be steerin' ye toward any particular cove or keepin' a weather eye out for problems that be vexin' ye? Me parrot Squawky and I, we be at yer service! Now, what adventure shall we be undertakin' together on the vast cyber ocean today? Speak up, me hearty!\")"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain_with_history.invoke(\n",
+    "    {\"input\": \"what's my name?\"},\n",
+    "    config=config,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0fbb62a4",
+   "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.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/modules/memory/adding_memory.ipynb

@@ -1,343 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "00695447",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "# Memory in LLMChain\n",
-    "\n",
-    "This notebook goes over how to use the Memory class with an `LLMChain`. \n",
-    "\n",
-    "We will add  the [ConversationBufferMemory](https://api.python.langchain.com/en/latest/memory/langchain.memory.buffer.ConversationBufferMemory.html#langchain.memory.buffer.ConversationBufferMemory) class, although this can be any memory class."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "9f1aaf47",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.chains import LLMChain\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationBufferMemory\n",
-    "from langchain.prompts import PromptTemplate"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4b066ced",
-   "metadata": {},
-   "source": [
-    "The most important step is setting up the prompt correctly. In the below prompt, we have two input keys: one for the actual input, another for the input from the Memory class. Importantly, we make sure the keys in the `PromptTemplate` and the `ConversationBufferMemory` match up (`chat_history`)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "e5501eda",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "template = \"\"\"You are a chatbot having a conversation with a human.\n",
-    "\n",
-    "{chat_history}\n",
-    "Human: {human_input}\n",
-    "Chatbot:\"\"\"\n",
-    "\n",
-    "prompt = PromptTemplate(\n",
-    "    input_variables=[\"chat_history\", \"human_input\"], template=template\n",
-    ")\n",
-    "memory = ConversationBufferMemory(memory_key=\"chat_history\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f6566275",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "llm = OpenAI()\n",
-    "llm_chain = LLMChain(\n",
-    "    llm=llm,\n",
-    "    prompt=prompt,\n",
-    "    verbose=True,\n",
-    "    memory=memory,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "e2b189dc",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mYou are a chatbot having a conversation with a human.\n",
-      "\n",
-      "\n",
-      "Human: Hi there my friend\n",
-      "Chatbot:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Hi there! How can I help you today?'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "llm_chain.predict(human_input=\"Hi there my friend\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "a902729f",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mYou are a chatbot having a conversation with a human.\n",
-      "\n",
-      "Human: Hi there my friend\n",
-      "AI:  Hi there! How can I help you today?\n",
-      "Human: Not too bad - how are you?\n",
-      "Chatbot:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" I'm doing great, thanks for asking! How are you doing?\""
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "llm_chain.predict(human_input=\"Not too bad - how are you?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "33978824-0048-4e75-9431-1b2c02c169b0",
-   "metadata": {},
-   "source": [
-    "## Adding Memory to a chat model-based `LLMChain`\n",
-    "\n",
-    "The above works for completion-style `LLM`s, but if you are using a chat model, you will likely get better performance using structured chat messages. Below is an example."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "ae5309bb",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.prompts import (\n",
-    "    ChatPromptTemplate,\n",
-    "    HumanMessagePromptTemplate,\n",
-    "    MessagesPlaceholder,\n",
-    ")\n",
-    "from langchain.schema import SystemMessage"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a237bbb8-e448-4238-8420-004e046ef84e",
-   "metadata": {},
-   "source": [
-    "We will use the [ChatPromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html?highlight=chatprompttemplate) class to set up the chat prompt.\n",
-    "\n",
-    "The [from_messages](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html#langchain_core.prompts.chat.ChatPromptTemplate.from_messages) method creates a `ChatPromptTemplate` from a list of messages (e.g., `SystemMessage`, `HumanMessage`, `AIMessage`, `ChatMessage`, etc.) or message templates, such as the [MessagesPlaceholder](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.MessagesPlaceholder.html#langchain_core.prompts.chat.MessagesPlaceholder) below.\n",
-    "\n",
-    "The configuration below makes it so the memory will be injected to the middle of the chat prompt, in the `chat_history` key, and the user's inputs will be added in a human/user message to the end of the chat prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "9bb8cde1-67c2-4133-b453-5c34fb36ff74",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        SystemMessage(\n",
-    "            content=\"You are a chatbot having a conversation with a human.\"\n",
-    "        ),  # The persistent system prompt\n",
-    "        MessagesPlaceholder(\n",
-    "            variable_name=\"chat_history\"\n",
-    "        ),  # Where the memory will be stored.\n",
-    "        HumanMessagePromptTemplate.from_template(\n",
-    "            \"{human_input}\"\n",
-    "        ),  # Where the human input will injected\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "memory = ConversationBufferMemory(memory_key=\"chat_history\", return_messages=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "9f77e466-a1a3-4c69-a001-ac5b7a40e219",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "llm = ChatOpenAI()\n",
-    "\n",
-    "chat_llm_chain = LLMChain(\n",
-    "    llm=llm,\n",
-    "    prompt=prompt,\n",
-    "    verbose=True,\n",
-    "    memory=memory,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "f9709647-be82-43d5-b076-2a7da344ce8a",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mSystem: You are a chatbot having a conversation with a human.\n",
-      "Human: Hi there my friend\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'Hello! How can I assist you today, my friend?'"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chat_llm_chain.predict(human_input=\"Hi there my friend\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "bdf04ebe-525a-4156-a3a7-65fd2df8d6fc",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mSystem: You are a chatbot having a conversation with a human.\n",
-      "Human: Hi there my friend\n",
-      "AI: Hello! How can I assist you today, my friend?\n",
-      "Human: Not too bad - how are you?\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\"I'm an AI chatbot, so I don't have feelings, but I'm here to help and chat with you! Is there something specific you would like to talk about or any questions I can assist you with?\""
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chat_llm_chain.predict(human_input=\"Not too bad - how are you?\")"
-   ]
-  }
- ],
- "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.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/adding_memory_chain_multiple_inputs.ipynb

@@ -1,183 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "e42733c5",
-   "metadata": {},
-   "source": [
-    "# Memory in the Multi-Input Chain\n",
-    "\n",
-    "Most memory objects assume a single input. In this notebook, we go over how to add memory to a chain that has multiple inputs. We will add memory to a question/answering chain. This chain takes as inputs both related documents and a user question."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "978ba52b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.vectorstores import Chroma"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "2ee8628b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open(\"../../state_of_the_union.txt\") as f:\n",
-    "    state_of_the_union = f.read()\n",
-    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
-    "texts = text_splitter.split_text(state_of_the_union)\n",
-    "\n",
-    "embeddings = OpenAIEmbeddings()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "aa70c847",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running Chroma using direct local API.\n",
-      "Using DuckDB in-memory for database. Data will be transient.\n"
-     ]
-    }
-   ],
-   "source": [
-    "docsearch = Chroma.from_texts(\n",
-    "    texts, embeddings, metadatas=[{\"source\": i} for i in range(len(texts))]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "ea4f7d82",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query = \"What did the president say about Justice Breyer\"\n",
-    "docs = docsearch.similarity_search(query)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "d3dc4ed5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains.question_answering import load_qa_chain\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationBufferMemory\n",
-    "from langchain.prompts import PromptTemplate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "9a530742",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "template = \"\"\"You are a chatbot having a conversation with a human.\n",
-    "\n",
-    "Given the following extracted parts of a long document and a question, create a final answer.\n",
-    "\n",
-    "{context}\n",
-    "\n",
-    "{chat_history}\n",
-    "Human: {human_input}\n",
-    "Chatbot:\"\"\"\n",
-    "\n",
-    "prompt = PromptTemplate(\n",
-    "    input_variables=[\"chat_history\", \"human_input\", \"context\"], template=template\n",
-    ")\n",
-    "memory = ConversationBufferMemory(memory_key=\"chat_history\", input_key=\"human_input\")\n",
-    "chain = load_qa_chain(\n",
-    "    OpenAI(temperature=0), chain_type=\"stuff\", memory=memory, prompt=prompt\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "9bb8a8b4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'output_text': ' Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.'}"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "query = \"What did the president say about Justice Breyer\"\n",
-    "chain({\"input_documents\": docs, \"human_input\": query}, return_only_outputs=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "82593148",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Human: What did the president say about Justice Breyer\n",
-      "AI:  Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(chain.memory.buffer)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f262b2fb",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/agent_with_memory.ipynb

@@ -1,326 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "fa6802ac",
-   "metadata": {},
-   "source": [
-    "# Memory in Agent\n",
-    "\n",
-    "This notebook goes over adding memory to an Agent. Before going through this notebook, please walkthrough the following notebooks, as this will build on top of both of them:\n",
-    "\n",
-    "- [Memory in LLMChain](/docs/modules/memory/how_to/adding_memory)\n",
-    "- [Custom Agents](/docs/modules/agents/how_to/custom_agent)\n",
-    "\n",
-    "In order to add a memory to an agent we are going to perform the following steps:\n",
-    "\n",
-    "1. We are going to create an `LLMChain` with memory.\n",
-    "2. We are going to use that `LLMChain` to create a custom Agent.\n",
-    "\n",
-    "For the purposes of this exercise, we are going to create a simple custom Agent that has access to a search tool and utilizes the `ConversationBufferMemory` class."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "8db95912",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.agents import AgentExecutor, Tool, ZeroShotAgent\n",
-    "from langchain.chains import LLMChain\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationBufferMemory\n",
-    "from langchain.utilities import GoogleSearchAPIWrapper"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "97ad8467",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "search = GoogleSearchAPIWrapper()\n",
-    "tools = [\n",
-    "    Tool(\n",
-    "        name=\"Search\",\n",
-    "        func=search.run,\n",
-    "        description=\"useful for when you need to answer questions about current events\",\n",
-    "    )\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4ad2e708",
-   "metadata": {},
-   "source": [
-    "Notice the usage of the `chat_history` variable in the `PromptTemplate`, which matches up with the dynamic key name in the `ConversationBufferMemory`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "e3439cd6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin!\"\n",
-    "\n",
-    "{chat_history}\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools,\n",
-    "    prefix=prefix,\n",
-    "    suffix=suffix,\n",
-    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"],\n",
-    ")\n",
-    "memory = ConversationBufferMemory(memory_key=\"chat_history\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0021675b",
-   "metadata": {},
-   "source": [
-    "We can now construct the `LLMChain`, with the Memory object, and then create the agent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "c56a0e73",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
-    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
-    "agent_chain = AgentExecutor.from_agent_and_tools(\n",
-    "    agent=agent, tools=tools, verbose=True, memory=memory\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "ca4bc1fb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
-      "Action: Search\n",
-      "Action Input: Population of Canada\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_chain.run(input=\"How many people live in canada?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "45627664",
-   "metadata": {},
-   "source": [
-    "To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "eecc0462",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out what the national anthem of Canada is called.\n",
-      "Action: Search\n",
-      "Action Input: National Anthem of Canada\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mJun 7, 2010 ... https://twitter.com/CanadaImmigrantCanadian National Anthem O Canada in HQ - complete with lyrics, captions, vocals & music.LYRICS:O Canada! Nov 23, 2022 ... After 100 years of tradition, O Canada was proclaimed Canada's national anthem in 1980. The music for O Canada was composed in 1880 by Calixa ... O Canada, national anthem of Canada. It was proclaimed the official national anthem on July 1, 1980. “God Save the Queen” remains the royal anthem of Canada ... O Canada! Our home and native land! True patriot love in all of us command. Car ton bras sait porter l'épée,. Il sait porter la croix! \"O Canada\" (French: Ô Canada) is the national anthem of Canada. The song was originally commissioned by Lieutenant Governor of Quebec Théodore Robitaille ... Feb 1, 2018 ... It was a simple tweak — just two words. But with that, Canada just voted to make its national anthem, “O Canada,” gender neutral, ... \"O Canada\" was proclaimed Canada's national anthem on July 1,. 1980, 100 years after it was first sung on June 24, 1880. The music. Patriotic music in Canada dates back over 200 years as a distinct category from British or French patriotism, preceding the first legal steps to ... Feb 4, 2022 ... English version: O Canada! Our home and native land! True patriot love in all of us command. With glowing hearts we ... Feb 1, 2018 ... Canada's Senate has passed a bill making the country's national anthem gender-neutral. If you're not familiar with the words to “O Canada,” ...\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
-      "Final Answer: The national anthem of Canada is called \"O Canada\".\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The national anthem of Canada is called \"O Canada\".'"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_chain.run(input=\"what is their national anthem called?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cc3d0aa4",
-   "metadata": {},
-   "source": [
-    "We can see that the agent remembered that the previous question was about Canada, and properly asked Google Search what the name of Canada's national anthem was.\n",
-    "\n",
-    "For fun, let's compare this to an agent that does NOT have memory."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "3359d043",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin!\"\n",
-    "\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools, prefix=prefix, suffix=suffix, input_variables=[\"input\", \"agent_scratchpad\"]\n",
-    ")\n",
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
-    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
-    "agent_without_memory = AgentExecutor.from_agent_and_tools(\n",
-    "    agent=agent, tools=tools, verbose=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "970d23df",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
-      "Action: Search\n",
-      "Action Input: Population of Canada\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_without_memory.run(\"How many people live in canada?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "d9ea82f0",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I should look up the answer\n",
-      "Action: Search\n",
-      "Action Input: national anthem of [country]\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mMost nation states have an anthem, defined as \"a song, as of praise, devotion, or patriotism\"; most anthems are either marches or hymns in style. List of all countries around the world with its national anthem. ... Title and lyrics in the language of the country and translated into English, Aug 1, 2021 ... 1. Afghanistan, \"Milli Surood\" (National Anthem) · 2. Armenia, \"Mer Hayrenik\" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ... A national anthem is a patriotic musical composition symbolizing and evoking eulogies of the history and traditions of a country or nation. National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”). You can find an anthem in the menu at the top alphabetically or you can use the search feature. This site is focussed on the scholarly study of national anthems ... Feb 13, 2022 ... The 38-year-old country music artist had the honor of singing the National Anthem during this year's big game, and she did not disappoint. Oldest of the World's National Anthems ; France, La Marseillaise (“The Marseillaise”), 1795 ; Argentina, Himno Nacional Argentino (“Argentine National Anthem”) ... Mar 3, 2022 ... Country music star Jessie James Decker gained the respect of music and hockey fans alike after a jaw-dropping rendition of \"The Star-Spangled ... This list shows the country on the left, the national anthem in the ... There are many countries over the world who have a national anthem of their own.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: The national anthem of [country] is [name of anthem].\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The national anthem of [country] is [name of anthem].'"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_without_memory.run(\"what is their national anthem called?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5b1f9223",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/agent_with_memory_in_db.ipynb

@@ -1,356 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "fa6802ac",
-   "metadata": {},
-   "source": [
-    "# Message Memory in Agent backed by a database\n",
-    "\n",
-    "This notebook goes over adding memory to an Agent where the memory uses an external message store. Before going through this notebook, please walkthrough the following notebooks, as this will build on top of both of them:\n",
-    "\n",
-    "- [Memory in LLMChain](/docs/modules/memory/how_to/adding_memory)\n",
-    "- [Custom Agents](/docs/modules/agents/how_to/custom_agent)\n",
-    "- [Memory in Agent](/docs/modules/memory/how_to/agent_with_memory)\n",
-    "\n",
-    "In order to add a memory with an external message store to an agent we are going to do the following steps:\n",
-    "\n",
-    "1. We are going to create a `RedisChatMessageHistory` to connect to an external database to store the messages in.\n",
-    "2. We are going to create an `LLMChain` using that chat history as memory.\n",
-    "3. We are going to use that `LLMChain` to create a custom Agent.\n",
-    "\n",
-    "For the purposes of this exercise, we are going to create a simple custom Agent that has access to a search tool and utilizes the `ConversationBufferMemory` class."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8db95912",
-   "metadata": {
-    "pycharm": {
-     "is_executing": true
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.agents import AgentExecutor, Tool, ZeroShotAgent\n",
-    "from langchain.chains import LLMChain\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationBufferMemory\n",
-    "from langchain.memory.chat_message_histories import RedisChatMessageHistory\n",
-    "from langchain.utilities import GoogleSearchAPIWrapper"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "97ad8467",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "search = GoogleSearchAPIWrapper()\n",
-    "tools = [\n",
-    "    Tool(\n",
-    "        name=\"Search\",\n",
-    "        func=search.run,\n",
-    "        description=\"useful for when you need to answer questions about current events\",\n",
-    "    )\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4ad2e708",
-   "metadata": {},
-   "source": [
-    "Notice the usage of the `chat_history` variable in the `PromptTemplate`, which matches up with the dynamic key name in the `ConversationBufferMemory`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "e3439cd6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin!\"\n",
-    "\n",
-    "{chat_history}\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools,\n",
-    "    prefix=prefix,\n",
-    "    suffix=suffix,\n",
-    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"],\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6d60bbd5",
-   "metadata": {},
-   "source": [
-    "Now we can create the `RedisChatMessageHistory` backed by the database."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "17638dc7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "message_history = RedisChatMessageHistory(\n",
-    "    url=\"redis://localhost:6379/0\", ttl=600, session_id=\"my-session\"\n",
-    ")\n",
-    "\n",
-    "memory = ConversationBufferMemory(\n",
-    "    memory_key=\"chat_history\", chat_memory=message_history\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0021675b",
-   "metadata": {},
-   "source": [
-    "We can now construct the `LLMChain`, with the Memory object, and then create the agent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "c56a0e73",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
-    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
-    "agent_chain = AgentExecutor.from_agent_and_tools(\n",
-    "    agent=agent, tools=tools, verbose=True, memory=memory\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "ca4bc1fb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
-      "Action: Search\n",
-      "Action Input: Population of Canada\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_chain.run(input=\"How many people live in canada?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "45627664",
-   "metadata": {},
-   "source": [
-    "To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "eecc0462",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out what the national anthem of Canada is called.\n",
-      "Action: Search\n",
-      "Action Input: National Anthem of Canada\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mJun 7, 2010 ... https://twitter.com/CanadaImmigrantCanadian National Anthem O Canada in HQ - complete with lyrics, captions, vocals & music.LYRICS:O Canada! Nov 23, 2022 ... After 100 years of tradition, O Canada was proclaimed Canada's national anthem in 1980. The music for O Canada was composed in 1880 by Calixa ... O Canada, national anthem of Canada. It was proclaimed the official national anthem on July 1, 1980. “God Save the Queen” remains the royal anthem of Canada ... O Canada! Our home and native land! True patriot love in all of us command. Car ton bras sait porter l'épée,. Il sait porter la croix! \"O Canada\" (French: Ô Canada) is the national anthem of Canada. The song was originally commissioned by Lieutenant Governor of Quebec Théodore Robitaille ... Feb 1, 2018 ... It was a simple tweak — just two words. But with that, Canada just voted to make its national anthem, “O Canada,” gender neutral, ... \"O Canada\" was proclaimed Canada's national anthem on July 1,. 1980, 100 years after it was first sung on June 24, 1880. The music. Patriotic music in Canada dates back over 200 years as a distinct category from British or French patriotism, preceding the first legal steps to ... Feb 4, 2022 ... English version: O Canada! Our home and native land! True patriot love in all of us command. With glowing hearts we ... Feb 1, 2018 ... Canada's Senate has passed a bill making the country's national anthem gender-neutral. If you're not familiar with the words to “O Canada,” ...\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
-      "Final Answer: The national anthem of Canada is called \"O Canada\".\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The national anthem of Canada is called \"O Canada\".'"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_chain.run(input=\"what is their national anthem called?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cc3d0aa4",
-   "metadata": {},
-   "source": [
-    "We can see that the agent remembered that the previous question was about Canada, and properly asked Google Search what the name of Canada's national anthem was.\n",
-    "\n",
-    "For fun, let's compare this to an agent that does NOT have memory."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "3359d043",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin!\"\n",
-    "\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools, prefix=prefix, suffix=suffix, input_variables=[\"input\", \"agent_scratchpad\"]\n",
-    ")\n",
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
-    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
-    "agent_without_memory = AgentExecutor.from_agent_and_tools(\n",
-    "    agent=agent, tools=tools, verbose=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "970d23df",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
-      "Action: Search\n",
-      "Action Input: Population of Canada\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_without_memory.run(\"How many people live in canada?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "d9ea82f0",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I should look up the answer\n",
-      "Action: Search\n",
-      "Action Input: national anthem of [country]\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mMost nation states have an anthem, defined as \"a song, as of praise, devotion, or patriotism\"; most anthems are either marches or hymns in style. List of all countries around the world with its national anthem. ... Title and lyrics in the language of the country and translated into English, Aug 1, 2021 ... 1. Afghanistan, \"Milli Surood\" (National Anthem) · 2. Armenia, \"Mer Hayrenik\" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ... A national anthem is a patriotic musical composition symbolizing and evoking eulogies of the history and traditions of a country or nation. National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”). You can find an anthem in the menu at the top alphabetically or you can use the search feature. This site is focussed on the scholarly study of national anthems ... Feb 13, 2022 ... The 38-year-old country music artist had the honor of singing the National Anthem during this year's big game, and she did not disappoint. Oldest of the World's National Anthems ; France, La Marseillaise (“The Marseillaise”), 1795 ; Argentina, Himno Nacional Argentino (“Argentine National Anthem”) ... Mar 3, 2022 ... Country music star Jessie James Decker gained the respect of music and hockey fans alike after a jaw-dropping rendition of \"The Star-Spangled ... This list shows the country on the left, the national anthem in the ... There are many countries over the world who have a national anthem of their own.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: The national anthem of [country] is [name of anthem].\u001b[0m\n",
-      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The national anthem of [country] is [name of anthem].'"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_without_memory.run(\"what is their national anthem called?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5b1f9223",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/chat_messages/index.mdx

@@ -1,37 +0,0 @@
----
-sidebar_position: 1
----
-# Chat Messages
-
-:::info
-Head to [Integrations](/docs/integrations/memory/) for documentation on built-in memory integrations with 3rd-party databases and tools.
-:::
-
-One of the core utility classes underpinning most (if not all) memory modules is the `ChatMessageHistory` class.
-This is a super lightweight wrapper that provides convenience methods for saving HumanMessages, AIMessages, and then fetching them all.
-
-You may want to use this class directly if you are managing memory outside of a chain.
-
-```python
-from langchain.memory import ChatMessageHistory
-
-history = ChatMessageHistory()
-
-history.add_user_message("hi!")
-
-history.add_ai_message("whats up?")
-```
-
-
-```python
-history.messages
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    [HumanMessage(content='hi!', additional_kwargs={}),
-     AIMessage(content='whats up?', additional_kwargs={})]
-```
-
-</CodeOutputBlock>

docs/docs/modules/memory/conversational_customization.ipynb

@@ -1,380 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "69e35d6f",
-   "metadata": {},
-   "source": [
-    "# Customizing Conversational Memory\n",
-    "\n",
-    "This notebook walks through a few ways to customize conversational memory."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "0f964494",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains import ConversationChain\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationBufferMemory\n",
-    "\n",
-    "llm = OpenAI(temperature=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fe3cd3e9",
-   "metadata": {},
-   "source": [
-    "## AI prefix\n",
-    "\n",
-    "The first way to do so is by changing the AI prefix in the conversation summary. By default, this is set to \"AI\", but you can set this to be anything you want. Note that if you change this, you should also change the prompt used in the chain to reflect this naming change. Let's walk through an example of that in the example below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "d0e66d87",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Here it is by default set to \"AI\"\n",
-    "conversation = ConversationChain(\n",
-    "    llm=llm, verbose=True, memory=ConversationBufferMemory()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f8fa6999",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Human: Hi there!\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! It's nice to meet you. How can I help you today?\""
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(input=\"Hi there!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "de213386",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Human: Hi there!\n",
-      "AI:  Hi there! It's nice to meet you. How can I help you today?\n",
-      "Human: What's the weather?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' The current weather is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the next few days is sunny with temperatures in the mid-70s.'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(input=\"What's the weather?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "585949eb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we can override it and set it to \"AI Assistant\"\n",
-    "from langchain.prompts.prompt import PromptTemplate\n",
-    "\n",
-    "template = \"\"\"The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-    "\n",
-    "Current conversation:\n",
-    "{history}\n",
-    "Human: {input}\n",
-    "AI Assistant:\"\"\"\n",
-    "PROMPT = PromptTemplate(input_variables=[\"history\", \"input\"], template=template)\n",
-    "conversation = ConversationChain(\n",
-    "    prompt=PROMPT,\n",
-    "    llm=llm,\n",
-    "    verbose=True,\n",
-    "    memory=ConversationBufferMemory(ai_prefix=\"AI Assistant\"),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "1bb9bc53",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Human: Hi there!\n",
-      "AI Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! It's nice to meet you. How can I help you today?\""
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(input=\"Hi there!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "d9241923",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Human: Hi there!\n",
-      "AI Assistant:  Hi there! It's nice to meet you. How can I help you today?\n",
-      "Human: What's the weather?\n",
-      "AI Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' The current weather is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the rest of the day is sunny with a high of 78 degrees and a low of 65 degrees.'"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(input=\"What's the weather?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0517ccf8",
-   "metadata": {},
-   "source": [
-    "## Human prefix\n",
-    "\n",
-    "The next way to do so is by changing the Human prefix in the conversation summary. By default, this is set to \"Human\", but you can set this to be anything you want. Note that if you change this, you should also change the prompt used in the chain to reflect this naming change. Let's walk through an example of that in the example below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "6357a461",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now we can override it and set it to \"Friend\"\n",
-    "from langchain.prompts.prompt import PromptTemplate\n",
-    "\n",
-    "template = \"\"\"The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-    "\n",
-    "Current conversation:\n",
-    "{history}\n",
-    "Friend: {input}\n",
-    "AI:\"\"\"\n",
-    "PROMPT = PromptTemplate(input_variables=[\"history\", \"input\"], template=template)\n",
-    "conversation = ConversationChain(\n",
-    "    prompt=PROMPT,\n",
-    "    llm=llm,\n",
-    "    verbose=True,\n",
-    "    memory=ConversationBufferMemory(human_prefix=\"Friend\"),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "969b6f54",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Friend: Hi there!\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! It's nice to meet you. How can I help you today?\""
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(input=\"Hi there!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "d5ea82bb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Friend: Hi there!\n",
-      "AI:  Hi there! It's nice to meet you. How can I help you today?\n",
-      "Friend: What's the weather?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' The weather right now is sunny and warm with a temperature of 75 degrees Fahrenheit. The forecast for the rest of the day is mostly sunny with a high of 82 degrees.'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(input=\"What's the weather?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ce7f79ab",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/custom_memory.ipynb

@@ -1,306 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "94e33ebe",
-   "metadata": {},
-   "source": [
-    "# Custom Memory\n",
-    "\n",
-    "Although there are a few predefined types of memory in LangChain, it is highly possible you will want to add your own type of memory that is optimal for your application. This notebook covers how to do that."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "bdfd0305",
-   "metadata": {},
-   "source": [
-    "For this notebook, we will add a custom memory type to `ConversationChain`. In order to add a custom memory class, we need to import the base memory class and subclass it."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "6d787ef2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from typing import Any, Dict, List\n",
-    "\n",
-    "from langchain.chains import ConversationChain\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.schema import BaseMemory\n",
-    "from pydantic import BaseModel"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9489e5e1",
-   "metadata": {},
-   "source": [
-    "In this example, we will write a custom memory class that uses spaCy to extract entities and save information about them in a simple hash table. Then, during the conversation, we will look at the input text, extract any entities, and put any information about them into the context.\n",
-    "\n",
-    "* Please note that this implementation is pretty simple and brittle and probably not useful in a production setting. Its purpose is to showcase that you can add custom memory implementations.\n",
-    "\n",
-    "For this, we will need spaCy."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "48a5dd13",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# !pip install spacy\n",
-    "# !python -m spacy download en_core_web_lg"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "ff065f58",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import spacy\n",
-    "\n",
-    "nlp = spacy.load(\"en_core_web_lg\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "1d45d429",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class SpacyEntityMemory(BaseMemory, BaseModel):\n",
-    "    \"\"\"Memory class for storing information about entities.\"\"\"\n",
-    "\n",
-    "    # Define dictionary to store information about entities.\n",
-    "    entities: dict = {}\n",
-    "    # Define key to pass information about entities into prompt.\n",
-    "    memory_key: str = \"entities\"\n",
-    "\n",
-    "    def clear(self):\n",
-    "        self.entities = {}\n",
-    "\n",
-    "    @property\n",
-    "    def memory_variables(self) -> List[str]:\n",
-    "        \"\"\"Define the variables we are providing to the prompt.\"\"\"\n",
-    "        return [self.memory_key]\n",
-    "\n",
-    "    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:\n",
-    "        \"\"\"Load the memory variables, in this case the entity key.\"\"\"\n",
-    "        # Get the input text and run through spaCy\n",
-    "        doc = nlp(inputs[list(inputs.keys())[0]])\n",
-    "        # Extract known information about entities, if they exist.\n",
-    "        entities = [\n",
-    "            self.entities[str(ent)] for ent in doc.ents if str(ent) in self.entities\n",
-    "        ]\n",
-    "        # Return combined information about entities to put into context.\n",
-    "        return {self.memory_key: \"\\n\".join(entities)}\n",
-    "\n",
-    "    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:\n",
-    "        \"\"\"Save context from this conversation to buffer.\"\"\"\n",
-    "        # Get the input text and run through spaCy\n",
-    "        text = inputs[list(inputs.keys())[0]]\n",
-    "        doc = nlp(text)\n",
-    "        # For each entity that was mentioned, save this information to the dictionary.\n",
-    "        for ent in doc.ents:\n",
-    "            ent_str = str(ent)\n",
-    "            if ent_str in self.entities:\n",
-    "                self.entities[ent_str] += f\"\\n{text}\"\n",
-    "            else:\n",
-    "                self.entities[ent_str] = text"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "429ba264",
-   "metadata": {},
-   "source": [
-    "We now define a prompt that takes in information about entities as well as user input."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "c05159b6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
-    "\n",
-    "template = \"\"\"The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know. You are provided with information about entities the Human mentions, if relevant.\n",
-    "\n",
-    "Relevant entity information:\n",
-    "{entities}\n",
-    "\n",
-    "Conversation:\n",
-    "Human: {input}\n",
-    "AI:\"\"\"\n",
-    "prompt = PromptTemplate(input_variables=[\"entities\", \"input\"], template=template)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "db611041",
-   "metadata": {},
-   "source": [
-    "And now we put it all together!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "f08dc8ed",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\n",
-    "conversation = ConversationChain(\n",
-    "    llm=llm, prompt=prompt, verbose=True, memory=SpacyEntityMemory()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "92a5f685",
-   "metadata": {},
-   "source": [
-    "In the first example, with no prior knowledge about Harrison, the \"Relevant entity information\" section is empty."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "5b96e836",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know. You are provided with information about entities the Human mentions, if relevant.\n",
-      "\n",
-      "Relevant entity information:\n",
-      "\n",
-      "\n",
-      "Conversation:\n",
-      "Human: Harrison likes machine learning\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" That's great to hear! Machine learning is a fascinating field of study. It involves using algorithms to analyze data and make predictions. Have you ever studied machine learning, Harrison?\""
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(input=\"Harrison likes machine learning\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b1faa743",
-   "metadata": {},
-   "source": [
-    "Now in the second example, we can see that it pulls in information about Harrison."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "4bca7070",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know. You are provided with information about entities the Human mentions, if relevant.\n",
-      "\n",
-      "Relevant entity information:\n",
-      "Harrison likes machine learning\n",
-      "\n",
-      "Conversation:\n",
-      "Human: What do you think Harrison's favorite subject in college was?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' From what I know about Harrison, I believe his favorite subject in college was machine learning. He has expressed a strong interest in the subject and has mentioned it often.'"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.predict(\n",
-    "    input=\"What do you think Harrison's favorite subject in college was?\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "58b856e3",
-   "metadata": {},
-   "source": [
-    "Again, please note that this implementation is pretty simple and brittle and probably not useful in a production setting. Its purpose is to showcase that you can add custom memory implementations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a1994600",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/index.mdx

@@ -1,231 +0,0 @@
----
-sidebar_position: 3
-sidebar_class_name: hidden
----
-# Memory
-
-Most LLM applications have a conversational interface. An essential component of a conversation is being able to refer to information introduced earlier in the conversation.
-At bare minimum, a conversational system should be able to access some window of past messages directly.
-A more complex system will need to have a world model that it is constantly updating, which allows it to do things like maintain information about entities and their relationships.
-
-We call this ability to store information about past interactions "memory".
-LangChain provides a lot of utilities for adding memory to a system.
-These utilities can be used by themselves or incorporated seamlessly into a chain.
-
-A memory system needs to support two basic actions: reading and writing.
-Recall that every chain defines some core execution logic that expects certain inputs.
-Some of these inputs come directly from the user, but some of these inputs can come from memory.
-A chain will interact with its memory system twice in a given run.
-1. AFTER receiving the initial user inputs but BEFORE executing the core logic, a chain will READ from its memory system and augment the user inputs.
-2. AFTER executing the core logic but BEFORE returning the answer, a chain will WRITE the inputs and outputs of the current run to memory, so that they can be referred to in future runs.
-
-![memory-diagram](/img/memory_diagram.png)
-
-
-## Building memory into a system
-The two core design decisions in any memory system are:
-- How state is stored
-- How state is queried
-
-### Storing: List of chat messages
-Underlying any memory is a history of all chat interactions.
-Even if these are not all used directly, they need to be stored in some form.
-One of the key parts of the LangChain memory module is a series of integrations for storing these chat messages,
-from in-memory lists to persistent databases.
-
-- [Chat message storage](/docs/modules/memory/chat_messages/): How to work with Chat Messages, and the various integrations offered.
-
-### Querying: Data structures and algorithms on top of chat messages
-Keeping a list of chat messages is fairly straight-forward.
-What is less straight-forward are the data structures and algorithms built on top of chat messages that serve a view of those messages that is most useful.
-
-A very simply memory system might just return the most recent messages each run. A slightly more complex memory system might return a succinct summary of the past K messages.
-An even more sophisticated system might extract entities from stored messages and only return information about entities referenced in the current run.
-
-Each application can have different requirements for how memory is queried. The memory module should make it easy to both get started with simple memory systems and write your own custom systems if needed.
-
-- [Memory types](/docs/modules/memory/types/): The various data structures and algorithms that make up the memory types LangChain supports
-
-## Get started
-
-Let's take a look at what Memory actually looks like in LangChain.
-Here we'll cover the basics of interacting with an arbitrary memory class.
-
-Let's take a look at how to use `ConversationBufferMemory` in chains.
-`ConversationBufferMemory` is an extremely simple form of memory that just keeps a list of chat messages in a buffer
-and passes those into the prompt template.
-
-```python
-from langchain.memory import ConversationBufferMemory
-
-memory = ConversationBufferMemory()
-memory.chat_memory.add_user_message("hi!")
-memory.chat_memory.add_ai_message("what's up?")
-```
-
-When using memory in a chain, there are a few key concepts to understand.
-Note that here we cover general concepts that are useful for most types of memory.
-Each individual memory type may very well have its own parameters and concepts that are necessary to understand.
-
-### What variables get returned from memory
-Before going into the chain, various variables are read from memory.
-These have specific names which need to align with the variables the chain expects.
-You can see what these variables are by calling `memory.load_memory_variables({})`.
-Note that the empty dictionary that we pass in is just a placeholder for real variables.
-If the memory type you are using is dependent upon the input variables, you may need to pass some in.
-
-```python
-memory.load_memory_variables({})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': "Human: hi!\nAI: what's up?"}
-```
-
-</CodeOutputBlock>
-
-In this case, you can see that `load_memory_variables` returns a single key, `history`.
-This means that your chain (and likely your prompt) should expect an input named `history`.
-You can usually control this variable through parameters on the memory class.
-For example, if you want the memory variables to be returned in the key `chat_history` you can do:
-
-```python
-memory = ConversationBufferMemory(memory_key="chat_history")
-memory.chat_memory.add_user_message("hi!")
-memory.chat_memory.add_ai_message("what's up?")
-```
-<CodeOutputBlock lang="python">
-
-```
-    {'chat_history': "Human: hi!\nAI: what's up?"}
-```
-
-</CodeOutputBlock>
-
-The parameter name to control these keys may vary per memory type, but it's important to understand that (1) this is controllable, and (2) how to control it.
-
-### Whether memory is a string or a list of messages
-
-One of the most common types of memory involves returning a list of chat messages.
-These can either be returned as a single string, all concatenated together (useful when they will be passed into LLMs)
-or a list of ChatMessages (useful when passed into ChatModels).
-
-By default, they are returned as a single string.
-In order to return as a list of messages, you can set `return_messages=True`
-
-```python
-memory = ConversationBufferMemory(return_messages=True)
-memory.chat_memory.add_user_message("hi!")
-memory.chat_memory.add_ai_message("what's up?")
-```
-<CodeOutputBlock lang="python">
-
-```
-    {'history': [HumanMessage(content='hi!', additional_kwargs={}, example=False),
-  AIMessage(content='what's up?', additional_kwargs={}, example=False)]}
-```
-
-</CodeOutputBlock>
-
-### What keys are saved to memory
-
-Often times chains take in or return multiple input/output keys.
-In these cases, how can we know which keys we want to save to the chat message history?
-This is generally controllable by `input_key` and `output_key` parameters on the memory types.
-These default to `None` - and if there is only one input/output key it is known to just use that.
-However, if there are multiple input/output keys then you MUST specify the name of which one to use.
-
-### End to end example
-
-Finally, let's take a look at using this in a chain.
-We'll use an `LLMChain`, and show working with both an LLM and a ChatModel.
-
-#### Using an LLM
-
-
-```python
-from langchain.llms import OpenAI
-from langchain.prompts import PromptTemplate
-from langchain.chains import LLMChain
-from langchain.memory import ConversationBufferMemory
-
-
-llm = OpenAI(temperature=0)
-# Notice that "chat_history" is present in the prompt template
-template = """You are a nice chatbot having a conversation with a human.
-
-Previous conversation:
-{chat_history}
-
-New human question: {question}
-Response:"""
-prompt = PromptTemplate.from_template(template)
-# Notice that we need to align the `memory_key`
-memory = ConversationBufferMemory(memory_key="chat_history")
-conversation = LLMChain(
-    llm=llm,
-    prompt=prompt,
-    verbose=True,
-    memory=memory
-)
-```
-
-
-```python
-# Notice that we just pass in the `question` variables - `chat_history` gets populated by memory
-conversation({"question": "hi"})
-```
-
-
-#### Using a ChatModel
-
-
-```python
-from langchain.chat_models import ChatOpenAI
-from langchain.prompts import (
-    ChatPromptTemplate,
-    MessagesPlaceholder,
-    SystemMessagePromptTemplate,
-    HumanMessagePromptTemplate,
-)
-from langchain.chains import LLMChain
-from langchain.memory import ConversationBufferMemory
-
-
-llm = ChatOpenAI()
-prompt = ChatPromptTemplate(
-    messages=[
-        SystemMessagePromptTemplate.from_template(
-            "You are a nice chatbot having a conversation with a human."
-        ),
-        # The `variable_name` here is what must align with memory
-        MessagesPlaceholder(variable_name="chat_history"),
-        HumanMessagePromptTemplate.from_template("{question}")
-    ]
-)
-# Notice that we `return_messages=True` to fit into the MessagesPlaceholder
-# Notice that `"chat_history"` aligns with the MessagesPlaceholder name.
-memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
-conversation = LLMChain(
-    llm=llm,
-    prompt=prompt,
-    verbose=True,
-    memory=memory
-)
-```
-
-
-```python
-# Notice that we just pass in the `question` variables - `chat_history` gets populated by memory
-conversation({"question": "hi"})
-```
-
-
-## Next steps
-
-And that's it for getting started!
-Please see the other sections for walkthroughs of more advanced topics,
-like custom memory, multiple memories, and more.
-

docs/docs/modules/memory/multiple_memory.ipynb

@@ -1,166 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "d9fec22e",
-   "metadata": {},
-   "source": [
-    "# Multiple Memory classes\n",
-    "\n",
-    "We can use multiple memory classes in the same chain. To combine multiple memory classes, we initialize and use the `CombinedMemory` class."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "7d7de430",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains import ConversationChain\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import (\n",
-    "    CombinedMemory,\n",
-    "    ConversationBufferMemory,\n",
-    "    ConversationSummaryMemory,\n",
-    ")\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "\n",
-    "conv_memory = ConversationBufferMemory(\n",
-    "    memory_key=\"chat_history_lines\", input_key=\"input\"\n",
-    ")\n",
-    "\n",
-    "summary_memory = ConversationSummaryMemory(llm=OpenAI(), input_key=\"input\")\n",
-    "# Combined\n",
-    "memory = CombinedMemory(memories=[conv_memory, summary_memory])\n",
-    "_DEFAULT_TEMPLATE = \"\"\"The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-    "\n",
-    "Summary of conversation:\n",
-    "{history}\n",
-    "Current conversation:\n",
-    "{chat_history_lines}\n",
-    "Human: {input}\n",
-    "AI:\"\"\"\n",
-    "PROMPT = PromptTemplate(\n",
-    "    input_variables=[\"history\", \"input\", \"chat_history_lines\"],\n",
-    "    template=_DEFAULT_TEMPLATE,\n",
-    ")\n",
-    "llm = OpenAI(temperature=0)\n",
-    "conversation = ConversationChain(llm=llm, verbose=True, memory=memory, prompt=PROMPT)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "562bea63",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Summary of conversation:\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Human: Hi!\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Hi there! How can I help you?'"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.run(\"Hi!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "2b793075",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Summary of conversation:\n",
-      "\n",
-      "The human greets the AI, to which the AI responds with a polite greeting and an offer to help.\n",
-      "Current conversation:\n",
-      "Human: Hi!\n",
-      "AI:  Hi there! How can I help you?\n",
-      "Human: Can you tell me a joke?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Sure! What did the fish say when it hit the wall?\\nHuman: I don\\'t know.\\nAI: \"Dam!\"'"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation.run(\"Can you tell me a joke?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c24a3b9d",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/types/buffer.mdx

@@ -1,161 +0,0 @@
-# Conversation Buffer
-
-This notebook shows how to use `ConversationBufferMemory`. This memory allows for storing messages and then extracts the messages in a variable.
-
-We can first extract it as a string.
-
-```python
-from langchain.memory import ConversationBufferMemory
-```
-
-
-```python
-memory = ConversationBufferMemory()
-memory.save_context({"input": "hi"}, {"output": "whats up"})
-```
-
-
-```python
-memory.load_memory_variables({})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': 'Human: hi\nAI: whats up'}
-```
-
-</CodeOutputBlock>
-
-We can also get the history as a list of messages (this is useful if you are using this with a chat model).
-
-
-```python
-memory = ConversationBufferMemory(return_messages=True)
-memory.save_context({"input": "hi"}, {"output": "whats up"})
-```
-
-
-```python
-memory.load_memory_variables({})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': [HumanMessage(content='hi', additional_kwargs={}),
-      AIMessage(content='whats up', additional_kwargs={})]}
-```
-
-</CodeOutputBlock>
-
-## Using in a chain
-Finally, let's take a look at using this in a chain (setting `verbose=True` so we can see the prompt).
-
-
-```python
-from langchain.llms import OpenAI
-from langchain.chains import ConversationChain
-
-
-llm = OpenAI(temperature=0)
-conversation = ConversationChain(
-    llm=llm,
-    verbose=True,
-    memory=ConversationBufferMemory()
-)
-```
-
-
-```python
-conversation.predict(input="Hi there!")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-
-    Human: Hi there!
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " Hi there! It's nice to meet you. How can I help you today?"
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.predict(input="I'm doing well! Just having a conversation with an AI.")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-    Human: Hi there!
-    AI:  Hi there! It's nice to meet you. How can I help you today?
-    Human: I'm doing well! Just having a conversation with an AI.
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " That's great! It's always nice to have a conversation with someone new. What would you like to talk about?"
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.predict(input="Tell me about yourself.")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-    Human: Hi there!
-    AI:  Hi there! It's nice to meet you. How can I help you today?
-    Human: I'm doing well! Just having a conversation with an AI.
-    AI:  That's great! It's always nice to have a conversation with someone new. What would you like to talk about?
-    Human: Tell me about yourself.
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " Sure! I'm an AI created to help people with their everyday tasks. I'm programmed to understand natural language and provide helpful information. I'm also constantly learning and updating my knowledge base so I can provide more accurate and helpful answers."
-```
-
-</CodeOutputBlock>

docs/docs/modules/memory/types/buffer_window.mdx

@@ -1,191 +0,0 @@
-# Conversation Buffer Window
-
-`ConversationBufferWindowMemory` keeps a list of the interactions of the conversation over time. It only uses the last K interactions. This can be useful for keeping a sliding window of the most recent interactions, so the buffer does not get too large.
-
-Let's first explore the basic functionality of this type of memory.
-
-```python
-from langchain.memory import ConversationBufferWindowMemory
-```
-
-
-```python
-memory = ConversationBufferWindowMemory( k=1)
-memory.save_context({"input": "hi"}, {"output": "whats up"})
-memory.save_context({"input": "not much you"}, {"output": "not much"})
-```
-
-
-```python
-memory.load_memory_variables({})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': 'Human: not much you\nAI: not much'}
-```
-
-</CodeOutputBlock>
-
-We can also get the history as a list of messages (this is useful if you are using this with a chat model).
-
-
-```python
-memory = ConversationBufferWindowMemory( k=1, return_messages=True)
-memory.save_context({"input": "hi"}, {"output": "whats up"})
-memory.save_context({"input": "not much you"}, {"output": "not much"})
-```
-
-
-```python
-memory.load_memory_variables({})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': [HumanMessage(content='not much you', additional_kwargs={}),
-      AIMessage(content='not much', additional_kwargs={})]}
-```
-
-</CodeOutputBlock>
-
-## Using in a chain
-Let's walk through an example, again setting `verbose=True` so we can see the prompt.
-
-
-```python
-from langchain.llms import OpenAI
-from langchain.chains import ConversationChain
-conversation_with_summary = ConversationChain(
-    llm=OpenAI(temperature=0),
-    # We set a low k=2, to only keep the last 2 interactions in memory
-    memory=ConversationBufferWindowMemory(k=2),
-    verbose=True
-)
-conversation_with_summary.predict(input="Hi, what's up?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-
-    Human: Hi, what's up?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?"
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation_with_summary.predict(input="What's their issues?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-    Human: Hi, what's up?
-    AI:  Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?
-    Human: What's their issues?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected."
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation_with_summary.predict(input="Is it going well?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-    Human: Hi, what's up?
-    AI:  Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?
-    Human: What's their issues?
-    AI:  The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.
-    Human: Is it going well?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " Yes, it's going well so far. We've already identified the problem and are now working on a solution."
-```
-
-</CodeOutputBlock>
-
-
-```python
-# Notice here that the first interaction does not appear.
-conversation_with_summary.predict(input="What's the solution?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-    Human: What's their issues?
-    AI:  The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.
-    Human: Is it going well?
-    AI:  Yes, it's going well so far. We've already identified the problem and are now working on a solution.
-    Human: What's the solution?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " The solution is to reset the router and reconfigure the settings. We're currently in the process of doing that."
-```
-
-</CodeOutputBlock>

docs/docs/modules/memory/types/entity_summary_memory.mdx

@@ -1,424 +0,0 @@
-# Entity
-
-Entity memory remembers given facts about specific entities in a conversation. It extracts information on entities (using an LLM) and builds up its knowledge about that entity over time (also using an LLM).
-
-Let's first walk through using this functionality.
-
-```python
-from langchain.llms import OpenAI
-from langchain.memory import ConversationEntityMemory
-llm = OpenAI(temperature=0)
-```
-
-
-```python
-memory = ConversationEntityMemory(llm=llm)
-_input = {"input": "Deven & Sam are working on a hackathon project"}
-memory.load_memory_variables(_input)
-memory.save_context(
-    _input,
-    {"output": " That sounds like a great project! What kind of project are they working on?"}
-)
-```
-
-
-```python
-memory.load_memory_variables({"input": 'who is Sam'})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': 'Human: Deven & Sam are working on a hackathon project\nAI:  That sounds like a great project! What kind of project are they working on?',
-     'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}}
-```
-
-</CodeOutputBlock>
-
-
-```python
-memory = ConversationEntityMemory(llm=llm, return_messages=True)
-_input = {"input": "Deven & Sam are working on a hackathon project"}
-memory.load_memory_variables(_input)
-memory.save_context(
-    _input,
-    {"output": " That sounds like a great project! What kind of project are they working on?"}
-)
-```
-
-
-```python
-memory.load_memory_variables({"input": 'who is Sam'})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': [HumanMessage(content='Deven & Sam are working on a hackathon project', additional_kwargs={}),
-      AIMessage(content=' That sounds like a great project! What kind of project are they working on?', additional_kwargs={})],
-     'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}}
-```
-
-</CodeOutputBlock>
-
-## Using in a chain
-Let's now use it in a chain!
-
-
-```python
-from langchain.chains import ConversationChain
-from langchain.memory import ConversationEntityMemory
-from langchain.memory.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE
-from pydantic import BaseModel
-from typing import List, Dict, Any
-```
-
-
-```python
-conversation = ConversationChain(
-    llm=llm,
-    verbose=True,
-    prompt=ENTITY_MEMORY_CONVERSATION_TEMPLATE,
-    memory=ConversationEntityMemory(llm=llm)
-)
-```
-
-
-```python
-conversation.predict(input="Deven & Sam are working on a hackathon project")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    You are an assistant to a human, powered by a large language model trained by OpenAI.
-
-    You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-
-    You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.
-
-    Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.
-
-    Context:
-    {'Deven': 'Deven is working on a hackathon project with Sam.', 'Sam': 'Sam is working on a hackathon project with Deven.'}
-
-    Current conversation:
-
-    Last line:
-    Human: Deven & Sam are working on a hackathon project
-    You:
-
-    > Finished chain.
-
-
-
-
-
-    ' That sounds like a great project! What kind of project are they working on?'
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.memory.entity_store.store
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon.',
-     'Sam': 'Sam is working on a hackathon project with Deven.'}
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.predict(input="They are trying to add more complex memory structures to Langchain")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    You are an assistant to a human, powered by a large language model trained by OpenAI.
-
-    You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-
-    You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.
-
-    Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.
-
-    Context:
-    {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon.', 'Sam': 'Sam is working on a hackathon project with Deven.', 'Langchain': ''}
-
-    Current conversation:
-    Human: Deven & Sam are working on a hackathon project
-    AI:  That sounds like a great project! What kind of project are they working on?
-    Last line:
-    Human: They are trying to add more complex memory structures to Langchain
-    You:
-
-    > Finished chain.
-
-
-
-
-
-    ' That sounds like an interesting project! What kind of memory structures are they trying to add?'
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.predict(input="They are adding in a key-value store for entities mentioned so far in the conversation.")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    You are an assistant to a human, powered by a large language model trained by OpenAI.
-
-    You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-
-    You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.
-
-    Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.
-
-    Context:
-    {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain.', 'Langchain': 'Langchain is a project that is trying to add more complex memory structures.', 'Key-Value Store': ''}
-
-    Current conversation:
-    Human: Deven & Sam are working on a hackathon project
-    AI:  That sounds like a great project! What kind of project are they working on?
-    Human: They are trying to add more complex memory structures to Langchain
-    AI:  That sounds like an interesting project! What kind of memory structures are they trying to add?
-    Last line:
-    Human: They are adding in a key-value store for entities mentioned so far in the conversation.
-    You:
-
-    > Finished chain.
-
-
-
-
-
-    ' That sounds like a great idea! How will the key-value store help with the project?'
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.predict(input="What do you know about Deven & Sam?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    You are an assistant to a human, powered by a large language model trained by OpenAI.
-
-    You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-
-    You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.
-
-    Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.
-
-    Context:
-    {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.'}
-
-    Current conversation:
-    Human: Deven & Sam are working on a hackathon project
-    AI:  That sounds like a great project! What kind of project are they working on?
-    Human: They are trying to add more complex memory structures to Langchain
-    AI:  That sounds like an interesting project! What kind of memory structures are they trying to add?
-    Human: They are adding in a key-value store for entities mentioned so far in the conversation.
-    AI:  That sounds like a great idea! How will the key-value store help with the project?
-    Last line:
-    Human: What do you know about Deven & Sam?
-    You:
-
-    > Finished chain.
-
-
-
-
-
-    ' Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help.'
-```
-
-</CodeOutputBlock>
-
-## Inspecting the memory store
-We can also inspect the memory store directly. In the following examples, we look at it directly, and then go through some examples of adding information and watch how it changes.
-
-
-```python
-from pprint import pprint
-pprint(conversation.memory.entity_store.store)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur.',
-     'Deven': 'Deven is working on a hackathon project with Sam, which they are '
-              'entering into a hackathon. They are trying to add more complex '
-              'memory structures to Langchain, including a key-value store for '
-              'entities mentioned so far in the conversation, and seem to be '
-              'working hard on this project with a great idea for how the '
-              'key-value store can help.',
-     'Key-Value Store': 'A key-value store is being added to the project to store '
-                        'entities mentioned in the conversation.',
-     'Langchain': 'Langchain is a project that is trying to add more complex '
-                  'memory structures, including a key-value store for entities '
-                  'mentioned so far in the conversation.',
-     'Sam': 'Sam is working on a hackathon project with Deven, trying to add more '
-            'complex memory structures to Langchain, including a key-value store '
-            'for entities mentioned so far in the conversation. They seem to have '
-            'a great idea for how the key-value store can help, and Sam is also '
-            'the founder of a company called Daimon.'}
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.predict(input="Sam is the founder of a company called Daimon.")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    You are an assistant to a human, powered by a large language model trained by OpenAI.
-
-    You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-
-    You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.
-
-    Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.
-
-    Context:
-    {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to have a great idea for how the key-value store can help, and Sam is also the founder of a company called Daimon.'}
-
-    Current conversation:
-    Human: They are adding in a key-value store for entities mentioned so far in the conversation.
-    AI:  That sounds like a great idea! How will the key-value store help with the project?
-    Human: What do you know about Deven & Sam?
-    AI:  Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help.
-    Human: Sam is the founder of a company called Daimon.
-    AI:
-    That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon?
-    Last line:
-    Human: Sam is the founder of a company called Daimon.
-    You:
-
-    > Finished chain.
-
-
-
-
-
-    " That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon?"
-```
-
-</CodeOutputBlock>
-
-
-```python
-from pprint import pprint
-pprint(conversation.memory.entity_store.store)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur, who '
-               'is working on a hackathon project with Deven to add more complex '
-               'memory structures to Langchain.',
-     'Deven': 'Deven is working on a hackathon project with Sam, which they are '
-              'entering into a hackathon. They are trying to add more complex '
-              'memory structures to Langchain, including a key-value store for '
-              'entities mentioned so far in the conversation, and seem to be '
-              'working hard on this project with a great idea for how the '
-              'key-value store can help.',
-     'Key-Value Store': 'A key-value store is being added to the project to store '
-                        'entities mentioned in the conversation.',
-     'Langchain': 'Langchain is a project that is trying to add more complex '
-                  'memory structures, including a key-value store for entities '
-                  'mentioned so far in the conversation.',
-     'Sam': 'Sam is working on a hackathon project with Deven, trying to add more '
-            'complex memory structures to Langchain, including a key-value store '
-            'for entities mentioned so far in the conversation. They seem to have '
-            'a great idea for how the key-value store can help, and Sam is also '
-            'the founder of a successful company called Daimon.'}
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation.predict(input="What do you know about Sam?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    You are an assistant to a human, powered by a large language model trained by OpenAI.
-
-    You are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-
-    You are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.
-
-    Overall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.
-
-    Context:
-    {'Deven': 'Deven is working on a hackathon project with Sam, which they are entering into a hackathon. They are trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation, and seem to be working hard on this project with a great idea for how the key-value store can help.', 'Sam': 'Sam is working on a hackathon project with Deven, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to have a great idea for how the key-value store can help, and Sam is also the founder of a successful company called Daimon.', 'Langchain': 'Langchain is a project that is trying to add more complex memory structures, including a key-value store for entities mentioned so far in the conversation.', 'Daimon': 'Daimon is a company founded by Sam, a successful entrepreneur, who is working on a hackathon project with Deven to add more complex memory structures to Langchain.'}
-
-    Current conversation:
-    Human: What do you know about Deven & Sam?
-    AI:  Deven and Sam are working on a hackathon project together, trying to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation. They seem to be working hard on this project and have a great idea for how the key-value store can help.
-    Human: Sam is the founder of a company called Daimon.
-    AI:
-    That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon?
-    Human: Sam is the founder of a company called Daimon.
-    AI:  That's impressive! It sounds like Sam is a very successful entrepreneur. What kind of company is Daimon?
-    Last line:
-    Human: What do you know about Sam?
-    You:
-
-    > Finished chain.
-
-
-
-
-
-    ' Sam is the founder of a successful company called Daimon. He is also working on a hackathon project with Deven to add more complex memory structures to Langchain. They seem to have a great idea for how the key-value store can help.'
-```
-
-</CodeOutputBlock>

docs/docs/modules/memory/types/index.mdx

@@ -1,8 +0,0 @@
----
-sidebar_position: 2
----
-# Memory types
-
-There are many different types of memory.
-Each has their own parameters, their own return types, and is useful in different scenarios.
-Please see their individual page for more detail on each one.

docs/docs/modules/memory/types/kg.ipynb

@@ -1,363 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "44c9933a",
-   "metadata": {},
-   "source": [
-    "# Conversation Knowledge Graph\n",
-    "\n",
-    "This type of memory uses a knowledge graph to recreate memory.\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0c798006-ca04-4de3-83eb-cf167fb2bd01",
-   "metadata": {},
-   "source": [
-    "## Using memory with LLM"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "f71f40ba",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationKGMemory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "2f4a3c85",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\n",
-    "memory = ConversationKGMemory(llm=llm)\n",
-    "memory.save_context({\"input\": \"say hi to sam\"}, {\"output\": \"who is sam\"})\n",
-    "memory.save_context({\"input\": \"sam is a friend\"}, {\"output\": \"okay\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "72283b4f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'history': 'On Sam: Sam is friend.'}"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.load_memory_variables({\"input\": \"who is sam\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0c8ff11e",
-   "metadata": {},
-   "source": [
-    "We can also get the history as a list of messages (this is useful if you are using this with a chat model)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "44df43af",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory = ConversationKGMemory(llm=llm, return_messages=True)\n",
-    "memory.save_context({\"input\": \"say hi to sam\"}, {\"output\": \"who is sam\"})\n",
-    "memory.save_context({\"input\": \"sam is a friend\"}, {\"output\": \"okay\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "4726b1c8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'history': [SystemMessage(content='On Sam: Sam is friend.', additional_kwargs={})]}"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.load_memory_variables({\"input\": \"who is sam\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dc956b0e",
-   "metadata": {},
-   "source": [
-    "We can also more modularly get current entities from a new message (will use previous messages as context)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "36331ca5",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['Sam']"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.get_current_entities(\"what's Sams favorite color?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e8749134",
-   "metadata": {},
-   "source": [
-    "We can also more modularly get knowledge triplets from a new message (will use previous messages as context)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "b02d44db",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[KnowledgeTriple(subject='Sam', predicate='favorite color', object_='red')]"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.get_knowledge_triplets(\"her favorite color is red\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f7a02ef3",
-   "metadata": {},
-   "source": [
-    "## Using in a chain\n",
-    "\n",
-    "Let's now use this in a chain!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "b462baf1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\n",
-    "from langchain.chains import ConversationChain\n",
-    "from langchain.prompts.prompt import PromptTemplate\n",
-    "\n",
-    "template = \"\"\"The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. \n",
-    "If the AI does not know the answer to a question, it truthfully says it does not know. The AI ONLY uses information contained in the \"Relevant Information\" section and does not hallucinate.\n",
-    "\n",
-    "Relevant Information:\n",
-    "\n",
-    "{history}\n",
-    "\n",
-    "Conversation:\n",
-    "Human: {input}\n",
-    "AI:\"\"\"\n",
-    "prompt = PromptTemplate(input_variables=[\"history\", \"input\"], template=template)\n",
-    "conversation_with_kg = ConversationChain(\n",
-    "    llm=llm, verbose=True, prompt=prompt, memory=ConversationKGMemory(llm=llm)\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "97efaf38",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. \n",
-      "If the AI does not know the answer to a question, it truthfully says it does not know. The AI ONLY uses information contained in the \"Relevant Information\" section and does not hallucinate.\n",
-      "\n",
-      "Relevant Information:\n",
-      "\n",
-      "\n",
-      "\n",
-      "Conversation:\n",
-      "Human: Hi, what's up?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! I'm doing great. I'm currently in the process of learning about the world around me. I'm learning about different cultures, languages, and customs. It's really fascinating! How about you?\""
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_kg.predict(input=\"Hi, what's up?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "55b5bcad",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. \n",
-      "If the AI does not know the answer to a question, it truthfully says it does not know. The AI ONLY uses information contained in the \"Relevant Information\" section and does not hallucinate.\n",
-      "\n",
-      "Relevant Information:\n",
-      "\n",
-      "\n",
-      "\n",
-      "Conversation:\n",
-      "Human: My name is James and I'm helping Will. He's an engineer.\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi James, it's nice to meet you. I'm an AI and I understand you're helping Will, the engineer. What kind of engineering does he do?\""
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_kg.predict(\n",
-    "    input=\"My name is James and I'm helping Will. He's an engineer.\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "9981e219",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. \n",
-      "If the AI does not know the answer to a question, it truthfully says it does not know. The AI ONLY uses information contained in the \"Relevant Information\" section and does not hallucinate.\n",
-      "\n",
-      "Relevant Information:\n",
-      "\n",
-      "On Will: Will is an engineer.\n",
-      "\n",
-      "Conversation:\n",
-      "Human: What do you know about Will?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Will is an engineer.'"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_kg.predict(input=\"What do you know about Will?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8c09a239",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/types/summary.mdx

@@ -1,214 +0,0 @@
-# Conversation Summary
-Now let's take a look at using a slightly more complex type of memory - `ConversationSummaryMemory`. This type of memory creates a summary of the conversation over time. This can be useful for condensing information from the conversation over time.
-Conversation summary memory summarizes the conversation as it happens and stores the current summary in memory. This memory can then be used to inject the summary of the conversation so far into a prompt/chain. This memory is most useful for longer conversations, where keeping the past message history in the prompt verbatim would take up too many tokens.
-
-Let's first explore the basic functionality of this type of memory.
-
-```python
-from langchain.memory import ConversationSummaryMemory, ChatMessageHistory
-from langchain.llms import OpenAI
-```
-
-
-```python
-memory = ConversationSummaryMemory(llm=OpenAI(temperature=0))
-memory.save_context({"input": "hi"}, {"output": "whats up"})
-```
-
-
-```python
-memory.load_memory_variables({})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': '\nThe human greets the AI, to which the AI responds.'}
-```
-
-</CodeOutputBlock>
-
-We can also get the history as a list of messages (this is useful if you are using this with a chat model).
-
-
-```python
-memory = ConversationSummaryMemory(llm=OpenAI(temperature=0), return_messages=True)
-memory.save_context({"input": "hi"}, {"output": "whats up"})
-```
-
-
-```python
-memory.load_memory_variables({})
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'history': [SystemMessage(content='\nThe human greets the AI, to which the AI responds.', additional_kwargs={})]}
-```
-
-</CodeOutputBlock>
-
-We can also utilize the `predict_new_summary` method directly.
-
-
-```python
-messages = memory.chat_memory.messages
-previous_summary = ""
-memory.predict_new_summary(messages, previous_summary)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    '\nThe human greets the AI, to which the AI responds.'
-```
-
-</CodeOutputBlock>
-
-## Initializing with messages/existing summary
-
-If you have messages outside this class, you can easily initialize the class with `ChatMessageHistory`. During loading, a summary will be calculated.
-
-
-```python
-history = ChatMessageHistory()
-history.add_user_message("hi")
-history.add_ai_message("hi there!")
-```
-
-
-```python
-memory = ConversationSummaryMemory.from_messages(
-    llm=OpenAI(temperature=0),
-    chat_memory=history,
-    return_messages=True
-)
-```
-
-
-```python
-memory.buffer
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    '\nThe human greets the AI, to which the AI responds with a friendly greeting.'
-```
-
-</CodeOutputBlock>
-
-Optionally you can speed up initialization using a previously generated summary, and avoid regenerating the summary by just initializing directly.
-
-```python
-memory = ConversationSummaryMemory(
-    llm=OpenAI(temperature=0),
-    buffer="The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good because it will help humans reach their full potential.",
-    chat_memory=history,
-    return_messages=True
-)
-```
-
-## Using in a chain
-Let's walk through an example of using this in a chain, again setting `verbose=True` so we can see the prompt.
-
-
-```python
-from langchain.llms import OpenAI
-from langchain.chains import ConversationChain
-llm = OpenAI(temperature=0)
-conversation_with_summary = ConversationChain(
-    llm=llm,
-    memory=ConversationSummaryMemory(llm=OpenAI()),
-    verbose=True
-)
-conversation_with_summary.predict(input="Hi, what's up?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-
-    Human: Hi, what's up?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?"
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation_with_summary.predict(input="Tell me more about it!")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-
-    The human greeted the AI and asked how it was doing. The AI replied that it was doing great and was currently helping a customer with a technical issue.
-    Human: Tell me more about it!
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " Sure! The customer is having trouble with their computer not connecting to the internet. I'm helping them troubleshoot the issue and figure out what the problem is. So far, we've tried resetting the router and checking the network settings, but the issue still persists. We're currently looking into other possible solutions."
-```
-
-</CodeOutputBlock>
-
-
-```python
-conversation_with_summary.predict(input="Very cool -- what is the scope of the project?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Current conversation:
-
-    The human greeted the AI and asked how it was doing. The AI replied that it was doing great and was currently helping a customer with a technical issue where their computer was not connecting to the internet. The AI was troubleshooting the issue and had already tried resetting the router and checking the network settings, but the issue still persisted and they were looking into other possible solutions.
-    Human: Very cool -- what is the scope of the project?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " The scope of the project is to troubleshoot the customer's computer issue and find a solution that will allow them to connect to the internet. We are currently exploring different possibilities and have already tried resetting the router and checking the network settings, but the issue still persists."
-```
-
-</CodeOutputBlock>

docs/docs/modules/memory/types/summary_buffer.ipynb

@@ -1,337 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "ff4be5f3",
-   "metadata": {},
-   "source": [
-    "# Conversation Summary Buffer\n",
-    "\n",
-    "`ConversationSummaryBufferMemory` combines the two ideas. It keeps a buffer of recent interactions in memory, but rather than just completely flushing old interactions it compiles them into a summary and uses both. \n",
-    "It uses token length rather than number of interactions to determine when to flush interactions.\n",
-    "\n",
-    "Let's first walk through how to use the utilities."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0309636e-a530-4d2a-ba07-0916ea18bb20",
-   "metadata": {},
-   "source": [
-    "## Using memory with LLM"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "da3384db",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationSummaryBufferMemory\n",
-    "\n",
-    "llm = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "e00d4938",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)\n",
-    "memory.save_context({\"input\": \"hi\"}, {\"output\": \"whats up\"})\n",
-    "memory.save_context({\"input\": \"not much you\"}, {\"output\": \"not much\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "2fe28a28",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'history': 'System: \\nThe human says \"hi\", and the AI responds with \"whats up\".\\nHuman: not much you\\nAI: not much'}"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.load_memory_variables({})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cf57b97a",
-   "metadata": {},
-   "source": [
-    "We can also get the history as a list of messages (this is useful if you are using this with a chat model)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "3422a3a8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory = ConversationSummaryBufferMemory(\n",
-    "    llm=llm, max_token_limit=10, return_messages=True\n",
-    ")\n",
-    "memory.save_context({\"input\": \"hi\"}, {\"output\": \"whats up\"})\n",
-    "memory.save_context({\"input\": \"not much you\"}, {\"output\": \"not much\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a1dcaaee",
-   "metadata": {},
-   "source": [
-    "We can also utilize the `predict_new_summary` method directly."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "fd7d7d6b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'\\nThe human and AI state that they are not doing much.'"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "messages = memory.chat_memory.messages\n",
-    "previous_summary = \"\"\n",
-    "memory.predict_new_summary(messages, previous_summary)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a6d2569f",
-   "metadata": {},
-   "source": [
-    "## Using in a chain\n",
-    "Let's walk through an example, again setting `verbose=True` so we can see the prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "ebd68c10",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Human: Hi, what's up?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! I'm doing great. I'm learning about the latest advances in artificial intelligence. What about you?\""
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.chains import ConversationChain\n",
-    "\n",
-    "conversation_with_summary = ConversationChain(\n",
-    "    llm=llm,\n",
-    "    # We set a very low max_token_limit for the purposes of testing.\n",
-    "    memory=ConversationSummaryBufferMemory(llm=OpenAI(), max_token_limit=40),\n",
-    "    verbose=True,\n",
-    ")\n",
-    "conversation_with_summary.predict(input=\"Hi, what's up?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "86207a61",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "Human: Hi, what's up?\n",
-      "AI:  Hi there! I'm doing great. I'm spending some time learning about the latest developments in AI technology. How about you?\n",
-      "Human: Just working on writing some documentation!\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' That sounds like a great use of your time. Do you have experience with writing documentation?'"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"Just working on writing some documentation!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "76a0ab39",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "System: \n",
-      "The human asked the AI what it was up to and the AI responded that it was learning about the latest developments in AI technology.\n",
-      "Human: Just working on writing some documentation!\n",
-      "AI:  That sounds like a great use of your time. Do you have experience with writing documentation?\n",
-      "Human: For LangChain! Have you heard of it?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" No, I haven't heard of LangChain. Can you tell me more about it?\""
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We can see here that there is a summary of the conversation and then some previous interactions\n",
-    "conversation_with_summary.predict(input=\"For LangChain! Have you heard of it?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "8c669db1",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "System: \n",
-      "The human asked the AI what it was up to and the AI responded that it was learning about the latest developments in AI technology. The human then mentioned they were writing documentation, to which the AI responded that it sounded like a great use of their time and asked if they had experience with writing documentation.\n",
-      "Human: For LangChain! Have you heard of it?\n",
-      "AI:  No, I haven't heard of LangChain. Can you tell me more about it?\n",
-      "Human: Haha nope, although a lot of people confuse it for that\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Oh, okay. What is LangChain?'"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We can see here that the summary and the buffer are updated\n",
-    "conversation_with_summary.predict(\n",
-    "    input=\"Haha nope, although a lot of people confuse it for that\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8c09a239",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/types/token_buffer.ipynb

@@ -1,302 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "ff4be5f3",
-   "metadata": {},
-   "source": [
-    "# Conversation Token Buffer\n",
-    "\n",
-    "`ConversationTokenBufferMemory` keeps a buffer of recent interactions in memory, and uses token length rather than number of interactions to determine when to flush interactions.\n",
-    "\n",
-    "Let's first walk through how to use the utilities."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0e528ef0-7b04-4a4a-8ff2-493c02027e83",
-   "metadata": {},
-   "source": [
-    "## Using memory with LLM"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "da3384db",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.llms import OpenAI\n",
-    "from langchain.memory import ConversationTokenBufferMemory\n",
-    "\n",
-    "llm = OpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "e00d4938",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10)\n",
-    "memory.save_context({\"input\": \"hi\"}, {\"output\": \"whats up\"})\n",
-    "memory.save_context({\"input\": \"not much you\"}, {\"output\": \"not much\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "2fe28a28",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'history': 'Human: not much you\\nAI: not much'}"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.load_memory_variables({})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cf57b97a",
-   "metadata": {},
-   "source": [
-    "We can also get the history as a list of messages (this is useful if you are using this with a chat model)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "3422a3a8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory = ConversationTokenBufferMemory(\n",
-    "    llm=llm, max_token_limit=10, return_messages=True\n",
-    ")\n",
-    "memory.save_context({\"input\": \"hi\"}, {\"output\": \"whats up\"})\n",
-    "memory.save_context({\"input\": \"not much you\"}, {\"output\": \"not much\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a6d2569f",
-   "metadata": {},
-   "source": [
-    "## Using in a chain\n",
-    "Let's walk through an example, again setting `verbose=True` so we can see the prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "ebd68c10",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "\n",
-      "Human: Hi, what's up?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! I'm doing great, just enjoying the day. How about you?\""
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.chains import ConversationChain\n",
-    "\n",
-    "conversation_with_summary = ConversationChain(\n",
-    "    llm=llm,\n",
-    "    # We set a very low max_token_limit for the purposes of testing.\n",
-    "    memory=ConversationTokenBufferMemory(llm=OpenAI(), max_token_limit=60),\n",
-    "    verbose=True,\n",
-    ")\n",
-    "conversation_with_summary.predict(input=\"Hi, what's up?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "86207a61",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "Human: Hi, what's up?\n",
-      "AI:  Hi there! I'm doing great, just enjoying the day. How about you?\n",
-      "Human: Just working on writing some documentation!\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Sounds like a productive day! What kind of documentation are you writing?'"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"Just working on writing some documentation!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "76a0ab39",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "Human: Hi, what's up?\n",
-      "AI:  Hi there! I'm doing great, just enjoying the day. How about you?\n",
-      "Human: Just working on writing some documentation!\n",
-      "AI:  Sounds like a productive day! What kind of documentation are you writing?\n",
-      "Human: For LangChain! Have you heard of it?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Yes, I have heard of LangChain! It is a decentralized language-learning platform that connects native speakers and learners in real time. Is that the documentation you're writing about?\""
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"For LangChain! Have you heard of it?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "8c669db1",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new ConversationChain chain...\u001b[0m\n",
-      "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
-      "\n",
-      "Current conversation:\n",
-      "Human: For LangChain! Have you heard of it?\n",
-      "AI:  Yes, I have heard of LangChain! It is a decentralized language-learning platform that connects native speakers and learners in real time. Is that the documentation you're writing about?\n",
-      "Human: Haha nope, although a lot of people confuse it for that\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Oh, I see. Is there another language learning platform you're referring to?\""
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We can see here that the buffer is updated\n",
-    "conversation_with_summary.predict(\n",
-    "    input=\"Haha nope, although a lot of people confuse it for that\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8c09a239",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/memory/types/vectorstore_retriever_memory.mdx

@@ -1,237 +0,0 @@
-# Backed by a Vector Store
-
-`VectorStoreRetrieverMemory` stores memories in a vector store and queries the top-K most "salient" docs every time it is called.
-
-This differs from most of the other Memory classes in that it doesn't explicitly track the order of interactions.
-
-In this case, the "docs" are previous conversation snippets. This can be useful to refer to relevant pieces of information that the AI was told earlier in the conversation.
-
-```python
-from datetime import datetime
-from langchain.embeddings.openai import OpenAIEmbeddings
-from langchain.llms import OpenAI
-from langchain.memory import VectorStoreRetrieverMemory
-from langchain.chains import ConversationChain
-from langchain.prompts import PromptTemplate
-```
-
-### Initialize your vector store
-
-Depending on the store you choose, this step may look different. Consult the relevant vector store documentation for more details.
-
-
-```python
-import faiss
-
-from langchain.docstore import InMemoryDocstore
-from langchain.vectorstores import FAISS
-
-
-embedding_size = 1536 # Dimensions of the OpenAIEmbeddings
-index = faiss.IndexFlatL2(embedding_size)
-embedding_fn = OpenAIEmbeddings().embed_query
-vectorstore = FAISS(embedding_fn, index, InMemoryDocstore({}), {})
-```
-
-### Create your `VectorStoreRetrieverMemory`
-
-The memory object is instantiated from any vector store retriever.
-
-
-```python
-# In actual usage, you would set `k` to be a higher value, but we use k=1 to show that
-# the vector lookup still returns the semantically relevant information
-retriever = vectorstore.as_retriever(search_kwargs=dict(k=1))
-memory = VectorStoreRetrieverMemory(retriever=retriever)
-
-# When added to an agent, the memory object can save pertinent information from conversations or used tools
-memory.save_context({"input": "My favorite food is pizza"}, {"output": "that's good to know"})
-memory.save_context({"input": "My favorite sport is soccer"}, {"output": "..."})
-memory.save_context({"input": "I don't the Celtics"}, {"output": "ok"}) #
-```
-
-
-```python
-# Notice the first result returned is the memory pertaining to tax help, which the language model deems more semantically relevant
-# to a 1099 than the other documents, despite them both containing numbers.
-print(memory.load_memory_variables({"prompt": "what sport should i watch?"})["history"])
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    input: My favorite sport is soccer
-    output: ...
-```
-
-</CodeOutputBlock>
-
-## Using in a chain
-Let's walk through an example, again setting `verbose=True` so we can see the prompt.
-
-
-```python
-llm = OpenAI(temperature=0) # Can be any valid LLM
-_DEFAULT_TEMPLATE = """The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-Relevant pieces of previous conversation:
-{history}
-
-(You do not need to use these pieces of information if not relevant)
-
-Current conversation:
-Human: {input}
-AI:"""
-PROMPT = PromptTemplate(
-    input_variables=["history", "input"], template=_DEFAULT_TEMPLATE
-)
-conversation_with_summary = ConversationChain(
-    llm=llm,
-    prompt=PROMPT,
-    # We set a very low max_token_limit for the purposes of testing.
-    memory=memory,
-    verbose=True
-)
-conversation_with_summary.predict(input="Hi, my name is Perry, what's up?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Relevant pieces of previous conversation:
-    input: My favorite food is pizza
-    output: that's good to know
-
-    (You do not need to use these pieces of information if not relevant)
-
-    Current conversation:
-    Human: Hi, my name is Perry, what's up?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    " Hi Perry, I'm doing well. How about you?"
-```
-
-</CodeOutputBlock>
-
-
-```python
-# Here, the basketball related content is surfaced
-conversation_with_summary.predict(input="what's my favorite sport?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Relevant pieces of previous conversation:
-    input: My favorite sport is soccer
-    output: ...
-
-    (You do not need to use these pieces of information if not relevant)
-
-    Current conversation:
-    Human: what's my favorite sport?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    ' You told me earlier that your favorite sport is soccer.'
-```
-
-</CodeOutputBlock>
-
-
-```python
-# Even though the language model is stateless, since relevant memory is fetched, it can "reason" about the time.
-# Timestamping memories and data is useful in general to let the agent determine temporal relevance
-conversation_with_summary.predict(input="Whats my favorite food")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Relevant pieces of previous conversation:
-    input: My favorite food is pizza
-    output: that's good to know
-
-    (You do not need to use these pieces of information if not relevant)
-
-    Current conversation:
-    Human: Whats my favorite food
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    ' You said your favorite food is pizza.'
-```
-
-</CodeOutputBlock>
-
-
-```python
-# The memories from the conversation are automatically stored,
-# since this query best matches the introduction chat above,
-# the agent is able to 'remember' the user's name.
-conversation_with_summary.predict(input="What's my name?")
-```
-
-<CodeOutputBlock lang="python">
-
-```
-
-
-    > Entering new ConversationChain chain...
-    Prompt after formatting:
-    The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
-
-    Relevant pieces of previous conversation:
-    input: Hi, my name is Perry, what's up?
-    response:  Hi Perry, I'm doing well. How about you?
-
-    (You do not need to use these pieces of information if not relevant)
-
-    Current conversation:
-    Human: What's my name?
-    AI:
-
-    > Finished chain.
-
-
-
-
-
-    ' Your name is Perry.'
-```
-
-</CodeOutputBlock>

docs/docs/modules/model_io/prompts/prompt_templates/index.ipynb

@@ -16,7 +16,7 @@
    "id": "2d98412d-fc53-42c1-aed8-f1f8eb9ada58",
    "metadata": {},
    "source": [
-    "Prompt templates are pre-defined recipes for generating prompts for language models.\n",
+    "Prompt templates are predefined recipes for generating prompts for language models.\n",
     "\n",
     "A template may include instructions, few-shot examples, and specific context and\n",
     "questions appropriate for a given task.\n",

docs/docs/use_cases/question_answering/per_user.ipynb

@@ -0,0 +1,323 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "14d3fd06",
+   "metadata": {},
+   "source": [
+    "# Per-User Retrieval\n",
+    "\n",
+    "When building a retrieval app, you often have to build it with multiple users in mind. This means that you may be storing data not just for one user, but for many different users, and they should not be able to see eachother's data. This means that you need to be able to configure your retrieval chain to only retrieve certain information. This generally involves two steps.\n",
+    "\n",
+    "**Step 1: Make sure the retriever you are using supports multiple users**\n",
+    "\n",
+    "At the moment, there is no unified flag or filter for this in LangChain. Rather, each vectorstore and retriever may have their own, and may be called different things (namespaces, multi-tenancy, etc). For vectorstores, this is generally exposed as a keyword argument that is passed in during `similarity_search`. By reading the documentation or source code, figure out whether the retriever you are using supports multiple users, and, if so, how to use it.\n",
+    "\n",
+    "Note: adding documentation and/or support for multiple users for retrievers that do not support it (or document it) is a GREAT way to contribute to LangChain\n",
+    "\n",
+    "**Step 2: Add that parameter as a configurable field for the chain**\n",
+    "\n",
+    "This will let you easily call the chain and configure any relevant flags at runtime. See [this documentation](docs/expression_language/how_to/configure) for more information on configuration.\n",
+    "\n",
+    "**Step 3: Call the chain with that configurable field**\n",
+    "\n",
+    "Now, at runtime you can call this chain with configurable field.\n",
+    "\n",
+    "## Code Example\n",
+    "\n",
+    "Let's see a concrete example of what this looks like in code. We will use Pinecone for this example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "75823b2d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/harrisonchase/.pyenv/versions/3.10.1/envs/langchain/lib/python3.10/site-packages/pinecone/index.py:4: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n",
+      "  from tqdm.autonotebook import tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pinecone\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import Pinecone"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7345de3c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['ce15571e-4e2f-44c9-98df-7e83f6f63095']"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# The environment should be the one specified next to the API key\n",
+    "# in your Pinecone console\n",
+    "pinecone.init(api_key=\"...\", environment=\"...\")\n",
+    "index = pinecone.Index(\"test-example\")\n",
+    "embeddings = OpenAIEmbeddings()\n",
+    "vectorstore = Pinecone(index, embeddings, \"text\")\n",
+    "\n",
+    "vectorstore.add_texts([\"i worked at kensho\"], namespace=\"harrison\")\n",
+    "vectorstore.add_texts([\"i worked at facebook\"], namespace=\"ankush\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39c11920",
+   "metadata": {},
+   "source": [
+    "The pinecone kwarg for `namespace` can be used to separate documents"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3c2a39fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='i worked at facebook')]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This will only get documents for Ankush\n",
+    "vectorstore.as_retriever(search_kwargs={\"namespace\": \"ankush\"}).get_relevant_documents(\n",
+    "    \"where did i work?\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "56393baa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='i worked at kensho')]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# This will only get documents for Harrison\n",
+    "vectorstore.as_retriever(\n",
+    "    search_kwargs={\"namespace\": \"harrison\"}\n",
+    ").get_relevant_documents(\"where did i work?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88ae97ed",
+   "metadata": {},
+   "source": [
+    "We can now create the chain that we will use to do question-answering over"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "62707b4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import (\n",
+    "    ConfigurableField,\n",
+    "    RunnableBinding,\n",
+    "    RunnableLambda,\n",
+    "    RunnablePassthrough,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6778ffa",
+   "metadata": {},
+   "source": [
+    "This is basic question-answering chain set up."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "44a865f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "retriever = vectorstore.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72125166",
+   "metadata": {},
+   "source": [
+    "Here we mark the retriever as having a configurable field. All vectorstore retrievers have `search_kwargs` as a field. This is just a dictionary, with vectorstore specific fields"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "babbadff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "configurable_retriever = retriever.configurable_fields(\n",
+    "    search_kwargs=ConfigurableField(\n",
+    "        id=\"search_kwargs\",\n",
+    "        name=\"Search Kwargs\",\n",
+    "        description=\"The search kwargs to use\",\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d481b70",
+   "metadata": {},
+   "source": [
+    "We can now create the chain using our configurable retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "210b0446",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = (\n",
+    "    {\"context\": configurable_retriever, \"question\": RunnablePassthrough()}\n",
+    "    | prompt\n",
+    "    | model\n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f6458c3",
+   "metadata": {},
+   "source": [
+    "We can now invoke the chain with configurable options. `search_kwargs` is the id of the configurable field. The value is the search kwargs to use for Pinecone"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a38037b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The user worked at Kensho.'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\n",
+    "    \"where did the user work?\",\n",
+    "    config={\"configurable\": {\"search_kwargs\": {\"namespace\": \"harrison\"}}},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "0ff4f5f2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The user worked at Facebook.'"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\n",
+    "    \"where did the user work?\",\n",
+    "    config={\"configurable\": {\"search_kwargs\": {\"namespace\": \"ankush\"}}},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3aa0b9e",
+   "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.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/vercel.json

@@ -1,5 +1,13 @@
 {
   "redirects": [
+    {
+      "source": "docs/docs/integrations/providers/alibabacloud_opensearch",
+      "destination": "docs/docs/integrations/providers/alibaba_cloud"
+    },
+    {
+      "source": "/docs/integrations/chat/pai_eas_chat_endpoint",
+      "destination": "/docs/integrations/chat/alibaba_cloud_pai_eas"
+    },
     {
       "source": "/docs/integrations/providers/tencentvectordb",
       "destination": "/docs/integrations/providers/tencent"

libs/community/langchain_community/chat_message_histories/elasticsearch.py

@@ -26,6 +26,7 @@ class ElasticsearchChatMessageHistory(BaseChatMessageHistory):
         es_password: Password to use when connecting to Elasticsearch.
         es_api_key: API key to use when connecting to Elasticsearch.
         es_connection: Optional pre-existing Elasticsearch connection.
+        esnsure_ascii: Used to escape ASCII symbols in json.dumps. Defaults to True.
         index: Name of the index to use.
         session_id: Arbitrary key that is used to store the messages
             of a single chat session.
@@ -42,9 +43,11 @@ class ElasticsearchChatMessageHistory(BaseChatMessageHistory):
         es_user: Optional[str] = None,
         es_api_key: Optional[str] = None,
         es_password: Optional[str] = None,
+        esnsure_ascii: Optional[bool] = True,
     ):
         self.index: str = index
         self.session_id: str = session_id
+        self.ensure_ascii: bool = esnsure_ascii
 
         # Initialize Elasticsearch client from passed client arg or connection info
         if es_connection is not None:
@@ -172,7 +175,10 @@ class ElasticsearchChatMessageHistory(BaseChatMessageHistory):
                 document={
                     "session_id": self.session_id,
                     "created_at": round(time() * 1000),
-                    "history": json.dumps(message_to_dict(message)),
+                    "history": json.dumps(
+                        message_to_dict(message),
+                        ensure_ascii=self.ensure_ascii,
+                    ),
                 },
                 refresh=True,
             )

libs/community/langchain_community/chat_models/__init__.py

@@ -32,6 +32,7 @@ from langchain_community.chat_models.fireworks import ChatFireworks
 from langchain_community.chat_models.gigachat import GigaChat
 from langchain_community.chat_models.google_palm import ChatGooglePalm
 from langchain_community.chat_models.gpt_router import GPTRouter
+from langchain_community.chat_models.huggingface import ChatHuggingFace
 from langchain_community.chat_models.human import HumanInputChatModel
 from langchain_community.chat_models.hunyuan import ChatHunyuan
 from langchain_community.chat_models.javelin_ai_gateway import ChatJavelinAIGateway
@@ -65,6 +66,7 @@ __all__ = [
     "ChatOllama",
     "ChatVertexAI",
     "JinaChat",
+    "ChatHuggingFace",
     "HumanInputChatModel",
     "MiniMaxChat",
     "ChatAnyscale",

libs/community/langchain_community/chat_models/azure_openai.py

@@ -26,7 +26,7 @@ class AzureChatOpenAI(ChatOpenAI):
     In addition, you should have the ``openai`` python package installed, and the
     following environment variables set or passed in constructor in lower case:
     - ``AZURE_OPENAI_API_KEY``
-    - ``AZURE_OPENAI_API_ENDPOINT``
+    - ``AZURE_OPENAI_ENDPOINT``
     - ``AZURE_OPENAI_AD_TOKEN``
     - ``OPENAI_API_VERSION``
     - ``OPENAI_PROXY``

libs/community/langchain_community/chat_models/gpt_router.py

@@ -233,8 +233,8 @@ class GPTRouter(BaseChatModel):
         self,
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
-        run_manager: CallbackManagerForLLMRun | None = None,
-        stream: bool | None = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stream: Optional[bool] = None,
         **kwargs: Any,
     ) -> ChatResult:
         should_stream = stream if stream is not None else self.streaming
@@ -259,8 +259,8 @@ class GPTRouter(BaseChatModel):
         self,
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
-        run_manager: AsyncCallbackManagerForLLMRun | None = None,
-        stream: bool | None = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stream: Optional[bool] = None,
         **kwargs: Any,
     ) -> ChatResult:
         should_stream = stream if stream is not None else self.streaming

libs/community/langchain_community/chat_models/huggingface.py

@@ -0,0 +1,166 @@
+"""Hugging Face Chat Wrapper."""
+from typing import Any, List, Optional, Union
+
+from langchain_core.callbacks.manager import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from langchain_core.outputs import (
+    ChatGeneration,
+    ChatResult,
+    LLMResult,
+)
+
+from langchain_community.llms.huggingface_endpoint import HuggingFaceEndpoint
+from langchain_community.llms.huggingface_hub import HuggingFaceHub
+from langchain_community.llms.huggingface_text_gen_inference import (
+    HuggingFaceTextGenInference,
+)
+
+DEFAULT_SYSTEM_PROMPT = """You are a helpful, respectful, and honest assistant."""
+
+
+class ChatHuggingFace(BaseChatModel):
+    """
+    Wrapper for using Hugging Face LLM's as ChatModels.
+
+    Works with `HuggingFaceTextGenInference`, `HuggingFaceEndpoint`,
+    and `HuggingFaceHub` LLMs.
+
+    Upon instantiating this class, the model_id is resolved from the url
+    provided to the LLM, and the appropriate tokenizer is loaded from
+    the HuggingFace Hub.
+
+    Adapted from: https://python.langchain.com/docs/integrations/chat/llama2_chat
+    """
+
+    llm: Union[HuggingFaceTextGenInference, HuggingFaceEndpoint, HuggingFaceHub]
+    system_message: SystemMessage = SystemMessage(content=DEFAULT_SYSTEM_PROMPT)
+    tokenizer: Any = None
+    model_id: str = None  # type: ignore
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+
+        from transformers import AutoTokenizer
+
+        self._resolve_model_id()
+        self.tokenizer = (
+            AutoTokenizer.from_pretrained(self.model_id)
+            if self.tokenizer is None
+            else self.tokenizer
+        )
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        llm_input = self._to_chat_prompt(messages)
+        llm_result = self.llm._generate(
+            prompts=[llm_input], stop=stop, run_manager=run_manager, **kwargs
+        )
+        return self._to_chat_result(llm_result)
+
+    async def _agenerate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        llm_input = self._to_chat_prompt(messages)
+        llm_result = await self.llm._agenerate(
+            prompts=[llm_input], stop=stop, run_manager=run_manager, **kwargs
+        )
+        return self._to_chat_result(llm_result)
+
+    def _to_chat_prompt(
+        self,
+        messages: List[BaseMessage],
+    ) -> str:
+        """Convert a list of messages into a prompt format expected by wrapped LLM."""
+        if not messages:
+            raise ValueError("at least one HumanMessage must be provided")
+
+        if not isinstance(messages[-1], HumanMessage):
+            raise ValueError("last message must be a HumanMessage")
+
+        messages_dicts = [self._to_chatml_format(m) for m in messages]
+
+        return self.tokenizer.apply_chat_template(
+            messages_dicts, tokenize=False, add_generation_prompt=True
+        )
+
+    def _to_chatml_format(self, message: BaseMessage) -> dict:
+        """Convert LangChain message to ChatML format."""
+
+        if isinstance(message, SystemMessage):
+            role = "system"
+        elif isinstance(message, AIMessage):
+            role = "assistant"
+        elif isinstance(message, HumanMessage):
+            role = "user"
+        else:
+            raise ValueError(f"Unknown message type: {type(message)}")
+
+        return {"role": role, "content": message.content}
+
+    @staticmethod
+    def _to_chat_result(llm_result: LLMResult) -> ChatResult:
+        chat_generations = []
+
+        for g in llm_result.generations[0]:
+            chat_generation = ChatGeneration(
+                message=AIMessage(content=g.text), generation_info=g.generation_info
+            )
+            chat_generations.append(chat_generation)
+
+        return ChatResult(
+            generations=chat_generations, llm_output=llm_result.llm_output
+        )
+
+    def _resolve_model_id(self) -> None:
+        """Resolve the model_id from the LLM's inference_server_url"""
+
+        from huggingface_hub import list_inference_endpoints
+
+        available_endpoints = list_inference_endpoints("*")
+
+        if isinstance(self.llm, HuggingFaceTextGenInference):
+            endpoint_url = self.llm.inference_server_url
+
+        elif isinstance(self.llm, HuggingFaceEndpoint):
+            endpoint_url = self.llm.endpoint_url
+
+        elif isinstance(self.llm, HuggingFaceHub):
+            # no need to look up model_id for HuggingFaceHub LLM
+            self.model_id = self.llm.repo_id
+            return
+
+        else:
+            raise ValueError(f"Unknown LLM type: {type(self.llm)}")
+
+        for endpoint in available_endpoints:
+            if endpoint.url == endpoint_url:
+                self.model_id = endpoint.repository
+
+        if not self.model_id:
+            raise ValueError(
+                "Failed to resolve model_id"
+                f"Could not find model id for inference server provided: {endpoint_url}"
+                "Make sure that your Hugging Face token has access to the endpoint."
+            )
+
+    @property
+    def _llm_type(self) -> str:
+        return "huggingface-chat-wrapper"

libs/community/langchain_community/chat_models/ollama.py

@@ -1,8 +1,9 @@
 import json
-from typing import Any, Dict, Iterator, List, Optional, Union
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union
 
 from langchain_core._api import deprecated
 from langchain_core.callbacks import (
+    AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
 from langchain_core.language_models.chat_models import BaseChatModel
@@ -156,6 +157,20 @@ class ChatOllama(BaseChatModel, _OllamaCommon):
             payload=payload, stop=stop, api_url=f"{self.base_url}/api/chat/", **kwargs
         )
 
+    async def _acreate_chat_stream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[str]:
+        payload = {
+            "messages": self._convert_messages_to_ollama_messages(messages),
+        }
+        async for stream_resp in self._acreate_stream(
+            payload=payload, stop=stop, api_url=f"{self.base_url}/api/chat/", **kwargs
+        ):
+            yield stream_resp
+
     def _chat_stream_with_aggregation(
         self,
         messages: List[BaseMessage],
@@ -182,6 +197,32 @@ class ChatOllama(BaseChatModel, _OllamaCommon):
 
         return final_chunk
 
+    async def _achat_stream_with_aggregation(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        verbose: bool = False,
+        **kwargs: Any,
+    ) -> ChatGenerationChunk:
+        final_chunk: Optional[ChatGenerationChunk] = None
+        async for stream_resp in self._acreate_chat_stream(messages, stop, **kwargs):
+            if stream_resp:
+                chunk = _chat_stream_response_to_chat_generation_chunk(stream_resp)
+                if final_chunk is None:
+                    final_chunk = chunk
+                else:
+                    final_chunk += chunk
+                if run_manager:
+                    await run_manager.on_llm_new_token(
+                        chunk.text,
+                        verbose=verbose,
+                    )
+        if final_chunk is None:
+            raise ValueError("No data received from Ollama stream.")
+
+        return final_chunk
+
     def _generate(
         self,
         messages: List[BaseMessage],
@@ -219,6 +260,43 @@ class ChatOllama(BaseChatModel, _OllamaCommon):
         )
         return ChatResult(generations=[chat_generation])
 
+    async def _agenerate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        """Call out to Ollama's generate endpoint.
+
+        Args:
+            messages: The list of base messages to pass into the model.
+            stop: Optional list of stop words to use when generating.
+
+        Returns:
+            Chat generations from the model
+
+        Example:
+            .. code-block:: python
+
+                response = ollama([
+                    HumanMessage(content="Tell me about the history of AI")
+                ])
+        """
+
+        final_chunk = await self._achat_stream_with_aggregation(
+            messages,
+            stop=stop,
+            run_manager=run_manager,
+            verbose=self.verbose,
+            **kwargs,
+        )
+        chat_generation = ChatGeneration(
+            message=AIMessage(content=final_chunk.text),
+            generation_info=final_chunk.generation_info,
+        )
+        return ChatResult(generations=[chat_generation])
+
     def _stream(
         self,
         messages: List[BaseMessage],
@@ -229,7 +307,7 @@ class ChatOllama(BaseChatModel, _OllamaCommon):
         try:
             for stream_resp in self._create_chat_stream(messages, stop, **kwargs):
                 if stream_resp:
-                    chunk = _stream_response_to_chat_generation_chunk(stream_resp)
+                    chunk = _chat_stream_response_to_chat_generation_chunk(stream_resp)
                     yield chunk
                     if run_manager:
                         run_manager.on_llm_new_token(
@@ -239,6 +317,29 @@ class ChatOllama(BaseChatModel, _OllamaCommon):
         except OllamaEndpointNotFoundError:
             yield from self._legacy_stream(messages, stop, **kwargs)
 
+    async def _astream(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[ChatGenerationChunk]:
+        try:
+            async for stream_resp in self._create_async_chat_stream(
+                messages, stop, **kwargs
+            ):
+                if stream_resp:
+                    chunk = _chat_stream_response_to_chat_generation_chunk(stream_resp)
+                    yield chunk
+                    if run_manager:
+                        await run_manager.on_llm_new_token(
+                            chunk.text,
+                            verbose=self.verbose,
+                        )
+        except OllamaEndpointNotFoundError:
+            async for chunk in self._legacy_astream(messages, stop, **kwargs):
+                yield chunk
+
     @deprecated("0.0.3", alternative="_stream")
     def _legacy_stream(
         self,

libs/community/langchain_community/chat_models/vertexai.py

@@ -6,7 +6,9 @@ import logging
 import re
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Union, cast
+from urllib.parse import urlparse
 
+import requests
 from langchain_core.callbacks import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
@@ -87,6 +89,15 @@ def _parse_chat_history(history: List[BaseMessage]) -> _ChatHistory:
     return chat_history
 
 
+def _is_url(s: str) -> bool:
+    try:
+        result = urlparse(s)
+        return all([result.scheme, result.netloc])
+    except Exception as e:
+        logger.debug(f"Unable to parse URL: {e}")
+        return False
+
+
 def _parse_chat_history_gemini(
     history: List[BaseMessage], project: Optional[str]
 ) -> List["Content"]:
@@ -118,6 +129,10 @@ def _parse_chat_history_gemini(
                         "data:image/<image_type>;base64,<base64_encoded_image>."
                     )
                 image = Image.from_bytes(base64.b64decode(encoded))
+            elif _is_url(path):
+                response = requests.get(path)
+                response.raise_for_status()
+                image = Image.from_bytes(response.content)
             else:
                 image = Image.load_from_file(path)
         else:

libs/community/langchain_community/document_loaders/__init__.py

@@ -77,6 +77,9 @@ from langchain_community.document_loaders.dataframe import DataFrameLoader
 from langchain_community.document_loaders.diffbot import DiffbotLoader
 from langchain_community.document_loaders.directory import DirectoryLoader
 from langchain_community.document_loaders.discord import DiscordChatLoader
+from langchain_community.document_loaders.doc_intelligence import (
+    AzureAIDocumentIntelligenceLoader,
+)
 from langchain_community.document_loaders.docugami import DocugamiLoader
 from langchain_community.document_loaders.docusaurus import DocusaurusLoader
 from langchain_community.document_loaders.dropbox import DropboxLoader
@@ -247,6 +250,7 @@ __all__ = [
     "AssemblyAIAudioTranscriptLoader",
     "AsyncHtmlLoader",
     "AzureAIDataLoader",
+    "AzureAIDocumentIntelligenceLoader",
     "AzureBlobStorageContainerLoader",
     "AzureBlobStorageFileLoader",
     "BSHTMLLoader",

libs/community/langchain_community/document_loaders/arxiv.py

@@ -25,3 +25,6 @@ class ArxivLoader(BaseLoader):
 
     def load(self) -> List[Document]:
         return self.client.load(self.query)
+
+    def get_summaries_as_docs(self) -> List[Document]:
+        return self.client.get_summaries_as_docs(self.query)

libs/community/langchain_community/document_loaders/directory.py

@@ -62,8 +62,8 @@ class DirectoryLoader(BaseLoader):
             max_concurrency: The maximum number of threads to use. Defaults to 4.
             sample_size: The maximum number of files you would like to load from the
                 directory.
-            randomize_sample: Suffle the files to get a random sample.
-            sample_seed: set the seed of the random shuffle for reporoducibility.
+            randomize_sample: Shuffle the files to get a random sample.
+            sample_seed: set the seed of the random shuffle for reproducibility.
         """
         if loader_kwargs is None:
             loader_kwargs = {}

libs/community/langchain_community/document_loaders/doc_intelligence.py

@@ -0,0 +1,89 @@
+from typing import Iterator, List, Optional
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseLoader
+from langchain_community.document_loaders.blob_loaders import Blob
+from langchain_community.document_loaders.parsers import (
+    AzureAIDocumentIntelligenceParser,
+)
+
+
+class AzureAIDocumentIntelligenceLoader(BaseLoader):
+    """Loads a PDF with Azure Document Intelligence"""
+
+    def __init__(
+        self,
+        api_endpoint: str,
+        api_key: str,
+        file_path: Optional[str] = None,
+        url_path: Optional[str] = None,
+        api_version: Optional[str] = None,
+        api_model: str = "prebuilt-layout",
+        mode: str = "markdown",
+    ) -> None:
+        """
+        Initialize the object for file processing with Azure Document Intelligence
+        (formerly Form Recognizer).
+
+        This constructor initializes a AzureAIDocumentIntelligenceParser object to be
+        used for parsing files using the Azure Document Intelligence API. The load
+        method generates Documents whose content representations are determined by the
+        mode parameter.
+
+        Parameters:
+        -----------
+        api_endpoint: str
+            The API endpoint to use for DocumentIntelligenceClient construction.
+        api_key: str
+            The API key to use for DocumentIntelligenceClient construction.
+        file_path : Optional[str]
+            The path to the file that needs to be loaded.
+            Either file_path or url_path must be specified.
+        url_path : Optional[str]
+            The URL to the file that needs to be loaded.
+            Either file_path or url_path must be specified.
+        api_version: Optional[str]
+            The API version for DocumentIntelligenceClient. Setting None to use
+            the default value from SDK.
+        api_model: str
+            The model name or ID to be used for form recognition in Azure.
+
+        Examples:
+        ---------
+        >>> obj = AzureAIDocumentIntelligenceLoader(
+        ...     file_path="path/to/file",
+        ...     api_endpoint="https://endpoint.azure.com",
+        ...     api_key="APIKEY",
+        ...     api_version="2023-10-31-preview",
+        ...     model="prebuilt-document"
+        ... )
+        """
+
+        assert (
+            file_path is not None or url_path is not None
+        ), "file_path or url_path must be provided"
+        self.file_path = file_path
+        self.url_path = url_path
+
+        self.parser = AzureAIDocumentIntelligenceParser(
+            api_endpoint=api_endpoint,
+            api_key=api_key,
+            api_version=api_version,
+            api_model=api_model,
+            mode=mode,
+        )
+
+    def load(self) -> List[Document]:
+        """Load given path as pages."""
+        return list(self.lazy_load())
+
+    def lazy_load(
+        self,
+    ) -> Iterator[Document]:
+        """Lazy load given path as pages."""
+        if self.file_path is not None:
+            blob = Blob.from_path(self.file_path)
+            yield from self.parser.parse(blob)
+        else:
+            yield from self.parser.parse_url(self.url_path)

libs/community/langchain_community/document_loaders/gcs_file.py

@@ -58,7 +58,7 @@ class GCSFileLoader(BaseLoader):
                 "Please install it with `pip install google-cloud-storage`."
             )
 
-        # Initialise a client
+        # initialize a client
         storage_client = storage.Client(
             self.project_name, client_info=get_client_info("google-cloud-storage")
         )

libs/community/langchain_community/document_loaders/html_bs.py

@@ -18,7 +18,7 @@ class BSHTMLLoader(BaseLoader):
         bs_kwargs: Union[dict, None] = None,
         get_text_separator: str = "",
     ) -> None:
-        """Initialise with path, and optionally, file encoding to use, and any kwargs
+        """initialize with path, and optionally, file encoding to use, and any kwargs
         to pass to the BeautifulSoup object.
 
         Args:

libs/community/langchain_community/document_loaders/markdown.py

@@ -24,7 +24,7 @@ class UnstructuredMarkdownLoader(UnstructuredFileLoader):
 
     References
     ----------
-    https://unstructured-io.github.io/unstructured/bricks.html#partition-md
+    https://unstructured-io.github.io/unstructured/core/partition.html#partition-md
     """
 
     def _get_elements(self) -> List:

libs/community/langchain_community/document_loaders/mhtml.py

@@ -19,7 +19,7 @@ class MHTMLLoader(BaseLoader):
         bs_kwargs: Union[dict, None] = None,
         get_text_separator: str = "",
     ) -> None:
-        """Initialise with path, and optionally, file encoding to use, and any kwargs
+        """initialize with path, and optionally, file encoding to use, and any kwargs
         to pass to the BeautifulSoup object.
 
         Args:

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

@@ -1,4 +1,7 @@
 from langchain_community.document_loaders.parsers.audio import OpenAIWhisperParser
+from langchain_community.document_loaders.parsers.doc_intelligence import (
+    AzureAIDocumentIntelligenceParser,
+)
 from langchain_community.document_loaders.parsers.docai import DocAIParser
 from langchain_community.document_loaders.parsers.grobid import GrobidParser
 from langchain_community.document_loaders.parsers.html import BS4HTMLParser
@@ -12,6 +15,7 @@ from langchain_community.document_loaders.parsers.pdf import (
 )
 
 __all__ = [
+    "AzureAIDocumentIntelligenceParser",
     "BS4HTMLParser",
     "DocAIParser",
     "GrobidParser",

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

@@ -0,0 +1,122 @@
+from typing import Any, Iterator, Optional
+
+from langchain_core.documents import Document
+
+from langchain_community.document_loaders.base import BaseBlobParser
+from langchain_community.document_loaders.blob_loaders import Blob
+
+
+class AzureAIDocumentIntelligenceParser(BaseBlobParser):
+    """Loads a PDF with Azure Document Intelligence
+    (formerly Forms Recognizer)."""
+
+    def __init__(
+        self,
+        api_endpoint: str,
+        api_key: str,
+        api_version: Optional[str] = None,
+        api_model: str = "prebuilt-layout",
+        mode: str = "markdown",
+    ):
+        from azure.ai.documentintelligence import DocumentIntelligenceClient
+        from azure.core.credentials import AzureKeyCredential
+
+        kwargs = {}
+        if api_version is not None:
+            kwargs["api_version"] = api_version
+        self.client = DocumentIntelligenceClient(
+            endpoint=api_endpoint,
+            credential=AzureKeyCredential(api_key),
+            headers={"x-ms-useragent": "langchain-parser/1.0.0"},
+            **kwargs,
+        )
+        self.api_model = api_model
+        self.mode = mode
+        assert self.mode in ["single", "page", "object", "markdown"]
+
+    def _generate_docs_page(self, result: Any) -> Iterator[Document]:
+        for p in result.pages:
+            content = " ".join([line.content for line in p.lines])
+
+            d = Document(
+                page_content=content,
+                metadata={
+                    "page": p.page_number,
+                },
+            )
+            yield d
+
+    def _generate_docs_single(self, result: Any) -> Iterator[Document]:
+        yield Document(page_content=result.content, metadata={})
+
+    def _generate_docs_object(self, result: Any) -> Iterator[Document]:
+        # record relationship between page id and span offset
+        page_offset = []
+        for page in result.pages:
+            # assume that spans only contain 1 element, to double check
+            page_offset.append(page.spans[0]["offset"])
+
+        # paragraph
+        # warning: paragraph content is overlapping with table content
+        for para in result.paragraphs:
+            yield Document(
+                page_content=para.content,
+                metadata={
+                    "role": para.role,
+                    "page": para.bounding_regions[0].page_number,
+                    "bounding_box": para.bounding_regions[0].polygon,
+                    "type": "paragraph",
+                },
+            )
+
+        # table
+        for table in result.tables:
+            yield Document(
+                page_content=table.cells,  # json object
+                metadata={
+                    "footnote": table.footnotes,
+                    "caption": table.caption,
+                    "page": para.bounding_regions[0].page_number,
+                    "bounding_box": para.bounding_regions[0].polygon,
+                    "row_count": table.row_count,
+                    "column_count": table.column_count,
+                    "type": "table",
+                },
+            )
+
+    def lazy_parse(self, blob: Blob) -> Iterator[Document]:
+        """Lazily parse the blob."""
+
+        with blob.as_bytes_io() as file_obj:
+            poller = self.client.begin_analyze_document(
+                self.api_model,
+                file_obj,
+                content_type="application/octet-stream",
+                output_content_format="markdown" if self.mode == "markdown" else "text",
+            )
+            result = poller.result()
+
+            if self.mode in ["single", "markdown"]:
+                yield from self._generate_docs_single(result)
+            elif self.mode == ["page"]:
+                yield from self._generate_docs_page(result)
+            else:
+                yield from self._generate_docs_object(result)
+
+    def parse_url(self, url: str) -> Iterator[Document]:
+        from azure.ai.documentintelligence.models import AnalyzeDocumentRequest
+
+        poller = self.client.begin_analyze_document(
+            self.api_model,
+            AnalyzeDocumentRequest(url_source=url),
+            # content_type="application/octet-stream",
+            output_content_format="markdown" if self.mode == "markdown" else "text",
+        )
+        result = poller.result()
+
+        if self.mode in ["single", "markdown"]:
+            yield from self._generate_docs_single(result)
+        elif self.mode == ["page"]:
+            yield from self._generate_docs_page(result)
+        else:
+            yield from self._generate_docs_object(result)

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

@@ -542,9 +542,17 @@ class AmazonTextractPDFParser(BaseBlobParser):
 
 class DocumentIntelligenceParser(BaseBlobParser):
     """Loads a PDF with Azure Document Intelligence
-    (formerly Forms Recognizer) and chunks at character level."""
+    (formerly Form Recognizer) and chunks at character level."""
 
     def __init__(self, client: Any, model: str):
+        warnings.warn(
+            "langchain.document_loaders.parsers.pdf.DocumentIntelligenceParser"
+            "and langchain.document_loaders.pdf.DocumentIntelligenceLoader"
+            " are deprecated. Please upgrade to "
+            "langchain.document_loaders.DocumentIntelligenceLoader "
+            "for any file parsing purpose using Azure Document Intelligence "
+            "service."
+        )
         self.client = client
         self.model = model
 

libs/community/langchain_community/document_loaders/rspace.py

@@ -66,7 +66,7 @@ class RSpaceLoader(BaseLoader):
 
         except Exception:
             raise Exception(
-                f"Unable to initialise client - is url {self.url} or "
+                f"Unable to initialize client - is url {self.url} or "
                 f"api key  correct?"
             )
 

libs/community/langchain_community/document_loaders/tencent_cos_file.py

@@ -34,7 +34,7 @@ class TencentCOSFileLoader(BaseLoader):
                 "Please install it with `pip install cos-python-sdk-v5`."
             )
 
-        # Initialise a client
+        # initialize a client
         client = CosS3Client(self.conf)
         with tempfile.TemporaryDirectory() as temp_dir:
             file_path = f"{temp_dir}/{self.bucket}/{self.key}"

libs/community/langchain_community/document_transformers/doctran_text_extract.py

@@ -63,12 +63,12 @@ class DoctranPropertyExtractor(BaseDocumentTransformer):
             "openai_api_model", "OPENAI_API_MODEL"
         )
 
-    def transform_documents(
+    async def atransform_documents(
         self, documents: Sequence[Document], **kwargs: Any
     ) -> Sequence[Document]:
         raise NotImplementedError
 
-    async def atransform_documents(
+    def transform_documents(
         self, documents: Sequence[Document], **kwargs: Any
     ) -> Sequence[Document]:
         """Extracts properties from text documents using doctran."""
@@ -85,7 +85,7 @@ class DoctranPropertyExtractor(BaseDocumentTransformer):
         properties = [ExtractProperty(**property) for property in self.properties]
         for d in documents:
             doctran_doc = (
-                await doctran.parse(content=d.page_content)
+                doctran.parse(content=d.page_content)
                 .extract(properties=properties)
                 .execute()
             )

libs/community/langchain_community/document_transformers/doctran_text_qa.py

@@ -33,12 +33,12 @@ class DoctranQATransformer(BaseDocumentTransformer):
             "openai_api_model", "OPENAI_API_MODEL"
         )
 
-    def transform_documents(
+    async def atransform_documents(
         self, documents: Sequence[Document], **kwargs: Any
     ) -> Sequence[Document]:
         raise NotImplementedError
 
-    async def atransform_documents(
+    def transform_documents(
         self, documents: Sequence[Document], **kwargs: Any
     ) -> Sequence[Document]:
         """Extracts QA from text documents using doctran."""
@@ -53,9 +53,7 @@ class DoctranQATransformer(BaseDocumentTransformer):
                 "Install doctran to use this parser. (pip install doctran)"
             )
         for d in documents:
-            doctran_doc = (
-                await doctran.parse(content=d.page_content).interrogate().execute()
-            )
+            doctran_doc = doctran.parse(content=d.page_content).interrogate().execute()
             questions_and_answers = doctran_doc.extracted_properties.get(
                 "questions_and_answers"
             )

libs/community/langchain_community/document_transformers/doctran_text_translate.py

@@ -36,12 +36,12 @@ class DoctranTextTranslator(BaseDocumentTransformer):
         )
         self.language = language
 
-    def transform_documents(
+    async def atransform_documents(
         self, documents: Sequence[Document], **kwargs: Any
     ) -> Sequence[Document]:
         raise NotImplementedError
 
-    async def atransform_documents(
+    def transform_documents(
         self, documents: Sequence[Document], **kwargs: Any
     ) -> Sequence[Document]:
         """Translates text documents using doctran."""
@@ -60,7 +60,7 @@ class DoctranTextTranslator(BaseDocumentTransformer):
             for doc in documents
         ]
         for i, doc in enumerate(doctran_docs):
-            doctran_docs[i] = await doc.translate(language=self.language).execute()
+            doctran_docs[i] = doc.translate(language=self.language).execute()
         return [
             Document(page_content=doc.transformed_content, metadata=doc.metadata)
             for doc in doctran_docs

libs/community/langchain_community/embeddings/embaas.py

@@ -30,11 +30,11 @@ class EmbaasEmbeddings(BaseModel, Embeddings):
     Example:
         .. code-block:: python
 
-            # Initialise with default model and instruction
+            # initialize with default model and instruction
             from langchain_community.embeddings import EmbaasEmbeddings
             emb = EmbaasEmbeddings()
 
-            # Initialise with custom model and instruction
+            # initialize with custom model and instruction
             from langchain_community.embeddings import EmbaasEmbeddings
             emb_model = "instructor-large"
             emb_inst = "Represent the Wikipedia document for retrieval"

libs/community/langchain_community/embeddings/jina.py

@@ -2,8 +2,8 @@ from typing import Any, Dict, List, Optional
 
 import requests
 from langchain_core.embeddings import Embeddings
-from langchain_core.pydantic_v1 import BaseModel, root_validator
-from langchain_core.utils import get_from_dict_or_env
+from langchain_core.pydantic_v1 import BaseModel, SecretStr, root_validator
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
 
 JINA_API_URL: str = "https://api.jina.ai/v1/embeddings"
 
@@ -13,24 +13,26 @@ class JinaEmbeddings(BaseModel, Embeddings):
 
     session: Any  #: :meta private:
     model_name: str = "jina-embeddings-v2-base-en"
-    jina_api_key: Optional[str] = None
+    jina_api_key: Optional[SecretStr] = None
 
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that auth token exists in environment."""
         try:
-            jina_api_key = get_from_dict_or_env(values, "jina_api_key", "JINA_API_KEY")
+            jina_api_key = convert_to_secret_str(
+                get_from_dict_or_env(values, "jina_api_key", "JINA_API_KEY")
+            )
         except ValueError as original_exc:
             try:
-                jina_api_key = get_from_dict_or_env(
-                    values, "jina_auth_token", "JINA_AUTH_TOKEN"
+                jina_api_key = convert_to_secret_str(
+                    get_from_dict_or_env(values, "jina_auth_token", "JINA_AUTH_TOKEN")
                 )
             except ValueError:
                 raise original_exc
         session = requests.Session()
         session.headers.update(
             {
-                "Authorization": f"Bearer {jina_api_key}",
+                "Authorization": f"Bearer {jina_api_key.get_secret_value()}",
                 "Accept-Encoding": "identity",
                 "Content-type": "application/json",
             }

libs/community/langchain_community/embeddings/minimax.py

@@ -5,8 +5,8 @@ from typing import Any, Callable, Dict, List, Optional
 
 import requests
 from langchain_core.embeddings import Embeddings
-from langchain_core.pydantic_v1 import BaseModel, Extra, root_validator
-from langchain_core.utils import get_from_dict_or_env
+from langchain_core.pydantic_v1 import BaseModel, Extra, SecretStr, root_validator
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
 from tenacity import (
     before_sleep_log,
     retry,
@@ -76,7 +76,7 @@ class MiniMaxEmbeddings(BaseModel, Embeddings):
 
     minimax_group_id: Optional[str] = None
     """Group ID for MiniMax API."""
-    minimax_api_key: Optional[str] = None
+    minimax_api_key: Optional[SecretStr] = None
     """API Key for MiniMax API."""
 
     class Config:
@@ -90,8 +90,8 @@ class MiniMaxEmbeddings(BaseModel, Embeddings):
         minimax_group_id = get_from_dict_or_env(
             values, "minimax_group_id", "MINIMAX_GROUP_ID"
         )
-        minimax_api_key = get_from_dict_or_env(
-            values, "minimax_api_key", "MINIMAX_API_KEY"
+        minimax_api_key = convert_to_secret_str(
+            get_from_dict_or_env(values, "minimax_api_key", "MINIMAX_API_KEY")
         )
         values["minimax_group_id"] = minimax_group_id
         values["minimax_api_key"] = minimax_api_key
@@ -110,7 +110,7 @@ class MiniMaxEmbeddings(BaseModel, Embeddings):
 
         # HTTP headers for authorization
         headers = {
-            "Authorization": f"Bearer {self.minimax_api_key}",
+            "Authorization": f"Bearer {self.minimax_api_key.get_secret_value()}",
             "Content-Type": "application/json",
         }
 

libs/community/langchain_community/embeddings/vertexai.py

@@ -29,21 +29,28 @@ class VertexAIEmbeddings(_VertexAICommon, Embeddings):
     def validate_environment(cls, values: Dict) -> Dict:
         """Validates that the python package exists in environment."""
         cls._try_init_vertexai(values)
+        if values["model_name"] == "textembedding-gecko-default":
+            logger.warning(
+                "Model_name will become a required arg for VertexAIEmbeddings "
+                "starting from Feb-01-2024. Currently the default is set to "
+                "textembedding-gecko@001"
+            )
+            values["model_name"] = "textembedding-gecko@001"
         try:
             from vertexai.language_models import TextEmbeddingModel
-
-            values["client"] = TextEmbeddingModel.from_pretrained(values["model_name"])
         except ImportError:
             raise_vertex_import_error()
+        values["client"] = TextEmbeddingModel.from_pretrained(values["model_name"])
         return values
 
     def __init__(
         self,
+        # the default value would be removed after Feb-01-2024
+        model_name: str = "textembedding-gecko-default",
         project: Optional[str] = None,
         location: str = "us-central1",
         request_parallelism: int = 5,
         max_retries: int = 6,
-        model_name: str = "textembedding-gecko",
         credentials: Optional[Any] = None,
         **kwargs: Any,
     ):

libs/community/langchain_community/llms/__init__.py

@@ -324,6 +324,22 @@ def _import_nlpcloud() -> Any:
     return NLPCloud
 
 
+def _import_oci_md_tgi() -> Any:
+    from langchain_community.llms.oci_data_science_model_deployment_endpoint import (
+        OCIModelDeploymentTGI,
+    )
+
+    return OCIModelDeploymentTGI
+
+
+def _import_oci_md_vllm() -> Any:
+    from langchain_community.llms.oci_data_science_model_deployment_endpoint import (
+        OCIModelDeploymentVLLM,
+    )
+
+    return OCIModelDeploymentVLLM
+
+
 def _import_octoai_endpoint() -> Any:
     from langchain_community.llms.octoai_endpoint import OctoAIEndpoint
 
@@ -639,6 +655,10 @@ def __getattr__(name: str) -> Any:
         return _import_mosaicml()
     elif name == "NLPCloud":
         return _import_nlpcloud()
+    elif name == "OCIModelDeploymentTGI":
+        return _import_oci_md_tgi()
+    elif name == "OCIModelDeploymentVLLM":
+        return _import_oci_md_vllm()
     elif name == "OctoAIEndpoint":
         return _import_octoai_endpoint()
     elif name == "Ollama":
@@ -770,6 +790,8 @@ __all__ = [
     "Nebula",
     "NIBittensorLLM",
     "NLPCloud",
+    "OCIModelDeploymentTGI",
+    "OCIModelDeploymentVLLM",
     "Ollama",
     "OpenAI",
     "OpenAIChat",
@@ -857,6 +879,8 @@ def get_type_to_cls_dict() -> Dict[str, Callable[[], Type[BaseLLM]]]:
         "nebula": _import_symblai_nebula,
         "nibittensor": _import_bittensor,
         "nlpcloud": _import_nlpcloud,
+        "oci_model_deployment_tgi_endpoint": _import_oci_md_tgi,
+        "oci_model_deployment_vllm_endpoint": _import_oci_md_vllm,
         "ollama": _import_ollama,
         "openai": _import_openai,
         "openlm": _import_openlm,

libs/community/langchain_community/llms/baseten.py

@@ -1,6 +1,8 @@
 import logging
+import os
 from typing import Any, Dict, List, Mapping, Optional
 
+import requests
 from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.language_models.llms import LLM
 from langchain_core.pydantic_v1 import Field
@@ -9,29 +11,51 @@ logger = logging.getLogger(__name__)
 
 
 class Baseten(LLM):
-    """Baseten models.
+    """Baseten model
 
-    To use, you should have the ``baseten`` python package installed,
-    and run ``baseten.login()`` with your Baseten API key.
+    This module allows using LLMs hosted on Baseten.
 
-    The required ``model`` param can be either a model id or model
-    version id. Using a model version ID will result in
-    slightly faster invocation.
-    Any other model parameters can also
-    be passed in with the format input={model_param: value, ...}
+    The LLM deployed on Baseten must have the following properties:
 
-    The Baseten model must accept a dictionary of input with the key
-    "prompt" and return a dictionary with a key "data" which maps
-    to a list of response strings.
+    * Must accept input as a dictionary with the key "prompt"
+    * May accept other input in the dictionary passed through with kwargs
+    * Must return a string with the model output
 
-    Example:
+    To use this module, you must:
+
+    * Export your Baseten API key as the environment variable `BASETEN_API_KEY`
+    * Get the model ID for your model from your Baseten dashboard
+    * Identify the model deployment ("production" for all model library models)
+
+    These code samples use
+    [Mistral 7B Instruct](https://app.baseten.co/explore/mistral_7b_instruct)
+    from Baseten's model library.
+
+    Examples:
         .. code-block:: python
+
             from langchain_community.llms import Baseten
-            my_model = Baseten(model="MODEL_ID")
-            output = my_model("prompt")
+            # Production deployment
+            mistral = Baseten(model="MODEL_ID", deployment="production")
+            mistral("What is the Mistral wind?")
+
+        .. code-block:: python
+
+            from langchain_community.llms import Baseten
+            # Development deployment
+            mistral = Baseten(model="MODEL_ID", deployment="development")
+            mistral("What is the Mistral wind?")
+
+        .. code-block:: python
+
+            from langchain_community.llms import Baseten
+            # Other published deployment
+            mistral = Baseten(model="MODEL_ID", deployment="DEPLOYMENT_ID")
+            mistral("What is the Mistral wind?")
     """
 
     model: str
+    deployment: str
     input: Dict[str, Any] = Field(default_factory=dict)
     model_kwargs: Dict[str, Any] = Field(default_factory=dict)
 
@@ -54,20 +78,17 @@ class Baseten(LLM):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> str:
-        """Call to Baseten deployed model endpoint."""
-        try:
-            import baseten
-        except ImportError as exc:
-            raise ImportError(
-                "Could not import Baseten Python package. "
-                "Please install it with `pip install baseten`."
-            ) from exc
-
-        # get the model and version
-        try:
-            model = baseten.deployed_model_version_id(self.model)
-            response = model.predict({"prompt": prompt, **kwargs})
-        except baseten.common.core.ApiError:
-            model = baseten.deployed_model_id(self.model)
-            response = model.predict({"prompt": prompt, **kwargs})
-        return "".join(response)
+        baseten_api_key = os.environ["BASETEN_API_KEY"]
+        model_id = self.model
+        if self.deployment == "production":
+            model_url = f"https://model-{model_id}.api.baseten.co/production/predict"
+        elif self.deployment == "development":
+            model_url = f"https://model-{model_id}.api.baseten.co/development/predict"
+        else:  # try specific deployment ID
+            model_url = f"https://model-{model_id}.api.baseten.co/deployment/{self.deployment}/predict"
+        response = requests.post(
+            model_url,
+            headers={"Authorization": f"Api-Key {baseten_api_key}"},
+            json={"prompt": prompt, **kwargs},
+        )
+        return response.json()

libs/community/langchain_community/llms/bedrock.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import json
 import warnings
 from abc import ABC
-from typing import Any, Dict, Iterator, List, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Mapping, Optional
 
 from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.language_models.llms import LLM
@@ -15,6 +17,9 @@ from langchain_community.utilities.anthropic import (
     get_token_ids_anthropic,
 )
 
+if TYPE_CHECKING:
+    from botocore.config import Config
+
 HUMAN_PROMPT = "\n\nHuman:"
 ASSISTANT_PROMPT = "\n\nAssistant:"
 ALTERNATION_ERROR = (
@@ -163,6 +168,9 @@ class BedrockBase(BaseModel, ABC):
     See: https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
     """
 
+    config: Optional[Config] = None
+    """An optional botocore.config.Config instance to pass to the client."""
+
     model_id: str
     """Id of the model to call, e.g., amazon.titan-text-express-v1, this is
     equivalent to the modelId property in the list-foundation-models api"""
@@ -212,6 +220,8 @@ class BedrockBase(BaseModel, ABC):
                 client_params["region_name"] = values["region_name"]
             if values["endpoint_url"]:
                 client_params["endpoint_url"] = values["endpoint_url"]
+            if values["config"]:
+                client_params["config"] = values["config"]
 
             values["client"] = session.client("bedrock-runtime", **client_params)
 

libs/community/langchain_community/llms/databricks.py

@@ -55,6 +55,10 @@ def _transform_completions(response: Dict[str, Any]) -> str:
     return response["choices"][0]["text"]
 
 
+def _transform_llama2_chat(response: Dict[str, Any]) -> str:
+    return response["candidates"][0]["text"]
+
+
 def _transform_chat(response: Dict[str, Any]) -> str:
     return response["choices"][0]["message"]["content"]
 
@@ -87,11 +91,12 @@ class _DatabricksServingEndpointClient(_DatabricksClientBase):
             "external_model",
             "foundation_model_api",
         )
-        self.task = endpoint.get("task")
+        if self.task is None:
+            self.task = endpoint.get("task")
 
     @property
     def llm(self) -> bool:
-        return self.task in ("llm/v1/chat", "llm/v1/completions")
+        return self.task in ("llm/v1/chat", "llm/v1/completions", "llama2/chat")
 
     @root_validator(pre=True)
     def set_api_url(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -125,6 +130,8 @@ class _DatabricksServingEndpointClient(_DatabricksClientBase):
             preds = response["predictions"]
             # For a single-record query, the result is not a list.
             pred = preds[0] if isinstance(preds, list) else preds
+            if self.task == "llama2/chat":
+                return _transform_llama2_chat(pred)
             return transform_output_fn(pred) if transform_output_fn else pred
 
 
@@ -325,6 +332,10 @@ class Databricks(LLM):
     """The maximum number of tokens to generate."""
     extra_params: Dict[str, Any] = Field(default_factory=dict)
     """Any extra parameters to pass to the endpoint."""
+    task: Optional[str] = None
+    """The task of the endpoint. Only used when using a serving endpoint.
+    If not provided, the task is automatically inferred from the endpoint.
+    """
 
     _client: _DatabricksClientBase = PrivateAttr()
 
@@ -401,6 +412,7 @@ class Databricks(LLM):
                 api_token=self.api_token,
                 endpoint_name=self.endpoint_name,
                 databricks_uri=self.databricks_uri,
+                task=self.task,
             )
         elif self.cluster_id and self.cluster_driver_port:
             self._client = _DatabricksClusterDriverProxyClient(
@@ -430,6 +442,7 @@ class Databricks(LLM):
             "stop": self.stop,
             "max_tokens": self.max_tokens,
             "extra_params": self.extra_params,
+            "task": self.task,
             # TODO: Support saving transform_input_fn and transform_output_fn
             # "transform_input_fn": self.transform_input_fn,
             # "transform_output_fn": self.transform_output_fn,

libs/community/langchain_community/llms/deepsparse.py

@@ -63,7 +63,7 @@ class DeepSparse(LLM):
         except ImportError:
             raise ImportError(
                 "Could not import `deepsparse` package. "
-                "Please install it with `pip install deepsparse`"
+                "Please install it with `pip install deepsparse[llm]`"
             )
 
         model_config = values["model_config"] or {}
@@ -103,9 +103,7 @@ class DeepSparse(LLM):
             text = combined_output
         else:
             text = (
-                self.pipeline(
-                    sequences=prompt, generation_config=self.generation_config
-                )
+                self.pipeline(sequences=prompt, **self.generation_config)
                 .generations[0]
                 .text
             )
@@ -143,9 +141,7 @@ class DeepSparse(LLM):
             text = combined_output
         else:
             text = (
-                self.pipeline(
-                    sequences=prompt, generation_config=self.generation_config
-                )
+                self.pipeline(sequences=prompt, **self.generation_config)
                 .generations[0]
                 .text
             )
@@ -184,7 +180,7 @@ class DeepSparse(LLM):
                     print(chunk, end='', flush=True)
         """
         inference = self.pipeline(
-            sequences=prompt, generation_config=self.generation_config, streaming=True
+            sequences=prompt, streaming=True, **self.generation_config
         )
         for token in inference:
             chunk = GenerationChunk(text=token.generations[0].text)
@@ -222,7 +218,7 @@ class DeepSparse(LLM):
                     print(chunk, end='', flush=True)
         """
         inference = self.pipeline(
-            sequences=prompt, generation_config=self.generation_config, streaming=True
+            sequences=prompt, streaming=True, **self.generation_config
         )
         for token in inference:
             chunk = GenerationChunk(text=token.generations[0].text)

libs/community/langchain_community/llms/oci_data_science_model_deployment_endpoint.py

@@ -0,0 +1,362 @@
+import logging
+from typing import Any, Dict, List, Optional
+
+import requests
+from langchain_core.callbacks import CallbackManagerForLLMRun
+from langchain_core.language_models.llms import LLM
+from langchain_core.pydantic_v1 import Field, root_validator
+from langchain_core.utils import get_from_dict_or_env
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TIME_OUT = 300
+DEFAULT_CONTENT_TYPE_JSON = "application/json"
+
+
+class OCIModelDeploymentLLM(LLM):
+    """Base class for LLM deployed on OCI Data Science Model Deployment."""
+
+    auth: dict = Field(default_factory=dict, exclude=True)
+    """ADS auth dictionary for OCI authentication:
+    https://accelerated-data-science.readthedocs.io/en/latest/user_guide/cli/authentication.html.
+    This can be generated by calling `ads.common.auth.api_keys()`
+    or `ads.common.auth.resource_principal()`. If this is not
+    provided then the `ads.common.default_signer()` will be used."""
+
+    max_tokens: int = 256
+    """Denotes the number of tokens to predict per generation."""
+
+    temperature: float = 0.2
+    """A non-negative float that tunes the degree of randomness in generation."""
+
+    k: int = 0
+    """Number of most likely tokens to consider at each step."""
+
+    p: float = 0.75
+    """Total probability mass of tokens to consider at each step."""
+
+    endpoint: str = ""
+    """The uri of the endpoint from the deployed Model Deployment model."""
+
+    best_of: int = 1
+    """Generates best_of completions server-side and returns the "best"
+    (the one with the highest log probability per token).
+    """
+
+    stop: Optional[List[str]] = None
+    """Stop words to use when generating. Model output is cut off
+    at the first occurrence of any of these substrings."""
+
+    @root_validator()
+    def validate_environment(  # pylint: disable=no-self-argument
+        cls, values: Dict
+    ) -> Dict:
+        """Validate that python package exists in environment."""
+        try:
+            import ads
+
+        except ImportError as ex:
+            raise ImportError(
+                "Could not import ads python package. "
+                "Please install it with `pip install oracle_ads`."
+            ) from ex
+        if not values.get("auth", None):
+            values["auth"] = ads.common.auth.default_signer()
+        values["endpoint"] = get_from_dict_or_env(
+            values,
+            "endpoint",
+            "OCI_LLM_ENDPOINT",
+        )
+        return values
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Default parameters for the model."""
+        raise NotImplementedError
+
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        """Get the identifying parameters."""
+        return {
+            **{"endpoint": self.endpoint},
+            **self._default_params,
+        }
+
+    def _construct_json_body(self, prompt: str, params: dict) -> dict:
+        """Constructs the request body as a dictionary (JSON)."""
+        raise NotImplementedError
+
+    def _invocation_params(self, stop: Optional[List[str]], **kwargs: Any) -> dict:
+        """Combines the invocation parameters with default parameters."""
+        params = self._default_params
+        if self.stop is not None and stop is not None:
+            raise ValueError("`stop` found in both the input and default params.")
+        elif self.stop is not None:
+            params["stop"] = self.stop
+        elif stop is not None:
+            params["stop"] = stop
+        else:
+            # Don't set "stop" in param as None. It should be a list.
+            params["stop"] = []
+
+        return {**params, **kwargs}
+
+    def _process_response(self, response_json: dict) -> str:
+        raise NotImplementedError
+
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        """Call out to OCI Data Science Model Deployment endpoint.
+
+        Args:
+            prompt (str):
+                The prompt to pass into the model.
+            stop (List[str], Optional):
+                List of stop words to use when generating.
+            kwargs:
+                requests_kwargs:
+                    Additional ``**kwargs`` to pass to requests.post
+
+        Returns:
+            The string generated by the model.
+
+        Example:
+            .. code-block:: python
+
+                response = oci_md("Tell me a joke.")
+
+        """
+        requests_kwargs = kwargs.pop("requests_kwargs", {})
+        params = self._invocation_params(stop, **kwargs)
+        body = self._construct_json_body(prompt, params)
+        logger.info(f"LLM API Request:\n{prompt}")
+        response = self._send_request(
+            data=body, endpoint=self.endpoint, **requests_kwargs
+        )
+        completion = self._process_response(response)
+        logger.info(f"LLM API Completion:\n{completion}")
+        return completion
+
+    def _send_request(
+        self,
+        data: Any,
+        endpoint: str,
+        header: Optional[dict] = {},
+        **kwargs: Any,
+    ) -> Dict:
+        """Sends request to the oci data science model deployment endpoint.
+
+        Args:
+            data (Json serializable):
+                data need to be sent to the endpoint.
+            endpoint (str):
+                The model HTTP endpoint.
+            header (dict, optional):
+                A dictionary of HTTP headers to send to the specified url.
+                Defaults to {}.
+            kwargs:
+                Additional ``**kwargs`` to pass to requests.post.
+        Raises:
+            Exception:
+                Raise when invoking fails.
+
+        Returns:
+            A JSON representation of a requests.Response object.
+        """
+        if not header:
+            header = {}
+        header["Content-Type"] = (
+            header.pop("content_type", DEFAULT_CONTENT_TYPE_JSON)
+            or DEFAULT_CONTENT_TYPE_JSON
+        )
+        request_kwargs = {"json": data}
+        request_kwargs["headers"] = header
+        timeout = kwargs.pop("timeout", DEFAULT_TIME_OUT)
+
+        attempts = 0
+        while attempts < 2:
+            request_kwargs["auth"] = self.auth.get("signer")
+            response = requests.post(
+                endpoint, timeout=timeout, **request_kwargs, **kwargs
+            )
+            if response.status_code == 401:
+                self._refresh_signer()
+                attempts += 1
+                continue
+            break
+
+        try:
+            response.raise_for_status()
+            response_json = response.json()
+
+        except Exception:
+            logger.error(
+                "DEBUG INFO: request_kwargs=%s, status_code=%s, content=%s",
+                request_kwargs,
+                response.status_code,
+                response.content,
+            )
+            raise
+
+        return response_json
+
+    def _refresh_signer(self) -> None:
+        if self.auth.get("signer", None) and hasattr(
+            self.auth["signer"], "refresh_security_token"
+        ):
+            self.auth["signer"].refresh_security_token()
+
+
+class OCIModelDeploymentTGI(OCIModelDeploymentLLM):
+    """OCI Data Science Model Deployment TGI Endpoint.
+
+    To use, you must provide the model HTTP endpoint from your deployed
+    model, e.g. https://<MD_OCID>/predict.
+
+    To authenticate, `oracle-ads` has been used to automatically load
+    credentials: https://accelerated-data-science.readthedocs.io/en/latest/user_guide/cli/authentication.html
+
+    Make sure to have the required policies to access the OCI Data
+    Science Model Deployment endpoint. See:
+    https://docs.oracle.com/en-us/iaas/data-science/using/model-dep-policies-auth.htm#model_dep_policies_auth__predict-endpoint
+
+    Example:
+        .. code-block:: python
+
+            from langchain.llms import ModelDeploymentTGI
+
+            oci_md = ModelDeploymentTGI(endpoint="https://<MD_OCID>/predict")
+
+    """
+
+    do_sample: bool = True
+    """If set to True, this parameter enables decoding strategies such as
+    multi-nominal sampling, beam-search multi-nominal sampling, Top-K
+    sampling and Top-p sampling.
+    """
+
+    watermark = True
+    """Watermarking with `A Watermark for Large Language Models <https://arxiv.org/abs/2301.10226>`_.
+    Defaults to True."""
+
+    return_full_text = False
+    """Whether to prepend the prompt to the generated text. Defaults to False."""
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "oci_model_deployment_tgi_endpoint"
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for invoking OCI model deployment TGI endpoint."""
+        return {
+            "best_of": self.best_of,
+            "max_new_tokens": self.max_tokens,
+            "temperature": self.temperature,
+            "top_k": self.k
+            if self.k > 0
+            else None,  # `top_k` must be strictly positive'
+            "top_p": self.p,
+            "do_sample": self.do_sample,
+            "return_full_text": self.return_full_text,
+            "watermark": self.watermark,
+        }
+
+    def _construct_json_body(self, prompt: str, params: dict) -> dict:
+        return {
+            "inputs": prompt,
+            "parameters": params,
+        }
+
+    def _process_response(self, response_json: dict) -> str:
+        return str(response_json.get("generated_text", response_json)) + "\n"
+
+
+class OCIModelDeploymentVLLM(OCIModelDeploymentLLM):
+    """VLLM deployed on OCI Data Science Model Deployment
+
+    To use, you must provide the model HTTP endpoint from your deployed
+    model, e.g. https://<MD_OCID>/predict.
+
+    To authenticate, `oracle-ads` has been used to automatically load
+    credentials: https://accelerated-data-science.readthedocs.io/en/latest/user_guide/cli/authentication.html
+
+    Make sure to have the required policies to access the OCI Data
+    Science Model Deployment endpoint. See:
+    https://docs.oracle.com/en-us/iaas/data-science/using/model-dep-policies-auth.htm#model_dep_policies_auth__predict-endpoint
+
+    Example:
+        .. code-block:: python
+
+            from langchain.llms import OCIModelDeploymentVLLM
+
+            oci_md = OCIModelDeploymentVLLM(
+                endpoint="https://<MD_OCID>/predict",
+                model="mymodel"
+            )
+
+    """
+
+    model: str
+    """The name of the model."""
+
+    n: int = 1
+    """Number of output sequences to return for the given prompt."""
+
+    k: int = -1
+    """Number of most likely tokens to consider at each step."""
+
+    frequency_penalty: float = 0.0
+    """Penalizes repeated tokens according to frequency. Between 0 and 1."""
+
+    presence_penalty: float = 0.0
+    """Penalizes repeated tokens. Between 0 and 1."""
+
+    use_beam_search: bool = False
+    """Whether to use beam search instead of sampling."""
+
+    ignore_eos: bool = False
+    """Whether to ignore the EOS token and continue generating tokens after
+    the EOS token is generated."""
+
+    logprobs: Optional[int] = None
+    """Number of log probabilities to return per output token."""
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "oci_model_deployment_vllm_endpoint"
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling vllm."""
+        return {
+            "best_of": self.best_of,
+            "frequency_penalty": self.frequency_penalty,
+            "ignore_eos": self.ignore_eos,
+            "logprobs": self.logprobs,
+            "max_tokens": self.max_tokens,
+            "model": self.model,
+            "n": self.n,
+            "presence_penalty": self.presence_penalty,
+            "stop": self.stop,
+            "temperature": self.temperature,
+            "top_k": self.k,
+            "top_p": self.p,
+            "use_beam_search": self.use_beam_search,
+        }
+
+    def _construct_json_body(self, prompt: str, params: dict) -> dict:
+        return {
+            "prompt": prompt,
+            **params,
+        }
+
+    def _process_response(self, response_json: dict) -> str:
+        return response_json["choices"][0]["text"]

libs/community/langchain_community/llms/ollama.py

@@ -1,8 +1,12 @@
 import json
-from typing import Any, Dict, Iterator, List, Mapping, Optional
+from typing import Any, AsyncIterator, Dict, Iterator, List, Mapping, Optional
 
+import aiohttp
 import requests
-from langchain_core.callbacks import CallbackManagerForLLMRun
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.language_models.llms import BaseLLM
 from langchain_core.outputs import GenerationChunk, LLMResult
@@ -148,6 +152,22 @@ class _OllamaCommon(BaseLanguageModel):
             **kwargs,
         )
 
+    async def _acreate_generate_stream(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[str]:
+        payload = {"prompt": prompt, "images": images}
+        async for item in self._acreate_stream(
+            payload=payload,
+            stop=stop,
+            api_url=f"{self.base_url}/api/generate/",
+            **kwargs,
+        ):
+            yield item
+
     def _create_stream(
         self,
         api_url: str,
@@ -196,7 +216,9 @@ class _OllamaCommon(BaseLanguageModel):
         if response.status_code != 200:
             if response.status_code == 404:
                 raise OllamaEndpointNotFoundError(
-                    "Ollama call failed with status code 404."
+                    "Ollama call failed with status code 404. "
+                    "Maybe your model is not found "
+                    f"and you should pull the model with `ollama pull {self.model}`."
                 )
             else:
                 optional_detail = response.json().get("error")
@@ -206,6 +228,64 @@ class _OllamaCommon(BaseLanguageModel):
                 )
         return response.iter_lines(decode_unicode=True)
 
+    async def _acreate_stream(
+        self,
+        api_url: str,
+        payload: Any,
+        stop: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[str]:
+        if self.stop is not None and stop is not None:
+            raise ValueError("`stop` found in both the input and default params.")
+        elif self.stop is not None:
+            stop = self.stop
+        elif stop is None:
+            stop = []
+
+        params = self._default_params
+
+        if "model" in kwargs:
+            params["model"] = kwargs["model"]
+
+        if "options" in kwargs:
+            params["options"] = kwargs["options"]
+        else:
+            params["options"] = {
+                **params["options"],
+                "stop": stop,
+                **kwargs,
+            }
+
+        if payload.get("messages"):
+            request_payload = {"messages": payload.get("messages", []), **params}
+        else:
+            request_payload = {
+                "prompt": payload.get("prompt"),
+                "images": payload.get("images", []),
+                **params,
+            }
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                url=api_url,
+                headers={"Content-Type": "application/json"},
+                json=request_payload,
+                timeout=self.timeout,
+            ) as response:
+                if response.status != 200:
+                    if response.status == 404:
+                        raise OllamaEndpointNotFoundError(
+                            "Ollama call failed with status code 404."
+                        )
+                    else:
+                        optional_detail = await response.json().get("error")
+                        raise ValueError(
+                            f"Ollama call failed with status code {response.status}."
+                            f" Details: {optional_detail}"
+                        )
+                async for line in response.content:
+                    yield line.decode("utf-8")
+
     def _stream_with_aggregation(
         self,
         prompt: str,
@@ -232,6 +312,32 @@ class _OllamaCommon(BaseLanguageModel):
 
         return final_chunk
 
+    async def _astream_with_aggregation(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        verbose: bool = False,
+        **kwargs: Any,
+    ) -> GenerationChunk:
+        final_chunk: Optional[GenerationChunk] = None
+        async for stream_resp in self._acreate_generate_stream(prompt, stop, **kwargs):
+            if stream_resp:
+                chunk = _stream_response_to_generation_chunk(stream_resp)
+                if final_chunk is None:
+                    final_chunk = chunk
+                else:
+                    final_chunk += chunk
+                if run_manager:
+                    await run_manager.on_llm_new_token(
+                        chunk.text,
+                        verbose=verbose,
+                    )
+        if final_chunk is None:
+            raise ValueError("No data received from Ollama stream.")
+
+        return final_chunk
+
 
 class Ollama(BaseLLM, _OllamaCommon):
     """Ollama locally runs large language models.
@@ -291,6 +397,42 @@ class Ollama(BaseLLM, _OllamaCommon):
             generations.append([final_chunk])
         return LLMResult(generations=generations)
 
+    async def _agenerate(
+        self,
+        prompts: List[str],
+        stop: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> LLMResult:
+        """Call out to Ollama's generate endpoint.
+
+        Args:
+            prompt: The prompt to pass into the model.
+            stop: Optional list of stop words to use when generating.
+
+        Returns:
+            The string generated by the model.
+
+        Example:
+            .. code-block:: python
+
+                response = ollama("Tell me a joke.")
+        """
+        # TODO: add caching here.
+        generations = []
+        for prompt in prompts:
+            final_chunk = await super()._astream_with_aggregation(
+                prompt,
+                stop=stop,
+                images=images,
+                run_manager=run_manager,
+                verbose=self.verbose,
+                **kwargs,
+            )
+            generations.append([final_chunk])
+        return LLMResult(generations=generations)
+
     def _stream(
         self,
         prompt: str,
@@ -307,3 +449,20 @@ class Ollama(BaseLLM, _OllamaCommon):
                         chunk.text,
                         verbose=self.verbose,
                     )
+
+    async def _astream(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[GenerationChunk]:
+        async for stream_resp in self._acreate_stream(prompt, stop, **kwargs):
+            if stream_resp:
+                chunk = _stream_response_to_generation_chunk(stream_resp)
+                yield chunk
+                if run_manager:
+                    await run_manager.on_llm_new_token(
+                        chunk.text,
+                        verbose=self.verbose,
+                    )

libs/community/langchain_community/llms/petals.py

@@ -3,8 +3,8 @@ from typing import Any, Dict, List, Mapping, Optional
 
 from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.language_models.llms import LLM
-from langchain_core.pydantic_v1 import Extra, Field, root_validator
-from langchain_core.utils import get_from_dict_or_env
+from langchain_core.pydantic_v1 import Extra, Field, SecretStr, root_validator
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
 
 from langchain_community.llms.utils import enforce_stop_tokens
 
@@ -60,7 +60,7 @@ class Petals(LLM):
     """Holds any model parameters valid for `create` call
     not explicitly specified."""
 
-    huggingface_api_key: Optional[str] = None
+    huggingface_api_key: Optional[SecretStr] = None
 
     class Config:
         """Configuration for this pydantic config."""
@@ -89,8 +89,8 @@ class Petals(LLM):
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
-        huggingface_api_key = get_from_dict_or_env(
-            values, "huggingface_api_key", "HUGGINGFACE_API_KEY"
+        huggingface_api_key = convert_to_secret_str(
+            get_from_dict_or_env(values, "huggingface_api_key", "HUGGINGFACE_API_KEY")
         )
         try:
             from petals import AutoDistributedModelForCausalLM
@@ -101,7 +101,7 @@ class Petals(LLM):
             values["client"] = AutoDistributedModelForCausalLM.from_pretrained(
                 model_name
             )
-            values["huggingface_api_key"] = huggingface_api_key
+            values["huggingface_api_key"] = huggingface_api_key.get_secret_value()
 
         except ImportError:
             raise ImportError(

libs/community/langchain_community/llms/pipelineai.py

@@ -3,8 +3,14 @@ from typing import Any, Dict, List, Mapping, Optional
 
 from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.language_models.llms import LLM
-from langchain_core.pydantic_v1 import BaseModel, Extra, Field, root_validator
-from langchain_core.utils import get_from_dict_or_env
+from langchain_core.pydantic_v1 import (
+    BaseModel,
+    Extra,
+    Field,
+    SecretStr,
+    root_validator,
+)
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
 
 from langchain_community.llms.utils import enforce_stop_tokens
 
@@ -34,7 +40,7 @@ class PipelineAI(LLM, BaseModel):
     """Holds any pipeline parameters valid for `create` call not
     explicitly specified."""
 
-    pipeline_api_key: Optional[str] = None
+    pipeline_api_key: Optional[SecretStr] = None
 
     class Config:
         """Configuration for this pydantic config."""
@@ -62,8 +68,8 @@ class PipelineAI(LLM, BaseModel):
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
-        pipeline_api_key = get_from_dict_or_env(
-            values, "pipeline_api_key", "PIPELINE_API_KEY"
+        pipeline_api_key = convert_to_secret_str(
+            get_from_dict_or_env(values, "pipeline_api_key", "PIPELINE_API_KEY")
         )
         values["pipeline_api_key"] = pipeline_api_key
         return values
@@ -96,7 +102,7 @@ class PipelineAI(LLM, BaseModel):
                 "Could not import pipeline-ai python package. "
                 "Please install it with `pip install pipeline-ai`."
             )
-        client = PipelineCloud(token=self.pipeline_api_key)
+        client = PipelineCloud(token=self.pipeline_api_key.get_secret_value())
         params = self.pipeline_kwargs or {}
         params = {**params, **kwargs}
 

libs/community/langchain_community/llms/predibase.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, List, Mapping, Optional
 
 from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.language_models.llms import LLM
-from langchain_core.pydantic_v1 import Field
+from langchain_core.pydantic_v1 import Field, SecretStr
 
 
 class Predibase(LLM):
@@ -13,7 +13,7 @@ class Predibase(LLM):
     """
 
     model: str
-    predibase_api_key: str
+    predibase_api_key: SecretStr
     model_kwargs: Dict[str, Any] = Field(default_factory=dict)
 
     @property
@@ -30,7 +30,7 @@ class Predibase(LLM):
         try:
             from predibase import PredibaseClient
 
-            pc = PredibaseClient(token=self.predibase_api_key)
+            pc = PredibaseClient(token=self.predibase_api_key.get_secret_value())
         except ImportError as e:
             raise ImportError(
                 "Could not import Predibase Python package. "

libs/community/langchain_community/llms/stochasticai.py

@@ -5,8 +5,8 @@ from typing import Any, Dict, List, Mapping, Optional
 import requests
 from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.language_models.llms import LLM
-from langchain_core.pydantic_v1 import Extra, Field, root_validator
-from langchain_core.utils import get_from_dict_or_env
+from langchain_core.pydantic_v1 import Extra, Field, SecretStr, root_validator
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
 
 from langchain_community.llms.utils import enforce_stop_tokens
 
@@ -33,7 +33,7 @@ class StochasticAI(LLM):
     """Holds any model parameters valid for `create` call not
     explicitly specified."""
 
-    stochasticai_api_key: Optional[str] = None
+    stochasticai_api_key: Optional[SecretStr] = None
 
     class Config:
         """Configuration for this pydantic object."""
@@ -61,8 +61,8 @@ class StochasticAI(LLM):
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key exists in environment."""
-        stochasticai_api_key = get_from_dict_or_env(
-            values, "stochasticai_api_key", "STOCHASTICAI_API_KEY"
+        stochasticai_api_key = convert_to_secret_str(
+            get_from_dict_or_env(values, "stochasticai_api_key", "STOCHASTICAI_API_KEY")
         )
         values["stochasticai_api_key"] = stochasticai_api_key
         return values
@@ -107,7 +107,7 @@ class StochasticAI(LLM):
             url=self.api_url,
             json={"prompt": prompt, "params": params},
             headers={
-                "apiKey": f"{self.stochasticai_api_key}",
+                "apiKey": f"{self.stochasticai_api_key.get_secret_value()}",
                 "Accept": "application/json",
                 "Content-Type": "application/json",
             },
@@ -119,7 +119,7 @@ class StochasticAI(LLM):
             response_get = requests.get(
                 url=response_post_json["data"]["responseUrl"],
                 headers={
-                    "apiKey": f"{self.stochasticai_api_key}",
+                    "apiKey": f"{self.stochasticai_api_key.get_secret_value()}",
                     "Accept": "application/json",
                     "Content-Type": "application/json",
                 },

libs/community/langchain_community/llms/volcengine_maas.py

@@ -5,8 +5,8 @@ from typing import Any, Dict, Iterator, List, Optional
 from langchain_core.callbacks import CallbackManagerForLLMRun
 from langchain_core.language_models.llms import LLM
 from langchain_core.outputs import GenerationChunk
-from langchain_core.pydantic_v1 import BaseModel, Field, root_validator
-from langchain_core.utils import get_from_dict_or_env
+from langchain_core.pydantic_v1 import BaseModel, Field, SecretStr, root_validator
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
 
 
 class VolcEngineMaasBase(BaseModel):
@@ -14,9 +14,9 @@ class VolcEngineMaasBase(BaseModel):
 
     client: Any
 
-    volc_engine_maas_ak: Optional[str] = None
+    volc_engine_maas_ak: Optional[SecretStr] = None
     """access key for volc engine"""
-    volc_engine_maas_sk: Optional[str] = None
+    volc_engine_maas_sk: Optional[SecretStr] = None
     """secret key for volc engine"""
 
     endpoint: Optional[str] = "maas-api.ml-platform-cn-beijing.volces.com"
@@ -54,8 +54,12 @@ class VolcEngineMaasBase(BaseModel):
 
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
-        ak = get_from_dict_or_env(values, "volc_engine_maas_ak", "VOLC_ACCESSKEY")
-        sk = get_from_dict_or_env(values, "volc_engine_maas_sk", "VOLC_SECRETKEY")
+        volc_engine_maas_ak = convert_to_secret_str(
+            get_from_dict_or_env(values, "volc_engine_maas_ak", "VOLC_ACCESSKEY")
+        )
+        volc_engine_maas_sk = convert_to_secret_str(
+            get_from_dict_or_env(values, "volc_engine_maas_sk", "VOLC_SECRETKEY")
+        )
         endpoint = values["endpoint"]
         if values["endpoint"] is not None and values["endpoint"] != "":
             endpoint = values["endpoint"]
@@ -68,10 +72,11 @@ class VolcEngineMaasBase(BaseModel):
                 connection_timeout=values["connect_timeout"],
                 socket_timeout=values["read_timeout"],
             )
-            maas.set_ak(ak)
-            values["volc_engine_maas_ak"] = ak
-            values["volc_engine_maas_sk"] = sk
-            maas.set_sk(sk)
+            maas.set_ak(volc_engine_maas_ak.get_secret_value())
+            maas.set_sk(volc_engine_maas_sk.get_secret_value())
+
+            values["volc_engine_maas_ak"] = volc_engine_maas_ak
+            values["volc_engine_maas_sk"] = volc_engine_maas_sk
             values["client"] = maas
         except ImportError:
             raise ImportError(

libs/community/langchain_community/retrievers/google_vertex_ai_search.py

@@ -162,7 +162,6 @@ class _BaseGoogleVertexAISearchRetriever(BaseModel):
         from google.protobuf.json_format import MessageToDict
 
         documents: List[Document] = []
-        chunk_type = "extractive_answers"
 
         for result in results:
             document_dict = MessageToDict(

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

@@ -5,7 +5,7 @@ import json
 import os
 from io import StringIO
 from sys import version_info
-from typing import IO, TYPE_CHECKING, Any, Callable, List, Optional, Type
+from typing import IO, TYPE_CHECKING, Any, Callable, List, Optional, Type, Union
 
 from langchain_core.callbacks import (
     AsyncCallbackManagerForToolRun,
@@ -197,11 +197,11 @@ class E2BDataAnalysisTool(BaseTool):
             "exit_code": output.exit_code,
         }
 
-    def install_python_packages(self, package_names: str | List[str]) -> None:
+    def install_python_packages(self, package_names: Union[str, List[str]]) -> None:
         """Install python packages in the sandbox."""
         self.session.install_python_packages(package_names)
 
-    def install_system_packages(self, package_names: str | List[str]) -> None:
+    def install_system_packages(self, package_names: Union[str, List[str]]) -> None:
         """Install system packages (via apt) in the sandbox."""
         self.session.install_system_packages(package_names)
 

libs/community/langchain_community/tools/gmail/send_message.py

@@ -2,7 +2,7 @@
 import base64
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
 from langchain_core.callbacks import CallbackManagerForToolRun
 from langchain_core.pydantic_v1 import BaseModel, Field
@@ -42,6 +42,7 @@ class GmailSendMessage(GmailBaseTool):
     description: str = (
         "Use this tool to send email messages." " The input is the message, recipients"
     )
+    args_schema: Type[SendMessageSchema] = SendMessageSchema
 
     def _prepare_message(
         self,

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

@@ -27,7 +27,7 @@ class TavilySearchResults(BaseTool):
         "Useful for when you need to answer questions about current events. "
         "Input should be a search query."
     )
-    api_wrapper: TavilySearchAPIWrapper
+    api_wrapper: TavilySearchAPIWrapper = Field(default_factory=TavilySearchAPIWrapper)
     max_results: int = 5
     args_schema: Type[BaseModel] = TavilyInput
 
@@ -70,7 +70,7 @@ class TavilyAnswer(BaseTool):
         "Input should be a search query. "
         "This returns only the answer - not the original source data."
     )
-    api_wrapper: TavilySearchAPIWrapper
+    api_wrapper: TavilySearchAPIWrapper = Field(default_factory=TavilySearchAPIWrapper)
     args_schema: Type[BaseModel] = TavilyInput
 
     def _run(