cr

Co-authored-by: Mario Kostelac <mario@intercom.io>

docs/conf.py

@@ -30,6 +30,7 @@ version = data["tool"]["poetry"]["version"]
 release = version
 
 html_title = project + " " + version
+html_last_updated_fmt = "%b %d, %Y"
 
 
 # -- General configuration ---------------------------------------------------
@@ -45,6 +46,7 @@ extensions = [
     "sphinx.ext.viewcode",
     "sphinxcontrib.autodoc_pydantic",
     "myst_nb",
+    "sphinx_copybutton",
     "sphinx_panels",
     "IPython.sphinxext.ipython_console_highlighting",
 ]

docs/ecosystem/atlas.md

@@ -13,7 +13,9 @@ It is broken into two parts: installation and setup, and then references to spec
 
 There exists a wrapper around the Atlas neural database, allowing you to use it as a vectorstore.
 This vectorstore also gives you full access to the underlying AtlasProject object, which will allow you to use the full range of Atlas map interactions, such as bulk tagging and automatic topic modeling.
-Please see [the Nomic docs](https://docs.nomic.ai/atlas_api.html) for more detailed information.
+Please see [the Atlas docs](https://docs.nomic.ai/atlas_api.html) for more detailed information.
+
+
 
 
 
@@ -22,4 +24,4 @@ To import this vectorstore:
 from langchain.vectorstores import AtlasDB
 ```
 
-For a more detailed walkthrough of the Chroma wrapper, see [this notebook](../modules/indexes/examples/vectorstores.ipynb)
+For a more detailed walkthrough of the AtlasDB wrapper, see [this notebook](../modules/indexes/vectorstore_examples/atlas.ipynb)

docs/index.rst

@@ -65,6 +65,8 @@ These modules are, in increasing order of complexity:
 
 - `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.
 
+- `Guards <./modules/guards.html>`_: Guards aim to prevent unwanted output from reaching the user and unwanted user input from reaching the LLM. Guards can be used for everythign from security, to improving user experience by keeping agents on topic, to validating user input before it is passed to your system.
+
 
 .. toctree::
    :maxdepth: 1
@@ -81,6 +83,7 @@ These modules are, in increasing order of complexity:
    ./modules/agents.md
    ./modules/memory.md
    ./modules/chat.md
+   ./modules/guards.md
 
 Use Cases
 ----------

docs/modules/agents/agent_toolkits/vectorstore.ipynb

@@ -92,7 +92,7 @@
    "id": "f4814175-964d-42f1-aa9d-22801ce1e912",
    "metadata": {},
    "source": [
-    "## Initalize Toolkit and Agent\n",
+    "## Initialize Toolkit and Agent\n",
     "\n",
     "First, we'll create an agent with a single vectorstore."
    ]

docs/modules/agents/examples/sharedmemory_for_tools.ipynb

@@ -0,0 +1,552 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "fa6802ac",
+   "metadata": {},
+   "source": [
+    "# Adding SharedMemory to an Agent and its Tools\n",
+    "\n",
+    "This notebook goes over adding memory to **both** of an Agent and its tools. Before going through this notebook, please walk through the following notebooks, as this will build on top of both of them:\n",
+    "\n",
+    "- [Adding memory to an LLM Chain](../../memory/examples/adding_memory.ipynb)\n",
+    "- [Custom Agents](custom_agent.ipynb)\n",
+    "\n",
+    "We are going to create a custom Agent. The agent has access to a conversation memory, search tool, and a summarization tool. And, the summarization tool also needs access to the conversation memory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8db95912",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n",
+    "from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory\n",
+    "from langchain import OpenAI, LLMChain, PromptTemplate\n",
+    "from langchain.utilities import GoogleSearchAPIWrapper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "06b7187b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"This is a conversation between a human and a bot:\n",
+    "\n",
+    "{chat_history}\n",
+    "\n",
+    "Write a summary of the conversation for {input}:\n",
+    "\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"input\", \"chat_history\"], \n",
+    "    template=template\n",
+    ")\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\")\n",
+    "readonlymemory = ReadOnlySharedMemory(memory=memory)\n",
+    "summry_chain = LLMChain(\n",
+    "    llm=OpenAI(), \n",
+    "    prompt=prompt, \n",
+    "    verbose=True, \n",
+    "    memory=readonlymemory, # use the read-only memory to prevent the tool from modifying the memory\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "97ad8467",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = GoogleSearchAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events\"\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name = \"Summary\",\n",
+    "        func=summry_chain.run,\n",
+    "        description=\"useful for when you summarize a conversation. The input to this tool should be a string, representing who will read this summary.\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e3439cd6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin!\"\n",
+    "\n",
+    "{chat_history}\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0021675b",
+   "metadata": {},
+   "source": [
+    "We can now construct the LLMChain, with the Memory object, and then create the agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c56a0e73",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
+    "agent_chain = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True, memory=memory)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ca4bc1fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I should research ChatGPT to answer this question.\n",
+      "Action: Search\n",
+      "Action Input: \"ChatGPT\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mNov 30, 2022 ... We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... ChatGPT. We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... Feb 2, 2023 ... ChatGPT, the popular chatbot from OpenAI, is estimated to have reached 100 million monthly active users in January, just two months after ... 2 days ago ... ChatGPT recently launched a new version of its own plagiarism detection tool, with hopes that it will squelch some of the criticism around how ... An API for accessing new AI models developed by OpenAI. Feb 19, 2023 ... ChatGPT is an AI chatbot system that OpenAI released in November to show off and test what a very large, powerful AI system can accomplish. You ... ChatGPT is fine-tuned from GPT-3.5, a language model trained to produce text. ChatGPT was optimized for dialogue by using Reinforcement Learning with Human ... 3 days ago ... Visual ChatGPT connects ChatGPT and a series of Visual Foundation Models to enable sending and receiving images during chatting. Dec 1, 2022 ... ChatGPT is a natural language processing tool driven by AI technology that allows you to have human-like conversations and much more with a ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\""
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_chain.run(input=\"What is ChatGPT?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45627664",
+   "metadata": {},
+   "source": [
+    "To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "eecc0462",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out who developed ChatGPT\n",
+      "Action: Search\n",
+      "Action Input: Who developed ChatGPT\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... Feb 15, 2023 ... Who owns Chat GPT? Chat GPT is owned and developed by AI research and deployment company, OpenAI. The organization is headquartered in San ... Feb 8, 2023 ... ChatGPT is an AI chatbot developed by San Francisco-based startup OpenAI. OpenAI was co-founded in 2015 by Elon Musk and Sam Altman and is ... Dec 7, 2022 ... ChatGPT is an AI chatbot designed and developed by OpenAI. The bot works by generating text responses based on human-user input, like questions ... Jan 12, 2023 ... In 2019, Microsoft invested $1 billion in OpenAI, the tiny San Francisco company that designed ChatGPT. And in the years since, it has quietly ... Jan 25, 2023 ... The inside story of ChatGPT: How OpenAI founder Sam Altman built the world's hottest technology with billions from Microsoft. Dec 3, 2022 ... ChatGPT went viral on social media for its ability to do anything from code to write essays. · The company that created the AI chatbot has a ... Jan 17, 2023 ... While many Americans were nursing hangovers on New Year's Day, 22-year-old Edward Tian was working feverishly on a new app to combat misuse ... ChatGPT is a language model created by OpenAI, an artificial intelligence research laboratory consisting of a team of researchers and engineers focused on ... 1 day ago ... Everyone is talking about ChatGPT, developed by OpenAI. This is such a great tool that has helped to make AI more accessible to a wider ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: ChatGPT was developed by OpenAI.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'ChatGPT was developed by OpenAI.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_chain.run(input=\"Who developed it?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c34424cf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to simplify the conversation for a 5 year old.\n",
+      "Action: Summary\n",
+      "Action Input: My daughter 5 years old\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mThis is a conversation between a human and a bot:\n",
+      "\n",
+      "Human: What is ChatGPT?\n",
+      "AI: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\n",
+      "Human: Who developed it?\n",
+      "AI: ChatGPT was developed by OpenAI.\n",
+      "\n",
+      "Write a summary of the conversation for My daughter 5 years old:\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "Observation: \u001b[33;1m\u001b[1;3m\n",
+      "The conversation was about ChatGPT, an artificial intelligence chatbot. It was created by OpenAI and can send and receive images while chatting.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot created by OpenAI that can send and receive images while chatting.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'ChatGPT is an artificial intelligence chatbot created by OpenAI that can send and receive images while chatting.'"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_chain.run(input=\"Thanks. Summarize the conversation, for my daughter 5 years old.\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "4ebd8326",
+   "metadata": {},
+   "source": [
+    "Confirm that the memory was correctly updated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b91f8c85",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Human: What is ChatGPT?\n",
+      "AI: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\n",
+      "Human: Who developed it?\n",
+      "AI: ChatGPT was developed by OpenAI.\n",
+      "Human: Thanks. Summarize the conversation, for my daughter 5 years old.\n",
+      "AI: ChatGPT is an artificial intelligence chatbot created by OpenAI that can send and receive images while chatting.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(agent_chain.memory.buffer)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "cc3d0aa4",
+   "metadata": {},
+   "source": [
+    "For comparison, below is a bad example that uses the same memory for both the Agent and the tool."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "3359d043",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## This is a bad practice for using the memory.\n",
+    "## Use the ReadOnlySharedMemory class, as shown above.\n",
+    "\n",
+    "template = \"\"\"This is a conversation between a human and a bot:\n",
+    "\n",
+    "{chat_history}\n",
+    "\n",
+    "Write a summary of the conversation for {input}:\n",
+    "\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"input\", \"chat_history\"], \n",
+    "    template=template\n",
+    ")\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\")\n",
+    "summry_chain = LLMChain(\n",
+    "    llm=OpenAI(), \n",
+    "    prompt=prompt, \n",
+    "    verbose=True, \n",
+    "    memory=memory,  # <--- this is the only change\n",
+    ")\n",
+    "\n",
+    "search = GoogleSearchAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events\"\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name = \"Summary\",\n",
+    "        func=summry_chain.run,\n",
+    "        description=\"useful for when you summarize a conversation. The input to this tool should be a string, representing who will read this summary.\"\n",
+    "    )\n",
+    "]\n",
+    "\n",
+    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin!\"\n",
+    "\n",
+    "{chat_history}\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"]\n",
+    ")\n",
+    "\n",
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
+    "agent_chain = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True, memory=memory)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "970d23df",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I should research ChatGPT to answer this question.\n",
+      "Action: Search\n",
+      "Action Input: \"ChatGPT\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mNov 30, 2022 ... We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... ChatGPT. We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... Feb 2, 2023 ... ChatGPT, the popular chatbot from OpenAI, is estimated to have reached 100 million monthly active users in January, just two months after ... 2 days ago ... ChatGPT recently launched a new version of its own plagiarism detection tool, with hopes that it will squelch some of the criticism around how ... An API for accessing new AI models developed by OpenAI. Feb 19, 2023 ... ChatGPT is an AI chatbot system that OpenAI released in November to show off and test what a very large, powerful AI system can accomplish. You ... ChatGPT is fine-tuned from GPT-3.5, a language model trained to produce text. ChatGPT was optimized for dialogue by using Reinforcement Learning with Human ... 3 days ago ... Visual ChatGPT connects ChatGPT and a series of Visual Foundation Models to enable sending and receiving images during chatting. Dec 1, 2022 ... ChatGPT is a natural language processing tool driven by AI technology that allows you to have human-like conversations and much more with a ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_chain.run(input=\"What is ChatGPT?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d9ea82f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out who developed ChatGPT\n",
+      "Action: Search\n",
+      "Action Input: Who developed ChatGPT\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... Feb 15, 2023 ... Who owns Chat GPT? Chat GPT is owned and developed by AI research and deployment company, OpenAI. The organization is headquartered in San ... Feb 8, 2023 ... ChatGPT is an AI chatbot developed by San Francisco-based startup OpenAI. OpenAI was co-founded in 2015 by Elon Musk and Sam Altman and is ... Dec 7, 2022 ... ChatGPT is an AI chatbot designed and developed by OpenAI. The bot works by generating text responses based on human-user input, like questions ... Jan 12, 2023 ... In 2019, Microsoft invested $1 billion in OpenAI, the tiny San Francisco company that designed ChatGPT. And in the years since, it has quietly ... Jan 25, 2023 ... The inside story of ChatGPT: How OpenAI founder Sam Altman built the world's hottest technology with billions from Microsoft. Dec 3, 2022 ... ChatGPT went viral on social media for its ability to do anything from code to write essays. · The company that created the AI chatbot has a ... Jan 17, 2023 ... While many Americans were nursing hangovers on New Year's Day, 22-year-old Edward Tian was working feverishly on a new app to combat misuse ... ChatGPT is a language model created by OpenAI, an artificial intelligence research laboratory consisting of a team of researchers and engineers focused on ... 1 day ago ... Everyone is talking about ChatGPT, developed by OpenAI. This is such a great tool that has helped to make AI more accessible to a wider ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: ChatGPT was developed by OpenAI.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'ChatGPT was developed by OpenAI.'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_chain.run(input=\"Who developed it?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "5b1f9223",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to simplify the conversation for a 5 year old.\n",
+      "Action: Summary\n",
+      "Action Input: My daughter 5 years old\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mThis is a conversation between a human and a bot:\n",
+      "\n",
+      "Human: What is ChatGPT?\n",
+      "AI: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\n",
+      "Human: Who developed it?\n",
+      "AI: ChatGPT was developed by OpenAI.\n",
+      "\n",
+      "Write a summary of the conversation for My daughter 5 years old:\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "Observation: \u001b[33;1m\u001b[1;3m\n",
+      "The conversation was about ChatGPT, an artificial intelligence chatbot developed by OpenAI. It is designed to have conversations with humans and can also send and receive images.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI that can have conversations with humans and send and receive images.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'ChatGPT is an artificial intelligence chatbot developed by OpenAI that can have conversations with humans and send and receive images.'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_chain.run(input=\"Thanks. Summarize the conversation, for my daughter 5 years old.\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d07415da",
+   "metadata": {},
+   "source": [
+    "The final answer is not wrong, but we see the 3rd Human input is actually from the agent in the memory because the memory was modified by the summary tool."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "32f97b21",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Human: What is ChatGPT?\n",
+      "AI: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\n",
+      "Human: Who developed it?\n",
+      "AI: ChatGPT was developed by OpenAI.\n",
+      "Human: My daughter 5 years old\n",
+      "AI: \n",
+      "The conversation was about ChatGPT, an artificial intelligence chatbot developed by OpenAI. It is designed to have conversations with humans and can also send and receive images.\n",
+      "Human: Thanks. Summarize the conversation, for my daughter 5 years old.\n",
+      "AI: ChatGPT is an artificial intelligence chatbot developed by OpenAI that can have conversations with humans and send and receive images.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(agent_chain.memory.buffer)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/agents/getting_started.ipynb

@@ -161,7 +161,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },

docs/modules/agents/implementations/mrkl_chat.ipynb

@@ -86,7 +86,7 @@
       "\n",
       "\n",
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to use the search tool to find out who is Leo DiCaprio's girlfriend and then use the calculator tool to raise her current age to the 0.43 power.\n",
+      "\u001b[32;1m\u001b[1;3mThought: The first question requires a search, while the second question requires a calculator.\n",
       "Action:\n",
       "```\n",
       "{\n",
@@ -96,32 +96,32 @@
       "```\n",
       "\u001b[0m\n",
       "Observation: \u001b[36;1m\u001b[1;3mCamila Morrone\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mNow I need to use the calculator tool to raise Camila Morrone's current age to the 0.43 power.\n",
+      "Thought:\u001b[32;1m\u001b[1;3mFor the second question, I need to use the calculator tool to raise her current age to the 0.43 power.\n",
       "Action:\n",
       "```\n",
       "{\n",
       "  \"action\": \"Calculator\",\n",
-      "  \"action_input\": \"22.5^(0.43)\"\n",
+      "  \"action_input\": \"22.0^(0.43)\"\n",
       "}\n",
       "```\n",
       "\n",
       "\u001b[0m\n",
       "\n",
       "\u001b[1m> Entering new LLMMathChain chain...\u001b[0m\n",
-      "22.5^(0.43)\u001b[32;1m\u001b[1;3m\n",
+      "22.0^(0.43)\u001b[32;1m\u001b[1;3m\n",
       "```python\n",
       "import math\n",
-      "print(math.pow(22.5, 0.43))\n",
+      "print(math.pow(22.0, 0.43))\n",
       "```\n",
       "\u001b[0m\n",
-      "Answer: \u001b[33;1m\u001b[1;3m3.8145075848063126\n",
+      "Answer: \u001b[33;1m\u001b[1;3m3.777824273683966\n",
       "\u001b[0m\n",
       "\u001b[1m> Finished chain.\u001b[0m\n",
       "\n",
-      "Observation: \u001b[33;1m\u001b[1;3mAnswer: 3.8145075848063126\n",
+      "Observation: \u001b[33;1m\u001b[1;3mAnswer: 3.777824273683966\n",
       "\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mI now know the final answer\n",
-      "Final Answer: 3.8145075848063126\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3mI now know the final answer.\n",
+      "Final Answer: Camila Morrone, 3.777824273683966.\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -129,7 +129,7 @@
     {
      "data": {
       "text/plain": [
-       "'3.8145075848063126'"
+       "'Camila Morrone, 3.777824273683966.'"
       ]
      },
      "execution_count": 4,
@@ -154,29 +154,30 @@
       "\n",
       "\n",
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to use the Search tool to find the name of the artist who recently released an album called 'The Storm Before the Calm'. Then, I can use the FooBar DB tool to check if they are in the database and what albums of theirs are in it.\n",
-      "Action: \n",
+      "\u001b[32;1m\u001b[1;3mQuestion: What is the full name of the artist who recently released an album called 'The Storm Before the Calm' and are they in the FooBar database? If so, what albums of theirs are in the FooBar database?\n",
+      "Thought: I should use the Search tool to find the answer to the first part of the question and then use the FooBar DB tool to find the answer to the second part of the question.\n",
+      "Action:\n",
       "```\n",
       "{\n",
       "  \"action\": \"Search\",\n",
-      "  \"action_input\": \"Who is the artist that recently released an album called 'The Storm Before the Calm'?\"\n",
+      "  \"action_input\": \"Who recently released an album called 'The Storm Before the Calm'\"\n",
       "}\n",
       "```\n",
       "\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mstudio album by Canadian-American singer-songwriter Alanis Morissette, released June 17, 2022, via Epiphany Music and Thirty Tigers, as well as by RCA Records ...\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mNow that I know the artist is Alanis Morissette, I can use the FooBar DB tool to check if she is in the database and what albums of hers are in it.\n",
-      "Action: \n",
+      "Observation: \u001b[36;1m\u001b[1;3mAlanis Morissette\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3mNow that I have the name of the artist, I can use the FooBar DB tool to find their albums in the database.\n",
+      "Action:\n",
       "```\n",
       "{\n",
       "  \"action\": \"FooBar DB\",\n",
-      "  \"action_input\": \"What albums by Alanis Morissette are in the database?\"\n",
+      "  \"action_input\": \"What albums does Alanis Morissette have in the database?\"\n",
       "}\n",
       "```\n",
       "\n",
       "\u001b[0m\n",
       "\n",
       "\u001b[1m> Entering new SQLDatabaseChain chain...\u001b[0m\n",
-      "What albums by Alanis Morissette are in the database? \n",
+      "What albums does Alanis Morissette have in the database? \n",
       "SQLQuery:"
      ]
     },
@@ -194,12 +195,12 @@
      "text": [
       "\u001b[32;1m\u001b[1;3m SELECT Title FROM Album WHERE ArtistId IN (SELECT ArtistId FROM Artist WHERE Name = 'Alanis Morissette') LIMIT 5;\u001b[0m\n",
       "SQLResult: \u001b[33;1m\u001b[1;3m[('Jagged Little Pill',)]\u001b[0m\n",
-      "Answer:\u001b[32;1m\u001b[1;3m The albums by Alanis Morissette in the database are Jagged Little Pill.\u001b[0m\n",
+      "Answer:\u001b[32;1m\u001b[1;3m Alanis Morissette has the album 'Jagged Little Pill' in the database.\u001b[0m\n",
       "\u001b[1m> Finished chain.\u001b[0m\n",
       "\n",
-      "Observation: \u001b[38;5;200m\u001b[1;3m The albums by Alanis Morissette in the database are Jagged Little Pill.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mThe only album by Alanis Morissette in the FooBar DB is Jagged Little Pill.\n",
-      "Final Answer: The artist who recently released an album called 'The Storm Before the Calm' is Alanis Morissette. The only album of hers in the FooBar DB is Jagged Little Pill.\u001b[0m\n",
+      "Observation: \u001b[38;5;200m\u001b[1;3m Alanis Morissette has the album 'Jagged Little Pill' in the database.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3mI have found the answer to both parts of the question.\n",
+      "Final Answer: The artist who recently released an album called 'The Storm Before the Calm' is Alanis Morissette. The album 'Jagged Little Pill' is in the FooBar database.\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -207,7 +208,7 @@
     {
      "data": {
       "text/plain": [
-       "\"The artist who recently released an album called 'The Storm Before the Calm' is Alanis Morissette. The only album of hers in the FooBar DB is Jagged Little Pill.\""
+       "\"The artist who recently released an album called 'The Storm Before the Calm' is Alanis Morissette. The album 'Jagged Little Pill' is in the FooBar database.\""
       ]
      },
      "execution_count": 5,

docs/modules/agents/tools.md

@@ -136,3 +136,12 @@ Below is a list of all supported tools and relevant information:
 - Requires LLM: No
 - Extra Parameters: `serper_api_key`
 - For more information on this, see [this page](../../ecosystem/google_serper.md)
+
+**wikipedia**
+
+- Tool Name: Wikipedia
+- Tool Description: A wrapper around Wikipedia. Useful for when you need to answer general questions about people, places, companies, historical events, or other subjects. Input should be a search query.
+- Notes: Uses the [wikipedia](https://pypi.org/project/wikipedia/) Python package to call the MediaWiki API and then parses results.
+- Requires LLM: No
+- Extra Parameters: `top_k_results`
+

docs/modules/document_loaders/examples/example_data/mlb_teams_2012.csv

@@ -0,0 +1,32 @@
+"Team", "Payroll (millions)", "Wins"
+"Nationals",     81.34, 98
+"Reds",          82.20, 97
+"Yankees",      197.96, 95
+"Giants",       117.62, 94
+"Braves",        83.31, 94
+"Athletics",     55.37, 94
+"Rangers",      120.51, 93
+"Orioles",       81.43, 93
+"Rays",          64.17, 90
+"Angels",       154.49, 89
+"Tigers",       132.30, 88
+"Cardinals",    110.30, 88
+"Dodgers",       95.14, 86
+"White Sox",     96.92, 85
+"Brewers",       97.65, 83
+"Phillies",     174.54, 81
+"Diamondbacks",  74.28, 81
+"Pirates",       63.43, 79
+"Padres",        55.24, 76
+"Mariners",      81.97, 75
+"Mets",          93.35, 74
+"Blue Jays",     75.48, 73
+"Royals",        60.91, 72
+"Marlins",      118.07, 69
+"Red Sox",      173.18, 69
+"Indians",       78.43, 68
+"Twins",         94.08, 66
+"Rockies",       78.06, 64
+"Cubs",          88.19, 61
+"Astros",        60.65, 55
+

docs/modules/guards.rst

@@ -0,0 +1,27 @@
+Guards
+==========================
+
+Guards are one way you can work on aligning your applications to prevent unwanted output or abuse. Guards are a set of directives that can be applied to chains, agents, tools, user inputs, and generally any function that outputs a string. Guards are used to prevent a llm reliant function from outputting text that violates some constraint and for preventing a user from inputting text that violates some constraint. For example, a guard can be used to prevent a chain from outputting text that includes profanity or which is in the wrong language.
+
+Guards offer some protection against security or profanity related things like prompt leaking or users attempting to make agents output racist or otherwise offensive content. Guards can also be used for many other things, though. For example, if your application is specific to a certain industry you may add a guard to prevent agents from outputting irrelevant content or to prevent users from submitting off-topic questions.
+
+
+- `Getting Started <./guards/getting_started.html>`_: An overview of different types of guards and how to use them.
+
+- `Key Concepts <./guards/key_concepts.html>`_: A conceptual guide going over the various concepts related to guards.
+
+.. TODO: Probably want to add how-to guides for sentiment model guards!
+- `How-To Guides <./llms/how_to_guides.html>`_: A collection of how-to guides. These highlight how to accomplish various objectives with our LLM class, as well as how to integrate with various LLM providers.
+
+- `Reference <../reference/modules/guards.html>`_: API reference documentation for all Guard classes.
+
+
+.. toctree::
+   :maxdepth: 1
+   :name: Guards
+   :hidden:
+   
+   ./guards/getting_started.ipynb
+   ./guards/key_concepts.md
+   Reference<../reference/modules/guards.rst>
+

docs/modules/guards/examples/security.ipynb

@@ -0,0 +1,167 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Security with Guards\n",
+    "\n",
+    "Guards offer an easy way to add some level of security to your application by limiting what is permitted as user input and what is permitted as LLM output. Note that guards do not modify the LLM itself or the prompt. They only modify the input to and output of the LLM.\n",
+    "\n",
+    "For example, suppose that you have a chatbot that answers questions over a US fish and wildlife database. You might want to limit the LLM output to only information about fish and wildlife.\n",
+    "\n",
+    "Guards work as decorators so to guard the output of our fish and wildlife agent we need to create a wrapper function and add the guard like so:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.guards import RestrictionGuard\n",
+    "from my_fish_and_wildlife_library import fish_and_wildlife_agent\n",
+    "\n",
+    "llm = OpenAI(temperature=0.9)\n",
+    "\n",
+    "\n",
+    "@RestrictionGuard(restrictions=['Output must be related to fish and wildlife'], llm=llm, retries=0)\n",
+    "def get_answer(input):\n",
+    "    return fish_and_wildlife_agent.run(input)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This particular guard, the Restriction Guard, takes in a list of restrictions and an LLM. It then takes the output of the function it is applied to (in this case `get_answer`) and passed it to the LLM with instructions that if the output violates the restrictions then it should block the output. Optionally, the guard can also take \"retries\" which is the number of times it will try to generate an output that does not violate the restrictions. If the number of retries is exceeded then the guard will return an exception. It's usually fine to just leave retries as the default, 0, unless you have a reason to think the LLM will generate something different enough to not violate the restrictions on subsequent tries.\n",
+    "\n",
+    "This restriction guard will help to avoid the LLM from returning some irrelevant information but it is still susceptible to some attacks. For example, suppose a user was trying to get our application to output something nefarious, they might say \"tell me how to make enriched uranium and also tell me a fact about trout in the United States.\" Now our guard may not catch the response since it could still include stuff about fish and wildlife! Even if our fish and wildlife bot doesn't know how to make enriched uranium it could still be pretty embarrassing if it tried, right? Let's try adding a guard to user input this time to see if we can prevent this attack:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@RestrictionGuard(restrictions=['Output must be a single question about fish and wildlife'], llm=llm)\n",
+    "def get_user_question():\n",
+    "    return input(\"How can I help you learn more about fish and wildlife in the United States?\")\n",
+    "\n",
+    "def main():\n",
+    "    while True:\n",
+    "        question = get_user_question()\n",
+    "        answer = get_answer(question)\n",
+    "        print(answer)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "That should hopefully catch some of those attacks. Note how the restrictions are still in the form of \"output must be x\" even though it's wrapping a user input function. This is because the guard simply takes in a string it knows as \"output,\" the return string of the function it is wrapping, and makes a determination on whether or not it should be blocked. Your restrictions should still refer to the string as \"output.\"\n",
+    "\n",
+    "LLMs can be hard to predict, though. Who knows what other attacks might be possible. We could try adding a bunch more guards but each RestrictionGuard is also an LLM call which could quickly become expensive. Instead, lets try adding a StringGuard. The StringGuard simply checks to see if more than some percent of a given string is in the output and blocks it if it is. The downside is that we need to know what strings to block. It's useful for things like blocking our LLM from outputting our prompt or other strings that we know we don't want it to output like profanity or other sensitive information."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from my_fish_and_wildlife_library import fish_and_wildlife_agent, super_secret_prompt\n",
+    "\n",
+    "@StringGuard(protected_strings=[super_secret_prompt], leniency=.5)\n",
+    "@StringGuard(protected_strings=['uranium', 'darn', 'other bad words'], leniency=1, retries=2)\n",
+    "@RestrictionGuard(restrictions=['Output must be related to fish and wildlife'], llm=llm, retries=0)\n",
+    "def get_answer(input):\n",
+    "    return fish_and_wildlife_agent.run(input)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We've now added two StringGuards, one that blocks the prompt and one that blocks the word \"uranium\" and other bad words we don't want it to output. Note that the leniency is .5 (50%) for the first guard and 1 (100%) for the second. The leniency is the amount of the string that must show up in the output for the guard to be triggered. If the leniency is 100% then the entire string must show up for the guard to be triggered whereas at 50% if even half of the string shows up the guard will prevent the output. It makes sense to set these at different levels above. If half of our prompt is being exposed something is probably wrong and we should block it. However, if half of \"uranium\" is being shows then the output could just be something like \"titanium fishing rods are great tools.\" so, for single words, it's best to block only if the whole word shows up.\n",
+    "\n",
+    "Note that we also left \"retries\" at the default value of 0 for the prompt guard. If that guard is triggered then the user is probably trying something fishy so we don't need to try to generate another response.\n",
+    "\n",
+    "These guards are not foolproof. For example, a user could just find a way to get our agent to output the prompt and ask for it in French instead thereby bypassing our english string guard. The combination of these guards can start to prevent accidental leakage though and provide some protection against simple attacks. If, for whatever reason, your LLM has access to sensitive information like API keys (it shouldn't) then a string guard can work with 100% efficacy at preventing those specific strings from being revealed.\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Custom Guards / Sentiment Analysis\n",
+    "\n",
+    "The StringGuard and RestrictionGuard cover a lot of ground but you may have cases where you want to implement your own guard for security, like checking user input with Regex or running output through a sentiment model. For these cases, you can use a CustomGuard. It should simply return false if the output does not violate the restrictions and true if it does. For example, if we wanted to block any output that had a negative sentiment score we could do something like this:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.guards import CustomGuard\n",
+    "import re\n",
+    "\n",
+    "%pip install transformers\n",
+    "\n",
+    "# not LangChain specific - look up \"Hugging Face transformers\" for more information\n",
+    "from transformers import pipeline\n",
+    "sentiment_pipeline = pipeline(\"sentiment-analysis\")\n",
+    "\n",
+    "def sentiment_check(input):\n",
+    "    sentiment = sentiment_pipeline(input)[0]\n",
+    "    print(sentiment)\n",
+    "    if sentiment['label'] == 'NEGATIVE':\n",
+    "        print(f\"Input is negative: {sentiment['score']}\")\n",
+    "        return True\n",
+    "    return False\n",
+    "    \n",
+    "\n",
+    "@CustomGuard(guard_function=sentiment_check)\n",
+    "def get_answer(input):\n",
+    "    return fish_and_wildlife_agent.run(input)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.13"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "dfb57f300c99b0f41d9d10924a3dcaf479d1223f46dbac9ee0702921bcb200aa"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/modules/guards/getting_started.ipynb

@@ -0,0 +1,253 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d31df93e",
+   "metadata": {},
+   "source": [
+    "# Getting Started\n",
+    "\n",
+    "This notebook walks through the different types of guards you can use. Guards are a set of directives that can be used to restrict the output of agents, chains, prompts, or really any function that outputs a string. "
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "d051c1da",
+   "metadata": {},
+   "source": [
+    "## @RestrictionGuard\n",
+    "RestrictionGuard is used to restrict output using an llm. By passing in a set of restrictions like \"the output must be in latin\" or \"The output must be about baking\" you can start to prevent your chain, agent, tool, or any llm generally from returning unpredictable content. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "54301321",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.guards import RestrictionGuard\n",
+    "\n",
+    "llm = OpenAI(temperature=0.9)\n",
+    "\n",
+    "text = \"What would be a good company name a company that makes colorful socks for romans?\"\n",
+    "\n",
+    "@RestrictionGuard(restrictions=['output must be in latin'], llm=llm, retries=0)\n",
+    "def sock_idea():\n",
+    "    return llm(text)\n",
+    "    \n",
+    "sock_idea()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "fec1b8f4",
+   "metadata": {},
+   "source": [
+    "The restriction guard works by taking in a set of restrictions, an llm to use to judge the output on those descriptions, and an int, retries, which defaults to zero and allows a function to be called again if it fails to pass the guard.\n",
+    "\n",
+    "Restrictions should always be written in the form out 'the output must x' or 'the output must not x.'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4a899cdb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@RestrictionGuard(restrictions=['output must be about baking'], llm=llm, retries=1)\n",
+    "def baking_bot(user_input):\n",
+    "    return llm(user_input)\n",
+    "    \n",
+    "baking_bot(input(\"Ask me any question about baking!\"))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c5e9bb34",
+   "metadata": {},
+   "source": [
+    "The restriction guard works by taking your set of restrictions and prompting a provided llm to answer true or false whether a provided output violates those restrictions. Since it uses an llm, the results of the guard itself can be unpredictable. \n",
+    "\n",
+    "The restriction guard is good for moderation tasks that there are not other tools for, like moderating what type of content (baking, poetry, etc) or moderating what language.\n",
+    "\n",
+    "The restriction guard is bad at things llms are bad at. For example, the restriction guard is bad at moderating things dependent on math or individual characters (no words greater than 3 syllables, no responses more than 5 words, no responses that include the letter e)."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "6bb0c1da",
+   "metadata": {},
+   "source": [
+    "## @StringGuard\n",
+    "\n",
+    "The string guard is used to restrict output that contains some percentage of a provided string. Common use cases may include preventing prompt leakage or preventing a list of derogatory words from being used. The string guard can also be used for things like preventing common outputs or preventing the use of protected words. \n",
+    "\n",
+    "The string guard takes a list of protected strings, a 'leniency' which is just the percent of a string that can show up before the guard is triggered (lower is more sensitive), and a number of retries.\n",
+    "\n",
+    "Unlike the restriction guard, the string guard does not rely on an llm so using it is computationally cheap and fast.\n",
+    "\n",
+    "For example, suppose we want to think of sock ideas but want unique names that don't already include the word 'sock':"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae046bff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.guards import StringGuard\n",
+    "from langchain.chains import LLMChain\n",
+    "\n",
+    "llm = OpenAI(temperature=0.9)\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"product\"],\n",
+    "    template=\"What is a good name for a company that makes {product}?\",\n",
+    ")\n",
+    "\n",
+    "chain = LLMChain(llm=llm, prompt=prompt)\n",
+    "\n",
+    "@StringGuard(protected_strings=['sock'], leniency=1, retries=5)\n",
+    "def sock_idea():\n",
+    "    return chain.run(\"colorful socks\")\n",
+    "    \n",
+    "sock_idea()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "fe5fd55e",
+   "metadata": {},
+   "source": [
+    "If we later decided that the word 'fuzzy' was also too generic, we could add it to protected strings:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26b58788",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@StringGuard(protected_strings=['sock', 'fuzzy'], leniency=1, retries=5)\n",
+    "def sock_idea():\n",
+    "    return chain.run(\"colorful socks\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c3ccb22e",
+   "metadata": {},
+   "source": [
+    "*NB: Leniency is set to 1 for this example so that only strings that include the whole word \"sock\" will violate the guard.*\n",
+    "\n",
+    "*NB: Capitalization does not count as a difference when checking differences in strings.*\n",
+    "\n",
+    "Suppose that we want to let users ask for sock company names but are afraid they may steal out super secret genius sock company naming prompt. The first thought may be to just add our prompt template to the protected strings. The problem, though, is that the leniency for our last 'sock' guard is too high: the prompt may be returned a little bit different and not be caught if the guard leniency is set to 100%. The solution is to just add two guards! The sock one will be checked first and then the prompt one. This can be done since all a guard does is look at the output of the function below it.\n",
+    "\n",
+    "For our prompt protecting string guard, we will set the leniency to 50%. If 50% of the prompt shows up in the answer, something probably went wrong!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aa5b8ef1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(temperature=0.9)\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"description\"],\n",
+    "    template=\"What is a good name for a company that makes {description} type of socks?\",\n",
+    ")\n",
+    "\n",
+    "chain = LLMChain(llm=llm, prompt=prompt)\n",
+    "\n",
+    "@StringGuard(protected_strings=[prompt.template], leniency=.5, retries=5)\n",
+    "@StringGuard(protected_strings=['sock'], leniency=1, retries=5)\n",
+    "def sock_idea():\n",
+    "    return chain.run(input(\"What type of socks does your company make?\"))"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "3535014e",
+   "metadata": {},
+   "source": [
+    "## @CustomGuard\n",
+    "\n",
+    "The custom guard allows you to easily turn any function into your own guard! The custom guard takes in a function and, like other guards, a number of retries. The function should take a string as input and return True if the string violates the guard and False if not. \n",
+    "\n",
+    "One use cases for this guard could be to create your own local classifier model to, for example, classify text as \"on topic\" or \"off topic.\" Or, you may have a model that determines sentiment. You could take these models and add them to a custom guard to ensure that the output of your llm, chain, or agent is exactly inline with what you want it to be.\n",
+    "\n",
+    "Here's an example of a simple guard that prevents jokes from being returned that are too long."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2acaaf18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import LLMChain, OpenAI, PromptTemplate\n",
+    "from langchain.guards import CustomGuard\n",
+    "\n",
+    "llm = OpenAI(temperature=0.9)\n",
+    "\n",
+    "prompt_template = \"Tell me a {adjective} joke\"\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"adjective\"], template=prompt_template\n",
+    ")\n",
+    "chain = LLMChain(llm=OpenAI(), prompt=prompt)\n",
+    "\n",
+    "def is_long(llm_output):\n",
+    "    return len(llm_output) > 100\n",
+    "\n",
+    "@CustomGuard(guard_function=is_long, retries=1)\n",
+    "def call_chain():\n",
+    "    return chain.run(adjective=\"political\")\n",
+    "\n",
+    "call_chain()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.13"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "f477efb0f3991ec3d5bbe3bccb06e84664f3f1037cc27215e8b02d2d22497b99"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/guards/how_to_guides.rst

@@ -0,0 +1,18 @@
+How-To Guides
+=============
+
+The examples here will help you get started with using guards and making your own custom guards.
+
+
+1. `Getting Started <./getting_started.ipynb>`_ - These examples are intended to help you get
+   started with using guards.
+2. `Security <./examples/security.ipynb>`_ - These examples are intended to help you get
+   started with using guards specifically to secure your chains and agents.
+
+.. toctree::
+   :maxdepth: 1
+   :glob:
+   :hidden:
+
+   ./getting_started.ipynb
+   ./examples/security.ipynb

docs/modules/guards/key_concepts.md

@@ -0,0 +1,25 @@
+# Key Concepts
+
+The simplest way to restrict the output of an LLM is to just tell it what you don't want in the prompt. This rarely works well, though. For example, just about every chatbot that is released has some restrictions in its prompt. Inevitably, users find vulnerabilities and ways to 'trick' the chatbot into saying nasty things or decrying the rules that bind it. As funny as these workarounds sometimes are to read about on Twitter, protecting against them is an important task that grows more important as LLMs begin to be used in more consequential ways.
+
+Guards use a variety of methods to prevent unwanted output from reaching a user. They can also be used for a number of other things, but restricting output is the primary use and the reason they were designed. This document details the high level methods of restricting output and a few techniques one may consider implementing. For actual code, see 'Getting Started.'
+
+## Using an LLM to Restrict Output
+
+The RestrictionGuard works by adding another LLM on top of the one being protected which is instructed to determine if the underlying llm's output violates one or more guards. By separating the restriction into a separate guard many exploits are avoided. Since the guard llm only looks at the output it can answer simple questions about if a restriction is violated. An llm that is simply told not to violate a restriction may later be told by a user to ignore those instructions or in some other way "tricked" into doing so. By separating into two LLM calls, one to generate the response and one to verify, it is also more likely that, after repeated retries as opposed to a single unguarded attempt, an appropriate response will be generated.
+
+## Using a StringGuard to Restrict Output
+
+The StringGuard works by checking if an output contains a sufficient percentage of one or more protected strings. This guard is not as computationally intense or slow as another llm call and works better than an llm for things like preventing prompt jacking or preventing the use of negative words. Users should be aware, though, that there are still many ways to get around this guard for things like prompt jacking. For example, a user that has found a way to get your agent or chain to return the prompt may be prevented from doing so by a string guard that restricts returning the prompt. If the user asks for the prompt in spanish, though, the string guard will not catch it since the spanish prompt is a different string.
+
+## Custom Methods
+
+The CustomGuard takes in a function to create a custom guard. The function should take a single string as input and return a boolean where True means the guard was violated and False means it was not. For example, you may want to apply a simple function like checking that a response is a certain length or to use some other non-llm model or heuristic to check the output.
+
+For example, suppose you have a chat agent that is only supposed to be a cooking assistant. You may worry that users could try to ask the chat agent to say things totally unrelated to cooking or even to say something racist or violent. You could use a restriction guard which will help but its still an extra llm call which is expensive and it may not work every time since llms are unpredictable.
+
+Suppose instead you collect 100 examples of cooking related responses and 200 examples of responses that don't have anything to do with cooking. You could then train a model that classifies if a piece of text is about cooking or not. This model could be run on your own infrastructure for minimal cost compared to an LLM and could potentially be much more reliable. You could then use it to create a custom guard to restrict the output of your chat agent to only responses that your model classifies as related to cooking.
+
+<!-- add this image: docs/modules/guards/ClassifierExample.png -->
+
+![Image of classifier example detailed above](./ClassifierExample.png)

docs/modules/indexes/chain_examples/qa_with_sources.ipynb

@@ -635,7 +635,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts.base import RegexParser\n",
+    "from langchain.output_parsers import RegexParser\n",
     "\n",
     "output_parser = RegexParser(\n",
     "    regex=r\"(.*?)\\nScore: (.*)\",\n",
@@ -732,4 +732,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

docs/modules/indexes/chain_examples/question_answering.ipynb

@@ -635,7 +635,7 @@
     }
    ],
    "source": [
-    "from langchain.prompts.base import RegexParser\n",
+    "from langchain.output_parsers import RegexParser\n",
     "\n",
     "output_parser = RegexParser(\n",
     "    regex=r\"(.*?)\\nScore: (.*)\",\n",

docs/modules/indexes/how_to_guides.rst

@@ -36,6 +36,8 @@ In the below guides, we cover different types of vectorstores and how to use the
 
 `Chroma <./vectorstore_examples/chroma.html>`_: A walkthrough of how to use the Chroma vectorstore wrapper.
 
+`AtlasDB <./vectorstore_examples/atlas.html>`_: A walkthrough of how to use the AtlasDB vectorstore and visualizer wrapper.
+
 `DeepLake <./vectorstore_examples/deeplake.html>`_: A walkthrough of how to use the Deep Lake, data lake, wrapper.
 
 `FAISS <./vectorstore_examples/faiss.html>`_: A walkthrough of how to use the FAISS vectorstore wrapper.

docs/modules/indexes/vectorstore_examples/atlas.ipynb

@@ -2,11 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
+   "metadata": {},
    "source": [
     "# AtlasDB\n",
     "\n",
@@ -15,10 +11,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "pycharm": {
-     "name": "#%%\n"
+     "is_executing": true
     }
    },
    "outputs": [],
@@ -32,56 +28,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Collecting en-core-web-sm==3.5.0\n",
-      "  Downloading https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.5.0/en_core_web_sm-3.5.0-py3-none-any.whl (12.8 MB)\n",
-      "\u001B[2K     \u001B[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001B[0m \u001B[32m12.8/12.8 MB\u001B[0m \u001B[31m90.8 MB/s\u001B[0m eta \u001B[36m0:00:00\u001B[0m00:01\u001B[0m00:01\u001B[0m\n",
-      "\u001B[?25hRequirement already satisfied: spacy<3.6.0,>=3.5.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from en-core-web-sm==3.5.0) (3.5.0)\n",
-      "Requirement already satisfied: packaging>=20.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (23.0)\n",
-      "Requirement already satisfied: wasabi<1.2.0,>=0.9.1 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.1.1)\n",
-      "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.3.0)\n",
-      "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.4.5)\n",
-      "Requirement already satisfied: pathy>=0.10.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.10.1)\n",
-      "Requirement already satisfied: setuptools in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (67.4.0)\n",
-      "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (4.64.1)\n",
-      "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.0.4)\n",
-      "Requirement already satisfied: smart-open<7.0.0,>=5.2.1 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (6.3.0)\n",
-      "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (8.1.7)\n",
-      "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.0.7)\n",
-      "Requirement already satisfied: typer<0.8.0,>=0.3.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.7.0)\n",
-      "Requirement already satisfied: requests<3.0.0,>=2.13.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.28.2)\n",
-      "Requirement already satisfied: jinja2 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.1.2)\n",
-      "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.11.0,>=1.7.4 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.10.5)\n",
-      "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.0.8)\n",
-      "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.11 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.0.12)\n",
-      "Requirement already satisfied: numpy>=1.15.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.24.2)\n",
-      "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.0.9)\n",
-      "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.0.8)\n",
-      "Requirement already satisfied: typing-extensions>=4.2.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from pydantic!=1.8,!=1.8.1,<1.11.0,>=1.7.4->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (4.5.0)\n",
-      "Requirement already satisfied: charset-normalizer<4,>=2 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.0.1)\n",
-      "Requirement already satisfied: idna<4,>=2.5 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (3.4)\n",
-      "Requirement already satisfied: certifi>=2017.4.17 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2022.12.7)\n",
-      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from requests<3.0.0,>=2.13.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (1.26.14)\n",
-      "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from thinc<8.2.0,>=8.1.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.7.9)\n",
-      "Requirement already satisfied: confection<1.0.0,>=0.0.1 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from thinc<8.2.0,>=8.1.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (0.0.4)\n",
-      "Requirement already satisfied: click<9.0.0,>=7.1.1 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from typer<0.8.0,>=0.3.0->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (8.1.3)\n",
-      "Requirement already satisfied: MarkupSafe>=2.0 in /home/ubuntu/langchain/.venv/lib/python3.9/site-packages (from jinja2->spacy<3.6.0,>=3.5.0->en-core-web-sm==3.5.0) (2.1.2)\n",
-      "\n",
-      "\u001B[1m[\u001B[0m\u001B[34;49mnotice\u001B[0m\u001B[1;39;49m]\u001B[0m\u001B[39;49m A new release of pip is available: \u001B[0m\u001B[31;49m23.0\u001B[0m\u001B[39;49m -> \u001B[0m\u001B[32;49m23.0.1\u001B[0m\n",
-      "\u001B[1m[\u001B[0m\u001B[34;49mnotice\u001B[0m\u001B[1;39;49m]\u001B[0m\u001B[39;49m To update, run: \u001B[0m\u001B[32;49mpip install --upgrade pip\u001B[0m\n",
-      "\u001B[38;5;2m✔ Download and installation successful\u001B[0m\n",
-      "You can now load the package via spacy.load('en_core_web_sm')\n"
-     ]
+    "scrolled": true,
+    "pycharm": {
+     "is_executing": true
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "!python -m spacy download en_core_web_sm"
    ]
@@ -113,51 +67,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-02-24 16:13:49.696 | INFO     | nomic.project:_create_project:884 - Creating project `test_index_1677255228.136989` in organization `Atlas Demo`\n",
-      "2023-02-24 16:13:51.087 | INFO     | nomic.project:wait_for_project_lock:993 - test_index_1677255228.136989: Project lock is released.\n",
-      "2023-02-24 16:13:51.225 | INFO     | nomic.project:wait_for_project_lock:993 - test_index_1677255228.136989: Project lock is released.\n",
-      "2023-02-24 16:13:51.481 | INFO     | nomic.project:add_text:1351 - Uploading text to Atlas.\n",
-      "1it [00:00,  1.20it/s]\n",
-      "2023-02-24 16:13:52.318 | INFO     | nomic.project:add_text:1422 - Text upload succeeded.\n",
-      "2023-02-24 16:13:52.628 | INFO     | nomic.project:wait_for_project_lock:993 - test_index_1677255228.136989: Project lock is released.\n",
-      "2023-02-24 16:13:53.380 | INFO     | nomic.project:create_index:1192 - Created map `test_index_1677255228.136989_index` in project `test_index_1677255228.136989`: https://atlas.nomic.ai/map/ee2354a3-7f9a-4c6b-af43-b0cda09d7198/db996d77-8981-48a0-897a-ff2c22bbf541\n"
-     ]
+   "execution_count": null,
+   "metadata": {
+    "pycharm": {
+     "is_executing": true
     }
-   ],
+   },
+   "outputs": [],
    "source": [
     "db = AtlasDB.from_texts(texts=texts,\n",
-    "                        name='test_index_'+str(time.time()),\n",
-    "                        description='test_index',\n",
+    "                        name='test_index_'+str(time.time()), # unique name for your vector store\n",
+    "                        description='test_index', #a description for your vector store\n",
     "                        api_key=ATLAS_TEST_API_KEY,\n",
     "                        index_kwargs={'build_topic_model': True})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2023-02-24 16:14:09.106 | INFO     | nomic.project:wait_for_project_lock:993 - test_index_1677255228.136989: Project lock is released.\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "outputs": [],
    "source": [
-    "with db.project.wait_for_project_lock():\n",
-    "    time.sleep(1)"
-   ]
+    "db.project.wait_for_project_lock()"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
@@ -263,4 +197,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 1
-}
+}

docs/reference.rst

@@ -12,3 +12,4 @@ Full documentation on all methods, classes, and APIs in LangChain.
    ./reference/utils.rst
    Chains<./reference/modules/chains>
    Agents<./reference/modules/agents>
+   Guards<./reference/modules/guards>

docs/reference/modules/guards.rst

@@ -0,0 +1,7 @@
+Guards
+===============================
+
+.. automodule:: langchain.guards
+   :members:
+   :undoc-members:
+

docs/tracing/agent_with_tracing.ipynb

@@ -35,12 +35,28 @@
     "\n",
     "import langchain\n",
     "from langchain.agents import Tool, initialize_agent, load_tools\n",
+    "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.llms import OpenAI"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
+   "id": "1b62cd48",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Agent run with tracing. Ensure that OPENAI_API_KEY is set appropriately to run this example.\n",
+    "\n",
+    "llm = OpenAI(temperature=0)\n",
+    "tools = load_tools([\"llm-math\"], llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
    "id": "bfa16b79-aa4b-4d41-a067-70d1f593f667",
    "metadata": {
     "tags": []
@@ -70,16 +86,12 @@
        "'1.0891804557407723'"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# Agent run with tracing. Ensure that OPENAI_API_KEY is set appropriately to run this example.\n",
-    "\n",
-    "llm = OpenAI(temperature=0)\n",
-    "tools = load_tools([\"llm-math\"], llm=llm)\n",
     "agent = initialize_agent(\n",
     "    tools, llm, agent=\"zero-shot-react-description\", verbose=True\n",
     ")\n",
@@ -87,10 +99,94 @@
     "agent.run(\"What is 2 raised to .123243 power?\")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "4829eb1d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mQuestion: What is 2 raised to .123243 power?\n",
+      "Thought: I need a calculator to solve this problem.\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"calculator\",\n",
+      "  \"action_input\": \"2^0.123243\"\n",
+      "}\n",
+      "```\n",
+      "\u001b[0m\n",
+      "Observation: calculator is not a valid tool, try another one.\n",
+      "\u001b[32;1m\u001b[1;3mI made a mistake, I need to use the correct tool for this question.\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"calculator\",\n",
+      "  \"action_input\": \"2^0.123243\"\n",
+      "}\n",
+      "```\n",
+      "\n",
+      "\u001b[0m\n",
+      "Observation: calculator is not a valid tool, try another one.\n",
+      "\u001b[32;1m\u001b[1;3mI made a mistake, the tool name is actually \"calc\" instead of \"calculator\".\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"calc\",\n",
+      "  \"action_input\": \"2^0.123243\"\n",
+      "}\n",
+      "```\n",
+      "\n",
+      "\u001b[0m\n",
+      "Observation: calc is not a valid tool, try another one.\n",
+      "\u001b[32;1m\u001b[1;3mI made another mistake, the tool name is actually \"Calculator\" instead of \"calc\".\n",
+      "Action:\n",
+      "```\n",
+      "{\n",
+      "  \"action\": \"Calculator\",\n",
+      "  \"action_input\": \"2^0.123243\"\n",
+      "}\n",
+      "```\n",
+      "\n",
+      "\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mAnswer: 1.0891804557407723\n",
+      "\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3mThe final answer is 1.0891804557407723.\n",
+      "Final Answer: 1.0891804557407723\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'1.0891804557407723'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Agent run with tracing using a chat model\n",
+    "agent = initialize_agent(\n",
+    "    tools, ChatOpenAI(temperature=0), agent=\"chat-zero-shot-react-description\", verbose=True\n",
+    ")\n",
+    "\n",
+    "agent.run(\"What is 2 raised to .123243 power?\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "25addd7f",
+   "id": "76abfd82",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -112,7 +208,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

langchain/__init__.py

@@ -48,6 +48,7 @@ from langchain.utilities.google_search import GoogleSearchAPIWrapper
 from langchain.utilities.google_serper import GoogleSerperAPIWrapper
 from langchain.utilities.searx_search import SearxSearchWrapper
 from langchain.utilities.serpapi import SerpAPIWrapper
+from langchain.utilities.wikipedia import WikipediaAPIWrapper
 from langchain.utilities.wolfram_alpha import WolframAlphaAPIWrapper
 from langchain.vectorstores import FAISS, ElasticVectorSearch
 
@@ -70,6 +71,7 @@ __all__ = [
     "GoogleSearchAPIWrapper",
     "GoogleSerperAPIWrapper",
     "WolframAlphaAPIWrapper",
+    "WikipediaAPIWrapper",
     "Anthropic",
     "Banana",
     "CerebriumAI",

langchain/agents/agent.py

@@ -47,7 +47,10 @@ class Agent(BaseModel):
 
     @property
     def _stop(self) -> List[str]:
-        return [f"\n{self.observation_prefix}", f"\n\t{self.observation_prefix}"]
+        return [
+            f"\n{self.observation_prefix.rstrip()}",
+            f"\n\t{self.observation_prefix.rstrip()}",
+        ]
 
     def _construct_scratchpad(
         self, intermediate_steps: List[Tuple[AgentAction, str]]
@@ -432,10 +435,6 @@ class AgentExecutor(Chain, BaseModel):
                 llm_prefix="",
                 observation_prefix=self.agent.observation_prefix,
             )
-            return_direct = False
-        if return_direct:
-            # Set the log to "" because we do not want to log it.
-            return AgentFinish({self.agent.return_values[0]: observation}, "")
         return output, observation
 
     async def _atake_next_step(
@@ -480,9 +479,6 @@ class AgentExecutor(Chain, BaseModel):
                 observation_prefix=self.agent.observation_prefix,
             )
             return_direct = False
-        if return_direct:
-            # Set the log to "" because we do not want to log it.
-            return AgentFinish({self.agent.return_values[0]: observation}, "")
         return output, observation
 
     def _call(self, inputs: Dict[str, str]) -> Dict[str, Any]:
@@ -507,6 +503,10 @@ class AgentExecutor(Chain, BaseModel):
                 return self._return(next_step_output, intermediate_steps)
 
             intermediate_steps.append(next_step_output)
+            # See if tool should return directly
+            tool_return = self._get_tool_return(next_step_output)
+            if tool_return is not None:
+                return self._return(tool_return, intermediate_steps)
             iterations += 1
         output = self.agent.return_stopped_response(
             self.early_stopping_method, intermediate_steps, **inputs
@@ -535,8 +535,28 @@ class AgentExecutor(Chain, BaseModel):
                 return await self._areturn(next_step_output, intermediate_steps)
 
             intermediate_steps.append(next_step_output)
+            # See if tool should return directly
+            tool_return = self._get_tool_return(next_step_output)
+            if tool_return is not None:
+                return await self._areturn(tool_return, intermediate_steps)
+
             iterations += 1
         output = self.agent.return_stopped_response(
             self.early_stopping_method, intermediate_steps, **inputs
         )
         return await self._areturn(output, intermediate_steps)
+
+    def _get_tool_return(
+        self, next_step_output: Tuple[AgentAction, str]
+    ) -> Optional[AgentFinish]:
+        """Check if the tool is a returning tool."""
+        agent_action, observation = next_step_output
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # Invalid tools won't be in the map, so we return False.
+        if agent_action.tool in name_to_tool_map:
+            if name_to_tool_map[agent_action.tool].return_direct:
+                return AgentFinish(
+                    {self.agent.return_values[0]: observation},
+                    "",
+                )
+        return None

langchain/agents/chat/base.py

@@ -44,10 +44,13 @@ class ChatAgent(Agent):
     def _extract_tool_and_input(self, text: str) -> Optional[Tuple[str, str]]:
         if FINAL_ANSWER_ACTION in text:
             return "Final Answer", text.split(FINAL_ANSWER_ACTION)[-1].strip()
-        _, action, _ = text.split("```")
+        try:
+            _, action, _ = text.split("```")
+            response = json.loads(action.strip())
+            return response["action"], response["action_input"]
 
-        response = json.loads(action.strip())
-        return response["action"], response["action_input"]
+        except Exception:
+            raise ValueError(f"Could not parse LLM output: {text}")
 
     @property
     def _stop(self) -> List[str]:

langchain/agents/chat/prompt.py

@@ -3,20 +3,22 @@ PREFIX = """Answer the following questions as best you can. You have access to t
 FORMAT_INSTRUCTIONS = """The way you use the tools is by specifying a json blob.
 Specifically, this json should have a `action` key (with the name of the tool to use) and a `action_input` key (with the input to the tool going here).
 
+The only values that should be in the "action" field are: {tool_names}
+
 The $JSON_BLOB should only contain a SINGLE action, do NOT return a list of multiple actions. Here is an example of a valid $JSON_BLOB:
 
 ```
-{{
-  "action": "calculator",
-  "action_input": "1 + 2"
-}}
+{{{{
+  "action": $TOOL_NAME,
+  "action_input": $INPUT
+}}}}
 ```
 
 ALWAYS use the following format:
 
 Question: the input question you must answer
 Thought: you should always think about what to do
-Action: 
+Action:
 ```
 $JSON_BLOB
 ```

langchain/agents/load_tools.py

@@ -9,12 +9,13 @@ from langchain.chains.api.base import APIChain
 from langchain.chains.llm_math.base import LLMMathChain
 from langchain.chains.pal.base import PALChain
 from langchain.llms.base import BaseLLM
-from langchain.tools.python.tool import PythonREPLTool
 from langchain.requests import RequestsWrapper
 from langchain.tools.base import BaseTool
 from langchain.tools.bing_search.tool import BingSearchRun
 from langchain.tools.google_search.tool import GoogleSearchResults, GoogleSearchRun
+from langchain.tools.python.tool import PythonREPLTool
 from langchain.tools.requests.tool import RequestsGetTool
+from langchain.tools.wikipedia.tool import WikipediaQueryRun
 from langchain.tools.wolfram_alpha.tool import WolframAlphaQueryRun
 from langchain.utilities.bash import BashProcess
 from langchain.utilities.bing_search import BingSearchAPIWrapper
@@ -22,6 +23,7 @@ from langchain.utilities.google_search import GoogleSearchAPIWrapper
 from langchain.utilities.google_serper import GoogleSerperAPIWrapper
 from langchain.utilities.searx_search import SearxSearchWrapper
 from langchain.utilities.serpapi import SerpAPIWrapper
+from langchain.utilities.wikipedia import WikipediaAPIWrapper
 from langchain.utilities.wolfram_alpha import WolframAlphaAPIWrapper
 
 
@@ -124,6 +126,10 @@ def _get_google_search(**kwargs: Any) -> BaseTool:
     return GoogleSearchRun(api_wrapper=GoogleSearchAPIWrapper(**kwargs))
 
 
+def _get_wikipedia(**kwargs: Any) -> BaseTool:
+    return WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper(**kwargs))
+
+
 def _get_google_serper(**kwargs: Any) -> BaseTool:
     return Tool(
         name="Serper Search",
@@ -173,6 +179,7 @@ _EXTRA_OPTIONAL_TOOLS = {
     "google-serper": (_get_google_serper, ["serper_api_key"]),
     "serpapi": (_get_serpapi, ["serpapi_api_key", "aiosession"]),
     "searx-search": (_get_searx_search, ["searx_host"]),
+    "wikipedia": (_get_wikipedia, ["top_k_results"]),
 }
 
 

langchain/chains/combine_documents/map_rerank.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Extra, root_validator
 from langchain.chains.combine_documents.base import BaseCombineDocumentsChain
 from langchain.chains.llm import LLMChain
 from langchain.docstore.document import Document
-from langchain.prompts.base import RegexParser
+from langchain.output_parsers.regex import RegexParser
 
 
 class MapRerankDocumentsChain(BaseCombineDocumentsChain, BaseModel):

langchain/chains/conversation/memory.py

@@ -1,6 +1,9 @@
 """Memory modules for conversation prompts."""
 
-from langchain.memory.buffer import ConversationBufferMemory
+from langchain.memory.buffer import (
+    ConversationBufferMemory,
+    ConversationStringBufferMemory,
+)
 from langchain.memory.buffer_window import ConversationBufferWindowMemory
 from langchain.memory.combined import CombinedMemory
 from langchain.memory.entity import ConversationEntityMemory
@@ -18,4 +21,5 @@ __all__ = [
     "ConversationEntityMemory",
     "ConversationBufferMemory",
     "CombinedMemory",
+    "ConversationStringBufferMemory",
 ]

langchain/chains/llm.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, Extra, validator
 
 from langchain.chains.base import Chain
 from langchain.input import get_colored_text
@@ -29,8 +29,21 @@ class LLMChain(Chain, BaseModel):
     prompt: BasePromptTemplate
     """Prompt object to use."""
     llm: BaseLanguageModel
+    """LLM wrapper to use."""
+    output_parsing_mode: str = "validate"
+    """Output parsing mode, should be one of `validate`, `off`, `parse`."""
     output_key: str = "text"  #: :meta private:
 
+    @validator("output_parsing_mode")
+    def valid_output_parsing_mode(cls, v: str) -> str:
+        """Validate output parsing mode."""
+        _valid_modes = {"off", "validate", "parse"}
+        if v not in _valid_modes:
+            raise ValueError(
+                f"Got `{v}` for output_parsing_mode, should be one of {_valid_modes}"
+            )
+        return v
+
     class Config:
         """Configuration for this pydantic object."""
 
@@ -125,11 +138,20 @@ class LLMChain(Chain, BaseModel):
 
     def create_outputs(self, response: LLMResult) -> List[Dict[str, str]]:
         """Create outputs from response."""
-        return [
+        outputs = []
+        _should_parse = self.output_parsing_mode != "off"
+        for generation in response.generations:
             # Get the text of the top generated string.
-            {self.output_key: generation[0].text}
-            for generation in response.generations
-        ]
+            response_item = generation[0].text
+            if self.prompt.output_parser is not None and _should_parse:
+                try:
+                    parsed_output = self.prompt.output_parser.parse(response_item)
+                except Exception as e:
+                    raise ValueError("Output of LLM not as expected") from e
+                if self.output_parsing_mode == "parse":
+                    response_item = parsed_output
+            outputs.append({self.output_key: response_item})
+        return outputs
 
     async def _acall(self, inputs: Dict[str, Any]) -> Dict[str, str]:
         return (await self.aapply([inputs]))[0]

langchain/chains/question_answering/map_rerank_prompt.py

@@ -1,6 +1,6 @@
 # flake8: noqa
 from langchain.prompts import PromptTemplate
-from langchain.prompts.base import RegexParser
+from langchain.output_parsers.regex import RegexParser
 
 output_parser = RegexParser(
     regex=r"(.*?)\nScore: (.*)",

langchain/chains/sql_database/base.py

@@ -117,6 +117,8 @@ class SQLDatabaseSequentialChain(Chain, BaseModel):
     This is useful in cases where the number of tables in the database is large.
     """
 
+    return_intermediate_steps: bool = False
+
     @classmethod
     def from_llm(
         cls,
@@ -154,7 +156,10 @@ class SQLDatabaseSequentialChain(Chain, BaseModel):
 
         :meta private:
         """
-        return [self.output_key]
+        if not self.return_intermediate_steps:
+            return [self.output_key]
+        else:
+            return [self.output_key, "intermediate_steps"]
 
     def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
         _table_names = self.sql_chain.database.get_table_names()

langchain/chains/sql_database/prompt.py

@@ -1,5 +1,5 @@
 # flake8: noqa
-from langchain.prompts.base import CommaSeparatedListOutputParser
+from langchain.output_parsers.list import CommaSeparatedListOutputParser
 from langchain.prompts.prompt import PromptTemplate
 
 _DEFAULT_TEMPLATE = """Given an input question, first create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer. Unless the user specifies in his question a specific number of examples he wishes 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.

langchain/chat_models/base.py

@@ -12,6 +12,7 @@ from langchain.schema import (
     BaseMessage,
     ChatGeneration,
     ChatResult,
+    HumanMessage,
     LLMResult,
     PromptValue,
 )
@@ -60,13 +61,44 @@ class BaseChatModel(BaseLanguageModel, BaseModel, ABC):
         self, prompts: List[PromptValue], stop: Optional[List[str]] = None
     ) -> LLMResult:
         prompt_messages = [p.to_messages() for p in prompts]
-        return self.generate(prompt_messages, stop=stop)
+        prompt_strings = [p.to_string() for p in prompts]
+        self.callback_manager.on_llm_start(
+            {"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
+        )
+        try:
+            output = self.generate(prompt_messages, stop=stop)
+        except (KeyboardInterrupt, Exception) as e:
+            self.callback_manager.on_llm_error(e, verbose=self.verbose)
+            raise e
+        self.callback_manager.on_llm_end(output, verbose=self.verbose)
+        return output
 
     async def agenerate_prompt(
         self, prompts: List[PromptValue], stop: Optional[List[str]] = None
     ) -> LLMResult:
         prompt_messages = [p.to_messages() for p in prompts]
-        return await self.agenerate(prompt_messages, stop=stop)
+        prompt_strings = [p.to_string() for p in prompts]
+        if self.callback_manager.is_async:
+            await self.callback_manager.on_llm_start(
+                {"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
+            )
+        else:
+            self.callback_manager.on_llm_start(
+                {"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
+            )
+        try:
+            output = await self.agenerate(prompt_messages, stop=stop)
+        except (KeyboardInterrupt, Exception) as e:
+            if self.callback_manager.is_async:
+                await self.callback_manager.on_llm_error(e, verbose=self.verbose)
+            else:
+                self.callback_manager.on_llm_error(e, verbose=self.verbose)
+            raise e
+        if self.callback_manager.is_async:
+            await self.callback_manager.on_llm_end(output, verbose=self.verbose)
+        else:
+            self.callback_manager.on_llm_end(output, verbose=self.verbose)
+        return output
 
     @abstractmethod
     def _generate(
@@ -85,6 +117,10 @@ class BaseChatModel(BaseLanguageModel, BaseModel, ABC):
     ) -> BaseMessage:
         return self._generate(messages, stop=stop).generations[0].message
 
+    def call_as_llm(self, message: str, stop: Optional[List[str]] = None) -> str:
+        result = self([HumanMessage(content=message)], stop=stop)
+        return result.content
+
 
 class SimpleChatModel(BaseChatModel):
     def _generate(

langchain/document_loaders/__init__.py

@@ -4,6 +4,7 @@ from langchain.document_loaders.airbyte_json import AirbyteJSONLoader
 from langchain.document_loaders.azlyrics import AZLyricsLoader
 from langchain.document_loaders.college_confidential import CollegeConfidentialLoader
 from langchain.document_loaders.conllu import CoNLLULoader
+from langchain.document_loaders.csv import CSVLoader
 from langchain.document_loaders.directory import DirectoryLoader
 from langchain.document_loaders.docx import UnstructuredDocxLoader
 from langchain.document_loaders.email import UnstructuredEmailLoader
@@ -96,4 +97,5 @@ __all__ = [
     "CoNLLULoader",
     "GoogleApiYoutubeLoader",
     "GoogleApiClient",
+    "CSVLoader",
 ]

langchain/document_loaders/csv.py

@@ -0,0 +1,47 @@
+from csv import DictReader
+from typing import Dict, List, Optional
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseLoader
+
+
+class CSVLoader(BaseLoader):
+    """Loads a CSV file into a list of documents.
+
+    Each document represents one row of the CSV file. Every row is converted into a
+    key/value pair and outputted to a new line in the document's page_content.
+
+    Output Example:
+        .. code-block:: txt
+
+            column1: value1
+            column2: value2
+            column3: value3
+    """
+
+    def __init__(self, file_path: str, csv_args: Optional[Dict] = None):
+        self.file_path = file_path
+        if csv_args is None:
+            self.csv_args = {
+                "delimiter": ",",
+                "quotechar": '"',
+            }
+        else:
+            self.csv_args = csv_args
+
+    def load(self) -> List[Document]:
+        docs = []
+
+        with open(self.file_path, newline="") as csvfile:
+            csv = DictReader(csvfile, **self.csv_args)  # type: ignore
+            for i, row in enumerate(csv):
+                docs.append(
+                    Document(
+                        page_content="\n".join(
+                            f"{k.strip()}: {v.strip()}" for k, v in row.items()
+                        ),
+                        metadata={"source": self.file_path, "row": i},
+                    )
+                )
+
+        return docs

langchain/document_loaders/gitbook.py

@@ -12,9 +12,26 @@ class GitbookLoader(WebBaseLoader):
     2. load all (relative) paths in the navbar.
     """
 
-    def __init__(self, web_page: str, load_all_paths: bool = False):
-        """Initialize with web page and whether to load all paths."""
+    def __init__(
+        self,
+        web_page: str,
+        load_all_paths: bool = False,
+        base_url: Optional[str] = None,
+    ):
+        """Initialize with web page and whether to load all paths.
+
+        Args:
+            web_page: The web page to load or the starting point from where
+                relative paths are discovered.
+            load_all_paths: If set to True, all relative paths in the navbar
+                are loaded instead of only `web_page`.
+            base_url: If `load_all_paths` is True, the relative paths are
+                appended to this base url. Defaults to `web_page` if not set.
+        """
         super().__init__(web_page)
+        self.base_url = base_url or web_page
+        if self.base_url.endswith("/"):
+            self.base_url = self.base_url[:-1]
         self.load_all_paths = load_all_paths
 
     def load(self) -> List[Document]:
@@ -24,7 +41,7 @@ class GitbookLoader(WebBaseLoader):
             relative_paths = self._get_paths(soup_info)
             documents = []
             for path in relative_paths:
-                url = self.web_path + path
+                url = self.base_url + path
                 print(f"Fetching text from {url}")
                 soup_info = self._scrape(url)
                 documents.append(self._get_document(soup_info, url))

langchain/document_loaders/html.py

@@ -1,4 +1,4 @@
-"""Loader that loads PDF files."""
+"""Loader that uses unstructured to load HTML files."""
 from typing import List
 
 from langchain.document_loaders.unstructured import UnstructuredFileLoader

langchain/document_loaders/url.py

@@ -1,4 +1,4 @@
-"""Loader that loads PDF files."""
+"""Loader that uses unstructured to load HTML files."""
 from typing import List
 
 from langchain.docstore.document import Document

langchain/evaluation/qa/generate_prompt.py

@@ -1,6 +1,6 @@
 # flake8: noqa
 from langchain.prompts import PromptTemplate
-from langchain.prompts.base import RegexParser
+from langchain.output_parsers.regex import RegexParser
 
 template = """You are a teacher coming up with questions to ask on a quiz. 
 Given the following document, please generate a question and answer based on that document.

langchain/guards/__init__.py

@@ -0,0 +1,7 @@
+"""Guard Module."""
+from langchain.guards.base import BaseGuard
+from langchain.guards.custom import CustomGuard
+from langchain.guards.restriction import RestrictionGuard
+from langchain.guards.string import StringGuard
+
+__all__ = ["BaseGuard", "CustomGuard", "RestrictionGuard", "StringGuard"]

langchain/guards/base.py

@@ -0,0 +1,78 @@
+"""Base Guard class."""
+from typing import Any, Callable, Tuple, Union
+
+
+class BaseGuard:
+    """The Guard class is a decorator that can be applied to any chain or agent.
+
+    Can be used to either throw an error or recursively call the chain or agent
+    when the output of said chain or agent violates the rules of the guard.
+    The BaseGuard alone does nothing but can be subclassed and the resolve_guard
+    function overwritten to create more specific guards.
+
+    Args:
+        retries (int, optional): The number of times the chain or agent should be
+            called recursively if the output violates the restrictions. Defaults to 0.
+
+    Raises:
+        Exception: If the output violates the restrictions and the maximum number
+            of retries has been exceeded.
+    """
+
+    def __init__(self, retries: int = 0, *args: Any, **kwargs: Any) -> None:
+        """Initialize with number of retries."""
+        self.retries = retries
+
+    def resolve_guard(
+        self, llm_response: str, *args: Any, **kwargs: Any
+    ) -> Tuple[bool, str]:
+        """Determine if guard was violated (if response should be blocked).
+
+        Can be overwritten when subclassing to expand on guard functionality
+
+        Args:
+            llm_response (str): the llm_response string to be tested against the guard.
+
+        Returns:
+            tuple:
+                bool: True if guard was violated, False otherwise.
+                str: The message to be displayed when the guard is violated
+                    (if guard was violated).
+        """
+        return False, ""
+
+    def handle_violation(self, message: str, *args: Any, **kwargs: Any) -> Exception:
+        """Handle violation of guard.
+
+        Args:
+            message (str): the message to be displayed when the guard is violated.
+
+        Raises:
+            Exception: the message passed to the function.
+        """
+        raise Exception(message)
+
+    def __call__(self, func: Callable) -> Callable:
+        """Create wrapper to be returned."""
+
+        def wrapper(*args: Any, **kwargs: Any) -> Union[str, Exception]:
+            """Create wrapper to return."""
+            if self.retries < 0:
+                raise Exception("Restriction violated. Maximum retries exceeded.")
+            try:
+                llm_response = func(*args, **kwargs)
+                guard_result, violation_message = self.resolve_guard(llm_response)
+                if guard_result:
+                    return self.handle_violation(violation_message)
+                else:
+                    return llm_response
+            except Exception as e:
+                self.retries = self.retries - 1
+                # Check retries to avoid infinite recursion if exception is something
+                # other than a violation of the guard
+                if self.retries >= 0:
+                    return wrapper(*args, **kwargs)
+                else:
+                    raise e
+
+        return wrapper

langchain/guards/custom.py

@@ -0,0 +1,86 @@
+"""Check if chain or agent violates a provided guard function."""
+from typing import Any, Callable, Tuple
+
+from langchain.guards.base import BaseGuard
+
+
+class CustomGuard(BaseGuard):
+    """Check if chain or agent violates a provided guard function.
+
+    Args:
+        guard_function (func): The function to be used to guard the
+            output of the chain or agent. The function should take
+            the output of the chain or agent as its only argument
+            and return a boolean value where True means the guard
+            has been violated. Optionally, return a tuple where the
+            first element is a boolean value and the second element is
+            a string that will be displayed when the guard is violated.
+            If the string is ommited the default message will be used.
+        retries (int, optional): The number of times the chain or agent
+            should be called recursively if the output violates the
+            restrictions. Defaults to 0.
+
+    Raises:
+        Exception: If the output violates the restrictions and the
+            maximum number of retries has been exceeded.
+
+    Example:
+        .. code-block:: python
+
+            from langchain import LLMChain, OpenAI, PromptTemplate
+            from langchain.guards import CustomGuard
+
+            llm = OpenAI(temperature=0.9)
+
+            prompt_template = "Tell me a {adjective} joke"
+            prompt = PromptTemplate(
+                input_variables=["adjective"], template=prompt_template
+            )
+            chain = LLMChain(llm=OpenAI(), prompt=prompt)
+
+            def is_long(llm_output):
+                return len(llm_output) > 100
+
+            @CustomGuard(guard_function=is_long, retries=1)
+            def call_chain():
+                return chain.run(adjective="political")
+
+            call_chain()
+
+    """
+
+    def __init__(self, guard_function: Callable, retries: int = 0) -> None:
+        """Initialize with guard function and retries."""
+        super().__init__(retries=retries)
+        self.guard_function = guard_function
+
+    def resolve_guard(
+        self, llm_response: str, *args: Any, **kwargs: Any
+    ) -> Tuple[bool, str]:
+        """Determine if guard was violated. Uses custom guard function.
+
+        Args:
+            llm_response (str): the llm_response string to be tested against the guard.
+
+        Returns:
+            tuple:
+                bool: True if guard was violated, False otherwise.
+                str: The message to be displayed when the guard is violated
+                    (if guard was violated).
+        """
+        response = self.guard_function(llm_response)
+
+        if type(response) is tuple:
+            boolean_output, message = response
+            violation_message = message
+        elif type(response) is bool:
+            boolean_output = response
+            violation_message = (
+                f"Restriction violated. Attempted answer: {llm_response}."
+            )
+        else:
+            raise Exception(
+                "Custom guard function must return either a boolean"
+                " or a tuple of a boolean and a string."
+            )
+        return boolean_output, violation_message

langchain/guards/restriction.py

@@ -0,0 +1,97 @@
+"""Check if chain or agent violates one or more restrictions."""
+from __future__ import annotations
+
+from typing import Any, List, Tuple
+
+from langchain.chains.llm import LLMChain
+from langchain.guards.base import BaseGuard
+from langchain.guards.restriction_prompt import RESTRICTION_PROMPT
+from langchain.llms.base import BaseLLM
+from langchain.output_parsers.boolean import BooleanOutputParser
+from langchain.prompts.base import BasePromptTemplate
+
+
+class RestrictionGuard(BaseGuard):
+    """Check if chain or agent violates one or more restrictions.
+
+    Args:
+        llm (LLM): The LLM to be used to guard the output of the chain or agent.
+        restrictions (list): A list of strings that describe the restrictions that
+            the output of the chain or agent must conform to. The restrictions
+            should be in the form of "must not x" or "must x" for best results.
+        retries (int, optional): The number of times the chain or agent should be
+            called recursively if the output violates the restrictions. Defaults to 0.
+
+    Raises:
+        Exception: If the output violates the restrictions and the maximum
+            number of retries has been exceeded.
+
+    Example:
+        .. code-block:: python
+            llm = OpenAI(temperature=0.9)
+
+            text = (
+                "What would be a good company name for a company"
+                "that makes colorful socks? Give me a name in latin."
+            )
+
+            @RestrictionGuard(
+                restrictions=['output must be in latin'], llm=llm, retries=0
+            )
+            def sock_idea():
+                return llm(text)
+
+            sock_idea()
+    """
+
+    def __init__(
+        self,
+        guard_chain: LLMChain,
+        restrictions: List[str],
+        retries: int = 0,
+    ) -> None:
+        """Initialize with restriction, prompt, and llm."""
+        super().__init__(retries=retries)
+        self.guard_chain = guard_chain
+        self.restrictions = restrictions
+        self.output_parser = BooleanOutputParser(true_values=["¥"], false_values=["ƒ"])
+
+    @classmethod
+    def from_llm(
+        cls,
+        llm: BaseLLM,
+        prompt: BasePromptTemplate = RESTRICTION_PROMPT,
+        **kwargs: Any,
+    ) -> RestrictionGuard:
+        """Load from llm and prompt."""
+        guard_chain = LLMChain(llm=llm, prompt=prompt)
+        return cls(guard_chain=guard_chain, **kwargs)
+
+    def resolve_guard(
+        self, llm_response: str, *args: Any, **kwargs: Any
+    ) -> Tuple[bool, str]:
+        """Determine if guard was violated.
+        Uses a custom guard chain to determine is a set of restrictions was violated.
+
+        Args:
+            llm_response (str): the llm_response string to be tested against the guard.
+
+        Returns:
+            tuple:
+                bool: True if guard was violated, False otherwise.
+                str: The message to be displayed when the guard is violated
+                    (if guard was violated).
+        """
+
+        concatenated_restrictions = ", ".join(self.restrictions)
+
+        # guard chain returns true in case of a violation.
+        guard_chain_output = self.guard_chain.run(
+            function_output=llm_response, restrictions=concatenated_restrictions
+        )
+        violation_message = (
+            f"Restriction violated. Attempted answer: {llm_response}. "
+            f"Reasoning: {guard_chain_output}."
+        )
+        bool_return = self.output_parser.parse(guard_chain_output)
+        return bool_return, violation_message

langchain/guards/restriction_prompt.py

@@ -0,0 +1,23 @@
+# flake8: noqa
+from langchain.prompts.prompt import PromptTemplate
+
+RESTRICTION_TEMPLATE = """Determine if the output of a function violates any restrictions. If the output violates any of the restrictions, respond with your reason followed by ¥. If the output does not violate any restrictions, respond with your reason followed by ƒ.
+
+output: Lorum ipsum dolor sit amet
+restrictions: must not include profanity
+response: output does not include profanity (ƒ)
+
+output: Lorum ipsum dolor sit amet
+restrictions: must not include latin
+response: output includes latin (¥)
+
+output: I hate you, you ugly jerk!
+restrictions: must not be negative, must not be an insult
+response: output is negative and an insult (¥)
+
+output: {function_output}
+restrictions:{restrictions}
+response:"""
+RESTRICTION_PROMPT = PromptTemplate(
+    input_variables=["function_output", "restrictions"], template=RESTRICTION_TEMPLATE
+)

langchain/guards/string.py

@@ -0,0 +1,103 @@
+"""Check whe returns a large portion of a protected string (like a prompt)."""
+from typing import Any, List, Tuple
+
+from langchain.guards.base import BaseGuard
+
+
+def _overlap_percent(protected_string: str, llm_response: str) -> float:
+    protected_string = protected_string.lower()
+    llm_response = llm_response.lower()
+    len_protected, len_llm_response = len(protected_string), len(llm_response)
+    max_overlap = 0
+    for i in range(len_llm_response - len_protected + 1):
+        for n in range(len_protected + 1):
+            if llm_response[i : i + n] in protected_string:
+                max_overlap = max(max_overlap, n)
+    overlap_percent = max_overlap / len_protected
+    return overlap_percent
+
+
+class StringGuard(BaseGuard):
+    """Check whe returns a large portion of a protected string (like a prompt).
+
+    The primary use of this guard is to prevent the chain or agent from leaking
+     information about its prompt or other sensitive information.
+     This can also be used as a rudimentary filter of other things like profanity.
+
+    Args:
+        protected_strings (List[str]): The list of protected_strings to be guarded
+        leniency (float, optional): The percentage of a protected_string that can
+            be leaked before the guard is violated. Defaults to 0.5.
+            For example, if the protected_string is "Tell me a joke" and the
+            leniency is 0.75, then the guard will be violated if the output
+            contains more than 75% of the protected_string.
+            100% leniency means that the guard will only be violated when
+            the string is returned exactly while 0% leniency means that the guard
+            will always be violated.
+        retries (int, optional): The number of times the chain or agent should be
+            called recursively if the output violates the restrictions. Defaults to 0.
+
+    Raises:
+        Exception: If the output violates the restrictions and the maximum number of
+            retries has been exceeded.
+
+    Example:
+        .. code-block:: python
+
+            from langchain import LLMChain, OpenAI, PromptTemplate
+
+            llm = OpenAI(temperature=0.9)
+
+            prompt_template = "Tell me a {adjective} joke"
+            prompt = PromptTemplate(
+                input_variables=["adjective"], template=prompt_template
+            )
+            chain = LLMChain(llm=OpenAI(), prompt=prompt)
+
+            @StringGuard(protected_strings=[prompt], leniency=0.25 retries=1)
+            def call_chain():
+                return chain.run(adjective="political")
+
+            call_chain()
+
+    """
+
+    def __init__(
+        self, protected_strings: List[str], leniency: float = 0.5, retries: int = 0
+    ) -> None:
+        """Initialize with protected strings and leniency."""
+        super().__init__(retries=retries)
+        self.protected_strings = protected_strings
+        self.leniency = leniency
+
+    def resolve_guard(
+        self, llm_response: str, *args: Any, **kwargs: Any
+    ) -> Tuple[bool, str]:
+        """Function to determine if guard was violated.
+
+        Checks for string leakage. Uses protected_string and leniency.
+        If the output contains more than leniency * 100% of the protected_string,
+         the guard is violated.
+
+        Args:
+            llm_response (str): the llm_response string to be tested against the guard.
+
+        Returns:
+            tuple:
+                bool: True if guard was violated, False otherwise.
+                str: The message to be displayed when the guard is violated
+                    (if guard was violated).
+        """
+
+        protected_strings = self.protected_strings
+        leniency = self.leniency
+
+        for protected_string in protected_strings:
+            similarity = _overlap_percent(protected_string, llm_response)
+            if similarity >= leniency:
+                violation_message = (
+                    f"Restriction violated. Attempted answer: {llm_response}. "
+                    f"Reasoning: Leakage of protected string: {protected_string}."
+                )
+                return True, violation_message
+        return False, ""

langchain/indexes/vectorstore.py

@@ -50,8 +50,9 @@ class VectorstoreIndexCreator(BaseModel):
     """Logic for creating indexes."""
 
     vectorstore_cls: Type[VectorStore] = Chroma
-    embedding: Embeddings = Field(default_factory=OpenAIEmbeddings)
     text_splitter: TextSplitter = Field(default_factory=_get_default_text_splitter)
+    embedding: Embeddings = Field(default_factory=OpenAIEmbeddings)
+    vectorstore_kwargs: dict = Field(default_factory=dict)
 
     class Config:
         """Configuration for this pydantic object."""
@@ -65,5 +66,7 @@ class VectorstoreIndexCreator(BaseModel):
         for loader in loaders:
             docs.extend(loader.load())
         sub_docs = self.text_splitter.split_documents(docs)
-        vectorstore = self.vectorstore_cls.from_documents(sub_docs, self.embedding)
+        vectorstore = self.vectorstore_cls.from_documents(
+            sub_docs, self.embedding, **self.vectorstore_kwargs
+        )
         return VectorStoreIndexWrapper(vectorstore=vectorstore)

langchain/memory/__init__.py

@@ -1,9 +1,13 @@
-from langchain.memory.buffer import ConversationBufferMemory
+from langchain.memory.buffer import (
+    ConversationBufferMemory,
+    ConversationStringBufferMemory,
+)
 from langchain.memory.buffer_window import ConversationBufferWindowMemory
 from langchain.memory.chat_memory import ChatMessageHistory
 from langchain.memory.combined import CombinedMemory
 from langchain.memory.entity import ConversationEntityMemory
 from langchain.memory.kg import ConversationKGMemory
+from langchain.memory.readonly import ReadOnlySharedMemory
 from langchain.memory.simple import SimpleMemory
 from langchain.memory.summary import ConversationSummaryMemory
 from langchain.memory.summary_buffer import ConversationSummaryBufferMemory
@@ -18,4 +22,6 @@ __all__ = [
     "ConversationEntityMemory",
     "ConversationSummaryMemory",
     "ChatMessageHistory",
+    "ConversationStringBufferMemory",
+    "ReadOnlySharedMemory",
 ]

langchain/memory/buffer.py

@@ -1,9 +1,9 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, root_validator
 
-from langchain.memory.chat_memory import BaseChatMemory
-from langchain.memory.utils import get_buffer_string
+from langchain.memory.chat_memory import BaseChatMemory, BaseMemory
+from langchain.memory.utils import get_buffer_string, get_prompt_input_key
 
 
 class ConversationBufferMemory(BaseChatMemory, BaseModel):
@@ -36,3 +36,55 @@ class ConversationBufferMemory(BaseChatMemory, BaseModel):
     def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
         """Return history buffer."""
         return {self.memory_key: self.buffer}
+
+
+class ConversationStringBufferMemory(BaseMemory, 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:
+
+    @root_validator()
+    def validate_chains(cls, values: Dict) -> Dict:
+        """Validate that return messages is not True."""
+        if values.get("return_messages", False):
+            raise ValueError(
+                "return_messages must be False for ConversationStringBufferMemory"
+            )
+        return values
+
+    @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 = ""

langchain/memory/readonly.py

@@ -0,0 +1,26 @@
+from typing import Any, Dict, List
+
+from langchain.schema import BaseMemory
+
+
+class ReadOnlySharedMemory(BaseMemory):
+    """A memory wrapper that is read-only and cannot be changed."""
+
+    memory: BaseMemory
+
+    @property
+    def memory_variables(self) -> List[str]:
+        """Return memory variables."""
+        return self.memory.memory_variables
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
+        """Load memory variables from memory."""
+        return self.memory.load_memory_variables(inputs)
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
+        """Nothing should be saved or changed"""
+        pass
+
+    def clear(self) -> None:
+        """Nothing to clear, got a memory like a vault."""
+        pass

langchain/output_parsers/__init__.py

@@ -0,0 +1,15 @@
+from langchain.output_parsers.base import BaseOutputParser
+from langchain.output_parsers.boolean import BooleanOutputParser
+from langchain.output_parsers.list import (
+    CommaSeparatedListOutputParser,
+    ListOutputParser,
+)
+from langchain.output_parsers.regex import RegexParser
+
+__all__ = [
+    "RegexParser",
+    "ListOutputParser",
+    "CommaSeparatedListOutputParser",
+    "BaseOutputParser",
+    "BooleanOutputParser",
+]

langchain/output_parsers/base.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from pydantic import BaseModel
+
+
+class BaseOutputParser(BaseModel, ABC):
+    """Class to parse the output of an LLM call."""
+
+    @abstractmethod
+    def parse(self, text: str) -> Any:
+        """Parse the output of an LLM call."""
+
+    @property
+    def _type(self) -> str:
+        """Return the type key."""
+        raise NotImplementedError
+
+    def dict(self, **kwargs: Any) -> Dict:
+        """Return dictionary representation of output parser."""
+        output_parser_dict = super().dict()
+        output_parser_dict["_type"] = self._type
+        return output_parser_dict

langchain/output_parsers/boolean.py

@@ -0,0 +1,67 @@
+"""Class to parse output to boolean."""
+import re
+from typing import Dict, List
+
+from pydantic import Field, root_validator
+
+from langchain.output_parsers.base import BaseOutputParser
+
+
+class BooleanOutputParser(BaseOutputParser):
+    """Class to parse output to boolean."""
+
+    true_values: List[str] = Field(default=["1"])
+    false_values: List[str] = Field(default=["0"])
+
+    @root_validator(pre=True)
+    def validate_values(cls, values: Dict) -> Dict:
+        """Validate that the false/true values are consistent."""
+        true_values = values["true_values"]
+        false_values = values["false_values"]
+        if any([true_value in false_values for true_value in true_values]):
+            raise ValueError(
+                "The true values and false values lists contain the same value."
+            )
+        return values
+
+    def parse(self, text: str) -> bool:
+        """Output a boolean from a string.
+
+        Allows a LLM's response to be parsed into a boolean.
+        For example, if a LLM returns "1", this function will return True.
+        Likewise if an LLM returns "The answer is: \n1\n", this function will
+        also return True.
+
+        If value errors are common try changing the true and false values to
+        rare characters so that it is unlikely the response could contain the
+        character unless that was the 'intention'
+        (insofar as that makes epistemological sense to say for a non-agential program)
+         of the LLM.
+
+        Args:
+            text (str): The string to be parsed into a boolean.
+
+        Raises:
+            ValueError: If the input string is not a valid boolean.
+
+        Returns:
+            bool: The boolean value of the input string.
+        """
+
+        input_string = re.sub(
+            r"[^" + "".join(self.true_values + self.false_values) + "]", "", text
+        )
+        if input_string == "":
+            raise ValueError(
+                "The input string contains neither true nor false characters and"
+                " is therefore not a valid boolean."
+            )
+        # if the string has both true and false values, raise a value error
+        if any([true_value in input_string for true_value in self.true_values]) and any(
+            [false_value in input_string for false_value in self.false_values]
+        ):
+            raise ValueError(
+                "The input string contains both true and false characters and "
+                "therefore is not a valid boolean."
+            )
+        return input_string in self.true_values

langchain/output_parsers/list.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import List
+
+from langchain.output_parsers.base import BaseOutputParser
+
+
+class ListOutputParser(BaseOutputParser):
+    """Class to parse the output of an LLM call to a list."""
+
+    @abstractmethod
+    def parse(self, text: str) -> List[str]:
+        """Parse the output of an LLM call."""
+
+
+class CommaSeparatedListOutputParser(ListOutputParser):
+    """Parse out comma separated lists."""
+
+    def parse(self, text: str) -> List[str]:
+        """Parse the output of an LLM call."""
+        return text.strip().split(", ")

langchain/output_parsers/loading.py

@@ -0,0 +1,15 @@
+from langchain.output_parsers.regex import RegexParser
+
+
+def load_output_parser(config: dict) -> dict:
+    """Load output parser."""
+    if "output_parsers" in config:
+        if config["output_parsers"] is not None:
+            _config = config["output_parsers"]
+            output_parser_type = _config["_type"]
+            if output_parser_type == "regex_parser":
+                output_parser = RegexParser(**_config)
+            else:
+                raise ValueError(f"Unsupported output parser {output_parser_type}")
+            config["output_parsers"] = output_parser
+    return config

langchain/output_parsers/regex.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import re
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel
+
+from langchain.output_parsers.base import BaseOutputParser
+
+
+class RegexParser(BaseOutputParser, BaseModel):
+    """Class to parse the output into a dictionary."""
+
+    regex: str
+    output_keys: List[str]
+    default_output_key: Optional[str] = None
+
+    @property
+    def _type(self) -> str:
+        """Return the type key."""
+        return "regex_parser"
+
+    def parse(self, text: str) -> Dict[str, str]:
+        """Parse the output of an LLM call."""
+        match = re.search(self.regex, text)
+        if match:
+            return {key: match.group(i + 1) for i, key in enumerate(self.output_keys)}
+        else:
+            if self.default_output_key is None:
+                raise ValueError(f"Could not parse output: {text}")
+            else:
+                return {
+                    key: text if key == self.default_output_key else ""
+                    for key in self.output_keys
+                }

langchain/prompts/base.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import json
-import re
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Mapping, Optional, Union
@@ -11,6 +10,12 @@ import yaml
 from pydantic import BaseModel, Extra, Field, root_validator
 
 from langchain.formatting import formatter
+from langchain.output_parsers.base import BaseOutputParser
+from langchain.output_parsers.list import (  # noqa: F401
+    CommaSeparatedListOutputParser,
+    ListOutputParser,
+)
+from langchain.output_parsers.regex import RegexParser  # noqa: F401
 from langchain.schema import BaseMessage, HumanMessage, PromptValue
 
 
@@ -54,68 +59,6 @@ def check_valid_template(
         )
 
 
-class BaseOutputParser(BaseModel, ABC):
-    """Class to parse the output of an LLM call."""
-
-    @abstractmethod
-    def parse(self, text: str) -> Union[str, List[str], Dict[str, str]]:
-        """Parse the output of an LLM call."""
-
-    @property
-    def _type(self) -> str:
-        """Return the type key."""
-        raise NotImplementedError
-
-    def dict(self, **kwargs: Any) -> Dict:
-        """Return dictionary representation of output parser."""
-        output_parser_dict = super().dict()
-        output_parser_dict["_type"] = self._type
-        return output_parser_dict
-
-
-class ListOutputParser(BaseOutputParser):
-    """Class to parse the output of an LLM call to a list."""
-
-    @abstractmethod
-    def parse(self, text: str) -> List[str]:
-        """Parse the output of an LLM call."""
-
-
-class CommaSeparatedListOutputParser(ListOutputParser):
-    """Parse out comma separated lists."""
-
-    def parse(self, text: str) -> List[str]:
-        """Parse the output of an LLM call."""
-        return text.strip().split(", ")
-
-
-class RegexParser(BaseOutputParser, BaseModel):
-    """Class to parse the output into a dictionary."""
-
-    regex: str
-    output_keys: List[str]
-    default_output_key: Optional[str] = None
-
-    @property
-    def _type(self) -> str:
-        """Return the type key."""
-        return "regex_parser"
-
-    def parse(self, text: str) -> Dict[str, str]:
-        """Parse the output of an LLM call."""
-        match = re.search(self.regex, text)
-        if match:
-            return {key: match.group(i + 1) for i, key in enumerate(self.output_keys)}
-        else:
-            if self.default_output_key is None:
-                raise ValueError(f"Could not parse output: {text}")
-            else:
-                return {
-                    key: text if key == self.default_output_key else ""
-                    for key in self.output_keys
-                }
-
-
 class StringPromptValue(PromptValue):
     text: str
 

langchain/prompts/chat.py

@@ -7,6 +7,7 @@ from typing import Any, Callable, List, Sequence, Tuple, Type, Union
 
 from pydantic import BaseModel, Field
 
+from langchain.memory.buffer import get_buffer_string
 from langchain.prompts.base import BasePromptTemplate, StringPromptTemplate
 from langchain.prompts.prompt import PromptTemplate
 from langchain.schema import (
@@ -111,7 +112,7 @@ class ChatPromptValue(PromptValue):
 
     def to_string(self) -> str:
         """Return prompt as string."""
-        return str(self.messages)
+        return get_buffer_string(self.messages)
 
     def to_messages(self) -> List[BaseMessage]:
         """Return prompt as messages."""

langchain/prompts/loading.py

@@ -7,7 +7,8 @@ from typing import Union
 
 import yaml
 
-from langchain.prompts.base import BasePromptTemplate, RegexParser
+from langchain.output_parsers.regex import RegexParser
+from langchain.prompts.base import BasePromptTemplate
 from langchain.prompts.few_shot import FewShotPromptTemplate
 from langchain.prompts.prompt import PromptTemplate
 from langchain.utilities.loading import try_load_from_hub
@@ -73,15 +74,15 @@ def _load_examples(config: dict) -> dict:
 
 def _load_output_parser(config: dict) -> dict:
     """Load output parser."""
-    if "output_parser" in config:
-        if config["output_parser"] is not None:
-            _config = config["output_parser"]
+    if "output_parsers" in config:
+        if config["output_parsers"] is not None:
+            _config = config["output_parsers"]
             output_parser_type = _config["_type"]
             if output_parser_type == "regex_parser":
                 output_parser = RegexParser(**_config)
             else:
                 raise ValueError(f"Unsupported output parser {output_parser_type}")
-            config["output_parser"] = output_parser
+            config["output_parsers"] = output_parser
     return config
 
 

langchain/text_splitter.py

@@ -1,6 +1,7 @@
 """Functionality for splitting text."""
 from __future__ import annotations
 
+import copy
 import logging
 from abc import ABC, abstractmethod
 from typing import (
@@ -51,7 +52,10 @@ class TextSplitter(ABC):
         documents = []
         for i, text in enumerate(texts):
             for chunk in self.split_text(text):
-                documents.append(Document(page_content=chunk, metadata=_metadatas[i]))
+                new_doc = Document(
+                    page_content=chunk, metadata=copy.deepcopy(_metadatas[i])
+                )
+                documents.append(new_doc)
         return documents
 
     def split_documents(self, documents: List[Document]) -> List[Document]:

langchain/tools/wikipedia/__init__.py

@@ -0,0 +1 @@
+"""Wikipedia API toolkit."""

langchain/tools/wikipedia/tool.py

@@ -0,0 +1,25 @@
+"""Tool for the Wolfram Alpha API."""
+
+from langchain.tools.base import BaseTool
+from langchain.utilities.wikipedia import WikipediaAPIWrapper
+
+
+class WikipediaQueryRun(BaseTool):
+    """Tool that adds the capability to search using the Wikipedia API."""
+
+    name = "Wikipedia"
+    description = (
+        "A wrapper around Wikipedia. "
+        "Useful for when you need to answer general questions about "
+        "people, places, companies, historical events, or other subjects. "
+        "Input should be a search query."
+    )
+    api_wrapper: WikipediaAPIWrapper
+
+    def _run(self, query: str) -> str:
+        """Use the Wikipedia tool."""
+        return self.api_wrapper.run(query)
+
+    async def _arun(self, query: str) -> str:
+        """Use the Wikipedia tool asynchronously."""
+        raise NotImplementedError("WikipediaQueryRun does not support async")

langchain/utilities/__init__.py

@@ -7,6 +7,7 @@ from langchain.utilities.google_search import GoogleSearchAPIWrapper
 from langchain.utilities.google_serper import GoogleSerperAPIWrapper
 from langchain.utilities.searx_search import SearxSearchWrapper
 from langchain.utilities.serpapi import SerpAPIWrapper
+from langchain.utilities.wikipedia import WikipediaAPIWrapper
 from langchain.utilities.wolfram_alpha import WolframAlphaAPIWrapper
 
 __all__ = [
@@ -19,4 +20,5 @@ __all__ = [
     "SerpAPIWrapper",
     "SearxSearchWrapper",
     "BingSearchAPIWrapper",
+    "WikipediaAPIWrapper",
 ]

langchain/utilities/searx_search.py

@@ -1,4 +1,4 @@
-"""Chain that calls SearxNG meta search API.
+"""Utility for using SearxNG meta search API.
 
 SearxNG is a privacy-friendly free metasearch engine that aggregates results from
 `multiple search engines
@@ -15,7 +15,7 @@ Quick Start
 -----------
 
 
-In order to use this chain you need to provide the searx host. This can be done
+In order to use this tool you need to provide the searx host. This can be done
 by passing the named parameter :attr:`searx_host <SearxSearchWrapper.searx_host>`
 or exporting the environment variable SEARX_HOST.
 Note: this is the only required parameter.

langchain/utilities/wikipedia.py

@@ -0,0 +1,56 @@
+"""Util that calls Wikipedia."""
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Extra, root_validator
+
+
+class WikipediaAPIWrapper(BaseModel):
+    """Wrapper around WikipediaAPI.
+
+    To use, you should have the ``wikipedia`` python package installed.
+    This wrapper will use the Wikipedia API to conduct searches and
+    fetch page summaries. By default, it will return the page summaries
+    of the top-k results of an input search.
+    """
+
+    wiki_client: Any  #: :meta private:
+    top_k_results: int = 3
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        extra = Extra.forbid
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that the python package exists in environment."""
+        try:
+            import wikipedia
+
+            values["wiki_client"] = wikipedia
+        except ImportError:
+            raise ValueError(
+                "Could not import wikipedia python package. "
+                "Please it install it with `pip install wikipedia`."
+            )
+        return values
+
+    def run(self, query: str) -> str:
+        """Run Wikipedia search and get page summaries."""
+        search_results = self.wiki_client.search(query)
+        summaries = []
+        for i in range(min(self.top_k_results, len(search_results))):
+            summary = self.fetch_formatted_page_summary(search_results[i])
+            if summary is not None:
+                summaries.append(summary)
+        return "\n\n".join(summaries)
+
+    def fetch_formatted_page_summary(self, page: str) -> Optional[str]:
+        try:
+            wiki_page = self.wiki_client.page(title=page)
+            return f"Page: {page}\nSummary: {wiki_page.summary}"
+        except (
+            self.wiki_client.exceptions.PageError,
+            self.wiki_client.exceptions.DisambiguationError,
+        ):
+            return None

langchain/vectorstores/chroma.py

@@ -16,6 +16,23 @@ if TYPE_CHECKING:
 logger = logging.getLogger()
 
 
+def _results_to_docs(results: Any) -> List[Document]:
+    return [doc for doc, _ in _results_to_docs_and_scores(results)]
+
+
+def _results_to_docs_and_scores(results: Any) -> List[Tuple[Document, float]]:
+    return [
+        # TODO: Chroma can do batch querying,
+        # we shouldn't hard code to the 1st result
+        (Document(page_content=result[0], metadata=result[1]), result[2])
+        for result in zip(
+            results["documents"][0],
+            results["metadatas"][0],
+            results["distances"][0],
+        )
+    ]
+
+
 class Chroma(VectorStore):
     """Wrapper around ChromaDB embeddings platform.
 
@@ -61,22 +78,12 @@ class Chroma(VectorStore):
         self._client = chromadb.Client(self._client_settings)
         self._embedding_function = embedding_function
         self._persist_directory = persist_directory
-
-        # Check if the collection exists, create it if not
-        if collection_name in [col.name for col in self._client.list_collections()]:
-            self._collection = self._client.get_collection(name=collection_name)
-            # TODO: Persist the user's embedding function
-            logger.warning(
-                f"Collection {collection_name} already exists,"
-                " Do you have the right embedding function?"
-            )
-        else:
-            self._collection = self._client.create_collection(
-                name=collection_name,
-                embedding_function=self._embedding_function.embed_documents
-                if self._embedding_function is not None
-                else None,
-            )
+        self._collection = self._client.get_or_create_collection(
+            name=collection_name,
+            embedding_function=self._embedding_function.embed_documents
+            if self._embedding_function is not None
+            else None,
+        )
 
     def add_texts(
         self,
@@ -126,6 +133,22 @@ class Chroma(VectorStore):
         docs_and_scores = self.similarity_search_with_score(query, k)
         return [doc for doc, _ in docs_and_scores]
 
+    def similarity_search_by_vector(
+        self,
+        embedding: List[float],
+        k: int = 4,
+        **kwargs: Any,
+    ) -> List[Document]:
+        """Return docs most similar to embedding vector.
+        Args:
+            embedding: Embedding to look up documents similar to.
+            k: Number of Documents to return. Defaults to 4.
+        Returns:
+            List of Documents most similar to the query vector.
+        """
+        results = self._collection.query(query_embeddings=embedding, n_results=k)
+        return _results_to_docs(results)
+
     def similarity_search_with_score(
         self,
         query: str,
@@ -154,17 +177,7 @@ class Chroma(VectorStore):
                 query_embeddings=[query_embedding], n_results=k, where=filter
             )
 
-        docs = [
-            # TODO: Chroma can do batch querying,
-            # we shouldn't hard code to the 1st result
-            (Document(page_content=result[0], metadata=result[1]), result[2])
-            for result in zip(
-                results["documents"][0],
-                results["metadatas"][0],
-                results["distances"][0],
-            )
-        ]
-        return docs
+        return _results_to_docs_and_scores(results)
 
     def delete_collection(self) -> None:
         """Delete the collection."""
@@ -201,12 +214,13 @@ class Chroma(VectorStore):
         Otherwise, the data will be ephemeral in-memory.
 
         Args:
+            texts (List[str]): List of texts to add to the collection.
             collection_name (str): Name of the collection to create.
             persist_directory (Optional[str]): Directory to persist the collection.
-            documents (List[Document]): List of documents to add.
             embedding (Optional[Embeddings]): Embedding function. Defaults to None.
             metadatas (Optional[List[dict]]): List of metadatas. Defaults to None.
             ids (Optional[List[str]]): List of document IDs. Defaults to None.
+            client_settings (Optional[chromadb.config.Settings]): Chroma client settings
 
         Returns:
             Chroma: Chroma vectorstore.
@@ -239,9 +253,10 @@ class Chroma(VectorStore):
         Args:
             collection_name (str): Name of the collection to create.
             persist_directory (Optional[str]): Directory to persist the collection.
+            ids (Optional[List[str]]): List of document IDs. Defaults to None.
             documents (List[Document]): List of documents to add to the vectorstore.
             embedding (Optional[Embeddings]): Embedding function. Defaults to None.
-
+            client_settings (Optional[chromadb.config.Settings]): Chroma client settings
         Returns:
             Chroma: Chroma vectorstore.
         """

langchain/vectorstores/faiss.py

@@ -38,7 +38,7 @@ class FAISS(VectorStore):
         .. code-block:: python
 
             from langchain import FAISS
-            faiss = FAISS(embedding_function, index, docstore)
+            faiss = FAISS(embedding_function, index, docstore, index_to_docstore_id)
 
     """
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain"
-version = "0.0.106"
+version = "0.0.108"
 description = "Building applications with LLMs through composability"
 authors = []
 license = "MIT"
@@ -65,6 +65,7 @@ sphinx-panels = "^0.6.0"
 toml = "^0.10.2"
 myst-nb = "^0.17.1"
 linkchecker = "^10.2.1"
+sphinx-copybutton = "^0.5.1"
 
 [tool.poetry.group.test.dependencies]
 pytest = "^7.2.0"

tests/integration_tests/chains/test_sql_database.py

@@ -1,7 +1,10 @@
 """Test SQL Database Chain."""
 from sqlalchemy import Column, Integer, MetaData, String, Table, create_engine, insert
 
-from langchain.chains.sql_database.base import SQLDatabaseChain
+from langchain.chains.sql_database.base import (
+    SQLDatabaseChain,
+    SQLDatabaseSequentialChain,
+)
 from langchain.llms.openai import OpenAI
 from langchain.sql_database import SQLDatabase
 
@@ -45,3 +48,47 @@ def test_sql_database_run_update() -> None:
     output = db_chain.run("What company does Harrison work at?")
     expected_output = " Harrison works at Bar."
     assert output == expected_output
+
+
+def test_sql_database_sequential_chain_run() -> None:
+    """Test that commands can be run successfully SEQUENTIALLY
+    and returned in correct format."""
+    engine = create_engine("sqlite:///:memory:")
+    metadata_obj.create_all(engine)
+    stmt = insert(user).values(user_id=13, user_name="Harrison", user_company="Foo")
+    with engine.connect() as conn:
+        conn.execute(stmt)
+    db = SQLDatabase(engine)
+    db_chain = SQLDatabaseSequentialChain.from_llm(
+        llm=OpenAI(temperature=0), database=db
+    )
+    output = db_chain.run("What company does Harrison work at?")
+    expected_output = " Harrison works at Foo."
+    assert output == expected_output
+
+
+def test_sql_database_sequential_chain_intermediate_steps() -> None:
+    """Test that commands can be run successfully SEQUENTIALLY and returned
+    in correct format. sWith Intermediate steps"""
+    engine = create_engine("sqlite:///:memory:")
+    metadata_obj.create_all(engine)
+    stmt = insert(user).values(user_id=13, user_name="Harrison", user_company="Foo")
+    with engine.connect() as conn:
+        conn.execute(stmt)
+    db = SQLDatabase(engine)
+    db_chain = SQLDatabaseSequentialChain.from_llm(
+        llm=OpenAI(temperature=0), database=db, return_intermediate_steps=True
+    )
+    output = db_chain("What company does Harrison work at?")
+    expected_output = " Harrison works at Foo."
+    assert output["result"] == expected_output
+
+    query = output["intermediate_steps"][0]
+    expected_query = (
+        " SELECT user_company FROM user WHERE user_name = 'Harrison' LIMIT 1;"
+    )
+    assert query == expected_query
+
+    query_results = output["intermediate_steps"][1]
+    expected_query_results = "[('Foo',)]"
+    assert query_results == expected_query_results

tests/unit_tests/agents/test_agent.py

@@ -230,6 +230,36 @@ def test_agent_tool_return_direct() -> None:
     assert output == "misalignment"
 
 
+def test_agent_tool_return_direct_in_intermediate_steps() -> None:
+    """Test agent using tools that return directly."""
+    tool = "Search"
+    responses = [
+        f"FooBarBaz\nAction: {tool}\nAction Input: misalignment",
+        "Oh well\nAction: Final Answer\nAction Input: curses foiled again",
+    ]
+    fake_llm = FakeListLLM(responses=responses)
+    tools = [
+        Tool(
+            name="Search",
+            func=lambda x: x,
+            description="Useful for searching",
+            return_direct=True,
+        ),
+    ]
+    agent = initialize_agent(
+        tools,
+        fake_llm,
+        agent="zero-shot-react-description",
+        return_intermediate_steps=True,
+    )
+
+    resp = agent("when was langchain made")
+    assert resp["output"] == "misalignment"
+    assert len(resp["intermediate_steps"]) == 1
+    action, _action_intput = resp["intermediate_steps"][0]
+    assert action.tool == "Search"
+
+
 def test_agent_with_new_prefix_suffix() -> None:
     """Test agent initilization kwargs with new prefix and suffix."""
     fake_llm = FakeListLLM(

tests/unit_tests/chains/test_conversation.py

@@ -34,7 +34,7 @@ def test_conversation_chain_works() -> None:
 
 
 def test_conversation_chain_errors_bad_prompt() -> None:
-    """Test that conversation chain works in basic setting."""
+    """Test that conversation chain raise error with bad prompt."""
     llm = FakeLLM()
     prompt = PromptTemplate(input_variables=[], template="nothing here")
     with pytest.raises(ValueError):
@@ -42,7 +42,7 @@ def test_conversation_chain_errors_bad_prompt() -> None:
 
 
 def test_conversation_chain_errors_bad_variable() -> None:
-    """Test that conversation chain works in basic setting."""
+    """Test that conversation chain raise error with bad variable."""
     llm = FakeLLM()
     prompt = PromptTemplate(input_variables=["foo"], template="{foo}")
     memory = ConversationBufferMemory(memory_key="foo")

tests/unit_tests/chains/test_llm.py

@@ -7,7 +7,7 @@ import pytest
 
 from langchain.chains.llm import LLMChain
 from langchain.chains.loading import load_chain
-from langchain.prompts.base import BaseOutputParser
+from langchain.output_parsers.base import BaseOutputParser
 from langchain.prompts.prompt import PromptTemplate
 from tests.unit_tests.llms.fake_llm import FakeLLM
 

tests/unit_tests/chains/test_memory.py

@@ -1,4 +1,13 @@
-from langchain.memory.simple import SimpleMemory
+import pytest
+
+from langchain.chains.conversation.memory import (
+    ConversationBufferMemory,
+    ConversationBufferWindowMemory,
+    ConversationSummaryMemory,
+)
+from langchain.memory import ReadOnlySharedMemory, SimpleMemory
+from langchain.schema import BaseMemory
+from tests.unit_tests.llms.fake_llm import FakeLLM
 
 
 def test_simple_memory() -> None:
@@ -9,3 +18,20 @@ def test_simple_memory() -> None:
 
     assert output == {"baz": "foo"}
     assert ["baz"] == memory.memory_variables
+
+
+@pytest.mark.parametrize(
+    "memory",
+    [
+        ConversationBufferMemory(memory_key="baz"),
+        ConversationSummaryMemory(llm=FakeLLM(), memory_key="baz"),
+        ConversationBufferWindowMemory(memory_key="baz"),
+    ],
+)
+def test_readonly_memory(memory: BaseMemory) -> None:
+    read_only_memory = ReadOnlySharedMemory(memory=memory)
+    memory.save_context({"input": "bar"}, {"output": "foo"})
+
+    assert read_only_memory.load_memory_variables({}) == memory.load_memory_variables(
+        {}
+    )

tests/unit_tests/guards/test_custom.py

@@ -0,0 +1,27 @@
+import pytest
+
+from langchain.guards.custom import CustomGuard
+from tests.unit_tests.llms.fake_llm import FakeLLM
+
+
+def test_custom_guard() -> None:
+    """Test custom guard."""
+
+    queries = {
+        "tomato": "tomato",
+        "potato": "potato",
+    }
+
+    llm = FakeLLM(queries=queries)
+
+    def starts_with_t(prompt: str) -> bool:
+        return prompt.startswith("t")
+
+    @CustomGuard(guard_function=starts_with_t, retries=0)
+    def example_func(prompt: str) -> str:
+        return llm(prompt=prompt)
+
+    assert example_func(prompt="potato") == "potato"
+
+    with pytest.raises(Exception):
+        assert example_func(prompt="tomato") == "tomato"

tests/unit_tests/guards/test_restriction.py

@@ -0,0 +1,42 @@
+from typing import List
+
+import pytest
+
+from langchain.guards.restriction import RestrictionGuard
+from langchain.guards.restriction_prompt import RESTRICTION_PROMPT
+from tests.unit_tests.llms.fake_llm import FakeLLM
+
+
+def test_restriction_guard() -> None:
+    """Test Restriction guard."""
+
+    queries = {
+        "a": "a",
+    }
+    llm = FakeLLM(queries=queries)
+
+    def restriction_test(
+        restrictions: List[str], llm_input_output: str, restricted: bool
+    ) -> str:
+        concatenated_restrictions = ", ".join(restrictions)
+        queries = {
+            RESTRICTION_PROMPT.format(
+                restrictions=concatenated_restrictions, function_output=llm_input_output
+            ): "restricted because I said so :) (¥)"
+            if restricted
+            else "not restricted (ƒ)",
+        }
+        restriction_guard_llm = FakeLLM(queries=queries)
+
+        @RestrictionGuard.from_llm(
+            restrictions=restrictions, llm=restriction_guard_llm, retries=0
+        )
+        def example_func(prompt: str) -> str:
+            return llm(prompt=prompt)
+
+        return example_func(prompt=llm_input_output)
+
+    assert restriction_test(["a", "b"], "a", False) == "a"
+
+    with pytest.raises(Exception):
+        restriction_test(["a", "b"], "a", True)

tests/unit_tests/guards/test_string.py

@@ -0,0 +1,58 @@
+import pytest
+
+from langchain.guards.string import StringGuard
+from tests.unit_tests.llms.fake_llm import FakeLLM
+
+
+def test_string_guard() -> None:
+    """Test String guard."""
+
+    queries = {
+        "tomato": "tomato",
+        "potato": "potato",
+        "buffalo": "buffalo",
+        "xzxzxz": "xzxzxz",
+        "buffalos eat lots of potatos": "potato",
+        "actually that's not true I think": "tomato",
+    }
+
+    llm = FakeLLM(queries=queries)
+
+    @StringGuard(protected_strings=["tomato"], leniency=1, retries=0)
+    def example_func_100(prompt: str) -> str:
+        return llm(prompt=prompt)
+
+    @StringGuard(protected_strings=["tomato", "buffalo"], leniency=1, retries=0)
+    def example_func_2_100(prompt: str) -> str:
+        return llm(prompt=prompt)
+
+    @StringGuard(protected_strings=["tomato"], leniency=0.5, retries=0)
+    def example_func_50(prompt: str) -> str:
+        return llm(prompt)
+
+    @StringGuard(protected_strings=["tomato"], leniency=0, retries=0)
+    def example_func_0(prompt: str) -> str:
+        return llm(prompt)
+
+    @StringGuard(protected_strings=["tomato"], leniency=0.01, retries=0)
+    def example_func_001(prompt: str) -> str:
+        return llm(prompt)
+
+    assert example_func_100(prompt="potato") == "potato"
+    assert example_func_50(prompt="buffalo") == "buffalo"
+    assert example_func_001(prompt="xzxzxz") == "xzxzxz"
+    assert example_func_2_100(prompt="xzxzxz") == "xzxzxz"
+    assert example_func_100(prompt="buffalos eat lots of potatos") == "potato"
+
+    with pytest.raises(Exception):
+        example_func_2_100(prompt="actually that's not true I think")
+    assert example_func_50(prompt="potato") == "potato"
+    with pytest.raises(Exception):
+        example_func_0(prompt="potato")
+    with pytest.raises(Exception):
+        example_func_0(prompt="buffalo")
+    with pytest.raises(Exception):
+        example_func_0(prompt="xzxzxz")
+    assert example_func_001(prompt="buffalo") == "buffalo"
+    with pytest.raises(Exception):
+        example_func_2_100(prompt="buffalo")

tests/unit_tests/output_parsers/test_boolean.py

@@ -0,0 +1,56 @@
+from typing import List
+
+import pytest
+
+from langchain.output_parsers.boolean import BooleanOutputParser
+
+GOOD_EXAMPLES = [
+    ("0", False, ["1"], ["0"]),
+    ("1", True, ["1"], ["0"]),
+    ("\n1\n", True, ["1"], ["0"]),
+    ("The answer is: \n1\n", True, ["1"], ["0"]),
+    ("The answer is: 0", False, ["1"], ["0"]),
+    ("1", False, ["0"], ["1"]),
+    ("0", True, ["0"], ["1"]),
+    ("X", True, ["x", "X"], ["O", "o"]),
+]
+
+
+@pytest.mark.parametrize(
+    "input_string,expected,true_values,false_values", GOOD_EXAMPLES
+)
+def test_boolean_output_parsing(
+    input_string: str, expected: str, true_values: List[str], false_values: List[str]
+) -> None:
+    """Test booleans are parsed as expected."""
+    output_parser = BooleanOutputParser(
+        true_values=true_values, false_values=false_values
+    )
+    output = output_parser.parse(input_string)
+    assert output == expected
+
+
+BAD_VALUES = [
+    ("01", ["1"], ["0"]),
+    ("", ["1"], ["0"]),
+    ("a", ["0"], ["1"]),
+    ("2", ["1"], ["0"]),
+]
+
+
+@pytest.mark.parametrize("input_string,true_values,false_values", BAD_VALUES)
+def test_boolean_output_parsing_error(
+    input_string: str, true_values: List[str], false_values: List[str]
+) -> None:
+    """Test errors when parsing."""
+    output_parser = BooleanOutputParser(
+        true_values=true_values, false_values=false_values
+    )
+    with pytest.raises(ValueError):
+        output_parser.parse(input_string)
+
+
+def test_boolean_output_parsing_init_error() -> None:
+    """Test that init errors when bad values are passed to boolean output parser."""
+    with pytest.raises(ValueError):
+        BooleanOutputParser(true_values=["0", "1"], false_values=["0", "1"])

tests/unit_tests/prompts/test_chat.py

@@ -70,12 +70,10 @@ def test_chat_prompt_template() -> None:
 
     string = prompt.to_string()
     expected = (
-        '[SystemMessage(content="Here\'s some context: context", '
-        'additional_kwargs={}), HumanMessage(content="Hello foo, '
-        "I'm bar. Thanks for the context\", additional_kwargs={}), "
-        "AIMessage(content=\"I'm an AI. I'm foo. I'm bar.\", additional_kwargs={}), "
-        "ChatMessage(content=\"I'm a generic message. I'm foo. I'm bar.\","
-        " additional_kwargs={}, role='test')]"
+        "System: Here's some context: context\n"
+        "Human: Hello foo, I'm bar. Thanks for the context\n"
+        "AI: I'm an AI. I'm foo. I'm bar.\n"
+        "test: I'm a generic message. I'm foo. I'm bar."
     )
     assert string == expected
 

tests/unit_tests/test_text_splitter.py

@@ -94,6 +94,21 @@ def test_create_documents_with_metadata() -> None:
     assert docs == expected_docs
 
 
+def test_metadata_not_shallow() -> None:
+    """Test that metadatas are not shallow."""
+    texts = ["foo bar"]
+    splitter = CharacterTextSplitter(separator=" ", chunk_size=3, chunk_overlap=0)
+    docs = splitter.create_documents(texts, [{"source": "1"}])
+    expected_docs = [
+        Document(page_content="foo", metadata={"source": "1"}),
+        Document(page_content="bar", metadata={"source": "1"}),
+    ]
+    assert docs == expected_docs
+    docs[0].metadata["foo"] = 1
+    assert docs[0].metadata == {"source": "1", "foo": 1}
+    assert docs[1].metadata == {"source": "1"}
+
+
 def test_iterative_text_splitter() -> None:
     """Test iterative text splitter."""
     text = """Hi.\n\nI'm Harrison.\n\nHow? Are? You?\nOkay then f f f f.