Harrison/prompt issues (#1537)

Resolves https://github.com/hwchase17/langchain/issues/1510

### Problem
When loading S3 Objects with `/` in the object key (eg.
`folder/some-document.txt`) using `S3FileLoader`, the objects are
downloaded into a temporary directory and saved as a file.

This errors out when the parent directory does not exist within the
temporary directory.

See
https://github.com/hwchase17/langchain/issues/1510#issuecomment-1459583696
on how to reproduce this bug

### What this pr does
Creates parent directories based on object key. 

This also works with deeply nested keys:
`folder/subfolder/some-document.txt`

.gitignore

@@ -106,6 +106,7 @@ celerybeat.pid
 
 # Environments
 .env
+.envrc
 .venv
 .venvs
 env/

README.md

@@ -42,7 +42,7 @@ Please see [here](https://langchain.readthedocs.io/en/latest/?) for full documen
 - Getting started (installation, setting up the environment, simple examples)
 - How-To examples (demos, integrations, helper functions)
 - Reference (full API docs)
-  Resources (high-level explanation of core concepts)
+- Resources (high-level explanation of core concepts)
 
 ## 🚀 What can this help with?
 

docs/ecosystem/pinecone.md

@@ -17,4 +17,4 @@ To import this vectorstore:
 from langchain.vectorstores import Pinecone
 ```
 
-For a more detailed walkthrough of the Pinecone wrapper, see [this notebook](../modules/indexes/examples/vectorstores.ipynb)
+For a more detailed walkthrough of the Pinecone wrapper, see [this notebook](../modules/indexes/vectorstore_examples/pinecone.ipynb)

docs/ecosystem/searx.md

@@ -5,21 +5,44 @@ It is broken into two parts: installation and setup, and then references to the
 
 ## Installation and Setup
 
-- You can find a list of public SearxNG instances [here](https://searx.space/). 
-- It recommended to use a self-hosted instance to avoid abuse on the public instances. Also note that public instances often have a limit on the number of requests.
-- To run a self-hosted instance see [this page](https://searxng.github.io/searxng/admin/installation.html) for more information.
-- To use the tool you need to provide the searx host url by:
-    1. passing the named parameter `searx_host` when creating the instance.
-    2. exporting the environment variable `SEARXNG_HOST`. 
+While it is possible to utilize the wrapper in conjunction with  [public searx
+instances](https://searx.space/) these instances frequently do not permit API
+access (see note on output format below) and have limitations on the frequency
+of requests. It is recommended to opt for a self-hosted instance instead.
+
+### Self Hosted Instance:
+
+See [this page](https://searxng.github.io/searxng/admin/installation.html) for installation instructions.
+
+When you install SearxNG, the only active output format by default is the HTML format.
+You need to activate the `json` format to use the API. This can be done by adding the following line to the `settings.yml` file:
+```yaml
+search:
+    formats:
+        - html
+        - json
+```
+You can make sure that the API is working by issuing a curl request to the API endpoint:
+
+`curl -kLX GET --data-urlencode q='langchain' -d format=json http://localhost:8888`
+
+This should return a JSON object with the results.
+
 
 ## Wrappers
 
 ### Utility
 
+To use the wrapper we need to pass the host of the SearxNG instance to the wrapper with:
+    1. the named parameter `searx_host` when creating the instance.
+    2. exporting the environment variable `SEARXNG_HOST`.
+
 You can use the wrapper to get results from a SearxNG instance. 
 
 ```python
 from langchain.utilities import SearxSearchWrapper
+s = SearxSearchWrapper(searx_host="http://localhost:8888")
+s.run("what is a large language model?")
 ```
 
 ### Tool
@@ -29,7 +52,7 @@ You can do this with:
 
 ```python
 from langchain.agents import load_tools
-tools = load_tools(["searx-search"], searx_host="https://searx.example.com")
+tools = load_tools(["searx-search"], searx_host="http://localhost:8888")
 ```
 
-For more information on this, see [this page](../modules/agents/tools.md)
+For more information on tools, see [this page](../modules/agents/tools.md)

docs/getting_started/getting_started.md

@@ -66,7 +66,7 @@ llm = OpenAI(temperature=0.9)
 We can now call it on some input!
 
 ```python
-text = "What would be a good company name a company that makes colorful socks?"
+text = "What would be a good company name for a company that makes colorful socks?"
 print(llm(text))
 ```
 

docs/index.rst

@@ -63,6 +63,8 @@ These modules are, in increasing order of complexity:
 
 - `Memory <./modules/memory.html>`_: Memory is the concept of persisting state between calls of a chain/agent. LangChain provides a standard interface for memory, a collection of memory implementations, and examples of chains/agents that use memory.
 
+- `Chat <./modules/chat.html>`_: Chat models are a variation on Language Models that expose a different API - rather than working with raw text, they work with messages. LangChain provides a standard interface for working with them and doing all the same things as above.
+
 
 .. toctree::
    :maxdepth: 1
@@ -78,6 +80,7 @@ These modules are, in increasing order of complexity:
    ./modules/chains.md
    ./modules/agents.md
    ./modules/memory.md
+   ./modules/chat.md
 
 Use Cases
 ----------

docs/modules/agents/agent_toolkits/csv.ipynb

@@ -5,11 +5,12 @@
    "id": "7094e328",
    "metadata": {},
    "source": [
-    "# Pandas Dataframe Agent\n",
+    "# CSV Agent\n",
     "\n",
-    "This notebook shows how to use agents to interact with a pandas dataframe. It is mostly optimized for question answering.\n",
+    "This notebook shows how to use agents to interact with a csv. It is mostly optimized for question answering.\n",
     "\n",
-    "**NOTE: this agent calls the Python agent under the hood, which executes LLM generated Python code - this can be bad if the LLM generated Python code is harmful. Use cautiously.**"
+    "**NOTE: this agent calls the Pandas DataFrame agent under the hood, which in turn calls the Python agent, which executes LLM generated Python code - this can be bad if the LLM generated Python code is harmful. Use cautiously.**\n",
+    "\n"
    ]
   },
   {

docs/modules/agents/agent_toolkits/pandas.ipynb

@@ -5,11 +5,11 @@
    "id": "c81da886",
    "metadata": {},
    "source": [
-    "# CSV Agent\n",
+    "# Pandas Dataframe Agent\n",
     "\n",
-    "This notebook shows how to use agents to interact with a csv. It is mostly optimized for question answering.\n",
+    "This notebook shows how to use agents to interact with a pandas dataframe. It is mostly optimized for question answering.\n",
     "\n",
-    "**NOTE: this agent calls the Pandas DataFrame agent under the hood, which in turn calls the Python agent, which executes LLM generated Python code - this can be bad if the LLM generated Python code is harmful. Use cautiously.**"
+    "**NOTE: this agent calls the Python agent under the hood, which executes LLM generated Python code - this can be bad if the LLM generated Python code is harmful. Use cautiously.**"
    ]
   },
   {

docs/modules/agents/agent_toolkits/python.ipynb

@@ -46,6 +46,7 @@
    "id": "c16161de",
    "metadata": {},
    "source": [
+    "## Fibonacci Example\n",
     "This example was created by [John Wiseman](https://twitter.com/lemonodor/status/1628270074074398720?s=20)."
    ]
   },
@@ -104,6 +105,7 @@
    "id": "7caa30de",
    "metadata": {},
    "source": [
+    "## Training neural net\n",
     "This example was created by [Samee Ur Rehman](https://twitter.com/sameeurehman/status/1630130518133207046?s=20)."
    ]
   },

docs/modules/agents/examples/load_from_hub.ipynb

@@ -29,16 +29,16 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3m Yes.\n",
-      "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\n",
-      "Intermediate answer: \u001b[36;1m\u001b[1;3m2016 · SUI · Stan Wawrinka ; 2017 · ESP · Rafael Nadal ; 2018 · SRB · Novak Djokovic ; 2019 · ESP · Rafael Nadal.\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mSo the reigning men's U.S. Open champion is Rafael Nadal.\n",
-      "Follow up: What is Rafael Nadal's hometown?\u001b[0m\n",
-      "Intermediate answer: \u001b[36;1m\u001b[1;3mIn 2016, he once again showed his deep ties to Mallorca and opened the Rafa Nadal Academy in his hometown of Manacor.\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mSo the final answer is: Manacor, Mallorca, Spain.\u001b[0m\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3m Yes.\n",
+      "Follow up: Who is the reigning men's U.S. Open champion?\u001B[0m\n",
+      "Intermediate answer: \u001B[36;1m\u001B[1;3m2016 · SUI · Stan Wawrinka ; 2017 · ESP · Rafael Nadal ; 2018 · SRB · Novak Djokovic ; 2019 · ESP · Rafael Nadal.\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mSo the reigning men's U.S. Open champion is Rafael Nadal.\n",
+      "Follow up: What is Rafael Nadal's hometown?\u001B[0m\n",
+      "Intermediate answer: \u001B[36;1m\u001B[1;3mIn 2016, he once again showed his deep ties to Mallorca and opened the Rafa Nadal Academy in his hometown of Manacor.\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mSo the final answer is: Manacor, Mallorca, Spain.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {

docs/modules/agents/examples/search_tools.ipynb

@@ -12,7 +12,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "e6860c2d",
    "metadata": {
     "pycharm": {
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "dadbcfcd",
    "metadata": {},
    "outputs": [],
@@ -238,6 +238,92 @@
    "source": [
     "agent.run(\"What is the weather in Pomfret?\")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eabad3af",
+   "metadata": {},
+   "source": [
+    "## SearxNG Meta Search Engine\n",
+    "\n",
+    "Here we will be using a self hosted SearxNG meta search engine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b196c704",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tools = load_tools([\"searx-search\"], searx_host=\"http://localhost:8888\", llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9023eeaa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = initialize_agent(tools, llm, agent=\"zero-shot-react-description\", verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3aad92c1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m I should look up the current weather\n",
+      "Action: SearX Search\n",
+      "Action Input: \"weather in Pomfret\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mMainly cloudy with snow showers around in the morning. High around 40F. Winds NNW at 5 to 10 mph. Chance of snow 40%. Snow accumulations less than one inch.\n",
+      "\n",
+      "10 Day Weather - Pomfret, MD As of 1:37 pm EST Today 49°/ 41° 52% Mon 27 | Day 49° 52% SE 14 mph Cloudy with occasional rain showers. High 49F. Winds SE at 10 to 20 mph. Chance of rain 50%....\n",
+      "\n",
+      "10 Day Weather - Pomfret, VT As of 3:51 am EST Special Weather Statement Today 39°/ 32° 37% Wed 01 | Day 39° 37% NE 4 mph Cloudy with snow showers developing for the afternoon. High 39F....\n",
+      "\n",
+      "Pomfret, CT ; Current Weather. 1:06 AM. 35°F · RealFeel® 32° ; TODAY'S WEATHER FORECAST. 3/3. 44°Hi. RealFeel® 50° ; TONIGHT'S WEATHER FORECAST. 3/3. 32°Lo.\n",
+      "\n",
+      "Pomfret, MD Forecast Today Hourly Daily Morning 41° 1% Afternoon 43° 0% Evening 35° 3% Overnight 34° 2% Don't Miss Finally, Here’s Why We Get More Colds and Flu When It’s Cold Coast-To-Coast...\n",
+      "\n",
+      "Pomfret, MD Weather Forecast | AccuWeather Current Weather 5:35 PM 35° F RealFeel® 36° RealFeel Shade™ 36° Air Quality Excellent Wind E 3 mph Wind Gusts 5 mph Cloudy More Details WinterCast...\n",
+      "\n",
+      "Pomfret, VT Weather Forecast | AccuWeather Current Weather 11:21 AM 23° F RealFeel® 27° RealFeel Shade™ 25° Air Quality Fair Wind ESE 3 mph Wind Gusts 7 mph Cloudy More Details WinterCast...\n",
+      "\n",
+      "Pomfret Center, CT Weather Forecast | AccuWeather Daily Current Weather 6:50 PM 39° F RealFeel® 36° Air Quality Fair Wind NW 6 mph Wind Gusts 16 mph Mostly clear More Details WinterCast...\n",
+      "\n",
+      "12:00 pm · Feels Like36° · WindN 5 mph · Humidity43% · UV Index3 of 10 · Cloud Cover65% · Rain Amount0 in ...\n",
+      "\n",
+      "Pomfret Center, CT Weather Conditions | Weather Underground star Popular Cities San Francisco, CA 49 °F Clear Manhattan, NY 37 °F Fair Schiller Park, IL (60176) warning39 °F Mostly Cloudy...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The current weather in Pomfret is mainly cloudy with snow showers around in the morning. The temperature is around 40F with winds NNW at 5 to 10 mph. Chance of snow is 40%.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The current weather in Pomfret is mainly cloudy with snow showers around in the morning. The temperature is around 40F with winds NNW at 5 to 10 mph. Chance of snow is 40%.'"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run(\"What is the weather in Pomfret\")"
+   ]
   }
  ],
  "metadata": {
@@ -256,7 +342,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.9.11"
   },
   "vscode": {
    "interpreter": {

docs/modules/agents/implementations/mrkl.ipynb

@@ -205,7 +205,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/agents/implementations/react.ipynb

@@ -81,7 +81,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.0 64-bit ('llm-env')",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -95,7 +95,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.0"
+   "version": "3.9.1"
   },
   "vscode": {
    "interpreter": {

docs/modules/chains/async_chain.ipynb

@@ -39,7 +39,7 @@
       "\n",
       "\n",
       "SparkleSmile Toothpaste\n",
-      "\u001b[1mConcurrent executed in 1.54 seconds.\u001b[0m\n",
+      "\u001B[1mConcurrent executed in 1.54 seconds.\u001B[0m\n",
       "\n",
       "\n",
       "BrightSmile Toothpaste Co.\n",
@@ -55,7 +55,7 @@
       "\n",
       "\n",
       "BrightSmile Toothpaste.\n",
-      "\u001b[1mSerial executed in 6.38 seconds.\u001b[0m\n"
+      "\u001B[1mSerial executed in 6.38 seconds.\u001B[0m\n"
      ]
     }
    ],

docs/modules/chains/examples/pal.ipynb

@@ -71,17 +71,17 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new PALChain chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mdef solution():\n",
+      "\u001B[1m> Entering new PALChain chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mdef solution():\n",
       "    \"\"\"Jan has three times the number of pets as Marcia. Marcia has two more pets than Cindy. If Cindy has four pets, how many total pets do the three have?\"\"\"\n",
       "    cindy_pets = 4\n",
       "    marcia_pets = cindy_pets + 2\n",
       "    jan_pets = marcia_pets * 3\n",
       "    total_pets = cindy_pets + marcia_pets + jan_pets\n",
       "    result = total_pets\n",
-      "    return result\u001b[0m\n",
+      "    return result\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -139,8 +139,8 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new PALChain chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3m# Put objects into a list to record ordering\n",
+      "\u001B[1m> Entering new PALChain chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3m# Put objects into a list to record ordering\n",
       "objects = []\n",
       "objects += [('booklet', 'blue')] * 2\n",
       "objects += [('booklet', 'purple')] * 2\n",
@@ -151,9 +151,9 @@
       "\n",
       "# Count number of purple objects\n",
       "num_purple = len([object for object in objects if object[1] == 'purple'])\n",
-      "answer = num_purple\u001b[0m\n",
+      "answer = num_purple\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished PALChain chain.\u001b[0m\n"
+      "\u001B[1m> Finished PALChain chain.\u001B[0m\n"
      ]
     },
     {
@@ -212,8 +212,8 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new PALChain chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3m# Put objects into a list to record ordering\n",
+      "\u001B[1m> Entering new PALChain chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3m# Put objects into a list to record ordering\n",
       "objects = []\n",
       "objects += [('booklet', 'blue')] * 2\n",
       "objects += [('booklet', 'purple')] * 2\n",
@@ -224,9 +224,9 @@
       "\n",
       "# Count number of purple objects\n",
       "num_purple = len([object for object in objects if object[1] == 'purple'])\n",
-      "answer = num_purple\u001b[0m\n",
+      "answer = num_purple\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     }
    ],

docs/modules/chains/generic/from_hub.ipynb

@@ -34,10 +34,10 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new LLMMathChain chain...\u001b[0m\n",
-      "whats 2 raised to .12\u001b[32;1m\u001b[1;3m\n",
-      "Answer: 1.0791812460476249\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Entering new LLMMathChain chain...\u001B[0m\n",
+      "whats 2 raised to .12\u001B[32;1m\u001B[1;3m\n",
+      "Answer: 1.0791812460476249\u001B[0m\n",
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {

docs/modules/chains/generic/llm_chain.ipynb

@@ -42,13 +42,13 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "\u001B[1m> Entering new LLMChain chain...\u001B[0m\n",
       "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mQuestion: What NFL team won the Super Bowl in the year Justin Beiber was born?\n",
+      "\u001B[32;1m\u001B[1;3mQuestion: What NFL team won the Super Bowl in the year Justin Beiber was born?\n",
       "\n",
-      "Answer: Let's think step by step.\u001b[0m\n",
+      "Answer: Let's think step by step.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n"
+      "\u001B[1m> Finished LLMChain chain.\u001B[0m\n"
      ]
     },
     {
@@ -95,11 +95,11 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "\u001B[1m> Entering new LLMChain chain...\u001B[0m\n",
       "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mWrite a sad poem about ducks.\u001b[0m\n",
+      "\u001B[32;1m\u001B[1;3mWrite a sad poem about ducks.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n"
+      "\u001B[1m> Finished LLMChain chain.\u001B[0m\n"
      ]
     },
     {

docs/modules/chains/generic/sequential_chains.ipynb

@@ -36,6 +36,25 @@
   {
    "cell_type": "code",
    "execution_count": 1,
+   "id": "7a886879",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cannot find .env file\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext dotenv\n",
+    "%dotenv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
    "id": "3f2f9b8c",
    "metadata": {},
    "outputs": [],
@@ -47,7 +66,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "b8237d1a",
    "metadata": {},
    "outputs": [],
@@ -64,7 +83,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "4a391730",
    "metadata": {},
    "outputs": [],
@@ -82,7 +101,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "9368bd63",
    "metadata": {},
    "outputs": [],
@@ -94,7 +113,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "d39e15f5",
    "metadata": {},
    "outputs": [
@@ -107,22 +126,20 @@
       "\u001b[1m> Entering new SimpleSequentialChain chain...\u001b[0m\n",
       "\u001b[36;1m\u001b[1;3m\n",
       "\n",
-      "Tragedy at Sunset on the Beach follows the story of a young couple, Jack and Annie, who have just started to explore the possibility of a relationship together. After a day spent in the sun and sand, they decide to take a romantic stroll down the beach as the sun sets. \n",
+      "Tragedy at Sunset on the Beach is a story of a young couple, Jack and Sarah, who are in love and looking forward to their future together. On the night of their anniversary, they decide to take a walk on the beach at sunset. As they are walking, they come across a mysterious figure, who tells them that their love will be tested in the near future. \n",
       "\n",
-      "However, their romantic evening quickly turns tragic when they stumble upon a body lying in the sand. As they approach to investigate, they are shocked to discover that it is Jack's long-lost brother, who has been missing for several years. \n",
+      "The figure then tells the couple that the sun will soon set, and with it, a tragedy will strike. If Jack and Sarah can stay together and pass the test, they will be granted everlasting love. However, if they fail, their love will be lost forever.\n",
       "\n",
-      "The story follows Jack and Annie as they navigate their way through the tragedy and their newfound relationship. With the help of their friends, family, and the beach's inhabitants, Jack and Annie must come to terms with their deep-seated emotions and the reality of the situation. \n",
-      "\n",
-      "Ultimately, the play explores themes of family, love, and loss, as Jack and Annie's story unfolds against the beautiful backdrop of the beach at sunset.\u001b[0m\n",
+      "The play follows the couple as they struggle to stay together and battle the forces that threaten to tear them apart. Despite the tragedy that awaits them, they remain devoted to one another and fight to keep their love alive. In the end, the couple must decide whether to take a chance on their future together or succumb to the tragedy of the sunset.\u001b[0m\n",
       "\u001b[33;1m\u001b[1;3m\n",
       "\n",
-      "Tragedy at Sunset on the Beach is an emotionally complex tale of family, love, and loss. Told against the beautiful backdrop of a beach at sunset, the story follows Jack and Annie, a young couple just beginning to explore a relationship together. When they stumble upon the body of Jack's long-lost brother on the beach, they must face the reality of the tragedy and come to terms with their deep-seated emotions. \n",
+      "Tragedy at Sunset on the Beach is an emotionally gripping story of love, hope, and sacrifice. Through the story of Jack and Sarah, the audience is taken on a journey of self-discovery and the power of love to overcome even the greatest of obstacles. \n",
       "\n",
-      "The playwright has crafted a heartfelt and thought-provoking story, one that probes into the depths of the human experience. The cast of characters is well-rounded and fully realized, and the dialogue is natural and emotional. The direction and choreography are top-notch, and the scenic design is breathtaking. \n",
+      "The play's talented cast brings the characters to life, allowing us to feel the depths of their emotion and the intensity of their struggle. With its compelling story and captivating performances, this play is sure to draw in audiences and leave them on the edge of their seats. \n",
       "\n",
-      "Overall, Tragedy at Sunset on the Beach is a powerful and moving story about the fragility of life and the strength of love. It is sure to tug at your heartstrings and leave you with a newfound appreciation of life's precious moments. Highly recommended.\u001b[0m\n",
+      "The play's setting of the beach at sunset adds a touch of poignancy and romanticism to the story, while the mysterious figure serves to keep the audience enthralled. Overall, Tragedy at Sunset on the Beach is an engaging and thought-provoking play that is sure to leave audiences feeling inspired and hopeful.\u001b[0m\n",
       "\n",
-      "\u001b[1m> Finished SimpleSequentialChain chain.\u001b[0m\n"
+      "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
     }
    ],
@@ -132,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "c6649a01",
    "metadata": {},
    "outputs": [
@@ -142,11 +159,11 @@
      "text": [
       "\n",
       "\n",
-      "Tragedy at Sunset on the Beach is an emotionally complex tale of family, love, and loss. Told against the beautiful backdrop of a beach at sunset, the story follows Jack and Annie, a young couple just beginning to explore a relationship together. When they stumble upon the body of Jack's long-lost brother on the beach, they must face the reality of the tragedy and come to terms with their deep-seated emotions. \n",
+      "Tragedy at Sunset on the Beach is an emotionally gripping story of love, hope, and sacrifice. Through the story of Jack and Sarah, the audience is taken on a journey of self-discovery and the power of love to overcome even the greatest of obstacles. \n",
       "\n",
-      "The playwright has crafted a heartfelt and thought-provoking story, one that probes into the depths of the human experience. The cast of characters is well-rounded and fully realized, and the dialogue is natural and emotional. The direction and choreography are top-notch, and the scenic design is breathtaking. \n",
+      "The play's talented cast brings the characters to life, allowing us to feel the depths of their emotion and the intensity of their struggle. With its compelling story and captivating performances, this play is sure to draw in audiences and leave them on the edge of their seats. \n",
       "\n",
-      "Overall, Tragedy at Sunset on the Beach is a powerful and moving story about the fragility of life and the strength of love. It is sure to tug at your heartstrings and leave you with a newfound appreciation of life's precious moments. Highly recommended.\n"
+      "The play's setting of the beach at sunset adds a touch of poignancy and romanticism to the story, while the mysterious figure serves to keep the audience enthralled. Overall, Tragedy at Sunset on the Beach is an engaging and thought-provoking play that is sure to leave audiences feeling inspired and hopeful.\n"
      ]
     }
    ],
@@ -167,7 +184,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "id": "02016a51",
    "metadata": {},
    "outputs": [],
@@ -185,7 +202,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "id": "8bd38cc2",
    "metadata": {},
    "outputs": [],
@@ -203,7 +220,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "524523af",
    "metadata": {},
    "outputs": [],
@@ -220,7 +237,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "3fd3a7be",
    "metadata": {},
    "outputs": [
@@ -231,14 +248,8 @@
       "\n",
       "\n",
       "\u001b[1m> Entering new SequentialChain chain...\u001b[0m\n",
-      "\u001b[1mChain 0\u001b[0m:\n",
-      "{'synopsis': \" \\n\\nTragedy at Sunset on the Beach is a dark and gripping drama set in Victorian England. The play follows the story of two lovers, Emma and Edward, whose passionate relationship is threatened by the strict rules and regulations of the time.\\n\\nThe two are deeply in love, but Edward is from a wealthy family and Emma is from a lower class background. Despite the obstacles, the two are determined to be together and decide to elope.\\n\\nOn the night of their planned escape, Emma and Edward meet at the beach at sunset to declare their love for one another and begin a new life together. However, their plans are disrupted when Emma's father discovers their plan and appears on the beach with a gun.\\n\\nIn a heartbreaking scene, Emma's father orders Edward to leave, but Edward refuses and fights for their love. In a fit of rage, Emma's father shoots Edward, killing him instantly. \\n\\nThe tragedy of the play lies in the fact that Emma and Edward are denied their chance at a happy ending due to the rigid social conventions of Victorian England. The audience is left with a heavy heart as the play ends with Emma standing alone on the beach, mourning the loss of her beloved.\"}\n",
       "\n",
-      "\u001b[1mChain 1\u001b[0m:\n",
-      "{'review': \"\\n\\nTragedy at Sunset on the Beach is an emotionally charged production that will leave audiences heartsick. The play follows the ill-fated love story of Emma and Edward, two star-crossed lovers whose passionate relationship is tragically thwarted by Victorian England's societal conventions. The performance is captivating from start to finish, as the audience is taken on an emotional rollercoaster of love, loss, and heartbreak.\\n\\nThe acting is powerful and sincere, and the performances of the two leads are particularly stirring. Emma and Edward are both portrayed with such tenderness and emotion that it's hard not to feel their pain as they fight for their forbidden love. The climactic scene, in which Edward is shot by Emma's father, is especially heartbreaking and will leave audience members on the edge of their seats.\\n\\nOverall, Tragedy at Sunset on the Beach is a powerful and moving work of theatre. It is a tragedy of impossible love, and a vivid reminder of the devastating consequences of social injustice. The play is sure to leave a lasting impression on anyone who experiences it.\"}\n",
-      "\n",
-      "\n",
-      "\u001b[1m> Finished SequentialChain chain.\u001b[0m\n"
+      "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
     }
    ],
@@ -246,10 +257,91 @@
     "review = overall_chain({\"title\":\"Tragedy at sunset on the beach\", \"era\": \"Victorian England\"})"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d2fac817",
+   "metadata": {},
+   "source": [
+    "### Memory in Sequential Chains\n",
+    "Sometimes you may want to pass along some context to use in each step of the chain or in a later part of the chain, but maintaining and chaining together the input/output variables can quickly get messy.  Using `SimpleMemory` is a convenient way to do manage this and clean up your chains.\n",
+    "\n",
+    "For example, using the previous playwright SequentialChain, lets say you wanted to include some context about date, time and location of the play, and using the generated synopsis and review, create some social media post text.  You could add these new context variables as `input_variables`, or we can add a `SimpleMemory` to the chain to manage this context:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2cf3098",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6b7b3a7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new SequentialChain chain...\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'title': 'Tragedy at sunset on the beach',\n",
+       " 'era': 'Victorian England',\n",
+       " 'time': 'December 25th, 8pm PST',\n",
+       " 'location': 'Theater in the Park',\n",
+       " 'social_post_text': \"\\nSpend your Christmas night with us at Theater in the Park and experience the heartbreaking story of love and loss that is 'A Walk on the Beach'. Set in Victorian England, this romantic tragedy follows the story of Frances and Edward, a young couple whose love is tragically cut short. Don't miss this emotional and thought-provoking production that is sure to leave you in tears. #AWalkOnTheBeach #LoveAndLoss #TheaterInThePark #VictorianEngland\"}"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chains import SequentialChain\n",
+    "from langchain.memory import SimpleMemory\n",
+    "\n",
+    "llm = OpenAI(temperature=.7)\n",
+    "template = \"\"\"You are a social media manager for a theater company.  Given the title of play, the era it is set in, the date,time and location, the synopsis of the play, and the review of the play, it is your job to write a social media post for that play.\n",
+    "\n",
+    "Here is some context about the time and location of the play:\n",
+    "Date and Time: {time}\n",
+    "Location: {location}\n",
+    "\n",
+    "Play Synopsis:\n",
+    "{synopsis}\n",
+    "Review from a New York Times play critic of the above play:\n",
+    "{review}\n",
+    "\n",
+    "Social Media Post:\n",
+    "\"\"\"\n",
+    "prompt_template = PromptTemplate(input_variables=[\"synopsis\", \"review\", \"time\", \"location\"], template=template)\n",
+    "social_chain = LLMChain(llm=llm, prompt=prompt_template, output_key=\"social_post_text\")\n",
+    "\n",
+    "overall_chain = SequentialChain(\n",
+    "    memory=SimpleMemory(memories={\"time\": \"December 25th, 8pm PST\", \"location\": \"Theater in the Park\"}),\n",
+    "    chains=[synopsis_chain, review_chain, social_chain],\n",
+    "    input_variables=[\"era\", \"title\"],\n",
+    "    # Here we return multiple variables\n",
+    "    output_variables=[\"social_post_text\"],\n",
+    "    verbose=True)\n",
+    "\n",
+    "overall_chain({\"title\":\"Tragedy at sunset on the beach\", \"era\": \"Victorian England\"})"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "6be70d27",
+   "id": "ee9bc09c",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -271,7 +363,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/chains/generic/serialization.ipynb

@@ -136,13 +136,13 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "\u001B[1m> Entering new LLMChain chain...\u001B[0m\n",
       "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mQuestion: whats 2 + 2\n",
+      "\u001B[32;1m\u001B[1;3mQuestion: whats 2 + 2\n",
       "\n",
-      "Answer: Let's think step by step.\u001b[0m\n",
+      "Answer: Let's think step by step.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -319,13 +319,13 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "\u001B[1m> Entering new LLMChain chain...\u001B[0m\n",
       "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mQuestion: whats 2 + 2\n",
+      "\u001B[32;1m\u001B[1;3mQuestion: whats 2 + 2\n",
       "\n",
-      "Answer: Let's think step by step.\u001b[0m\n",
+      "Answer: Let's think step by step.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {

docs/modules/chains/getting_started.ipynb

@@ -32,7 +32,9 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "from langchain.prompts import PromptTemplate\n",
@@ -55,7 +57,9 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -63,7 +67,7 @@
      "text": [
       "\n",
       "\n",
-      "Vibrancy Socks.\n"
+      "Rainbow Socks Co.\n"
      ]
     }
    ],
@@ -75,6 +79,48 @@
     "print(chain.run(\"colorful socks\"))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can use a chat model in an `LLMChain` as well:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "Rainbow Threads\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "human_message_prompt = HumanMessagePromptTemplate(\n",
+    "        prompt=PromptTemplate(\n",
+    "            template=\"What is a good name for a company that makes {product}?\",\n",
+    "            input_variables=[\"product\"],\n",
+    "        )\n",
+    "    )\n",
+    "chat_prompt_template = ChatPromptTemplate.from_messages([human_message_prompt])\n",
+    "chat = ChatOpenAI(temperature=0.9)\n",
+    "chain = LLMChain(llm=chat, prompt=chat_prompt_template)\n",
+    "print(chain.run(\"colorful socks\"))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -274,5 +320,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

docs/modules/chains/key_concepts.md

@@ -9,3 +9,12 @@ This is a specific type of chain where multiple other chains are run in sequence
 to the next. A subtype of this type of chain is the [`SimpleSequentialChain`](./generic/sequential_chains.html#simplesequentialchain), where all subchains have only one input and one output,
 and the output of one is therefore used as sole input to the next chain.
 
+## Prompt Selectors
+One thing that we've noticed is that the best prompt to use is really dependent on the model you use.
+Some prompts work really good with some models, but not great with others.
+One of our goals is provide good chains that "just work" out of the box. 
+A big part of chains like that is having prompts that "just work".
+So rather than having a default prompt for chains, we are moving towards a paradigm where if a prompt is not explicitly
+provided we select one with a PromptSelector. This class takes in the model passed in, and returns a default prompt.
+The inner workings of the PromptSelector can look at any aspect of the model - LLM vs ChatModel, OpenAI vs Cohere, GPT3 vs GPT4, etc.
+Due to this being a newer feature, this may not be implemented for all chains, but this is the direction we are moving.

docs/modules/chat.rst

@@ -0,0 +1,26 @@
+Chat
+==========================
+
+Chat models are a variation on language models.
+While chat models use language models under the hood, the interface they expose is a bit different.
+Rather than expose a "text in, text out" API, they expose an interface where "chat messages" are the inputs and outputs.
+
+Chat model APIs are fairly new, so we are still figuring out the correct abstractions.
+
+The following sections of documentation are provided:
+
+- `Getting Started <./chat/getting_started.html>`_: An overview of the basics of chat models.
+
+- `Key Concepts <./chat/key_concepts.html>`_: A conceptual guide going over the various concepts related to chat models.
+
+- `How-To Guides <./chat/how_to_guides.html>`_: A collection of how-to guides. These highlight how to accomplish various objectives with our chat model class, as well as how to integrate with various chat model providers.
+
+
+.. toctree::
+   :maxdepth: 1
+   :name: LLMs
+   :hidden:
+   
+   ./chat/getting_started.ipynb
+   ./chat/key_concepts.md
+   ./chat/how_to_guides.rst

docs/modules/chat/examples/agent.ipynb

@@ -0,0 +1,208 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e58f4d5a",
+   "metadata": {},
+   "source": [
+    "# Agent\n",
+    "This notebook covers how to create a custom agent for a chat model. It will utilize chat specific prompts."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5268c7fa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.utilities import SerpAPIWrapper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "fbaa4dbe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = SerpAPIWrapper()\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": "code",
+   "execution_count": 6,
+   "id": "f3ba6f08",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prefix = \"\"\"Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3547a37d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a78f886f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "messages = [\n",
+    "    SystemMessagePromptTemplate(prompt=prompt),\n",
+    "    HumanMessagePromptTemplate.from_template(\"{input}\\n\\nThis was your previous work \"\n",
+    "                f\"(but I haven't seen any of it! I only see what \"\n",
+    "                \"you return as final answer):\\n{agent_scratchpad}\")\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "dadadd70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages(messages)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b7180182",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(llm=ChatOpenAI(temperature=0), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "ddddb07b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tool_names = [tool.name for tool in tools]\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "36aef054",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "33a4d6cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mArrr, ye be in luck, matey! I'll find ye the answer to yer question.\n",
+      "\n",
+      "Thought: I need to search for the current population of Canada.\n",
+      "Action: Search\n",
+      "Action Input: \"current population of Canada 2023\"\n",
+      "\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,623,091 as of Saturday, March 4, 2023, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3mAhoy, me hearties! I've found the answer to yer question.\n",
+      "\n",
+      "Final Answer: As of March 4, 2023, the population of Canada be 38,623,091. Arrr!\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'As of March 4, 2023, the population of Canada be 38,623,091. Arrr!'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.run(\"How many people live in canada as of 2023?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6aefe978",
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/examples/chat_vector_db.ipynb

@@ -0,0 +1,376 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "134a0785",
+   "metadata": {},
+   "source": [
+    "# Chat Vector DB\n",
+    "\n",
+    "This notebook goes over how to set up a chat model to chat with a vector database.\n",
+    "\n",
+    "This notebook is very similar to the example of using an LLM in the ChatVectorDBChain. The only differences here are (1) using a ChatModel, and (2) passing in a ChatPromptTemplate (optimized for chat models)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "70c4e529",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.chains import ChatVectorDBChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cdff94be",
+   "metadata": {},
+   "source": [
+    "Load in documents. You can replace this with a loader for whatever type of data you want"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "01c46e92",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TextLoader\n",
+    "loader = TextLoader('../../state_of_the_union.txt')\n",
+    "documents = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e9be4779",
+   "metadata": {},
+   "source": [
+    "If you had multiple loaders that you wanted to combine, you do something like:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "433363a5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# loaders = [....]\n",
+    "# docs = []\n",
+    "# for loader in loaders:\n",
+    "#     docs.extend(loader.load())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "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."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a8930cf7",
+   "metadata": {
+    "tags": []
+   },
+   "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": [
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "documents = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()\n",
+    "vectorstore = Chroma.from_documents(documents, embeddings)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "18415aca",
+   "metadata": {},
+   "source": [
+    "We are now going to construct a prompt specifically designed for chat models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c8805230",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "cc86c30e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_template=\"\"\"Use the following pieces of context to answer the users question. \n",
+    "If you don't know the answer, just say that you don't know, don't try to make up an answer.\n",
+    "----------------\n",
+    "{context}\"\"\"\n",
+    "messages = [\n",
+    "    SystemMessagePromptTemplate.from_template(system_template),\n",
+    "    HumanMessagePromptTemplate.from_template(\"{question}\")\n",
+    "]\n",
+    "prompt = ChatPromptTemplate.from_messages(messages)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c96b118",
+   "metadata": {},
+   "source": [
+    "We now initialize the ChatVectorDBChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7b4110f3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "qa = ChatVectorDBChain.from_llm(ChatOpenAI(temperature=0), vectorstore,qa_prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3872432d",
+   "metadata": {},
+   "source": [
+    "Here's an example of asking a question with no chat history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7fe3e730",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "chat_history = []\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "bfff9cc8",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"The President nominated Circuit Court of Appeals Judge Ketanji Brown Jackson to serve on the United States Supreme Court. He described her as one of the nation's top legal minds, a former top litigator in private practice, a former federal public defender, and a consensus builder. He also mentioned that she has received a broad range of support from the Fraternal Order of Police to former judges appointed by Democrats and Republicans.\""
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result[\"answer\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e46edf7",
+   "metadata": {},
+   "source": [
+    "Here's an example of asking a question with some chat history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "00b4cf00",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "chat_history = [(query, result[\"answer\"])]\n",
+    "query = \"Did he mention who came before her\"\n",
+    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f01828d1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The context does not provide information about the predecessor of Ketanji Brown Jackson.'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result['answer']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2324cdc6-98bf-4708-b8cd-02a98b1e5b67",
+   "metadata": {},
+   "source": [
+    "## Chat Vector DB with streaming to `stdout`\n",
+    "\n",
+    "Output from the chain will be streamed to `stdout` token by token in this example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "2efacec3-2690-4b05-8de3-a32fd2ac3911",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.chains.llm import LLMChain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.callbacks.base import CallbackManager\n",
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "from langchain.chains.chat_vector_db.prompts import CONDENSE_QUESTION_PROMPT\n",
+    "from langchain.chains.question_answering import load_qa_chain\n",
+    "\n",
+    "# Construct a ChatVectorDBChain with a streaming llm for combine docs\n",
+    "# and a separate, non-streaming llm for question generation\n",
+    "llm = OpenAI(temperature=0)\n",
+    "streaming_llm = ChatOpenAI(streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), verbose=True, temperature=0)\n",
+    "\n",
+    "question_generator = LLMChain(llm=llm, prompt=CONDENSE_QUESTION_PROMPT)\n",
+    "doc_chain = load_qa_chain(streaming_llm, chain_type=\"stuff\", prompt=prompt)\n",
+    "\n",
+    "qa = ChatVectorDBChain(vectorstore=vectorstore, combine_docs_chain=doc_chain, question_generator=question_generator)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "fd6d43f4-7428-44a4-81bc-26fe88a98762",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The President nominated Circuit Court of Appeals Judge Ketanji Brown Jackson to serve on the United States Supreme Court. He described her as one of the nation's top legal minds, a former top litigator in private practice, a former federal public defender, and a consensus builder. He also mentioned that she has received a broad range of support from the Fraternal Order of Police to former judges appointed by Democrats and Republicans."
+     ]
+    }
+   ],
+   "source": [
+    "chat_history = []\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "result = qa({\"question\": query, \"chat_history\": chat_history})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "5ab38978-f3e8-4fa7-808c-c79dec48379a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The context does not provide information on who Ketanji Brown Jackson succeeded on the United States Supreme Court."
+     ]
+    }
+   ],
+   "source": [
+    "chat_history = [(query, result[\"answer\"])]\n",
+    "query = \"Did he mention who she suceeded\"\n",
+    "result = qa({\"question\": query, \"chat_history\": chat_history})\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e8d0055",
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/examples/few_shot_examples.ipynb

@@ -0,0 +1,166 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bb0735c0",
+   "metadata": {},
+   "source": [
+    "# Few Shot Examples\n",
+    "\n",
+    "This notebook covers how to use few shot examples in chat models.\n",
+    "\n",
+    "There does not appear to be solid consensus on how best to do few shot prompting. As a result, we are not solidifying any abstractions around this yet but rather using existing abstractions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6e9664c",
+   "metadata": {},
+   "source": [
+    "## Alternating Human/AI messages\n",
+    "The first way of doing few shot prompting relies on using alternating human/ai messages. See an example of this below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "62156fe4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain import PromptTemplate, LLMChain\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ed7ac3c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chat = ChatOpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "98791aa9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template=\"You are a helpful assistant that translates english to pirate.\"\n",
+    "system_message_prompt = SystemMessagePromptTemplate.from_template(template)\n",
+    "example_human = HumanMessagePromptTemplate.from_template(\"Hi\")\n",
+    "example_ai = AIMessagePromptTemplate.from_template(\"Argh me mateys\")\n",
+    "human_template=\"{text}\"\n",
+    "human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4eebdcd7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"I be lovin' programmin', me hearty!\""
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, example_human, example_ai, human_message_prompt])\n",
+    "chain = LLMChain(llm=chat, prompt=chat_prompt)\n",
+    "# get a chat completion from the formatted messages\n",
+    "chain.run(\"I love programming.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c4135d7",
+   "metadata": {},
+   "source": [
+    "## System Messages\n",
+    "\n",
+    "OpenAI provides an optional `name` parameter that they also recommend using in conjunction with system messages to do few shot prompting. Here is an example of how to do that below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1ba92d59",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template=\"You are a helpful assistant that translates english to pirate.\"\n",
+    "system_message_prompt = SystemMessagePromptTemplate.from_template(template)\n",
+    "example_human = SystemMessagePromptTemplate.from_template(\"Hi\", additional_kwargs={\"name\": \"example_user\"})\n",
+    "example_ai = SystemMessagePromptTemplate.from_template(\"Argh me mateys\", additional_kwargs={\"name\": \"example_assistant\"})\n",
+    "human_template=\"{text}\"\n",
+    "human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "56e488a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"I be lovin' programmin', me hearty.\""
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, example_human, example_ai, human_message_prompt])\n",
+    "chain = LLMChain(llm=chat, prompt=chat_prompt)\n",
+    "# get a chat completion from the formatted messages\n",
+    "chain.run(\"I love programming.\")"
+   ]
+  }
+ ],
+ "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/examples/memory.ipynb

@@ -0,0 +1,192 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9a9350a6",
+   "metadata": {},
+   "source": [
+    "# Memory\n",
+    "This notebook goes over how to use Memory with chat models. The main difference between this and Memory for LLMs is that rather than trying to condense all previous messages into a string, we can keep them as their own unique memory object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "110935ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import (\n",
+    "    ChatPromptTemplate, \n",
+    "    MessagesPlaceholder, \n",
+    "    SystemMessagePromptTemplate, \n",
+    "    HumanMessagePromptTemplate\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "161b6629",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages([\n",
+    "    SystemMessagePromptTemplate.from_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",
+    "    MessagesPlaceholder(variable_name=\"history\"),\n",
+    "    HumanMessagePromptTemplate.from_template(\"{input}\")\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4976fbda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import ConversationChain\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.memory import ConversationBufferMemory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "12a0bea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = ChatOpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6edcd6a",
+   "metadata": {},
+   "source": [
+    "We can now initialize the memory. Note that we set `return_messages=True` To denote that this should return a list of messages when appropriate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f55bea38",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(return_messages=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "737e8c78",
+   "metadata": {},
+   "source": [
+    "We can now use this in the rest of the chain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "80152db7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "conversation = ConversationChain(memory=memory, prompt=prompt, llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ac68e766",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Hello! How can I assist you today?'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.predict(input=\"Hi there!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "babb33d0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"That sounds like fun! I'm happy to chat with you. Is there anything specific you'd like to talk about?\""
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.predict(input=\"I'm doing well! Just having a conversation with an AI.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "36f8a1dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Sure! I am an AI language model created by OpenAI. I was trained on a large dataset of text from the internet, which allows me to understand and generate human-like language. I can answer questions, provide information, and even have conversations like this one. Is there anything else you'd like to know about me?\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.predict(input=\"Tell me about yourself.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79fb460b",
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/examples/streaming.ipynb

@@ -0,0 +1,119 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fe4e96b5",
+   "metadata": {},
+   "source": [
+    "# Streaming\n",
+    "\n",
+    "This notebook goes over how to use streaming with a chat model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e0244f2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.schema import (\n",
+    "    HumanMessage,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ad342bfa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "Verse 1:\n",
+      "Bubbles rising to the top\n",
+      "A refreshing drink that never stops\n",
+      "Clear and crisp, it's pure delight\n",
+      "A taste that's sure to excite\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Verse 2:\n",
+      "No sugar, no calories, just pure bliss\n",
+      "A drink that's hard to resist\n",
+      "It's the perfect way to quench my thirst\n",
+      "A drink that always comes first\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Bridge:\n",
+      "From the mountains to the sea\n",
+      "Sparkling water, you're the key\n",
+      "To a healthy life, a happy soul\n",
+      "A drink that makes me feel whole\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Outro:\n",
+      "Sparkling water, you're the one\n",
+      "A drink that's always so much fun\n",
+      "I'll never let you go, my friend\n",
+      "Sparkling"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.callbacks.base import CallbackManager\n",
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "chat = ChatOpenAI(streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), verbose=True, temperature=0)\n",
+    "resp = chat([HumanMessage(content=\"Write me a song about sparkling water.\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67c44deb",
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/examples/vector_db_qa.ipynb

@@ -0,0 +1,169 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "07c1e3b9",
+   "metadata": {},
+   "source": [
+    "# Vector DB Question/Answering\n",
+    "\n",
+    "This example showcases using a chat model to do question answering over a vector database.\n",
+    "\n",
+    "This notebook is very similar to the example of using an LLM in the ChatVectorDBChain. The only differences here are (1) using a ChatModel, and (2) passing in a ChatPromptTemplate (optimized for chat models)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "82525493",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.chains import VectorDBQA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5c7049db",
+   "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": [
+    "from langchain.document_loaders import TextLoader\n",
+    "loader = TextLoader('../../state_of_the_union.txt')\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "texts = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()\n",
+    "docsearch = Chroma.from_documents(texts, embeddings)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35f99145",
+   "metadata": {},
+   "source": [
+    "We can now set up the chat model and chat model specific prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "32a49412",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f231fb9b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_template=\"\"\"Use the following pieces of context to answer the users question. \n",
+    "If you don't know the answer, just say that you don't know, don't try to make up an answer.\n",
+    "----------------\n",
+    "{context}\"\"\"\n",
+    "messages = [\n",
+    "    SystemMessagePromptTemplate.from_template(system_template),\n",
+    "    HumanMessagePromptTemplate.from_template(\"{question}\")\n",
+    "]\n",
+    "prompt = ChatPromptTemplate.from_messages(messages)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3018f865",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain_type_kwargs = {\"prompt\": prompt}\n",
+    "qa = VectorDBQA.from_chain_type(llm=ChatOpenAI(), chain_type=\"stuff\", vectorstore=docsearch, chain_type_kwargs=chain_type_kwargs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "032a47f8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"The President nominated Ketanji Brown Jackson as a Judge for the United States Supreme Court. He described her as one of the nation's top legal minds and a former top litigator in private practice, a former federal public defender, and a consensus builder.\""
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "qa.run(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b403637",
+   "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.9.1"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "b1677b440931f40d89ef8be7bf03acb108ce003de0ac9b18e8d43753ea2e7103"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/examples/vector_db_qa_with_sources.ipynb

@@ -0,0 +1,218 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "efc5be67",
+   "metadata": {},
+   "source": [
+    "# VectorDB Question Answering with Sources\n",
+    "\n",
+    "This notebook goes over how to do question-answering with sources with a chat model over a vector database. It does this by using the `VectorDBQAWithSourcesChain`, which does the lookup of the documents from a vector database. \n",
+    "\n",
+    "This notebook is very similar to the example of using an LLM in the ChatVectorDBChain. The only differences here are (1) using a ChatModel, and (2) passing in a ChatPromptTemplate (optimized for chat models)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1c613960",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.embeddings.cohere import CohereEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch\n",
+    "from langchain.vectorstores import Chroma"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "17d1306e",
+   "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": 3,
+   "id": "0e745d99",
+   "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(texts, embeddings, metadatas=[{\"source\": f\"{i}-pl\"} for i in range(len(texts))])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8aa571ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import VectorDBQAWithSourcesChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f73b14a",
+   "metadata": {},
+   "source": [
+    "We can now set up the chat model and chat model specific prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9643c775",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "ed00e906",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_template=\"\"\"Use the following pieces of context to answer the users question. \n",
+    "If you don't know the answer, just say that you don't know, don't try to make up an answer.\n",
+    "ALWAYS return a \"SOURCES\" part in your answer.\n",
+    "The \"SOURCES\" part should be a reference to the source of the document from which you got your answer.\n",
+    "\n",
+    "Example of your response should be:\n",
+    "\n",
+    "```\n",
+    "The answer is foo\n",
+    "SOURCES: xyz\n",
+    "```\n",
+    "\n",
+    "Begin!\n",
+    "----------------\n",
+    "{summaries}\"\"\"\n",
+    "messages = [\n",
+    "    SystemMessagePromptTemplate.from_template(system_template),\n",
+    "    HumanMessagePromptTemplate.from_template(\"{question}\")\n",
+    "]\n",
+    "prompt = ChatPromptTemplate.from_messages(messages)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "aa859d4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain_type_kwargs = {\"prompt\": prompt}\n",
+    "chain = VectorDBQAWithSourcesChain.from_chain_type(\n",
+    "    ChatOpenAI(temperature=0), \n",
+    "    chain_type=\"stuff\", \n",
+    "    vectorstore=docsearch,\n",
+    "    chain_type_kwargs=chain_type_kwargs\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "8ba36fa7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'answer': 'The President honored Justice Stephen Breyer, an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court, for his dedicated service to the country. \\n',\n",
+       " 'sources': '30-pl'}"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain({\"question\": \"What did the president say about Justice Breyer\"}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c91fdc8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'answer': ' The president honored Justice Stephen Breyer for his service.\\n',\n",
+       " 'sources': '30-pl'}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qa({\"question\": \"What did the president say about Justice Breyer\"}, return_only_outputs=True)"
+   ]
+  }
+ ],
+ "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.9.1"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "b1677b440931f40d89ef8be7bf03acb108ce003de0ac9b18e8d43753ea2e7103"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/getting_started.ipynb

@@ -0,0 +1,380 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e49f1e0d",
+   "metadata": {},
+   "source": [
+    "# Getting Started\n",
+    "\n",
+    "This notebook covers how to get started with chat models. The interface is based around messages rather than raw text."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "522686de",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain import PromptTemplate, LLMChain\n",
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "62e0dbc3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "chat = ChatOpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bbaec18e-3684-4eef-955f-c1cec8bf765d",
+   "metadata": {},
+   "source": [
+    "You can get chat completions by passing one or more messages to the chat model. The response will be a message. The types of messages currently supported in LangChain are `AIMessage`, `HumanMessage`, `SystemMessage`, and `ChatMessage` -- `ChatMessage` takes in an arbitrary role parameter. Most of the time, you'll just be dealing with `HumanMessage`, `AIMessage`, and `SystemMessage`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "76a6e7b0-e927-4bfb-a414-1332a4149106",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"J'aime programmer.\", additional_kwargs={})"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chat([HumanMessage(content=\"Translate this sentence from English to French. I love programming.\")])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a62153d4-1211-411b-a493-3febfe446ae0",
+   "metadata": {},
+   "source": [
+    "OpenAI's chat model supports multiple messages as input. See [here](https://platform.openai.com/docs/guides/chat/chat-vs-completions) for more information. Here is an example of sending a system and user message to the chat model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ce16ad78-8e6f-48cd-954e-98be75eb5836",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"J'aime programmer.\", additional_kwargs={})"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "messages = [\n",
+    "    SystemMessage(content=\"You are a helpful assistant that translates English to French.\"),\n",
+    "    HumanMessage(content=\"Translate this sentence from English to French. I love programming.\")\n",
+    "]\n",
+    "chat(messages)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36dc8d7e-bd25-47ac-8c1b-60e3422603d3",
+   "metadata": {},
+   "source": [
+    "You can go one step further and generate completions for multiple sets of messages using `generate`. This returns an `LLMResult` with an additional `message` parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2b21fc52-74b6-4950-ab78-45d12c68fb4d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LLMResult(generations=[[ChatGeneration(text=\"J'aime programmer.\", generation_info=None, message=AIMessage(content=\"J'aime programmer.\", additional_kwargs={}))], [ChatGeneration(text=\"J'aime l'intelligence artificielle.\", generation_info=None, message=AIMessage(content=\"J'aime l'intelligence artificielle.\", additional_kwargs={}))]], llm_output=None)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "batch_messages = [\n",
+    "    [\n",
+    "        SystemMessage(content=\"You are a helpful assistant that translates English to French.\"),\n",
+    "        HumanMessage(content=\"Translate this sentence from English to French. I love programming.\")\n",
+    "    ],\n",
+    "    [\n",
+    "        SystemMessage(content=\"You are a helpful assistant that translates English to French.\"),\n",
+    "        HumanMessage(content=\"Translate this sentence from English to French. I love artificial intelligence.\")\n",
+    "    ],\n",
+    "]\n",
+    "chat.generate(batch_messages)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b10b00ef-f373-4bc3-8302-2dfc28033734",
+   "metadata": {},
+   "source": [
+    "## PromptTemplates"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "778f912a-66ea-4a5d-b3de-6c7db4baba26",
+   "metadata": {},
+   "source": [
+    "You can make use of templating by using a `MessagePromptTemplate`. You can build a `ChatPromptTemplate` from one or more `MessagePromptTemplates`. You can use `ChatPromptTemplate`'s `format_prompt` -- this returns a `PromptValue`, which you can convert to a string or Message object, depending on whether you want to use the formatted value as input to an llm or chat model.\n",
+    "\n",
+    "For convience, there is a `from_template` method exposed on the template. If you were to use this template, this is what it would look like:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "180c5cc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template=\"You are a helpful assistant that translates {input_language} to {output_language}.\"\n",
+    "system_message_prompt = SystemMessagePromptTemplate.from_template(template)\n",
+    "human_template=\"{text}\"\n",
+    "human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fbb043e6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"J'adore la programmation.\", additional_kwargs={})"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])\n",
+    "\n",
+    "# get a chat completion from the formatted messages\n",
+    "chat(chat_prompt.format_prompt(input_language=\"English\", output_language=\"French\", text=\"I love programming.\").to_messages())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e28b98da",
+   "metadata": {},
+   "source": [
+    "If you wanted to construct the MessagePromptTemplate more directly, you could create a PromptTemplate outside and then pass it in, eg:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d5b1ab1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt=PromptTemplate(\n",
+    "    template=\"You are a helpful assistant that translates {input_language} to {output_language}.\",\n",
+    "    input_variables=[\"input_language\", \"output_language\"],\n",
+    ")\n",
+    "system_message_prompt = SystemMessagePromptTemplate(prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92af0bba",
+   "metadata": {},
+   "source": [
+    "## LLMChain\n",
+    "You can use the existing LLMChain in a very similar way to before - provide a prompt and a model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f2cbfe3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = LLMChain(llm=chat, prompt=chat_prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "268543b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"J'adore la programmation.\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(input_language=\"English\", output_language=\"French\", text=\"I love programming.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb779f3f",
+   "metadata": {},
+   "source": [
+    "## Streaming\n",
+    "\n",
+    "Streaming is supported for `ChatOpenAI` through callback handling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "509181be",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "Verse 1:\n",
+      "Bubbles rising to the top\n",
+      "A refreshing drink that never stops\n",
+      "Clear and crisp, it's pure delight\n",
+      "A taste that's sure to excite\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Verse 2:\n",
+      "No sugar, no calories, just pure bliss\n",
+      "A drink that's hard to resist\n",
+      "It's the perfect way to quench my thirst\n",
+      "A drink that always comes first\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Bridge:\n",
+      "From the mountains to the sea\n",
+      "Sparkling water, you're the key\n",
+      "To a healthy life, a happy soul\n",
+      "A drink that makes me feel whole\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Outro:\n",
+      "Sparkling water, you're the one\n",
+      "A drink that's always so much fun\n",
+      "I'll never let you go, my friend\n",
+      "Sparkling"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.callbacks.base import CallbackManager\n",
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "chat = ChatOpenAI(streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), verbose=True, temperature=0)\n",
+    "resp = chat([HumanMessage(content=\"Write me a song about sparkling water.\")])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c095285d",
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/chat/how_to_guides.rst

@@ -0,0 +1,10 @@
+How-To Guides
+=============
+
+The examples here all address certain "how-to" guides for working with chat models.
+
+.. toctree::
+   :maxdepth: 1
+   :glob:
+
+   ./examples/*

docs/modules/chat/key_concepts.md

@@ -0,0 +1,29 @@
+# Key Concepts
+
+## ChatMessage
+A chat message is what we refer to as the modular unit of information.
+At the moment, this consists of "content", which refers to the content of the chat message.
+At the moment, most chat models are trained to predict sequences of Human <> AI messages.
+This is because so far the primary interaction mode has been between a human user and a singular AI system.
+
+At the moment, there are four different classes of Chat Messages
+
+### HumanMessage
+A HumanMessage is a ChatMessage that is sent as if from a Human's point of view.
+
+### AIMessage
+An AIMessage is a ChatMessage that is sent from the point of view of the AI system to which the Human is corresponding. 
+
+### SystemMessage
+A SystemMessage is still a bit ambiguous, and so far seems to be a concept unique to OpenAI
+
+### ChatMessage
+A chat message is a generic chat message, with not only a "content" field but also a "role" field.
+With this field, arbitrary roles may be assigned to a message.
+
+## ChatGeneration
+The output of a single prediction of a chat message.
+Currently this is just a chat message itself (eg content and a role)
+
+## Chat Model
+A model which takes in a list of chat messages, and predicts a chat message in response.

docs/modules/document_loaders/examples/pdf.ipynb

@@ -104,10 +104,10 @@
       "Efficient Data AnnotationC u s t o m i z e d  M o d e l  T r a i n i n gModel Cust omizationDI A Model HubDI A Pipeline SharingCommunity PlatformLa y out Detection ModelsDocument Images \n",
       "T h e  C o r e  L a y o u t P a r s e r  L i b r a r yOCR ModuleSt or age & VisualizationLa y out Data Structur e\n",
       "Fig. 1: The overall architecture of LayoutParser . For an input document image,\n",
-      "the core LayoutParser library provides a set of o\u000b",
+      "the core LayoutParser library provides a set of o\u000B",
       "-the-shelf tools for layout\n",
       "detection, OCR, visualization, and storage, backed by a carefully designed layout\n",
-      "data structure. LayoutParser also supports high level customization via e\u000ecient\n",
+      "data structure. LayoutParser also supports high level customization via e\u000Ecient\n",
       "layout annotation and model training functions. These improve model accuracy\n",
       "on the target samples. The community platform enables the easy sharing of DIA\n",
       "models and whole digitization pipelines to promote reusability and reproducibility.\n",
@@ -128,10 +128,10 @@
       "gure layouts) and\n",
       "HJDataset [31](historical Japanese document layouts). A spectrum of models\n",
       "trained on these datasets are currently available in the LayoutParser model zoo\n",
-      "to support di\u000b",
+      "to support di\u000B",
       "erent use cases.\n",
       "3 The Core LayoutParser Library\n",
-      "At the core of LayoutParser is an o\u000b",
+      "At the core of LayoutParser is an o\u000B",
       "-the-shelf toolkit that streamlines DL-\n",
       "based document image analysis. Five components support a simple interface\n",
       "with comprehensive functionalities: 1) The layout detection models enable using\n",
@@ -266,13 +266,87 @@
     "data = loader.load()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Using PyMuPDF\n",
+    "\n",
+    "This is the fastest of the PDF parsing options, and contains detailed metadata about the PDF and its pages, as well as returns one document per page."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import PyMuPDFLoader"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "outputs": [],
+   "source": [
+    "loader = PyMuPDFLoader(\"example_data/layout-parser-paper.pdf\")"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "outputs": [],
+   "source": [
+    "data = loader.load()"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "Document(page_content='LayoutParser: A Unified Toolkit for Deep\\nLearning Based Document Image Analysis\\nZejiang Shen1 (<28>), Ruochen Zhang2, Melissa Dell3, Benjamin Charles Germain\\nLee4, Jacob Carlson3, and Weining Li5\\n1 Allen Institute for AI\\nshannons@allenai.org\\n2 Brown University\\nruochen zhang@brown.edu\\n3 Harvard University\\n{melissadell,jacob carlson}@fas.harvard.edu\\n4 University of Washington\\nbcgl@cs.washington.edu\\n5 University of Waterloo\\nw422li@uwaterloo.ca\\nAbstract. Recent advances in document image analysis (DIA) have been\\nprimarily driven by the application of neural networks. Ideally, research\\noutcomes could be easily deployed in production and extended for further\\ninvestigation. However, various factors like loosely organized codebases\\nand sophisticated model configurations complicate the easy reuse of im-\\nportant innovations by a wide audience. Though there have been on-going\\nefforts to improve reusability and simplify deep learning (DL) model\\ndevelopment in disciplines like natural language processing and computer\\nvision, none of them are optimized for challenges in the domain of DIA.\\nThis represents a major gap in the existing toolkit, as DIA is central to\\nacademic research across a wide range of disciplines in the social sciences\\nand humanities. This paper introduces LayoutParser, an open-source\\nlibrary for streamlining the usage of DL in DIA research and applica-\\ntions. The core LayoutParser library comes with a set of simple and\\nintuitive interfaces for applying and customizing DL models for layout de-\\ntection, character recognition, and many other document processing tasks.\\nTo promote extensibility, LayoutParser also incorporates a community\\nplatform for sharing both pre-trained models and full document digiti-\\nzation pipelines. We demonstrate that LayoutParser is helpful for both\\nlightweight and large-scale digitization pipelines in real-word use cases.\\nThe library is publicly available at https://layout-parser.github.io.\\nKeywords: Document Image Analysis · Deep Learning · Layout Analysis\\n· Character Recognition · Open Source library · Toolkit.\\n1\\nIntroduction\\nDeep Learning(DL)-based approaches are the state-of-the-art for a wide range of\\ndocument image analysis (DIA) tasks including document image classification [11,\\narXiv:2103.15348v2  [cs.CV]  21 Jun 2021\\n', lookup_str='', metadata={'file_path': 'example_data/layout-parser-paper.pdf', 'page_number': 1, 'total_pages': 16, 'format': 'PDF 1.5', 'title': '', 'author': '', 'subject': '', 'keywords': '', 'creator': 'LaTeX with hyperref', 'producer': 'pdfTeX-1.40.21', 'creationDate': 'D:20210622012710Z', 'modDate': 'D:20210622012710Z', 'trapped': '', 'encryption': None}, lookup_index=0)"
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data[0]"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Additionally, you can pass along any of the options from the [PyMuPDF documentation](https://pymupdf.readthedocs.io/en/latest/app1.html#plain-text/) as keyword arguments in the `load` call, and it will be pass along to the `get_text()` call."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "7301c473",
-   "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
   }
  ],
  "metadata": {

docs/modules/indexes/chain_examples/graph_qa.ipynb

@@ -178,16 +178,16 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new GraphQAChain chain...\u001b[0m\n",
+      "\u001B[1m> Entering new GraphQAChain chain...\u001B[0m\n",
       "Entities Extracted:\n",
-      "\u001b[32;1m\u001b[1;3m Intel\u001b[0m\n",
+      "\u001B[32;1m\u001B[1;3m Intel\u001B[0m\n",
       "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3mIntel is going to build $20 billion semiconductor \"mega site\"\n",
+      "\u001B[32;1m\u001B[1;3mIntel is going to build $20 billion semiconductor \"mega site\"\n",
       "Intel is building state-of-the-art factories\n",
       "Intel is creating 10,000 new good-paying jobs\n",
-      "Intel is helping build Silicon Valley\u001b[0m\n",
+      "Intel is helping build Silicon Valley\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {

docs/modules/indexes/chain_examples/summarize.ipynb

@@ -21,7 +21,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 1,
    "id": "e9db25f3",
    "metadata": {},
    "outputs": [],
@@ -81,17 +81,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 7,
    "id": "5cfa89b2",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "\" In response to Russia's aggression in Ukraine, the United States and its allies have imposed economic sanctions and are taking other measures to hold Putin accountable. The US is also providing economic and military assistance to Ukraine, protecting NATO countries, and investing in American products to create jobs. President Biden and Vice President Harris have passed the American Rescue Plan and the Bipartisan Infrastructure Law to help working people and rebuild America.\""
+       "' In response to Russian aggression in Ukraine, the United States and its allies are taking action to hold Putin accountable, including economic sanctions, asset seizures, and military assistance. The US is also providing economic and humanitarian aid to Ukraine, and has passed the American Rescue Plan and the Bipartisan Infrastructure Law to help struggling families and create jobs. The US remains unified and determined to protect Ukraine and the free world.'"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -470,7 +470,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   },
   "vscode": {
    "interpreter": {

docs/modules/indexes/chain_examples/vector_db_qa_with_sources.ipynb

@@ -21,7 +21,7 @@
     "from langchain.embeddings.cohere import CohereEmbeddings\n",
     "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch\n",
-    "from langchain.vectorstores import Chromaoma"
+    "from langchain.vectorstores import Chroma"
    ]
   },
   {
@@ -215,4 +215,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

docs/modules/indexes/examples/embeddings.ipynb

@@ -463,6 +463,64 @@
    "source": [
     "query_result = embeddings.embed_query(text)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9c02c78",
+   "metadata": {},
+   "source": [
+    "## Fake Embeddings\n",
+    "\n",
+    "LangChain also provides a fake embedding class. You can use this to test your pipelines."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2ffc2e4b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import FakeEmbeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "80777571",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embeddings = FakeEmbeddings(size=1352)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3ec9d8f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query_result = embeddings.embed_query(\"foo\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3b9ae9e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "doc_results = embeddings.embed_documents([\"foo\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88d366bd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -481,7 +539,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   },
   "vscode": {
    "interpreter": {

docs/modules/indexes/examples/textsplitter.ipynb

@@ -43,7 +43,7 @@
    "metadata": {},
    "source": [
     "## Generic Recursive Text Splitting\n",
-    "This text splitter is the recommended one for generic text. It is parameterized by a list of characters. It tries to split on them in order until the chunks are small enough. The default list is `[\"\\n\\n\", \"\\n\", \" \", \"\"]`. This has the affect of trying to keep all paragraphs (and then sentences, and then words) together as long as possible, as those would generically seem to be the strongest semantically related pieces of text.\n",
+    "This text splitter is the recommended one for generic text. It is parameterized by a list of characters. It tries to split on them in order until the chunks are small enough. The default list is `[\"\\n\\n\", \"\\n\", \" \", \"\"]`. This has the effect of trying to keep all paragraphs (and then sentences, and then words) together as long as possible, as those would generically seem to be the strongest semantically related pieces of text.\n",
     "\n",
     "\n",
     "1. How the text is split: by list of characters\n",

docs/modules/indexes/examples/vectorstores.ipynb

@@ -11,7 +11,7 @@
    "source": [
     "#  VectorStores\n",
     "\n",
-    "This notebook showcases basic functionality related to VectorStores. A key part of working with vectorstores is creating the vector to put in them, which is usually created via embeddings. Therefor, it is recommended that you familiarize yourself with the [embedding notebook](embeddings.ipynb) before diving into this.\n",
+    "This notebook showcases basic functionality related to VectorStores. A key part of working with vectorstores is creating the vector to put in them, which is usually created via embeddings. Therefore, it is recommended that you familiarize yourself with the [embedding notebook](embeddings.ipynb) before diving into this.\n",
     "\n",
     "This covers generic high level functionality related to all vector stores. For guides on specific vectorstores, please see the how-to guides [here](../how_to_guides.rst)"
    ]

docs/modules/indexes/vectorstore_examples/chroma.ipynb

@@ -89,6 +89,46 @@
     "print(docs[0].page_content)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "18152965",
+   "metadata": {},
+   "source": [
+    "## Similarity search with score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "72aaa9c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs = db.similarity_search_with_score(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d88e958e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(Document(page_content='In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections. \\n\\nWe cannot let this happen. \\n\\nTonight. 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. \\n\\nTonight, 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\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd 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.', lookup_str='', metadata={'source': '../../state_of_the_union.txt'}, lookup_index=0),\n",
+       " 0.3913410007953644)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[0]"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "8061454b",

docs/modules/llms/async_llm.ipynb

@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "f6574496-b360-4ffa-9523-7fd34a590164",
    "metadata": {},
@@ -10,14 +9,14 @@
     "\n",
     "LangChain provides async support for LLMs by leveraging the [asyncio](https://docs.python.org/3/library/asyncio.html) library.\n",
     "\n",
-    "Async support is particularly useful for calling multiple LLMs concurrently, as these calls are network-bound. Currently, only `OpenAI` and `PromptLayerOpenAI` is supported, but async support for other LLMs is on the roadmap.\n",
+    "Async support is particularly useful for calling multiple LLMs concurrently, as these calls are network-bound. Currently, only `OpenAI` and `PromptLayerOpenAI` are supported, but async support for other LLMs is on the roadmap.\n",
     "\n",
     "You can use the `agenerate` method to call an OpenAI LLM asynchronously."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
    "id": "5e49e96c-0f88-466d-b3d3-ea0966bdf19e",
    "metadata": {
     "tags": []
@@ -29,7 +28,13 @@
      "text": [
       "\n",
       "\n",
-      "I'm doing well. How about you?\n",
+      "I'm doing well, thank you. How about you?\n",
+      "\n",
+      "\n",
+      "I'm doing well, thank you. How about you?\n",
+      "\n",
+      "\n",
+      "I'm doing well, how about you?\n",
       "\n",
       "\n",
       "I'm doing well, thank you. How about you?\n",
@@ -38,55 +43,50 @@
       "I'm doing well, thank you. How about you?\n",
       "\n",
       "\n",
-      "I'm doing well, thank you. How about you?\n",
+      "I'm doing well, thank you. How about yourself?\n",
       "\n",
-      "I am doing quite well. How about you?\n",
+      "\n",
+      "I'm doing well, thank you! How about you?\n",
       "\n",
       "\n",
       "I'm doing well, thank you. How about you?\n",
       "\n",
       "\n",
-      "I'm doing great, thank you! How about you?\n",
+      "I'm doing well, thank you! How about you?\n",
+      "\n",
+      "\n",
+      "I'm doing well, thank you. How about you?\n",
+      "\u001b[1mConcurrent executed in 1.39 seconds.\u001b[0m\n",
+      "\n",
+      "\n",
+      "I'm doing well, thank you. How about you?\n",
+      "\n",
+      "\n",
+      "I'm doing well, thank you. How about you?\n",
+      "\n",
+      "I'm doing well, thank you. How about you?\n",
+      "\n",
+      "\n",
+      "I'm doing well, thank you. How about you?\n",
+      "\n",
+      "\n",
+      "I'm doing well, thank you. How about yourself?\n",
       "\n",
       "\n",
       "I'm doing well, thanks for asking. How about you?\n",
       "\n",
       "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\u001b[1mConcurrent executed in 1.93 seconds.\u001b[0m\n",
+      "I'm doing well, thanks! How about you?\n",
       "\n",
       "\n",
       "I'm doing well, thank you. How about you?\n",
       "\n",
       "\n",
-      "I'm doing well, thank you. How about you?\n",
+      "I'm doing well, thank you. How about yourself?\n",
       "\n",
       "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "\n",
-      "I'm doing well, thank you. How about you?\n",
-      "\n",
-      "\n",
-      "I'm doing great, thank you. How about you?\n",
-      "\u001b[1mSerial executed in 10.54 seconds.\u001b[0m\n"
+      "I'm doing well, thanks for asking. How about you?\n",
+      "\u001b[1mSerial executed in 5.77 seconds.\u001b[0m\n"
      ]
     }
    ],
@@ -125,6 +125,14 @@
     "elapsed = time.perf_counter() - s\n",
     "print('\\033[1m' + f\"Serial executed in {elapsed:0.2f} seconds.\" + '\\033[0m')"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e1d3a966-3a27-44e8-9441-ed72f01b86f4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -143,7 +151,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/llms/examples/fake_llm.ipynb

@@ -80,14 +80,14 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mAction: Python REPL\n",
-      "Action Input: print(2 + 2)\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3m4\n",
-      "\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mFinal Answer: 4\u001b[0m\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mAction: Python REPL\n",
+      "Action Input: print(2 + 2)\u001B[0m\n",
+      "Observation: \u001B[36;1m\u001B[1;3m4\n",
+      "\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3mFinal Answer: 4\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {

docs/modules/llms/examples/llm_serialization.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# LLM Serialization\n",
     "\n",
-    "This notebook walks how to write and read an LLM Configuration to and from disk. This is useful if you want to save the configuration for a given LLM (eg the provider, the temperature, etc)."
+    "This notebook walks through how to write and read an LLM Configuration to and from disk. This is useful if you want to save the configuration for a given LLM (e.g., the provider, the temperature, etc)."
    ]
   },
   {

docs/modules/llms/integrations.rst

@@ -31,13 +31,13 @@ The examples here are all "how-to" guides for how to integrate with various LLM
 
 `Forefront AI <./integrations/forefrontai_example.html>`_: Covers how to utilize the Forefront AI wrapper.
 
-`PromptLayer OpenAI <./integrations/promptlayer_openai.html>`_: Covers how to use `PromptLayer <https://promptlayer.com>`_ with Langchain.
+`PromptLayer OpenAI <./integrations/promptlayer_openai.html>`_: Covers how to use `PromptLayer <https://promptlayer.com>`_ with LangChain.
 
-`Anthropic <./integrations/anthropic_example.html>`_: Covers how to use Anthropic models with Langchain.
+`Anthropic <./integrations/anthropic_example.html>`_: Covers how to use Anthropic models with LangChain.
 
 `DeepInfra <./integrations/deepinfra_example.html>`_: Covers how to utilize the DeepInfra wrapper.
 
-`Self-Hosted Models (via Runhouse) <./integrations/self_hosted_examples.html>`_: Covers how to run models on existing or on-demand remote compute with Langchain.
+`Self-Hosted Models (via Runhouse) <./integrations/self_hosted_examples.html>`_: Covers how to run models on existing or on-demand remote compute with LangChain.
 
 
 .. toctree::

docs/modules/llms/integrations/openai.ipynb

@@ -76,19 +76,11 @@
     "\n",
     "llm_chain.run(question)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4797d719",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.9.12 ('palm')",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -102,7 +94,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.9.1"
   },
   "vscode": {
    "interpreter": {

docs/modules/llms/key_concepts.md

@@ -2,9 +2,9 @@
 
 ## LLMs
 Wrappers around Large Language Models (in particular, the "generate" ability of large language models) are at the core of LangChain functionality.
-The core method that these classes expose is a `generate` method, which takes in a list of strings and returns an LLMResult (which contains outputs for all input strings).
-Read more about LLMResult. This interface operates over a list of strings because often the lists of strings can be batched to the LLM provider,
-providing speed and efficiency gains.
+The core method that these classes expose is a `generate` method, which takes in a list of strings and returns an LLMResult (which contains outputs for all input strings). Read more about [LLMResult](#llmresult). 
+
+This interface operates over a list of strings because often the lists of strings can be batched to the LLM provider, providing speed and efficiency gains.
 For convenience, this class also exposes a simpler, more user friendly interface (via `__call__`). 
 The interface for this takes in a single string, and returns a single string.
 

docs/modules/llms/streaming_llm.ipynb

@@ -7,12 +7,12 @@
    "source": [
     "# Streaming with LLMs\n",
     "\n",
-    "LangChain provides streaming support for LLMs. Currently, we only support streaming for the `OpenAI` LLM implementation, but streaming support for other LLM implementations is on the roadmap. To utilize streaming, use a [`CallbackHandler`](https://github.com/hwchase17/langchain/blob/master/langchain/callbacks/base.py) that implements `on_llm_new_token`. In this example, we are using [`StreamingStdOutCallbackHandler`]()."
+    "LangChain provides streaming support for LLMs. Currently, we only support streaming for the `OpenAI` and `ChatOpenAI` LLM implementation, but streaming support for other LLM implementations is on the roadmap. To utilize streaming, use a [`CallbackHandler`](https://github.com/hwchase17/langchain/blob/master/langchain/callbacks/base.py) that implements `on_llm_new_token`. In this example, we are using [`StreamingStdOutCallbackHandler`]()."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 2,
    "id": "4ac0ff54-540a-4f2b-8d9a-b590fec7fe07",
    "metadata": {
     "tags": []
@@ -27,45 +27,47 @@
       "Verse 1\n",
       "I'm sippin' on sparkling water,\n",
       "It's so refreshing and light,\n",
-      "It's the perfect way to quench my thirst,\n",
+      "It's the perfect way to quench my thirst\n",
       "On a hot summer night.\n",
       "\n",
       "Chorus\n",
       "Sparkling water, sparkling water,\n",
       "It's the best way to stay hydrated,\n",
-      "It's so refreshing and light,\n",
-      "It's the perfect way to stay alive.\n",
+      "It's so crisp and so clean,\n",
+      "It's the perfect way to stay refreshed.\n",
       "\n",
       "Verse 2\n",
       "I'm sippin' on sparkling water,\n",
       "It's so bubbly and bright,\n",
-      "It's the perfect way to cool me down,\n",
+      "It's the perfect way to cool me down\n",
       "On a hot summer night.\n",
       "\n",
       "Chorus\n",
       "Sparkling water, sparkling water,\n",
       "It's the best way to stay hydrated,\n",
-      "It's so refreshing and light,\n",
-      "It's the perfect way to stay alive.\n",
+      "It's so crisp and so clean,\n",
+      "It's the perfect way to stay refreshed.\n",
       "\n",
       "Verse 3\n",
       "I'm sippin' on sparkling water,\n",
-      "It's so crisp and clean,\n",
-      "It's the perfect way to keep me going,\n",
-      "On a hot summer day.\n",
+      "It's so light and so clear,\n",
+      "It's the perfect way to keep me cool\n",
+      "On a hot summer night.\n",
       "\n",
       "Chorus\n",
       "Sparkling water, sparkling water,\n",
       "It's the best way to stay hydrated,\n",
-      "It's so refreshing and light,\n",
-      "It's the perfect way to stay alive."
+      "It's so crisp and so clean,\n",
+      "It's the perfect way to stay refreshed."
      ]
     }
    ],
    "source": [
     "from langchain.llms import OpenAI\n",
+    "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.callbacks.base import CallbackManager\n",
     "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "from langchain.schema import HumanMessage\n",
     "\n",
     "\n",
     "llm = OpenAI(streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), verbose=True, temperature=0)\n",
@@ -84,7 +86,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 6,
    "id": "a35373f1-9ee6-4753-a343-5aee749b8527",
    "metadata": {
     "tags": []
@@ -103,10 +105,10 @@
     {
      "data": {
       "text/plain": [
-       "LLMResult(generations=[[Generation(text='\\n\\nQ: What did the fish say when it hit the wall?\\nA: Dam!', generation_info={'finish_reason': 'stop', 'logprobs': None})]], llm_output={'token_usage': {}})"
+       "LLMResult(generations=[[Generation(text='\\n\\nQ: What did the fish say when it hit the wall?\\nA: Dam!', generation_info={'finish_reason': None, 'logprobs': None})]], llm_output={'token_usage': {}})"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -114,6 +116,85 @@
    "source": [
     "llm.generate([\"Tell me a joke.\"])"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a93a4d61-0476-49db-8321-7de92bd74059",
+   "metadata": {},
+   "source": [
+    "Here's an example with `ChatOpenAI`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "22665f16-e05b-473c-a4bd-ad75744ea024",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "Verse 1:\n",
+      "Bubbles rising to the top\n",
+      "A refreshing drink that never stops\n",
+      "Clear and crisp, it's pure delight\n",
+      "A taste that's sure to excite\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Verse 2:\n",
+      "No sugar, no calories, just pure bliss\n",
+      "A drink that's hard to resist\n",
+      "It's the perfect way to quench my thirst\n",
+      "A drink that always comes first\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Bridge:\n",
+      "From the mountains to the sea\n",
+      "Sparkling water, you're the key\n",
+      "To a healthy life, a happy soul\n",
+      "A drink that makes me feel whole\n",
+      "\n",
+      "Chorus:\n",
+      "Sparkling water, oh so fine\n",
+      "A drink that's always on my mind\n",
+      "With every sip, I feel alive\n",
+      "Sparkling water, you're my vibe\n",
+      "\n",
+      "Outro:\n",
+      "Sparkling water, you're the one\n",
+      "A drink that's always so much fun\n",
+      "I'll never let you go, my friend\n",
+      "Sparkling"
+     ]
+    }
+   ],
+   "source": [
+    "chat = ChatOpenAI(streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), verbose=True, temperature=0)\n",
+    "resp = chat([HumanMessage(content=\"Write me a song about sparkling water.\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eadae4ba-9f21-4ec8-845d-dd43b0edc2dc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

docs/modules/memory.rst

@@ -2,18 +2,23 @@ Memory
 ==========================
 
 By default, Chains and Agents are stateless,
-meaning that they treat each incoming query independently.
+meaning that they treat each incoming query independently (as are the underlying LLMs and chat models).
 In some applications (chatbots being a GREAT example) it is highly important
 to remember previous interactions, both at a short term but also at a long term level.
 The concept of “Memory” exists to do exactly that.
 
+LangChain provides memory components in two forms.
+First, LangChain provides helper utilities for managing and manipulating previous chat messages.
+These are designed to be modular and useful regardless of how they are used.
+Secondly, LangChain provides easy ways to incorporate these utilities into chains.
+
 The following sections of documentation are provided:
 
 - `Getting Started <./memory/getting_started.html>`_: An overview of how to get started with different types of memory.
 
 - `Key Concepts <./memory/key_concepts.html>`_: A conceptual guide going over the various concepts related to memory.
 
-- `How-To Guides <./memory/how_to_guides.html>`_: A collection of how-to guides. These highlight how to work with different types of memory, as well as how to customize memory.
+- `How-To Guides <./memory/how_to_guides.html>`_: A collection of how-to guides. These highlight different types of memory, as well as how to use memory in chains.
 
 
 

docs/modules/memory/examples/adding_memory.ipynb

@@ -17,7 +17,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
+    "from langchain.memory import ConversationBufferMemory\n",
     "from langchain import OpenAI, LLMChain, PromptTemplate"
    ]
   },
@@ -167,7 +167,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/examples/adding_memory_chain_multiple_inputs.ipynb

@@ -72,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 1,
    "id": "d3dc4ed5",
    "metadata": {},
    "outputs": [],
@@ -80,7 +80,7 @@
     "from langchain.chains.question_answering import load_qa_chain\n",
     "from langchain.llms import OpenAI\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain.chains.conversation.memory import ConversationBufferMemory"
+    "from langchain.memory import ConversationBufferMemory"
    ]
   },
   {

docs/modules/memory/examples/agent_with_memory.ipynb

@@ -22,13 +22,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 1,
    "id": "8db95912",
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n",
-    "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
+    "from langchain.memory import ConversationBufferMemory\n",
     "from langchain import OpenAI, LLMChain\n",
     "from langchain.utilities import GoogleSearchAPIWrapper"
    ]
@@ -316,7 +316,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/examples/chatgpt_clone.ipynb

@@ -14,7 +14,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "a99acd89",
    "metadata": {},
    "outputs": [
@@ -38,18 +38,17 @@
       "Human: 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",
       "Assistant:\u001b[0m\n",
       "\n",
-      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
       "\n",
       "```\n",
-      "$ pwd\n",
-      "/\n",
+      "/home/user\n",
       "```\n"
      ]
     }
    ],
    "source": [
     "from langchain import OpenAI, ConversationChain, LLMChain, PromptTemplate\n",
-    "from langchain.chains.conversation.memory import ConversationalBufferWindowMemory\n",
+    "from langchain.memory import ConversationBufferWindowMemory\n",
     "\n",
     "\n",
     "template = \"\"\"Assistant is a large language model trained by OpenAI.\n",
@@ -74,7 +73,7 @@
     "    llm=OpenAI(temperature=0), \n",
     "    prompt=prompt, \n",
     "    verbose=True, \n",
-    "    memory=ConversationalBufferWindowMemory(k=2),\n",
+    "    memory=ConversationBufferWindowMemory(k=2),\n",
     ")\n",
     "\n",
     "output = chatgpt_chain.predict(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",
@@ -961,7 +960,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/examples/conversational_agent.ipynb

@@ -20,7 +20,7 @@
    "outputs": [],
    "source": [
     "from langchain.agents import Tool\n",
-    "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
+    "from langchain.memory import ConversationBufferMemory\n",
     "from langchain import OpenAI\n",
     "from langchain.utilities import GoogleSearchAPIWrapper\n",
     "from langchain.agents import initialize_agent"
@@ -272,7 +272,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/examples/conversational_customization.ipynb

@@ -19,7 +19,7 @@
    "source": [
     "from langchain.llms import OpenAI\n",
     "from langchain.chains import ConversationChain\n",
-    "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
+    "from langchain.memory import ConversationBufferMemory\n",
     "\n",
     "\n",
     "llm = OpenAI(temperature=0)"
@@ -379,7 +379,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/examples/custom_memory.ipynb

@@ -25,7 +25,7 @@
    "outputs": [],
    "source": [
     "from langchain import OpenAI, ConversationChain\n",
-    "from langchain.chains.base import Memory\n",
+    "from langchain.schema import BaseMemory\n",
     "from pydantic import BaseModel\n",
     "from typing import List, Dict, Any"
    ]
@@ -71,7 +71,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "class SpacyEntityMemory(Memory, BaseModel):\n",
+    "class SpacyEntityMemory(BaseMemory, BaseModel):\n",
     "    \"\"\"Memory class for storing information about entities.\"\"\"\n",
     "\n",
     "    # Define dictionary to store information about entities.\n",
@@ -290,7 +290,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/examples/multiple_memory.ipynb

@@ -11,7 +11,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 1,
    "id": "7d7de430",
    "metadata": {},
    "outputs": [],
@@ -19,7 +19,8 @@
     "from langchain.llms import OpenAI\n",
     "from langchain.prompts import PromptTemplate\n",
     "from langchain.chains import ConversationChain\n",
-    "from langchain.chains.conversation.memory import ConversationBufferMemory, ConversationSummaryMemory, CombinedMemory\n",
+    "from langchain.memory import ConversationBufferMemory, CombinedMemory, ConversationSummaryMemory\n",
+    "\n",
     "\n",
     "conv_memory = ConversationBufferMemory(\n",
     "    memory_key=\"chat_history_lines\",\n",
@@ -159,7 +160,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/getting_started.ipynb

@@ -7,7 +7,179 @@
    "source": [
     "# Getting Started\n",
     "\n",
-    "This notebook walks through the different types of memory you can use with the `ConversationChain`."
+    "This notebook walks through how LangChain thinks about memory. \n",
+    "\n",
+    "Memory involves keeping a concept of state around throughout a user's interactions with an language model. A user's interactions with a language model are captured in the concept of ChatMessages, so this boils down to ingesting, capturing, transforming and extracting knowledge from a sequence of chat messages. There are many different ways to do this, each of which exists as its own memory type.\n",
+    "\n",
+    "In general, for each type of memory there are two ways to understanding using memory. These are the standalone functions which extract information from a sequence of messages, and then there is the way you can use this type of memory in a chain. \n",
+    "\n",
+    "Memory can return multiple pieces of information (for example, the most recent N messages and a summary of all previous messages). The returned information can either be a string or a list of messages.\n",
+    "\n",
+    "In this notebook, we will walk through the simplest form of memory: \"buffer\" memory, which just involves keeping a buffer of all prior messages. We will show how to use the modular utility functions here, then show how it can be used in a chain (both returning a string as well as a list of messages).\n",
+    "\n",
+    "## ChatMessageHistory\n",
+    "One of the core utility classes underpinning most (if not all) memory modules is the `ChatMessageHistory` class. This is a super lightweight wrapper which exposes convienence methods for saving Human messages, AI messages, and then fetching them all. \n",
+    "\n",
+    "You may want to use this class directly if you are managing memory outside of a chain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "87235cf1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ChatMessageHistory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4404d509",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history = ChatMessageHistory()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "78c1a67b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history.add_user_message(\"hi!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "525ce606",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "history.add_ai_message(\"whats up?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "be030822",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[HumanMessage(content='hi!', additional_kwargs={}),\n",
+       " AIMessage(content='whats up?', additional_kwargs={})]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "history.messages"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c0328fb",
+   "metadata": {},
+   "source": [
+    "## ConversationBufferMemory\n",
+    "\n",
+    "We now show how to use this simple concept in a chain. We first showcase `ConversationBufferMemory` which is just a wrapper around ChatMessageHistory that extracts the messages in a variable.\n",
+    "\n",
+    "We can first extract it as a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a382b160",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationBufferMemory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a280d337",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory()\n",
+    "memory.chat_memory.add_user_message(\"hi!\")\n",
+    "memory.chat_memory.add_ai_message(\"whats up?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1b739c0a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': 'Human: hi!\\nAI: whats up?'}"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "989e9425",
+   "metadata": {},
+   "source": [
+    "We can also get the history as a list of messages"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "798ceb1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(return_messages=True)\n",
+    "memory.chat_memory.add_user_message(\"hi!\")\n",
+    "memory.chat_memory.add_ai_message(\"whats up?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "698688fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': [HumanMessage(content='hi!', additional_kwargs={}),\n",
+       "  AIMessage(content='whats up?', additional_kwargs={})]}"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
    ]
   },
   {
@@ -15,20 +187,19 @@
    "id": "d051c1da",
    "metadata": {},
    "source": [
-    "## ConversationBufferMemory (default)\n",
-    "By default, the `ConversationChain` uses `ConversationBufferMemory`: a simple type of memory that remembers all previous inputs/outputs and adds them to the context that is passed. Let's take a look at using this chain (setting `verbose=True` so we can see the prompt)."
+    "## Using in a chain\n",
+    "Finally, let's take a look at using this in a chain (setting `verbose=True` so we can see the prompt)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 15,
    "id": "54301321",
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain.llms import OpenAI\n",
     "from langchain.chains import ConversationChain\n",
-    "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
     "\n",
     "\n",
     "llm = OpenAI(temperature=0)\n",
@@ -41,7 +212,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 16,
    "id": "ae046bff",
    "metadata": {},
    "outputs": [
@@ -69,7 +240,7 @@
        "\" Hi there! It's nice to meet you. How can I help you today?\""
       ]
      },
-     "execution_count": 2,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -80,7 +251,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 17,
    "id": "d8e2a6ff",
    "metadata": {},
    "outputs": [
@@ -95,7 +266,6 @@
       "\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: I'm doing well! Just having a conversation with an AI.\n",
@@ -110,7 +280,7 @@
        "\" That's great! It's always nice to have a conversation with someone new. What would you like to talk about?\""
       ]
      },
-     "execution_count": 3,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -121,7 +291,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 18,
    "id": "15eda316",
    "metadata": {},
    "outputs": [
@@ -136,7 +306,6 @@
       "\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: I'm doing well! Just having a conversation with an AI.\n",
@@ -144,7 +313,7 @@
       "Human: Tell me about yourself.\n",
       "AI:\u001b[0m\n",
       "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
+      "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
     },
     {
@@ -153,7 +322,7 @@
        "\" 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.\""
       ]
      },
-     "execution_count": 4,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -164,718 +333,16 @@
   },
   {
    "cell_type": "markdown",
-   "id": "4fad9448",
+   "id": "7826c210",
    "metadata": {},
    "source": [
-    "## ConversationSummaryMemory\n",
-    "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.\n",
-    "\n",
-    "Let's walk through an example, again setting `verbose=True` so we can see the prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "f60a2fe8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains.conversation.memory import ConversationSummaryMemory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "b7274f2c",
-   "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 ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?\""
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary = ConversationChain(\n",
-    "    llm=llm, \n",
-    "    memory=ConversationSummaryMemory(llm=OpenAI()),\n",
-    "    verbose=True\n",
-    ")\n",
-    "conversation_with_summary.predict(input=\"Hi, what's up?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "a6b6b88f",
-   "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",
-      "The human greets the AI and the AI responds, saying it is doing well and is currently helping a customer with a technical issue.\n",
-      "Human: Tell me more about it!\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" 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 causes.\""
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"Tell me more about it!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "dad869fe",
-   "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",
-      "\n",
-      "The human greets the AI and the AI responds, saying it is doing well and is currently helping a customer with a technical issue. The customer is having trouble with their computer not connecting to the internet, and the AI is helping them troubleshoot the issue by resetting the router and checking the network settings. They are still looking into other possible causes.\n",
-      "Human: Very cool -- what is the scope of the project?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' The scope of the project is to help the customer troubleshoot the issue with their computer not connecting to the internet. We are currently resetting the router and checking the network settings, and we are looking into other possible causes.'"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"Very cool -- what is the scope of the project?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6eecf9d9",
-   "metadata": {},
-   "source": [
-    "## ConversationBufferWindowMemory\n",
-    "\n",
-    "`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\n",
-    "\n",
-    "Let's walk through an example, again setting `verbose=True` so we can see the prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "2dac7769",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains.conversation.memory import ConversationBufferWindowMemory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "0b9da4cd",
-   "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 ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?\""
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary = ConversationChain(\n",
-    "    llm=llm, \n",
-    "    # We set a low k=2, to only keep the last 2 interactions in memory\n",
-    "    memory=ConversationBufferWindowMemory(k=2), \n",
-    "    verbose=True\n",
-    ")\n",
-    "conversation_with_summary.predict(input=\"Hi, what's up?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "90f73431",
-   "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 currently helping a customer with a technical issue. How about you?\n",
-      "Human: What's their issues?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.\""
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"What's their issues?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "cbb499e7",
-   "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 currently helping a customer with a technical issue. How about you?\n",
-      "Human: What's their issues?\n",
-      "AI:  The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.\n",
-      "Human: Is it going well?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Yes, it's going well so far. We've already identified the problem and are now working on a solution.\""
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"Is it going well?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "0d209cfe",
-   "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: What's their issues?\n",
-      "AI:  The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.\n",
-      "Human: Is it going well?\n",
-      "AI:  Yes, it's going well so far. We've already identified the problem and are now working on a solution.\n",
-      "Human: What's the solution?\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" The solution is to reset the router and reconfigure the settings. We're currently in the process of doing that.\""
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Notice here that the first interaction does not appear.\n",
-    "conversation_with_summary.predict(input=\"What's the solution?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a6d2569f",
-   "metadata": {},
-   "source": [
-    "## ConversationSummaryBufferMemory\n",
-    "\n",
-    "`ConversationSummaryBufferMemory` combines the last 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. Unlike the previous implementation though, it uses token length rather than number of interactions to determine when to flush interactions.\n",
-    "\n",
-    "Let's walk through an example, again setting `verbose=True` so we can see the prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "e583a661",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains.conversation.memory import ConversationSummaryBufferMemory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "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 ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "\" Hi there! I'm doing great. I'm currently helping a customer with a technical issue. How about you?\""
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "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": 16,
-   "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 currently helping a customer with a technical issue. How about you?\n",
-      "Human: Just working on writing some documentation!\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' That sounds like a lot of work. What kind of documentation are you writing?'"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_summary.predict(input=\"Just working on writing some documentation!\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "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",
-      "\n",
-      "The human asked the AI what it was up to, and the AI responded that it was helping a customer with a technical issue.\n",
-      "Human: Just working on writing some documentation!\n",
-      "AI:  That sounds like a lot of work. 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 ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Yes, I have heard of LangChain. It is a blockchain-based language learning platform. Can you tell me more about the documentation you are writing?'"
-      ]
-     },
-     "execution_count": 17,
-     "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": 18,
-   "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",
-      "\n",
-      "The human asked the AI what it was up to, and the AI responded that it was helping a customer with a technical issue. The human then mentioned they were writing documentation for LangChain, a blockchain-based language learning platform, and the AI revealed they had heard of it and asked the human to tell them more about the documentation they were writing.\n",
-      "\n",
-      "Human: Haha nope, although a lot of people confuse it for that\n",
-      "AI:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished ConversationChain chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "' Oh, I see. So, what kind of documentation are you writing for LangChain?'"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We can see here that the summary and the buffer are updated\n",
-    "conversation_with_summary.predict(input=\"Haha nope, although a lot of people confuse it for that\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "44c9933a",
-   "metadata": {},
-   "source": [
-    "## Conversation Knowledge Graph Memory\n",
-    "\n",
-    "This type of memory uses a knowledge graph to recreate memory."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "f71f40ba",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains.conversation.memory import ConversationKGMemory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "b462baf1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\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(\n",
-    "    input_variables=[\"history\", \"input\"], template=template\n",
-    ")\n",
-    "conversation_with_kg = ConversationChain(\n",
-    "    llm=llm, \n",
-    "    verbose=True, \n",
-    "    prompt=prompt,\n",
-    "    memory=ConversationKGMemory(llm=llm)\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "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": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_kg.predict(input=\"Hi, what's up?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "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": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_kg.predict(input=\"My name is James and I'm helping Will. He's an engineer.\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "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": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversation_with_kg.predict(input=\"What do you know about Will?\")"
+    "And that's it for the getting started! There are plenty of different types of memory, check out our examples to see them all"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "8c09a239",
+   "id": "3dd37d93",
    "metadata": {},
    "outputs": [],
    "source": []

docs/modules/memory/how_to_guides.rst

@@ -1,15 +1,41 @@
 How-To Guides
 =============
 
+Types
+-----
+
+The first set of examples all highlight different types of memory.
+
+`Buffer <./types/buffer.html>`_: How to use a type of memory that just keeps previous messages in a buffer.
+
+`Buffer Window <./types/buffer_window.html>`_: How to use a type of memory that keeps previous messages in a buffer but only uses the previous `k` of them.
+
+`Summary <./types/summary.html>`_: How to use a type of memory that summarizes previous messages.
+
+`Summary Buffer <./types/summary_buffer.html>`_: How to use a type of memory that keeps a buffer of messages up to a point, and then summarizes them.
+
+`Entity Memory <./types/entity_summary_memory.html>`_: How to use a type of memory that organizes information by entity.
+
+`Knowledge Graph Memory <./types/kg.html>`_: How to use a type of memory that extracts and organizes information in a knowledge graph
+
+
+.. toctree::
+   :maxdepth: 1
+   :glob:
+   :hidden:
+
+   ./types/*
+
+
+Usage
+-----
+
 The examples here all highlight how to use memory in different ways.
 
 `Adding Memory <./examples/adding_memory.html>`_: How to add a memory component to any single input chain.
 
 `ChatGPT Clone <./examples/chatgpt_clone.html>`_: How to recreate ChatGPT with LangChain prompting + memory components.
 
-`Entity Memory <./examples/entity_summary_memory.html>`_: How to use a type of memory that organizes information by entity.
-
-
 `Adding Memory to Multi-Input Chain <./examples/adding_memory_chain_multiple_inputs.html>`_: How to add a memory component to any multiple input chain.
 
 `Conversational Memory Customization <./examples/conversational_customization.html>`_: How to customize existing conversation memory components.

docs/modules/memory/key_concepts.md

@@ -16,4 +16,4 @@ There are a few different ways to accomplish this:
 A more complex form of memory is remembering information about specific entities in the conversation.
 This is a more direct and organized way of remembering information over time.
 Putting it a more structured form also has the benefit of allowing easy inspection of what is known about specific entities.
-For a guide on how to use this type of memory, see [this notebook](./examples/entity_summary_memory.ipynb).
+For a guide on how to use this type of memory, see [this notebook](types/entity_summary_memory.ipynb).

docs/modules/memory/types/buffer.ipynb

@@ -0,0 +1,285 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "46196aa3",
+   "metadata": {},
+   "source": [
+    "## ConversationBufferMemory\n",
+    "\n",
+    "This notebook shows how to use `ConversationBufferMemory`. This memory allows for storing of messages and then extracts the messages in a variable.\n",
+    "\n",
+    "We can first extract it as a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3bac84f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationBufferMemory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cef35e7f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory()\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"ouput\": \"whats up\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2c9b39af",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': 'Human: hi\\nAI: whats up'}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "567f7c16",
+   "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": 5,
+   "id": "a481a415",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(return_messages=True)\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"ouput\": \"whats up\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "86a56348",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': [HumanMessage(content='hi', additional_kwargs={}),\n",
+       "  AIMessage(content='whats up', additional_kwargs={})]}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d051c1da",
+   "metadata": {},
+   "source": [
+    "## Using in a chain\n",
+    "Finally, let's take a look at using this in a chain (setting `verbose=True` so we can see the prompt)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "54301321",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.chains import ConversationChain\n",
+    "\n",
+    "\n",
+    "llm = OpenAI(temperature=0)\n",
+    "conversation = ConversationChain(\n",
+    "    llm=llm, \n",
+    "    verbose=True, \n",
+    "    memory=ConversationBufferMemory()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ae046bff",
+   "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 chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" Hi there! It's nice to meet you. How can I help you today?\""
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.predict(input=\"Hi there!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "d8e2a6ff",
+   "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 there!\n",
+      "AI:  Hi there! It's nice to meet you. How can I help you today?\n",
+      "Human: I'm doing well! Just having a conversation with an AI.\n",
+      "AI:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" That's great! It's always nice to have a conversation with someone new. What would you like to talk about?\""
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.predict(input=\"I'm doing well! Just having a conversation with an AI.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "15eda316",
+   "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 there!\n",
+      "AI:  Hi there! It's nice to meet you. How can I help you today?\n",
+      "Human: I'm doing well! Just having a conversation with an AI.\n",
+      "AI:  That's great! It's always nice to have a conversation with someone new. What would you like to talk about?\n",
+      "Human: Tell me about yourself.\n",
+      "AI:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" 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.\""
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.predict(input=\"Tell me about yourself.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd0146c2",
+   "metadata": {},
+   "source": [
+    "And that's it for the getting started! There are plenty of different types of memory, check out our examples to see them all"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "447c138d",
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/memory/types/buffer_window.ipynb

@@ -0,0 +1,311 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a20c4e38",
+   "metadata": {},
+   "source": [
+    "## ConversationBufferWindowMemory\n",
+    "\n",
+    "`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\n",
+    "\n",
+    "Let's first explore the basic functionality of this type of memory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1196da3f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationBufferWindowMemory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2dac7769",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferWindowMemory( k=1)\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"ouput\": \"whats up\"})\n",
+    "memory.save_context({\"input\": \"not much you\"}, {\"ouput\": \"not much\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0c034a90",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': 'Human: not much you\\nAI: not much'}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c5cce1d",
+   "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": 8,
+   "id": "9b15b427",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferWindowMemory( k=1, return_messages=True)\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"ouput\": \"whats up\"})\n",
+    "memory.save_context({\"input\": \"not much you\"}, {\"ouput\": \"not much\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3bb47191",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': [HumanMessage(content='not much you', additional_kwargs={}),\n",
+       "  AIMessage(content='not much', additional_kwargs={})]}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a95af04c",
+   "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": 12,
+   "id": "0b9da4cd",
+   "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 currently helping a customer with a technical issue. How about you?\""
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.chains import ConversationChain\n",
+    "conversation_with_summary = ConversationChain(\n",
+    "    llm=OpenAI(temperature=0), \n",
+    "    # We set a low k=2, to only keep the last 2 interactions in memory\n",
+    "    memory=ConversationBufferWindowMemory(k=2), \n",
+    "    verbose=True\n",
+    ")\n",
+    "conversation_with_summary.predict(input=\"Hi, what's up?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "90f73431",
+   "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 currently helping a customer with a technical issue. How about you?\n",
+      "Human: What's their issues?\n",
+      "AI:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.\""
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation_with_summary.predict(input=\"What's their issues?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "cbb499e7",
+   "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 currently helping a customer with a technical issue. How about you?\n",
+      "Human: What's their issues?\n",
+      "AI:  The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.\n",
+      "Human: Is it going well?\n",
+      "AI:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" Yes, it's going well so far. We've already identified the problem and are now working on a solution.\""
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation_with_summary.predict(input=\"Is it going well?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "0d209cfe",
+   "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: What's their issues?\n",
+      "AI:  The customer is having trouble connecting to their Wi-Fi network. I'm helping them troubleshoot the issue and get them connected.\n",
+      "Human: Is it going well?\n",
+      "AI:  Yes, it's going well so far. We've already identified the problem and are now working on a solution.\n",
+      "Human: What's the solution?\n",
+      "AI:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" The solution is to reset the router and reconfigure the settings. We're currently in the process of doing that.\""
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Notice here that the first interaction does not appear.\n",
+    "conversation_with_summary.predict(input=\"What's the solution?\")"
+   ]
+  },
+  {
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/memory/types/entity_summary_memory.ipynb

@@ -6,31 +6,130 @@
    "metadata": {},
    "source": [
     "# Entity Memory\n",
-    "This notebook shows how to work with a memory module that remembers things about specific entities. It extracts information on entities (using LLMs) and builds up its knowledge about that entity over time (also using LLMs)."
+    "This notebook shows how to work with a memory module that remembers things about specific entities. It extracts information on entities (using LLMs) and builds up its knowledge about that entity over time (also using LLMs).\n",
+    "\n",
+    "Let's first walk through using this functionality."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 1,
+   "id": "1bea1181",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.memory import ConversationEntityMemory\n",
+    "llm = OpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "34425079",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationEntityMemory(llm=llm)\n",
+    "_input = {\"input\": \"Deven & Sam are working on a hackathon project\"}\n",
+    "memory.load_memory_variables(_input)\n",
+    "memory.save_context(\n",
+    "    _input,\n",
+    "    {\"ouput\": \" That sounds like a great project! What kind of project are they working on?\"}\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b425642c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'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?',\n",
+       " 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({\"input\": 'who is Sam'})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3bf89b46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationEntityMemory(llm=llm, return_messages=True)\n",
+    "_input = {\"input\": \"Deven & Sam are working on a hackathon project\"}\n",
+    "memory.load_memory_variables(_input)\n",
+    "memory.save_context(\n",
+    "    _input,\n",
+    "    {\"ouput\": \" That sounds like a great project! What kind of project are they working on?\"}\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3e37d126",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': [HumanMessage(content='Deven & Sam are working on a hackathon project', additional_kwargs={}),\n",
+       "  AIMessage(content=' That sounds like a great project! What kind of project are they working on?', additional_kwargs={})],\n",
+       " 'entities': {'Sam': 'Sam is working on a hackathon project with Deven.'}}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({\"input\": 'who is Sam'})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee5ad043",
+   "metadata": {},
+   "source": [
+    "## Using in a chain\n",
+    "Let's now use it in a chain!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
    "id": "13471fbd",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain import OpenAI, ConversationChain\n",
-    "from langchain.chains.conversation.memory import ConversationEntityMemory\n",
-    "from langchain.chains.conversation.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE\n",
+    "from langchain.chains import ConversationChain\n",
+    "from langchain.memory import ConversationEntityMemory\n",
+    "from langchain.memory.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE\n",
     "from pydantic import BaseModel\n",
     "from typing import List, Dict, Any"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 7,
    "id": "183346e2",
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm = OpenAI(temperature=0)\n",
     "conversation = ConversationChain(\n",
     "    llm=llm, \n",
     "    verbose=True,\n",
@@ -41,7 +140,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
    "id": "7eb1460a",
    "metadata": {},
    "outputs": [
@@ -79,7 +178,7 @@
        "' That sounds like a great project! What kind of project are they working on?'"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -90,7 +189,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 9,
+   "id": "0269f513",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'Deven': 'Deven is working on a hackathon project with Sam.',\n",
+       " 'Sam': 'Sam is working on a hackathon project with Deven.'}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.memory.store"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "id": "46324ca8",
    "metadata": {},
    "outputs": [
@@ -129,7 +250,7 @@
        "' That sounds like an interesting project! What kind of memory structures are they trying to add?'"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -140,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 11,
    "id": "ff2ebf6b",
    "metadata": {},
    "outputs": [
@@ -161,7 +282,7 @@
       "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.\n",
       "\n",
       "Context:\n",
-      "{'Deven': 'Deven is working on a hackathon project with Sam to add more complex memory structures to Langchain.', 'Sam': 'Sam is working on a hackathon project with Deven to add more complex memory structures to Langchain.', 'Langchain': 'Langchain is a project that seeks to add more complex memory structures.', 'Key-Value Store': ''}\n",
+      "{'Deven': 'Deven is working on a hackathon project with Sam, attempting 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': ''}\n",
       "\n",
       "Current conversation:\n",
       "Human: Deven & Sam are working on a hackathon project\n",
@@ -181,7 +302,7 @@
        "' That sounds like a great idea! How will the key-value store work?'"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -192,7 +313,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 12,
    "id": "56cfd4ba",
    "metadata": {},
    "outputs": [
@@ -213,7 +334,7 @@
       "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.\n",
       "\n",
       "Context:\n",
-      "{'Deven': 'Deven is working on a hackathon project with Sam 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 to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.'}\n",
+      "{'Deven': 'Deven is working on a hackathon project with Sam, attempting 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.'}\n",
       "\n",
       "Current conversation:\n",
       "Human: Deven & Sam are working on a hackathon project\n",
@@ -232,10 +353,10 @@
     {
      "data": {
       "text/plain": [
-       "' Deven and Sam are working on a hackathon project 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 very motivated and passionate about their project, and are working hard to make it a success.'"
+       "' Deven and Sam are working on a hackathon project together, attempting to add more complex memory structures to Langchain, including a key-value store for entities mentioned so far in the conversation.'"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -263,19 +384,17 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'Deven': 'Deven is working on a hackathon project with Sam to add more '\n",
-      "          'complex memory structures to Langchain, including a key-value store '\n",
-      "          'for entities mentioned so far in the conversation.',\n",
-      " 'Key-Value Store': 'Key-Value Store: A data structure that stores values '\n",
-      "                    'associated with a unique key, allowing for efficient '\n",
-      "                    'retrieval of values. Deven and Sam are adding a key-value '\n",
-      "                    'store for entities mentioned so far in the conversation.',\n",
-      " 'Langchain': 'Langchain is a project that seeks to add more complex memory '\n",
-      "              'structures, including a key-value store for entities mentioned '\n",
-      "              'so far in the conversation.',\n",
-      " 'Sam': 'Sam is working on a hackathon project with Deven to add more complex '\n",
-      "        'memory structures to Langchain, including a key-value store for '\n",
-      "        'entities mentioned so far in the conversation.'}\n"
+      "{'Deven': 'Deven is working on a hackathon project with Sam, attempting to add '\n",
+      "          'more complex memory structures to Langchain, including a key-value '\n",
+      "          'store for entities mentioned so far in the conversation.',\n",
+      " 'Key-Value Store': 'A key-value store that stores entities mentioned in the '\n",
+      "                    'conversation.',\n",
+      " 'Langchain': 'Langchain is a project that is trying to add more complex '\n",
+      "              'memory structures, including a key-value store for entities '\n",
+      "              'mentioned so far in the conversation.',\n",
+      " 'Sam': 'Sam is working on a hackathon project with Deven, attempting to add '\n",
+      "        'more complex memory structures to Langchain, including a key-value '\n",
+      "        'store for entities mentioned so far in the conversation.'}\n"
      ]
     }
    ],
@@ -451,7 +570,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/modules/memory/types/kg.ipynb

@@ -0,0 +1,359 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "44c9933a",
+   "metadata": {},
+   "source": [
+    "## Conversation Knowledge Graph Memory\n",
+    "\n",
+    "This type of memory uses a knowledge graph to recreate memory.\n",
+    "\n",
+    "Let's first walk through how to use the utilities"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f71f40ba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationKGMemory\n",
+    "from langchain.llms import OpenAI"
+   ]
+  },
+  {
+   "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\"}, {\"ouput\": \"who is sam\"})\n",
+    "memory.save_context({\"input\": \"sam is a friend\"}, {\"ouput\": \"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\"}, {\"ouput\": \"who is sam\"})\n",
+    "memory.save_context({\"input\": \"sam is a friend\"}, {\"ouput\": \"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",
+    "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.prompts.prompt import PromptTemplate\n",
+    "from langchain.chains import ConversationChain\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(\n",
+    "    input_variables=[\"history\", \"input\"], template=template\n",
+    ")\n",
+    "conversation_with_kg = ConversationChain(\n",
+    "    llm=llm, \n",
+    "    verbose=True, \n",
+    "    prompt=prompt,\n",
+    "    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(input=\"My name is James and I'm helping Will. He's an engineer.\")"
+   ]
+  },
+  {
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/memory/types/summary.ipynb

@@ -0,0 +1,294 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1674bfd6",
+   "metadata": {},
+   "source": [
+    "## ConversationSummaryMemory\n",
+    "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.\n",
+    "\n",
+    "Let's first explore the basic functionality of this type of memory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c5565e5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationSummaryMemory\n",
+    "from langchain.llms import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "61621239",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationSummaryMemory(llm=OpenAI(temperature=0))\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"ouput\": \"whats up\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3bcb8b02",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': '\\nThe human greets the AI, to which the AI responds.'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dedf0698",
+   "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": "6cb06b22",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationSummaryMemory(llm=OpenAI(temperature=0), return_messages=True)\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"ouput\": \"whats up\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "47b03ed7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': [SystemMessage(content='\\nThe human greets the AI, to which the AI responds.', additional_kwargs={})]}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ec0a0ee",
+   "metadata": {},
+   "source": [
+    "We can also utilize the `predict_new_summary` method directly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9c4dafb9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\nThe human greets the AI, to which the AI responds.'"
+      ]
+     },
+     "execution_count": 6,
+     "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": "4fad9448",
+   "metadata": {},
+   "source": [
+    "## Using in a chain\n",
+    "Let's walk through an example of using this in a chain, again setting `verbose=True` so we can see the prompt."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "b7274f2c",
+   "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 currently helping a customer with a technical issue. How about you?\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.chains import ConversationChain\n",
+    "llm = OpenAI(temperature=0)\n",
+    "conversation_with_summary = ConversationChain(\n",
+    "    llm=llm, \n",
+    "    memory=ConversationSummaryMemory(llm=OpenAI()),\n",
+    "    verbose=True\n",
+    ")\n",
+    "conversation_with_summary.predict(input=\"Hi, what's up?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "a6b6b88f",
+   "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",
+      "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.\n",
+      "Human: Tell me more about it!\n",
+      "AI:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" 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.\""
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation_with_summary.predict(input=\"Tell me more about it!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "dad869fe",
+   "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",
+      "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.\n",
+      "Human: Very cool -- what is the scope of the project?\n",
+      "AI:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\" 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.\""
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation_with_summary.predict(input=\"Very cool -- what is the scope of the project?\")"
+   ]
+  },
+  {
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/memory/types/summary_buffer.ipynb

@@ -0,0 +1,322 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ff4be5f3",
+   "metadata": {},
+   "source": [
+    "## ConversationSummaryBufferMemory\n",
+    "\n",
+    "`ConversationSummaryBufferMemory` combines the last 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. Unlike the previous implementation though, 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": "code",
+   "execution_count": 1,
+   "id": "da3384db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationSummaryBufferMemory\n",
+    "from langchain.llms import OpenAI\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\"}, {\"ouput\": \"whats up\"})\n",
+    "memory.save_context({\"input\": \"not much you\"}, {\"ouput\": \"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(llm=llm, max_token_limit=10, return_messages=True)\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"ouput\": \"whats up\"})\n",
+    "memory.save_context({\"input\": \"not much you\"}, {\"ouput\": \"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",
+    "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(input=\"Haha nope, although a lot of people confuse it for that\")"
+   ]
+  },
+  {
+   "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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/prompts/examples/custom_example_selector.md

@@ -1,6 +1,6 @@
 # Create a custom example selector
 
-In this tutorial, we'll create a custom example selector that selects examples every alternate example given a list of examples.
+In this tutorial, we'll create a custom example selector that selects every alternate example from a given list of examples.
 
 An `ExampleSelector` must implement two methods:
 
@@ -65,4 +65,4 @@ example_selector.examples
 # Select examples
 example_selector.select_examples({"foo": "foo"})
 # -> array([{'foo': '1'}, {'foo': '4'}], dtype=object)
-```
+```

docs/modules/prompts/examples/example_prompt.json

@@ -1,4 +1,5 @@
 {
+    "_type": "prompt",
     "input_variables": ["input", "output"],
     "template": "Input: {input}\nOutput: {output}" 
 }

docs/modules/prompts/examples/few_shot_prompt.json

@@ -3,6 +3,7 @@
     "input_variables": ["adjective"],
     "prefix": "Write antonyms for the following words.",
     "example_prompt": {
+        "_type": "prompt",
         "input_variables": ["input", "output"],
         "template": "Input: {input}\nOutput: {output}"
     },

docs/modules/prompts/examples/few_shot_prompt.yaml

@@ -4,6 +4,7 @@ input_variables:
 prefix: 
     Write antonyms for the following words.
 example_prompt:
+    _type: prompt
     input_variables:
         ["input", "output"]
     template:

docs/modules/prompts/examples/few_shot_prompt_examples_in.json

@@ -3,6 +3,7 @@
     "input_variables": ["adjective"],
     "prefix": "Write antonyms for the following words.",
     "example_prompt": {
+        "_type": "prompt",
         "input_variables": ["input", "output"],
         "template": "Input: {input}\nOutput: {output}"
     },

docs/modules/prompts/examples/few_shot_prompt_yaml_examples.yaml

@@ -4,6 +4,7 @@ input_variables:
 prefix: 
     Write antonyms for the following words.
 example_prompt:
+    _type: prompt
     input_variables:
         ["input", "output"]
     template:

docs/modules/prompts/examples/prompt_serialization.ipynb

@@ -58,6 +58,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "_type: prompt\r\n",
       "input_variables:\r\n",
       "    [\"adjective\", \"content\"]\r\n",
       "template: \r\n",
@@ -108,6 +109,7 @@
      "output_type": "stream",
      "text": [
       "{\r\n",
+      "    \"_type\": \"prompt\",\r\n",
       "    \"input_variables\": [\"adjective\", \"content\"],\r\n",
       "    \"template\": \"Tell me a {adjective} joke about {content}.\"\r\n",
       "}\r\n"
@@ -156,6 +158,7 @@
      "output_type": "stream",
      "text": [
       "{\r\n",
+      "    \"_type\": \"prompt\",\r\n",
       "    \"input_variables\": [\"adjective\", \"content\"],\r\n",
       "    \"template_path\": \"simple_template.txt\"\r\n",
       "}\r\n"
@@ -279,6 +282,7 @@
       "prefix: \r\n",
       "    Write antonyms for the following words.\r\n",
       "example_prompt:\r\n",
+      "    _type: prompt\r\n",
       "    input_variables:\r\n",
       "        [\"input\", \"output\"]\r\n",
       "    template:\r\n",
@@ -346,6 +350,7 @@
       "prefix: \r\n",
       "    Write antonyms for the following words.\r\n",
       "example_prompt:\r\n",
+      "    _type: prompt\r\n",
       "    input_variables:\r\n",
       "        [\"input\", \"output\"]\r\n",
       "    template:\r\n",
@@ -413,6 +418,7 @@
       "    \"input_variables\": [\"adjective\"],\r\n",
       "    \"prefix\": \"Write antonyms for the following words.\",\r\n",
       "    \"example_prompt\": {\r\n",
+      "        \"_type\": \"prompt\",\r\n",
       "        \"input_variables\": [\"input\", \"output\"],\r\n",
       "        \"template\": \"Input: {input}\\nOutput: {output}\"\r\n",
       "    },\r\n",
@@ -478,6 +484,7 @@
       "    \"input_variables\": [\"adjective\"],\r\n",
       "    \"prefix\": \"Write antonyms for the following words.\",\r\n",
       "    \"example_prompt\": {\r\n",
+      "        \"_type\": \"prompt\",\r\n",
       "        \"input_variables\": [\"input\", \"output\"],\r\n",
       "        \"template\": \"Input: {input}\\nOutput: {output}\"\r\n",
       "    },\r\n",
@@ -542,6 +549,7 @@
      "output_type": "stream",
      "text": [
       "{\r\n",
+      "    \"_type\": \"prompt\",\r\n",
       "    \"input_variables\": [\"input\", \"output\"],\r\n",
       "    \"template\": \"Input: {input}\\nOutput: {output}\" \r\n",
       "}\r\n"
@@ -622,7 +630,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.11.2"
   },
   "vscode": {
    "interpreter": {

docs/modules/prompts/examples/simple_prompt.json

@@ -1,4 +1,5 @@
 {
+    "_type": "prompt",
     "input_variables": ["adjective", "content"],
     "template": "Tell me a {adjective} joke about {content}."
 }

docs/modules/prompts/examples/simple_prompt.yaml

@@ -1,3 +1,4 @@
+_type: prompt
 input_variables:
     ["adjective", "content"]
 template: 

docs/modules/prompts/examples/simple_prompt_with_template_file.json

@@ -1,4 +1,5 @@
 {
+    "_type": "prompt",
     "input_variables": ["adjective", "content"],
     "template_path": "simple_template.txt"
 }

docs/modules/prompts/getting_started.md

@@ -8,7 +8,7 @@ In this tutorial, we will learn about:
 
 ## What is a prompt template?
 
-A prompt template refers to a reproducible way to generate a prompt. It contains a text string ("the template"), that can can take in a set of parameters from the end user and generate a prompt.
+A prompt template refers to a reproducible way to generate a prompt. It contains a text string ("the template"), that can take in a set of parameters from the end user and generate a prompt.
 
 The prompt template may contain:
 - instructions to the language model,

docs/modules/prompts/key_concepts.md

@@ -62,7 +62,7 @@ To learn more about how to provide few shot examples, see [Few Shot Examples](ex
 
 If there are multiple examples that are relevant to a prompt, it is important to select the most relevant examples. Generally, the quality of the response from the LLM can be significantly improved by selecting the most relevant examples. This is because the language model will be able to better understand the context of the prompt, and also potentially learn failure modes to avoid.
 
-To help the user with selecting the most relevant examples, we provide example selectors that select the most relevant based on different criteria, such as length, semantic similarity, etc. The example selector takes in a list of examples and returns a list of selected examples, formatted as a string. The user can also provide their own example selector. To learn more about example selectors, see [Example Selection](example_selection.md).
+To help the user with selecting the most relevant examples, we provide example selectors that select the most relevant based on different criteria, such as length, semantic similarity, etc. The example selector takes in a list of examples and returns a list of selected examples, formatted as a string. The user can also provide their own example selector. To learn more about example selectors, see [Example Selectors](examples/example_selectors.ipynb).
 
 <!-- TODO(shreya): Add correct link here. -->
 

docs/modules/utils/examples/requests.ipynb

@@ -48,7 +48,7 @@
     }
    ],
    "source": [
-    "requests.run(\"https://www.google.com\")"
+    "requests.get(\"https://www.google.com\")"
    ]
   },
   {

docs/use_cases/evaluation/huggingface_datasets.ipynb

@@ -5,9 +5,9 @@
    "id": "3cadcf88",
    "metadata": {},
    "source": [
-    "# Using HuggingFace Datasets\n",
+    "# Using Hugging Face Datasets\n",
     "\n",
-    "This example shows how to use HuggingFace datasets to evaluate models. Specifically, we show how to load examples to evaluate models on from HuggingFace's dataset package."
+    "This example shows how to use Hugging Face datasets to evaluate models. Specifically, we show how to load examples to evaluate models on from Hugging Face's dataset package."
    ]
   },
   {
@@ -60,7 +60,7 @@
    "source": [
     "## Examples\n",
     "\n",
-    "Now we load a dataset from HuggingFace, and then convert it to a list of dictionaries for easier usage."
+    "Now we load a dataset from Hugging Face, and then convert it to a list of dictionaries for easier usage."
    ]
   },
   {

langchain/agents/agent_toolkits/sql/prompt.py

@@ -2,7 +2,7 @@
 
 SQL_PREFIX = """You are an agent designed to interact with a SQL database.
 Given an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.
-Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.
+Unless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results.
 You can order the results by a relevant column to return the most interesting examples in the database.
 Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
 You have access to tools for interacting with the database.

langchain/agents/initialize.py

@@ -17,12 +17,12 @@ def initialize_agent(
     agent_kwargs: Optional[dict] = None,
     **kwargs: Any,
 ) -> AgentExecutor:
-    """Load agent given tools and LLM.
+    """Load an agent executor given tools and LLM.
 
     Args:
         tools: List of tools this agent has access to.
         llm: Language model to use as the agent.
-        agent: The agent to use. Valid options are:
+        agent: A string that specified the agent type to use. Valid options are:
             `zero-shot-react-description`
             `react-docstore`
             `self-ask-with-search`
@@ -32,10 +32,11 @@ def initialize_agent(
         callback_manager: CallbackManager to use. Global callback manager is used if
             not provided. Defaults to None.
         agent_path: Path to serialized agent to use.
-        **kwargs: Additional key word arguments to pass to the agent.
+        agent_kwargs: Additional key word arguments to pass to the underlying agent
+        **kwargs: Additional key word arguments passed to the agent executor
 
     Returns:
-        An agent.
+        An agent executor
     """
     if agent is None and agent_path is None:
         agent = "zero-shot-react-description"

langchain/chains/__init__.py

@@ -11,6 +11,7 @@ from langchain.chains.llm_bash.base import LLMBashChain
 from langchain.chains.llm_checker.base import LLMCheckerChain
 from langchain.chains.llm_math.base import LLMMathChain
 from langchain.chains.llm_requests import LLMRequestsChain
+from langchain.chains.llm_summarization_checker.base import LLMSummarizationCheckerChain
 from langchain.chains.loading import load_chain
 from langchain.chains.mapreduce import MapReduceChain
 from langchain.chains.moderation import OpenAIModerationChain
@@ -30,6 +31,7 @@ __all__ = [
     "LLMChain",
     "LLMBashChain",
     "LLMCheckerChain",
+    "LLMSummarizationCheckerChain",
     "LLMMathChain",
     "PALChain",
     "QAWithSourcesChain",

langchain/chains/base.py

@@ -5,38 +5,12 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
 import yaml
-from pydantic import BaseModel, Extra, Field, validator
+from pydantic import BaseModel, Field, validator
 
 import langchain
 from langchain.callbacks import get_callback_manager
 from langchain.callbacks.base import BaseCallbackManager
-
-
-class Memory(BaseModel, ABC):
-    """Base interface for memory in chains."""
-
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-        arbitrary_types_allowed = True
-
-    @property
-    @abstractmethod
-    def memory_variables(self) -> List[str]:
-        """Input keys this memory class will load dynamically."""
-
-    @abstractmethod
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-        """Return key-value pairs given the text input to the chain."""
-
-    @abstractmethod
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save the context of this model run to memory."""
-
-    @abstractmethod
-    def clear(self) -> None:
-        """Clear memory contents."""
+from langchain.schema import BaseMemory
 
 
 def _get_verbosity() -> bool:
@@ -46,7 +20,7 @@ def _get_verbosity() -> bool:
 class Chain(BaseModel, ABC):
     """Base interface that all chains should implement."""
 
-    memory: Optional[Memory] = None
+    memory: Optional[BaseMemory] = None
     callback_manager: BaseCallbackManager = Field(
         default_factory=get_callback_manager, exclude=True
     )

langchain/chains/chat_vector_db/base.py

@@ -1,17 +1,17 @@
 """Chain for chatting with a vector database."""
 from __future__ import annotations
 
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 from pydantic import BaseModel
 
 from langchain.chains.base import Chain
-from langchain.chains.chat_vector_db.prompts import CONDENSE_QUESTION_PROMPT, QA_PROMPT
+from langchain.chains.chat_vector_db.prompts import CONDENSE_QUESTION_PROMPT
 from langchain.chains.combine_documents.base import BaseCombineDocumentsChain
 from langchain.chains.llm import LLMChain
 from langchain.chains.question_answering import load_qa_chain
-from langchain.llms.base import BaseLLM
 from langchain.prompts.base import BasePromptTemplate
+from langchain.schema import BaseLanguageModel
 from langchain.vectorstores.base import VectorStore
 
 
@@ -58,10 +58,10 @@ class ChatVectorDBChain(Chain, BaseModel):
     @classmethod
     def from_llm(
         cls,
-        llm: BaseLLM,
+        llm: BaseLanguageModel,
         vectorstore: VectorStore,
         condense_question_prompt: BasePromptTemplate = CONDENSE_QUESTION_PROMPT,
-        qa_prompt: BasePromptTemplate = QA_PROMPT,
+        qa_prompt: Optional[BasePromptTemplate] = None,
         chain_type: str = "stuff",
         **kwargs: Any,
     ) -> ChatVectorDBChain:

langchain/chains/constitutional_ai/base.py

@@ -6,7 +6,7 @@ from langchain.chains.constitutional_ai.models import ConstitutionalPrinciple
 from langchain.chains.constitutional_ai.prompts import CRITIQUE_PROMPT, REVISION_PROMPT
 from langchain.chains.llm import LLMChain
 from langchain.llms.base import BaseLLM
-from langchain.prompts.prompt import BasePromptTemplate
+from langchain.prompts.base import BasePromptTemplate
 
 
 class ConstitutionalChain(Chain):

langchain/chains/conversation/base.py

@@ -3,11 +3,11 @@ from typing import Dict, List
 
 from pydantic import BaseModel, Extra, Field, root_validator
 
-from langchain.chains.base import Memory
-from langchain.chains.conversation.memory import ConversationBufferMemory
 from langchain.chains.conversation.prompt import PROMPT
 from langchain.chains.llm import LLMChain
+from langchain.memory.buffer import ConversationBufferMemory
 from langchain.prompts.base import BasePromptTemplate
+from langchain.schema import BaseMemory
 
 
 class ConversationChain(LLMChain, BaseModel):
@@ -20,7 +20,7 @@ class ConversationChain(LLMChain, BaseModel):
             conversation = ConversationChain(llm=OpenAI())
     """
 
-    memory: Memory = Field(default_factory=ConversationBufferMemory)
+    memory: BaseMemory = Field(default_factory=ConversationBufferMemory)
     """Default memory store."""
     prompt: BasePromptTemplate = PROMPT
     """Default conversation prompt to use."""

langchain/chains/conversation/memory.py

@@ -1,487 +1,21 @@
 """Memory modules for conversation prompts."""
-from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, root_validator
-
-from langchain.chains.base import Memory
-from langchain.chains.conversation.prompt import (
-    ENTITY_EXTRACTION_PROMPT,
-    ENTITY_SUMMARIZATION_PROMPT,
-    KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT,
-    SUMMARY_PROMPT,
-)
-from langchain.chains.llm import LLMChain
-from langchain.graphs.networkx_graph import (
-    NetworkxEntityGraph,
-    get_entities,
-    parse_triples,
-)
-from langchain.llms.base import BaseLLM
-from langchain.prompts.base import BasePromptTemplate
-
-
-def _get_prompt_input_key(inputs: Dict[str, Any], memory_variables: List[str]) -> str:
-    # "stop" is a special key that can be passed as input but is not used to
-    # format the prompt.
-    prompt_input_keys = list(set(inputs).difference(memory_variables + ["stop"]))
-    if len(prompt_input_keys) != 1:
-        raise ValueError(f"One input key expected got {prompt_input_keys}")
-    return prompt_input_keys[0]
-
-
-class CombinedMemory(Memory, BaseModel):
-    """Class for combining multiple memories' data together."""
-
-    memories: List[Memory]
-    """For tracking all the memories that should be accessed."""
-
-    @property
-    def memory_variables(self) -> List[str]:
-        """All the memory variables that this instance provides."""
-        """Collected from the all the linked memories."""
-
-        memory_variables = []
-
-        for memory in self.memories:
-            memory_variables.extend(memory.memory_variables)
-
-        return memory_variables
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-        """Load all vars from sub-memories."""
-        memory_data: Dict[str, Any] = {}
-
-        # Collect vars from all sub-memories
-        for memory in self.memories:
-            data = memory.load_memory_variables(inputs)
-            memory_data = {
-                **memory_data,
-                **data,
-            }
-
-        return memory_data
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save context from this session for every memory."""
-        # Save context for all sub-memories
-        for memory in self.memories:
-            memory.save_context(inputs, outputs)
-
-    def clear(self) -> None:
-        """Clear context from this session for every memory."""
-        for memory in self.memories:
-            memory.clear()
-
-
-class ConversationBufferMemory(Memory, BaseModel):
-    """Buffer for storing conversation memory."""
-
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    """Prefix to use for AI generated responses."""
-    buffer: str = ""
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-    memory_key: str = "history"  #: :meta private:
-
-    @property
-    def memory_variables(self) -> List[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-        """Return history buffer."""
-        return {self.memory_key: self.buffer}
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        if self.input_key is None:
-            prompt_input_key = _get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        if self.output_key is None:
-            if len(outputs) != 1:
-                raise ValueError(f"One output key expected, got {outputs.keys()}")
-            output_key = list(outputs.keys())[0]
-        else:
-            output_key = self.output_key
-        human = f"{self.human_prefix}: " + inputs[prompt_input_key]
-        ai = f"{self.ai_prefix}: " + outputs[output_key]
-        self.buffer += "\n" + "\n".join([human, ai])
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        self.buffer = ""
-
-
-class ConversationBufferWindowMemory(Memory, BaseModel):
-    """Buffer for storing conversation memory."""
-
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    """Prefix to use for AI generated responses."""
-    buffer: List[str] = Field(default_factory=list)
-    memory_key: str = "history"  #: :meta private:
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-    k: int = 5
-
-    @property
-    def memory_variables(self) -> List[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-        """Return history buffer."""
-        return {self.memory_key: "\n".join(self.buffer[-self.k :])}
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        if self.input_key is None:
-            prompt_input_key = _get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        if self.output_key is None:
-            if len(outputs) != 1:
-                raise ValueError(f"One output key expected, got {outputs.keys()}")
-            output_key = list(outputs.keys())[0]
-        else:
-            output_key = self.output_key
-        human = f"{self.human_prefix}: " + inputs[prompt_input_key]
-        ai = f"{self.ai_prefix}: " + outputs[output_key]
-        self.buffer.append("\n".join([human, ai]))
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        self.buffer = []
-
-
-# For legacy naming reasons
-ConversationalBufferWindowMemory = ConversationBufferWindowMemory
-
-
-class ConversationSummaryMemory(Memory, BaseModel):
-    """Conversation summarizer to memory."""
-
-    buffer: str = ""
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    """Prefix to use for AI generated responses."""
-    llm: BaseLLM
-    prompt: BasePromptTemplate = SUMMARY_PROMPT
-    memory_key: str = "history"  #: :meta private:
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-
-    @property
-    def memory_variables(self) -> List[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-        """Return history buffer."""
-        return {self.memory_key: self.buffer}
-
-    @root_validator()
-    def validate_prompt_input_variables(cls, values: Dict) -> Dict:
-        """Validate that prompt input variables are consistent."""
-        prompt_variables = values["prompt"].input_variables
-        expected_keys = {"summary", "new_lines"}
-        if expected_keys != set(prompt_variables):
-            raise ValueError(
-                "Got unexpected prompt input variables. The prompt expects "
-                f"{prompt_variables}, but it should have {expected_keys}."
-            )
-        return values
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        if self.input_key is None:
-            prompt_input_key = _get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        if self.output_key is None:
-            if len(outputs) != 1:
-                raise ValueError(f"One output key expected, got {outputs.keys()}")
-            output_key = list(outputs.keys())[0]
-        else:
-            output_key = self.output_key
-        human = f"{self.human_prefix}: {inputs[prompt_input_key]}"
-        ai = f"{self.ai_prefix}: {outputs[output_key]}"
-        new_lines = "\n".join([human, ai])
-        chain = LLMChain(llm=self.llm, prompt=self.prompt)
-        self.buffer = chain.predict(summary=self.buffer, new_lines=new_lines)
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        self.buffer = ""
-
-
-class ConversationEntityMemory(Memory, BaseModel):
-    """Entity extractor & summarizer to memory."""
-
-    buffer: List[str] = []
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    """Prefix to use for AI generated responses."""
-    llm: BaseLLM
-    entity_extraction_prompt: BasePromptTemplate = ENTITY_EXTRACTION_PROMPT
-    entity_summarization_prompt: BasePromptTemplate = ENTITY_SUMMARIZATION_PROMPT
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-    store: Dict[str, Optional[str]] = {}
-    entity_cache: List[str] = []
-    k: int = 3
-    chat_history_key: str = "history"
-
-    @property
-    def memory_variables(self) -> List[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return ["entities", self.chat_history_key]
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
-        """Return history buffer."""
-        chain = LLMChain(llm=self.llm, prompt=self.entity_extraction_prompt)
-        if self.input_key is None:
-            prompt_input_key = _get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        output = chain.predict(
-            history="\n".join(self.buffer[-self.k :]),
-            input=inputs[prompt_input_key],
-        )
-        if output.strip() == "NONE":
-            entities = []
-        else:
-            entities = [w.strip() for w in output.split(",")]
-        entity_summaries = {}
-        for entity in entities:
-            entity_summaries[entity] = self.store.get(entity, "")
-        self.entity_cache = entities
-        return {
-            self.chat_history_key: "\n".join(self.buffer[-self.k :]),
-            "entities": entity_summaries,
-        }
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        if self.input_key is None:
-            prompt_input_key = _get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        if self.output_key is None:
-            if len(outputs) != 1:
-                raise ValueError(f"One output key expected, got {outputs.keys()}")
-            output_key = list(outputs.keys())[0]
-        else:
-            output_key = self.output_key
-        human = f"{self.human_prefix}: " + inputs[prompt_input_key]
-        ai = f"{self.ai_prefix}: " + outputs[output_key]
-        for entity in self.entity_cache:
-            chain = LLMChain(llm=self.llm, prompt=self.entity_summarization_prompt)
-            # key value store for entity
-            existing_summary = self.store.get(entity, "")
-            output = chain.predict(
-                summary=existing_summary,
-                history="\n".join(self.buffer[-self.k :]),
-                input=inputs[prompt_input_key],
-                entity=entity,
-            )
-            self.store[entity] = output.strip()
-        new_lines = "\n".join([human, ai])
-        self.buffer.append(new_lines)
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        self.buffer = []
-        self.store = {}
-
-
-class ConversationSummaryBufferMemory(Memory, BaseModel):
-    """Buffer with summarizer for storing conversation memory."""
-
-    buffer: List[str] = Field(default_factory=list)
-    max_token_limit: int = 2000
-    moving_summary_buffer: str = ""
-    llm: BaseLLM
-    prompt: BasePromptTemplate = SUMMARY_PROMPT
-    memory_key: str = "history"
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    """Prefix to use for AI generated responses."""
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-
-    @property
-    def memory_variables(self) -> List[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-        """Return history buffer."""
-        if self.moving_summary_buffer == "":
-            return {self.memory_key: "\n".join(self.buffer)}
-        memory_val = self.moving_summary_buffer + "\n" + "\n".join(self.buffer)
-        return {self.memory_key: memory_val}
-
-    @root_validator()
-    def validate_prompt_input_variables(cls, values: Dict) -> Dict:
-        """Validate that prompt input variables are consistent."""
-        prompt_variables = values["prompt"].input_variables
-        expected_keys = {"summary", "new_lines"}
-        if expected_keys != set(prompt_variables):
-            raise ValueError(
-                "Got unexpected prompt input variables. The prompt expects "
-                f"{prompt_variables}, but it should have {expected_keys}."
-            )
-        return values
-
-    def get_num_tokens_list(self, arr: List[str]) -> List[int]:
-        """Get list of number of tokens in each string in the input array."""
-        return [self.llm.get_num_tokens(x) for x in arr]
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        if self.input_key is None:
-            prompt_input_key = _get_prompt_input_key(inputs, self.memory_variables)
-        else:
-            prompt_input_key = self.input_key
-        if self.output_key is None:
-            if len(outputs) != 1:
-                raise ValueError(f"One output key expected, got {outputs.keys()}")
-            output_key = list(outputs.keys())[0]
-        else:
-            output_key = self.output_key
-        human = f"{self.human_prefix}: {inputs[prompt_input_key]}"
-        ai = f"{self.ai_prefix}: {outputs[output_key]}"
-        new_lines = "\n".join([human, ai])
-        self.buffer.append(new_lines)
-        # Prune buffer if it exceeds max token limit
-        curr_buffer_length = sum(self.get_num_tokens_list(self.buffer))
-        if curr_buffer_length > self.max_token_limit:
-            pruned_memory = []
-            while curr_buffer_length > self.max_token_limit:
-                pruned_memory.append(self.buffer.pop(0))
-                curr_buffer_length = sum(self.get_num_tokens_list(self.buffer))
-            chain = LLMChain(llm=self.llm, prompt=self.prompt)
-            self.moving_summary_buffer = chain.predict(
-                summary=self.moving_summary_buffer, new_lines=("\n".join(pruned_memory))
-            )
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        self.buffer = []
-        self.moving_summary_buffer = ""
-
-
-class ConversationKGMemory(Memory, BaseModel):
-    """Knowledge graph memory for storing conversation memory.
-
-    Integrates with external knowledge graph to store and retrieve
-    information about knowledge triples in the conversation.
-    """
-
-    k: int = 2
-    buffer: List[str] = Field(default_factory=list)
-    kg: NetworkxEntityGraph = Field(default_factory=NetworkxEntityGraph)
-    knowledge_extraction_prompt: BasePromptTemplate = KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT
-    entity_extraction_prompt: BasePromptTemplate = ENTITY_EXTRACTION_PROMPT
-    llm: BaseLLM
-    """Number of previous utterances to include in the context."""
-    human_prefix: str = "Human"
-    ai_prefix: str = "AI"
-    """Prefix to use for AI generated responses."""
-    output_key: Optional[str] = None
-    input_key: Optional[str] = None
-    memory_key: str = "history"  #: :meta private:
-
-    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
-        """Return history buffer."""
-        entities = self._get_current_entities(inputs)
-        summaries = {}
-        for entity in entities:
-            knowledge = self.kg.get_entity_knowledge(entity)
-            if knowledge:
-                summaries[entity] = ". ".join(knowledge) + "."
-        if summaries:
-            summary_strings = [
-                f"On {entity}: {summary}" for entity, summary in summaries.items()
-            ]
-            context_str = "\n".join(summary_strings)
-        else:
-            context_str = ""
-        return {self.memory_key: context_str}
-
-    @property
-    def memory_variables(self) -> List[str]:
-        """Will always return list of memory variables.
-
-        :meta private:
-        """
-        return [self.memory_key]
-
-    def _get_prompt_input_key(self, inputs: Dict[str, Any]) -> str:
-        """Get the input key for the prompt."""
-        if self.input_key is None:
-            return _get_prompt_input_key(inputs, self.memory_variables)
-        return self.input_key
-
-    def _get_prompt_output_key(self, outputs: Dict[str, Any]) -> str:
-        """Get the output key for the prompt."""
-        if self.output_key is None:
-            if len(outputs) != 1:
-                raise ValueError(f"One output key expected, got {outputs.keys()}")
-            return list(outputs.keys())[0]
-        return self.output_key
-
-    def _get_current_entities(self, inputs: Dict[str, Any]) -> List[str]:
-        """Get the current entities in the conversation."""
-        prompt_input_key = self._get_prompt_input_key(inputs)
-        chain = LLMChain(llm=self.llm, prompt=self.entity_extraction_prompt)
-        output = chain.predict(
-            history="\n".join(self.buffer[-self.k :]),
-            input=inputs[prompt_input_key],
-        )
-        return get_entities(output)
-
-    def _get_and_update_kg(self, inputs: Dict[str, Any]) -> None:
-        """Get and update knowledge graph from the conversation history."""
-        chain = LLMChain(llm=self.llm, prompt=self.knowledge_extraction_prompt)
-        prompt_input_key = self._get_prompt_input_key(inputs)
-        output = chain.predict(
-            history="\n".join(self.buffer[-self.k :]),
-            input=inputs[prompt_input_key],
-            verbose=True,
-        )
-        knowledge = parse_triples(output)
-        for triple in knowledge:
-            self.kg.add_triple(triple)
-
-    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-        """Save context from this conversation to buffer."""
-        self._get_and_update_kg(inputs)
-        prompt_input_key = self._get_prompt_input_key(inputs)
-        output_key = self._get_prompt_output_key(outputs)
-        human = f"{self.human_prefix}: {inputs[prompt_input_key]}"
-        ai = f"{self.ai_prefix}: {outputs[output_key]}"
-        new_lines = "\n".join([human.strip(), ai.strip()])
-        self.buffer.append(new_lines)
-
-    def clear(self) -> None:
-        """Clear memory contents."""
-        return self.kg.clear()
+from langchain.memory.buffer import ConversationBufferMemory
+from langchain.memory.buffer_window import ConversationBufferWindowMemory
+from langchain.memory.combined import CombinedMemory
+from langchain.memory.entity import ConversationEntityMemory
+from langchain.memory.kg import ConversationKGMemory
+from langchain.memory.summary import ConversationSummaryMemory
+from langchain.memory.summary_buffer import ConversationSummaryBufferMemory
+
+# This is only for backwards compatibility.
+
+__all__ = [
+    "ConversationSummaryBufferMemory",
+    "ConversationSummaryMemory",
+    "ConversationKGMemory",
+    "ConversationBufferWindowMemory",
+    "ConversationEntityMemory",
+    "ConversationBufferMemory",
+    "CombinedMemory",
+]

langchain/chains/conversation/prompt.py

@@ -1,4 +1,11 @@
 # flake8: noqa
+from langchain.memory.prompt import (
+    ENTITY_EXTRACTION_PROMPT,
+    ENTITY_MEMORY_CONVERSATION_TEMPLATE,
+    ENTITY_SUMMARIZATION_PROMPT,
+    KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT,
+    SUMMARY_PROMPT,
+)
 from langchain.prompts.prompt import PromptTemplate
 
 _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.
@@ -11,165 +18,13 @@ PROMPT = PromptTemplate(
     input_variables=["history", "input"], template=_DEFAULT_TEMPLATE
 )
 
-_DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE = """You are an assistant to a human, powered by a large language model trained by OpenAI.
+# Only for backwards compatibility
 
-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:
-{entities}
-
-Current conversation:
-{history}
-Last line:
-Human: {input}
-You:"""
-
-ENTITY_MEMORY_CONVERSATION_TEMPLATE = PromptTemplate(
-    input_variables=["entities", "history", "input"],
-    template=_DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE,
-)
-
-_DEFAULT_SUMMARIZER_TEMPLATE = """Progressively summarize the lines of conversation provided, adding onto the previous summary returning a new summary.
-
-EXAMPLE
-Current summary:
-The human asks what the AI thinks of artificial intelligence. The AI thinks artificial intelligence is a force for good.
-
-New lines of conversation:
-Human: Why do you think artificial intelligence is a force for good?
-AI: Because artificial intelligence will help humans reach their full potential.
-
-New summary:
-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.
-END OF EXAMPLE
-
-Current summary:
-{summary}
-
-New lines of conversation:
-{new_lines}
-
-New summary:"""
-SUMMARY_PROMPT = PromptTemplate(
-    input_variables=["summary", "new_lines"], template=_DEFAULT_SUMMARIZER_TEMPLATE
-)
-
-_DEFAULT_ENTITY_EXTRACTION_TEMPLATE = """You are an AI assistant reading the transcript of a conversation between an AI and a human. Extract all of the proper nouns from the last line of conversation. As a guideline, a proper noun is generally capitalized. You should definitely extract all names and places.
-
-The conversation history is provided just in case of a coreference (e.g. "What do you know about him" where "him" is defined in a previous line) -- ignore items mentioned there that are not in the last line.
-
-Return the output as a single comma-separated list, or NONE if there is nothing of note to return (e.g. the user is just issuing a greeting or having a simple conversation).
-
-EXAMPLE
-Conversation history:
-Person #1: how's it going today?
-AI: "It's going great! How about you?"
-Person #1: good! busy working on Langchain. lots to do.
-AI: "That sounds like a lot of work! What kind of things are you doing to make Langchain better?"
-Last line:
-Person #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff.
-Output: Langchain
-END OF EXAMPLE
-
-EXAMPLE
-Conversation history:
-Person #1: how's it going today?
-AI: "It's going great! How about you?"
-Person #1: good! busy working on Langchain. lots to do.
-AI: "That sounds like a lot of work! What kind of things are you doing to make Langchain better?"
-Last line:
-Person #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff. I'm working with Person #2.
-Output: Langchain, Person #2
-END OF EXAMPLE
-
-Conversation history (for reference only):
-{history}
-Last line of conversation (for extraction):
-Human: {input}
-
-Output:"""
-ENTITY_EXTRACTION_PROMPT = PromptTemplate(
-    input_variables=["history", "input"], template=_DEFAULT_ENTITY_EXTRACTION_TEMPLATE
-)
-
-_DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE = """You are an AI assistant helping a human keep track of facts about relevant people, places, and concepts in their life. Update the summary of the provided entity in the "Entity" section based on the last line of your conversation with the human. If you are writing the summary for the first time, return a single sentence.
-The update should only include facts that are relayed in the last line of conversation about the provided entity, and should only contain facts about the provided entity.
-
-If there is no new information about the provided entity or the information is not worth noting (not an important or relevant fact to remember long-term), return the existing summary unchanged.
-
-Full conversation history (for context):
-{history}
-
-Entity to summarize:
-{entity}
-
-Existing summary of {entity}:
-{summary}
-
-Last line of conversation:
-Human: {input}
-Updated summary:"""
-
-ENTITY_SUMMARIZATION_PROMPT = PromptTemplate(
-    input_variables=["entity", "summary", "history", "input"],
-    template=_DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE,
-)
-
-
-KG_TRIPLE_DELIMITER = "<|>"
-_DEFAULT_KNOWLEDGE_TRIPLE_EXTRACTION_TEMPLATE = (
-    "You are a networked intelligence helping a human track knowledge triples"
-    " about all relevant people, things, concepts, etc. and integrating"
-    " them with your knowledge stored within your weights"
-    " as well as that stored in a knowledge graph."
-    " Extract all of the knowledge triples from the last line of conversation."
-    " A knowledge triple is a clause that contains a subject, a predicate,"
-    " and an object. The subject is the entity being described,"
-    " the predicate is the property of the subject that is being"
-    " described, and the object is the value of the property.\n\n"
-    "EXAMPLE\n"
-    "Conversation history:\n"
-    "Person #1: Did you hear aliens landed in Area 51?\n"
-    "AI: No, I didn't hear that. What do you know about Area 51?\n"
-    "Person #1: It's a secret military base in Nevada.\n"
-    "AI: What do you know about Nevada?\n"
-    "Last line of conversation:\n"
-    "Person #1: It's a state in the US. It's also the number 1 producer of gold in the US.\n\n"
-    f"Output: (Nevada, is a, state){KG_TRIPLE_DELIMITER}(Nevada, is in, US)"
-    f"{KG_TRIPLE_DELIMITER}(Nevada, is the number 1 producer of, gold)\n"
-    "END OF EXAMPLE\n\n"
-    "EXAMPLE\n"
-    "Conversation history:\n"
-    "Person #1: Hello.\n"
-    "AI: Hi! How are you?\n"
-    "Person #1: I'm good. How are you?\n"
-    "AI: I'm good too.\n"
-    "Last line of conversation:\n"
-    "Person #1: I'm going to the store.\n\n"
-    "Output: NONE\n"
-    "END OF EXAMPLE\n\n"
-    "EXAMPLE\n"
-    "Conversation history:\n"
-    "Person #1: What do you know about Descartes?\n"
-    "AI: Descartes was a French philosopher, mathematician, and scientist who lived in the 17th century.\n"
-    "Person #1: The Descartes I'm referring to is a standup comedian and interior designer from Montreal.\n"
-    "AI: Oh yes, He is a comedian and an interior designer. He has been in the industry for 30 years. His favorite food is baked bean pie.\n"
-    "Person #1: Oh huh. I know Descartes likes to drive antique scooters and play the mandolin.\n"
-    "Last line of conversation:\n"
-    f"Output: (Descartes, likes to drive, antique scooters){KG_TRIPLE_DELIMITER}(Descartes, plays, mandolin)\n"
-    "END OF EXAMPLE\n\n"
-    "Conversation history (for reference only):\n"
-    "{history}"
-    "\nLast line of conversation (for extraction):\n"
-    "Human: {input}\n\n"
-    "Output:"
-)
-
-KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT = PromptTemplate(
-    input_variables=["history", "input"],
-    template=_DEFAULT_KNOWLEDGE_TRIPLE_EXTRACTION_TEMPLATE,
-)
+__all__ = [
+    "SUMMARY_PROMPT",
+    "ENTITY_MEMORY_CONVERSATION_TEMPLATE",
+    "ENTITY_SUMMARIZATION_PROMPT",
+    "ENTITY_EXTRACTION_PROMPT",
+    "KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT",
+    "PROMPT",
+]

langchain/chains/llm.py

@@ -1,14 +1,15 @@
 """Chain that just formats a prompt and calls an LLM."""
+from __future__ import annotations
+
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
 from pydantic import BaseModel, Extra
 
 from langchain.chains.base import Chain
 from langchain.input import get_colored_text
-from langchain.llms.base import BaseLLM
 from langchain.prompts.base import BasePromptTemplate
 from langchain.prompts.prompt import PromptTemplate
-from langchain.schema import LLMResult
+from langchain.schema import BaseLanguageModel, LLMResult, PromptValue
 
 
 class LLMChain(Chain, BaseModel):
@@ -27,8 +28,7 @@ class LLMChain(Chain, BaseModel):
 
     prompt: BasePromptTemplate
     """Prompt object to use."""
-    llm: BaseLLM
-    """LLM wrapper to use."""
+    llm: BaseLanguageModel
     output_key: str = "text"  #: :meta private:
 
     class Config:
@@ -53,21 +53,22 @@ class LLMChain(Chain, BaseModel):
         """
         return [self.output_key]
 
+    def _call(self, inputs: Dict[str, Any]) -> Dict[str, str]:
+        return self.apply([inputs])[0]
+
     def generate(self, input_list: List[Dict[str, Any]]) -> LLMResult:
         """Generate LLM result from inputs."""
         prompts, stop = self.prep_prompts(input_list)
-        response = self.llm.generate(prompts, stop=stop)
-        return response
+        return self.llm.generate_prompt(prompts, stop)
 
     async def agenerate(self, input_list: List[Dict[str, Any]]) -> LLMResult:
         """Generate LLM result from inputs."""
         prompts, stop = await self.aprep_prompts(input_list)
-        response = await self.llm.agenerate(prompts, stop=stop)
-        return response
+        return await self.llm.agenerate_prompt(prompts, stop)
 
     def prep_prompts(
         self, input_list: List[Dict[str, Any]]
-    ) -> Tuple[List[str], Optional[List[str]]]:
+    ) -> Tuple[List[PromptValue], Optional[List[str]]]:
         """Prepare prompts from inputs."""
         stop = None
         if "stop" in input_list[0]:
@@ -75,8 +76,8 @@ class LLMChain(Chain, BaseModel):
         prompts = []
         for inputs in input_list:
             selected_inputs = {k: inputs[k] for k in self.prompt.input_variables}
-            prompt = self.prompt.format(**selected_inputs)
-            _colored_text = get_colored_text(prompt, "green")
+            prompt = self.prompt.format_prompt(**selected_inputs)
+            _colored_text = get_colored_text(prompt.to_string(), "green")
             _text = "Prompt after formatting:\n" + _colored_text
             self.callback_manager.on_text(_text, end="\n", verbose=self.verbose)
             if "stop" in inputs and inputs["stop"] != stop:
@@ -88,7 +89,7 @@ class LLMChain(Chain, BaseModel):
 
     async def aprep_prompts(
         self, input_list: List[Dict[str, Any]]
-    ) -> Tuple[List[str], Optional[List[str]]]:
+    ) -> Tuple[List[PromptValue], Optional[List[str]]]:
         """Prepare prompts from inputs."""
         stop = None
         if "stop" in input_list[0]:
@@ -96,8 +97,8 @@ class LLMChain(Chain, BaseModel):
         prompts = []
         for inputs in input_list:
             selected_inputs = {k: inputs[k] for k in self.prompt.input_variables}
-            prompt = self.prompt.format(**selected_inputs)
-            _colored_text = get_colored_text(prompt, "green")
+            prompt = self.prompt.format_prompt(**selected_inputs)
+            _colored_text = get_colored_text(prompt.to_string(), "green")
             _text = "Prompt after formatting:\n" + _colored_text
             if self.callback_manager.is_async:
                 await self.callback_manager.on_text(
@@ -130,9 +131,6 @@ class LLMChain(Chain, BaseModel):
             for generation in response.generations
         ]
 
-    def _call(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-        return self.apply([inputs])[0]
-
     async def _acall(self, inputs: Dict[str, Any]) -> Dict[str, str]:
         return (await self.aapply([inputs]))[0]
 
@@ -205,7 +203,7 @@ class LLMChain(Chain, BaseModel):
         return "llm_chain"
 
     @classmethod
-    def from_string(cls, llm: BaseLLM, template: str) -> Chain:
+    def from_string(cls, llm: BaseLanguageModel, template: str) -> Chain:
         """Create LLMChain from LLM and template."""
         prompt_template = PromptTemplate.from_template(template)
         return cls(llm=llm, prompt=prompt_template)

langchain/chains/llm_math/base.py

@@ -62,6 +62,8 @@ class LLMMathChain(Chain, BaseModel):
             answer = "Answer: " + output
         elif t.startswith("Answer:"):
             answer = t
+        elif "Answer:" in t:
+            answer = "Answer: " + t.split("Answer:")[-1]
         else:
             raise ValueError(f"unknown format from LLM: {t}")
         return {self.output_key: answer}

langchain/chains/llm_summarization_checker/__init__.py

@@ -0,0 +1,7 @@
+"""Summarization checker chain for verifying accuracy of text generation.
+
+Chain that tries to verify the accuracy of text generation by splitting it into a
+list of facts, then checking if those facts are true or not, and rewriting
+the text to make it more truth-ful.  It will repeat this loop until it hits `max_tries`
+or gets to a "true" output.
+"""

langchain/chains/llm_summarization_checker/base.py

@@ -0,0 +1,133 @@
+"""Chain for summarization with self-verification."""
+
+from pathlib import Path
+from typing import Dict, List
+
+from pydantic import BaseModel, Extra
+
+from langchain.chains.base import Chain
+from langchain.chains.llm import LLMChain
+from langchain.chains.sequential import SequentialChain
+from langchain.llms.base import BaseLLM
+from langchain.prompts.prompt import PromptTemplate
+
+PROMPTS_DIR = Path(__file__).parent / "prompts"
+
+CREATE_ASSERTIONS_PROMPT = PromptTemplate.from_file(
+    PROMPTS_DIR / "create_facts.txt", ["summary"]
+)
+CHECK_ASSERTIONS_PROMPT = PromptTemplate.from_file(
+    PROMPTS_DIR / "check_facts.txt", ["assertions"]
+)
+REVISED_SUMMARY_PROMPT = PromptTemplate.from_file(
+    PROMPTS_DIR / "revise_summary.txt", ["checked_assertions", "summary"]
+)
+ARE_ALL_TRUE_PROMPT = PromptTemplate.from_file(
+    PROMPTS_DIR / "are_all_true_prompt.txt", ["checked_assertions"]
+)
+
+
+class LLMSummarizationCheckerChain(Chain, BaseModel):
+    """Chain for question-answering with self-verification.
+
+    Example:
+        .. code-block:: python
+
+            from langchain import OpenAI, LLMSummarizationCheckerChain
+            llm = OpenAI(temperature=0.0)
+            checker_chain = LLMSummarizationCheckerChain(llm=llm)
+    """
+
+    llm: BaseLLM
+    """LLM wrapper to use."""
+
+    create_assertions_prompt: PromptTemplate = CREATE_ASSERTIONS_PROMPT
+    check_assertions_prompt: PromptTemplate = CHECK_ASSERTIONS_PROMPT
+    revised_summary_prompt: PromptTemplate = REVISED_SUMMARY_PROMPT
+    are_all_true_prompt: PromptTemplate = ARE_ALL_TRUE_PROMPT
+
+    input_key: str = "query"  #: :meta private:
+    output_key: str = "result"  #: :meta private:
+    max_checks: int = 2
+    """Maximum number of times to check the assertions. Default to double-checking."""
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Return the singular input key.
+
+        :meta private:
+        """
+        return [self.input_key]
+
+    @property
+    def output_keys(self) -> List[str]:
+        """Return the singular output key.
+
+        :meta private:
+        """
+        return [self.output_key]
+
+    def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
+        all_true = False
+        count = 0
+        output = None
+        original_input = inputs[self.input_key]
+        chain_input = original_input
+
+        while not all_true and count < self.max_checks:
+            chain = SequentialChain(
+                chains=[
+                    LLMChain(
+                        llm=self.llm,
+                        prompt=self.create_assertions_prompt,
+                        output_key="assertions",
+                        verbose=self.verbose,
+                    ),
+                    LLMChain(
+                        llm=self.llm,
+                        prompt=self.check_assertions_prompt,
+                        output_key="checked_assertions",
+                        verbose=self.verbose,
+                    ),
+                    LLMChain(
+                        llm=self.llm,
+                        prompt=self.revised_summary_prompt,
+                        output_key="revised_summary",
+                        verbose=self.verbose,
+                    ),
+                    LLMChain(
+                        llm=self.llm,
+                        output_key="all_true",
+                        prompt=self.are_all_true_prompt,
+                        verbose=self.verbose,
+                    ),
+                ],
+                input_variables=["summary"],
+                output_variables=["all_true", "revised_summary"],
+                verbose=self.verbose,
+            )
+            output = chain({"summary": chain_input})
+            count += 1
+
+            if output["all_true"].strip() == "True":
+                break
+
+            if self.verbose:
+                print(output["revised_summary"])
+
+            chain_input = output["revised_summary"]
+
+        if not output:
+            raise ValueError("No output from chain")
+
+        return {self.output_key: output["revised_summary"].strip()}
+
+    @property
+    def _chain_type(self) -> str:
+        return "llm_summarization_checker_chain"

langchain/chains/llm_summarization_checker/prompts/are_all_true_prompt.txt

@@ -0,0 +1,38 @@
+Below are some assertions that have been fact checked and are labeled as true or false.
+
+If all of the assertions are true, return "True". If any of the assertions are false, return "False".
+
+Here are some examples:
+===
+
+Checked Assertions: """
+- The sky is red: False
+- Water is made of lava: False
+- The sun is a star: True
+"""
+Result: False
+
+===
+
+Checked Assertions: """
+- The sky is blue: True
+- Water is wet: True
+- The sun is a star: True
+"""
+Result: True
+
+===
+
+Checked Assertions: """
+- The sky is blue - True
+- Water is made of lava- False
+- The sun is a star - True
+"""
+Result: False
+
+===
+
+Checked Assertions:"""
+{checked_assertions}
+"""
+Result:

langchain/chains/llm_summarization_checker/prompts/check_facts.txt

@@ -0,0 +1,10 @@
+You are an expert fact checker. You have been hired by a major news organization to fact check a very important story.
+
+Here is a bullet point list of facts:
+"""
+{assertions}
+"""
+
+For each fact, determine whether it is true or false about the subject. If you are unable to determine whether the fact is true or false, output "Undetermined".
+If the fact is false, explain why.
+

langchain/chains/llm_summarization_checker/prompts/create_facts.txt

@@ -0,0 +1,10 @@
+Given some text, extract a list of facts from the text.
+
+Format your output as a bulleted list.
+
+Text:
+"""
+{summary}
+"""
+
+Facts:

langchain/chains/llm_summarization_checker/prompts/revise_summary.txt

@@ -0,0 +1,17 @@
+Below are some assertions that have been fact checked and are labeled as true of false.  If the answer is false, a suggestion is given for a correction.
+
+Checked Assertions:
+"""
+{checked_assertions}
+"""
+
+Original Summary:
+"""
+{summary}
+"""
+
+Using these checked assertions, rewrite the original summary to be completely true.
+
+The output should have the same structure and formatting as the original summary.
+
+Summary:

langchain/chains/prompt_selector.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from typing import Callable, List, Tuple
+
+from pydantic import BaseModel, Field
+
+from langchain.chat_models.base import BaseChatModel
+from langchain.llms.base import BaseLLM
+from langchain.prompts.base import BasePromptTemplate
+from langchain.schema import BaseLanguageModel
+
+
+class BasePromptSelector(BaseModel, ABC):
+    @abstractmethod
+    def get_prompt(self, llm: BaseLanguageModel) -> BasePromptTemplate:
+        """Get default prompt for a language model."""
+
+
+class ConditionalPromptSelector(BasePromptSelector):
+    """Prompt collection that goes through conditionals."""
+
+    default_prompt: BasePromptTemplate
+    conditionals: List[
+        Tuple[Callable[[BaseLanguageModel], bool], BasePromptTemplate]
+    ] = Field(default_factory=list)
+
+    def get_prompt(self, llm: BaseLanguageModel) -> BasePromptTemplate:
+        for condition, prompt in self.conditionals:
+            if condition(llm):
+                return prompt
+        return self.default_prompt
+
+
+def is_llm(llm: BaseLanguageModel) -> bool:
+    return isinstance(llm, BaseLLM)
+
+
+def is_chat_model(llm: BaseLanguageModel) -> bool:
+    return isinstance(llm, BaseChatModel)

langchain/chains/qa_with_sources/base.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Extra, root_validator
 
@@ -32,6 +32,8 @@ class BaseQAWithSourcesChain(Chain, BaseModel, ABC):
     input_docs_key: str = "docs"  #: :meta private:
     answer_key: str = "answer"  #: :meta private:
     sources_answer_key: str = "sources"  #: :meta private:
+    return_source_documents: bool = False
+    """Return the source documents."""
 
     @classmethod
     def from_llm(
@@ -62,10 +64,17 @@ class BaseQAWithSourcesChain(Chain, BaseModel, ABC):
 
     @classmethod
     def from_chain_type(
-        cls, llm: BaseLLM, chain_type: str = "stuff", **kwargs: Any
+        cls,
+        llm: BaseLLM,
+        chain_type: str = "stuff",
+        chain_type_kwargs: Optional[dict] = None,
+        **kwargs: Any,
     ) -> BaseQAWithSourcesChain:
         """Load chain from chain type."""
-        combine_document_chain = load_qa_with_sources_chain(llm, chain_type=chain_type)
+        _chain_kwargs = chain_type_kwargs or {}
+        combine_document_chain = load_qa_with_sources_chain(
+            llm, chain_type=chain_type, **_chain_kwargs
+        )
         return cls(combine_documents_chain=combine_document_chain, **kwargs)
 
     class Config:
@@ -88,7 +97,10 @@ class BaseQAWithSourcesChain(Chain, BaseModel, ABC):
 
         :meta private:
         """
-        return [self.answer_key, self.sources_answer_key]
+        _output_keys = [self.answer_key, self.sources_answer_key]
+        if self.return_source_documents:
+            _output_keys = _output_keys + ["source_documents"]
+        return _output_keys
 
     @root_validator(pre=True)
     def validate_naming(cls, values: Dict) -> Dict:
@@ -101,14 +113,20 @@ class BaseQAWithSourcesChain(Chain, BaseModel, ABC):
     def _get_docs(self, inputs: Dict[str, Any]) -> List[Document]:
         """Get docs to run questioning over."""
 
-    def _call(self, inputs: Dict[str, Any]) -> Dict[str, str]:
+    def _call(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
         docs = self._get_docs(inputs)
         answer, _ = self.combine_documents_chain.combine_docs(docs, **inputs)
         if "SOURCES: " in answer:
             answer, sources = answer.split("SOURCES: ")
         else:
             sources = ""
-        return {self.answer_key: answer, self.sources_answer_key: sources}
+        result: Dict[str, Any] = {
+            self.answer_key: answer,
+            self.sources_answer_key: sources,
+        }
+        if self.return_source_documents:
+            result["source_documents"] = docs
+        return result
 
 
 class QAWithSourcesChain(BaseQAWithSourcesChain, BaseModel):

langchain/chains/question_answering/__init__.py

@@ -14,19 +14,21 @@ from langchain.chains.question_answering import (
     refine_prompts,
     stuff_prompt,
 )
-from langchain.llms.base import BaseLLM
 from langchain.prompts.base import BasePromptTemplate
+from langchain.schema import BaseLanguageModel
 
 
 class LoadingCallable(Protocol):
     """Interface for loading the combine documents chain."""
 
-    def __call__(self, llm: BaseLLM, **kwargs: Any) -> BaseCombineDocumentsChain:
+    def __call__(
+        self, llm: BaseLanguageModel, **kwargs: Any
+    ) -> BaseCombineDocumentsChain:
         """Callable to load the combine documents chain."""
 
 
 def _load_map_rerank_chain(
-    llm: BaseLLM,
+    llm: BaseLanguageModel,
     prompt: BasePromptTemplate = map_rerank_prompt.PROMPT,
     verbose: bool = False,
     document_variable_name: str = "context",
@@ -50,15 +52,16 @@ def _load_map_rerank_chain(
 
 
 def _load_stuff_chain(
-    llm: BaseLLM,
-    prompt: BasePromptTemplate = stuff_prompt.PROMPT,
+    llm: BaseLanguageModel,
+    prompt: Optional[BasePromptTemplate] = None,
     document_variable_name: str = "context",
     verbose: Optional[bool] = None,
     callback_manager: Optional[BaseCallbackManager] = None,
     **kwargs: Any,
 ) -> StuffDocumentsChain:
+    _prompt = prompt or stuff_prompt.PROMPT_SELECTOR.get_prompt(llm)
     llm_chain = LLMChain(
-        llm=llm, prompt=prompt, verbose=verbose, callback_manager=callback_manager
+        llm=llm, prompt=_prompt, verbose=verbose, callback_manager=callback_manager
     )
     # TODO: document prompt
     return StuffDocumentsChain(
@@ -71,28 +74,34 @@ def _load_stuff_chain(
 
 
 def _load_map_reduce_chain(
-    llm: BaseLLM,
-    question_prompt: BasePromptTemplate = map_reduce_prompt.QUESTION_PROMPT,
-    combine_prompt: BasePromptTemplate = map_reduce_prompt.COMBINE_PROMPT,
+    llm: BaseLanguageModel,
+    question_prompt: Optional[BasePromptTemplate] = None,
+    combine_prompt: Optional[BasePromptTemplate] = None,
     combine_document_variable_name: str = "summaries",
     map_reduce_document_variable_name: str = "context",
     collapse_prompt: Optional[BasePromptTemplate] = None,
-    reduce_llm: Optional[BaseLLM] = None,
-    collapse_llm: Optional[BaseLLM] = None,
+    reduce_llm: Optional[BaseLanguageModel] = None,
+    collapse_llm: Optional[BaseLanguageModel] = None,
     verbose: Optional[bool] = None,
     callback_manager: Optional[BaseCallbackManager] = None,
     **kwargs: Any,
 ) -> MapReduceDocumentsChain:
+    _question_prompt = (
+        question_prompt or map_reduce_prompt.QUESTION_PROMPT_SELECTOR.get_prompt(llm)
+    )
+    _combine_prompt = (
+        combine_prompt or map_reduce_prompt.COMBINE_PROMPT_SELECTOR.get_prompt(llm)
+    )
     map_chain = LLMChain(
         llm=llm,
-        prompt=question_prompt,
+        prompt=_question_prompt,
         verbose=verbose,
         callback_manager=callback_manager,
     )
     _reduce_llm = reduce_llm or llm
     reduce_chain = LLMChain(
         llm=_reduce_llm,
-        prompt=combine_prompt,
+        prompt=_combine_prompt,
         verbose=verbose,
         callback_manager=callback_manager,
     )
@@ -135,26 +144,32 @@ def _load_map_reduce_chain(
 
 
 def _load_refine_chain(
-    llm: BaseLLM,
-    question_prompt: BasePromptTemplate = refine_prompts.DEFAULT_TEXT_QA_PROMPT,
-    refine_prompt: BasePromptTemplate = refine_prompts.DEFAULT_REFINE_PROMPT,
+    llm: BaseLanguageModel,
+    question_prompt: Optional[BasePromptTemplate] = None,
+    refine_prompt: Optional[BasePromptTemplate] = None,
     document_variable_name: str = "context_str",
     initial_response_name: str = "existing_answer",
-    refine_llm: Optional[BaseLLM] = None,
+    refine_llm: Optional[BaseLanguageModel] = None,
     verbose: Optional[bool] = None,
     callback_manager: Optional[BaseCallbackManager] = None,
     **kwargs: Any,
 ) -> RefineDocumentsChain:
+    _question_prompt = (
+        question_prompt or refine_prompts.REFINE_PROMPT_SELECTOR.get_prompt(llm)
+    )
+    _refine_prompt = refine_prompt or refine_prompts.REFINE_PROMPT_SELECTOR.get_prompt(
+        llm
+    )
     initial_chain = LLMChain(
         llm=llm,
-        prompt=question_prompt,
+        prompt=_question_prompt,
         verbose=verbose,
         callback_manager=callback_manager,
     )
     _refine_llm = refine_llm or llm
     refine_chain = LLMChain(
         llm=_refine_llm,
-        prompt=refine_prompt,
+        prompt=_refine_prompt,
         verbose=verbose,
         callback_manager=callback_manager,
     )
@@ -170,7 +185,7 @@ def _load_refine_chain(
 
 
 def load_qa_chain(
-    llm: BaseLLM,
+    llm: BaseLanguageModel,
     chain_type: str = "stuff",
     verbose: Optional[bool] = None,
     callback_manager: Optional[BaseCallbackManager] = None,