Merge branch 'master' into harrison/agent_multi_inputs

https://github.com/hwchase17/langchain/issues/363

@hwchase17 how much does this make you want to cry?

.coveragerc

@@ -0,0 +1,2 @@
+[run]
+omit = tests/*

.github/workflows/lint.yml

@@ -1,23 +1,36 @@
 name: lint
 
-on: [push, pull_request]
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+env:
+  POETRY_VERSION: "1.3.1"
 
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.7"]
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r test_requirements.txt
-    - name: Analysing the code with our lint
-      run: |
-        make lint
+      - uses: actions/checkout@v3
+      - name: Install poetry
+        run: |
+          pipx install poetry==$POETRY_VERSION
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: poetry
+      - name: Install dependencies
+        run: |
+          poetry install
+      - name: Analysing the code with our lint
+        run: |
+          make lint

.github/workflows/test.yml

@@ -1,23 +1,34 @@
 name: test
 
-on: [push, pull_request]
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+env:
+  POETRY_VERSION: "1.3.1"
 
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.7"]
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v3
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r test_requirements.txt
-    - name: Run unit tests
-      run: |
-        make tests
+      - uses: actions/checkout@v3
+      - name: Install poetry
+        run: pipx install poetry==$POETRY_VERSION
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "poetry"
+      - name: Install dependencies
+        run: poetry install
+      - name: Run unit tests
+        run: |
+          make tests

.gitignore

@@ -1,4 +1,5 @@
 .vscode/
+.idea/
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

CONTRIBUTING.md

@@ -0,0 +1,154 @@
+# Contributing to LangChain
+
+Hi there! Thank you for even being interested in contributing to LangChain.
+As an open source project in a rapidly developing field, we are extremely open
+to contributions, whether it be in the form of a new feature, improved infra, or better documentation.
+
+To contribute to this project, please follow a ["fork and pull request"](https://docs.github.com/en/get-started/quickstart/contributing-to-projects) workflow.
+Please do not try to push directly to this repo unless you are maintainer.
+
+## 🗺️Contributing Guidelines
+
+### 🚩GitHub Issues
+
+Our [issues](https://github.com/hwchase17/langchain/issues) page is kept up to date
+with bugs, improvements, and feature requests. There is a taxonomy of labels to help
+with sorting and discovery of issues of interest. These include:
+
+- prompts: related to prompt tooling/infra.
+- llms: related to LLM wrappers/tooling/infra.
+- chains
+- utilities: related to different types of utilities to integrate with (Python, SQL, etc.).
+- agents
+- memory
+- applications: related to example applications to build
+
+If you start working on an issue, please assign it to yourself.
+
+If you are adding an issue, please try to keep it focused on a single modular bug/improvement/feature.
+If the two issues are related, or blocking, please link them rather than keep them as one single one.
+
+We will try to keep these issues as up to date as possible, though
+with the rapid rate of develop in this field some may get out of date.
+If you notice this happening, please just let us know.
+
+### 🙋Getting Help
+
+Although we try to have a developer setup to make it as easy as possible for others to contribute (see below)
+it is possible that some pain point may arise around environment setup, linting, documentation, or other.
+Should that occur, please contact a maintainer! Not only do we want to help get you unblocked,
+but we also want to make sure that the process is smooth for future contributors.
+
+In a similar vein, we do enforce certain linting, formatting, and documentation standards in the codebase.
+If you are finding these difficult (or even just annoying) to work with,
+feel free to contact a maintainer for help - we do not want these to get in the way of getting
+good code into the codebase.
+
+### 🏭Release process
+
+As of now, LangChain has an ad hoc release process: releases are cut with high frequency via by
+a developer and published to [PyPI](https://pypi.org/project/ruff/).
+
+LangChain follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
+even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
+
+If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
+If you have a Twitter account you would like us to mention, please let us know in the PR or in another manner.
+
+## 🤖Developer Setup
+
+### 🚀Quick Start
+
+This project uses [Poetry](https://python-poetry.org/) as a dependency manager. Check out Poetry's [documentation on how to install it](https://python-poetry.org/docs/#installation) on your system before proceeding.
+
+To install requirements:
+
+```bash
+poetry install -E all
+```
+
+This will install all requirements for running the package, examples, linting, formatting, tests, and coverage. Note the `-E all` flag will install all optional dependencies necessary for integration testing.
+
+Now, you should be able to run the common tasks in the following section.
+
+### ✅Common Tasks
+
+#### Code Formatting
+
+Formatting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/) and [isort](https://pycqa.github.io/isort/).
+
+To run formatting for this project:
+
+```bash
+make format
+```
+
+#### Linting
+
+Linting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/), [isort](https://pycqa.github.io/isort/), [flake8](https://flake8.pycqa.org/en/latest/), and [mypy](http://mypy-lang.org/).
+
+To run linting for this project:
+
+```bash
+make lint
+```
+
+We recognize linting can be annoying - if you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
+
+#### Coverage
+
+Code coverage (i.e. the amount of code that is covered by unit tests) helps identify areas of the code that are potentially more or less brittle.
+
+To get a report of current coverage, run the following:
+
+```bash
+make coverage
+```
+
+#### Testing
+
+Unit tests cover modular logic that does not require calls to outside APIs.
+
+To run unit tests:
+
+```bash
+make tests
+```
+
+If you add new logic, please add a unit test.
+
+Integration tests cover logic that requires making calls to outside APIs (often integration with other services).
+
+To run integration tests:
+
+```bash
+make integration_tests
+```
+
+If you add support for a new external API, please add a new integration test.
+
+#### Adding a Jupyter Notebook
+
+If you are adding a Jupyter notebook example, you'll want to install the optional `dev` dependencies.
+
+To install dev dependencies:
+
+```bash
+poetry install --with dev
+```
+
+Launch a notebook:
+
+```bash
+poetry run jupyter notebook
+```
+
+When you run `poetry install`, the `langchain` package is installed as editable in the virtualenv, so your new logic can be imported into the notebook.
+
+#### Contribute Documentation
+
+Docs are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
+
+For that reason, we ask that you add good documentation to all classes and methods.
+
+Similar to linting, we recognize documentation can be annoying. If you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.

MANIFEST.in

@@ -1,3 +0,0 @@
-include langchain/py.typed
-include langchain/VERSION
-include LICENSE

Makefile

@@ -1,17 +1,23 @@
 .PHONY: format lint tests integration_tests
 
+coverage:
+	poetry run pytest --cov \
+		--cov-config=.coveragerc \
+		--cov-report xml \
+		--cov-report term-missing:skip-covered
+
 format:
-	black .
-	isort .
+	poetry run black .
+	poetry run isort .
 
 lint:
-	mypy .
-	black . --check
-	isort . --check
-	flake8 .
+	poetry run mypy .
+	poetry run black . --check
+	poetry run isort . --check
+	poetry run flake8 .
 
 tests:
-	pytest tests/unit_tests
+	poetry run pytest tests/unit_tests
 
 integration_tests:
-	pytest tests/integration_tests
+	poetry run pytest tests/integration_tests

README.md

@@ -13,120 +13,45 @@
 Large language models (LLMs) are emerging as a transformative technology, enabling
 developers to build applications that they previously could not.
 But using these LLMs in isolation is often not enough to
-create a truly powerful app - the real power comes when you are able to
-combine them with other sources of computation or knowledge.
+create a truly powerful app - the real power comes when you can combine them with other sources of computation or knowledge.
 
 This library is aimed at assisting in the development of those types of applications.
-It aims to create:
-
-1. a comprehensive collection of pieces you would ever want to combine
-2. a flexible interface for combining pieces into a single comprehensive "chain"
-3. a schema for easily saving and sharing those chains
 
 ## 📖 Documentation
 
 Please see [here](https://langchain.readthedocs.io/en/latest/?) for full documentation on:
-- Getting started (installation, setting up environment, simple examples)
+
+- Getting started (installation, setting up the environment, simple examples)
 - How-To examples (demos, integrations, helper functions)
 - Reference (full API docs)
-- Resources (high level explanation of core concepts)
+  Resources (high-level explanation of core concepts)
 
-## 🚀 What can I do with this
+## 🚀 What can this help with?
 
-This project was largely inspired by a few projects seen on Twitter for which we thought it would make sense to have more explicit tooling. A lot of the initial functionality was done in an attempt to recreate those. Those are:
+There are four main areas that LangChain is designed to help with.
+These are, in increasing order of complexity:
 
-**[Self-ask-with-search](https://ofir.io/self-ask.pdf)**
+**📃 LLMs and Prompts:**
 
-To recreate this paper, use the following code snippet or checkout the [example notebook](https://github.com/hwchase17/langchain/blob/master/examples/self_ask_with_search.ipynb).
+This includes prompt management, prompt optimization, generic interface for all LLMs, and common utilities for working with LLMs.
 
-```python
-from langchain import SelfAskWithSearchChain, OpenAI, SerpAPIChain
+**🔗 Chains:**
 
-llm = OpenAI(temperature=0)
-search = SerpAPIChain()
+Chains go beyond just a single LLM call, and are sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.
 
-self_ask_with_search = SelfAskWithSearchChain(llm=llm, search_chain=search)
+**🤖 Agents:**
 
-self_ask_with_search.run("What is the hometown of the reigning men's U.S. Open champion?")
-```
+Agents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end to end agents.
 
-**[LLM Math](https://twitter.com/amasad/status/1568824744367259648?s=20&t=-7wxpXBJinPgDuyHLouP1w)**
+**🧠 Memory:**
 
-To recreate this example, use the following code snippet or check out the [example notebook](https://github.com/hwchase17/langchain/blob/master/examples/llm_math.ipynb).
+Memory is the concept of persisting state between calls of a chain/agent. LangChain provides a standard interface for memory, a collection of memory implementations, and examples of chains/agents that use memory.
 
-```python
-from langchain import OpenAI, LLMMathChain
+For more information on these concepts, please see our [full documentation](https://langchain.readthedocs.io/en/latest/?).
 
-llm = OpenAI(temperature=0)
-llm_math = LLMMathChain(llm=llm)
+## 💁 Contributing
 
-llm_math.run("How many of the integers between 0 and 99 inclusive are divisible by 8?")
-```
+As an open source project in a rapidly developing field, we are extremely open
+to contributions, whether it be in the form of a new feature, improved infra, or better documentation.
 
-**Generic Prompting**
-
-You can also use this for simple prompting pipelines, as in the below example and this [example notebook](https://github.com/hwchase17/langchain/blob/master/examples/simple_prompts.ipynb).
-
-```python
-from langchain import Prompt, OpenAI, LLMChain
-
-template = """Question: {question}
-
-Answer: Let's think step by step."""
-prompt = Prompt(template=template, input_variables=["question"])
-llm = OpenAI(temperature=0)
-llm_chain = LLMChain(prompt=prompt, llm=llm)
-
-question = "What NFL team won the Super Bowl in the year Justin Bieber was born?"
-
-llm_chain.predict(question=question)
-```
-
-**Embed & Search Documents**
-
-We support two vector databases to store and search embeddings -- FAISS and Elasticsearch. Here's a code snippet showing how to use FAISS to store embeddings and search for text similar to a query. Both database backends are featured in this [example notebook](https://github.com/hwchase17/langchain/blob/master/examples/embeddings.ipynb).
-
-```python
-from langchain.embeddings.openai import OpenAIEmbeddings
-from langchain.faiss import FAISS
-from langchain.text_splitter import CharacterTextSplitter
-
-with open('state_of_the_union.txt') as f:
-    state_of_the_union = f.read()
-text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-texts = text_splitter.split_text(state_of_the_union)
-
-embeddings = OpenAIEmbeddings()
-
-docsearch = FAISS.from_texts(texts, embeddings)
-
-query = "What did the president say about Ketanji Brown Jackson"
-docs = docsearch.similarity_search(query)
-```
-
-## 🤖 Developer Guide
-
-To begin developing on this project, first clone to the repo locally.
-To install requirements, run `pip install -r requirements.txt`.
-This will install all requirements for running the package, examples, linting, formatting, and tests.
-
-Formatting for this project is a combination of [Black](https://black.readthedocs.io/en/stable/) and [isort](https://pycqa.github.io/isort/).
-To run formatting for this project, run `make format`.
-
-Linting for this project is a combination of [Black](https://black.readthedocs.io/en/stable/), [isort](https://pycqa.github.io/isort/), [flake8](https://flake8.pycqa.org/en/latest/), and [mypy](http://mypy-lang.org/).
-To run linting for this project, run `make lint`.
-We recognize linting can be annoying - if you do not want to do it, please contact a project maintainer and they can help you with it. We do not want this to be a blocker for good code getting contributed.
-
-Unit tests cover modular logic that does not require calls to outside apis.
-To run unit tests, run `make tests`.
-If you add new logic, please add a unit test.
-
-Integration tests cover logic that requires making calls to outside APIs (often integration with other services).
-To run integration tests, run `make integration_tests`.
-If you add support for a new external API, please add a new integration test.
-
-If you are adding a Jupyter notebook example, you can run `pip install -e .` to build the langchain package from your local changes, so your new logic can be imported into the notebook.
-
-Docs are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
-For that reason, we ask that you add good documentation to all classes and methods.
-Similar to linting, we recognize documentation can be annoying - if you do not want to do it, please contact a project maintainer and they can help you with it. We do not want this to be a blocker for good code getting contributed.
+For detailed information on how to contribute, see [here](CONTRIBUTING.md).

docs/conf.py

@@ -15,7 +15,10 @@
 # import sys
 # sys.path.insert(0, os.path.abspath('.'))
 
-import langchain
+import toml
+
+with open("../pyproject.toml") as f:
+    data = toml.load(f)
 
 # -- Project information -----------------------------------------------------
 
@@ -23,8 +26,8 @@ project = "LangChain"
 copyright = "2022, Harrison Chase"
 author = "Harrison Chase"
 
-version = langchain.__version__
-release = langchain.__version__
+version = data["tool"]["poetry"]["version"]
+release = version
 
 
 # -- General configuration ---------------------------------------------------

docs/examples/agents.rst

@@ -0,0 +1,47 @@
+Agents
+======
+
+The examples here are all end-to-end agents for specific applications.
+In all examples there is an Agent with a particular set of tools.
+
+- Tools: A tool can be anything that takes in a string and returns a string. This means that you can use both the primitives AND the chains found in `this <chains.rst>`_ documentation.
+- Agents: An agent uses an LLMChain to determine which tools to use. For a list of all available agent types, see `here <../explanation/agents.md>`_.
+
+**MRKL**
+
+- **Tools used**: Search, SQLDatabaseChain, LLMMathChain
+- **Agent used**: `zero-shot-react-description`
+- `Paper <https://arxiv.org/pdf/2205.00445.pdf>`_
+- **Note**: This is the most general purpose example, so if you are looking to use an agent with arbitrary tools, please start here.
+- `Example Notebook <agents/mrkl.ipynb>`_
+
+**Self-Ask-With-Search**
+
+- **Tools used**: Search
+- **Agent used**: `self-ask-with-search`
+- `Paper <https://ofir.io/self-ask.pdf>`_
+- `Example Notebook <agents/self_ask_with_search.ipynb>`_
+
+**ReAct**
+
+- **Tools used**: Wikipedia Docstore
+- **Agent used**: `react-docstore`
+- `Paper <https://arxiv.org/pdf/2210.03629.pdf>`_
+- `Example Notebook <agents/react.ipynb>`_
+
+
+
+Additionally, we also provide examples for how to do more customizability:
+
+**Custom Agent**
+
+- Purpose: How to create custom agents.
+- `Example Notebook <agents/custom_agent.ipynb>`_
+
+
+.. toctree::
+   :maxdepth: 1
+   :glob:
+   :hidden:
+
+   agents/*

docs/examples/agents/custom_agent.ipynb

@@ -0,0 +1,232 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ba5f8741",
+   "metadata": {},
+   "source": [
+    "# Custom Agent\n",
+    "\n",
+    "This notebook goes through how to create your own custom agent.\n",
+    "\n",
+    "An agent consists of three parts:\n",
+    "    \n",
+    "    - Tools: The tools the agent has available to use.\n",
+    "    - LLMChain: The LLMChain that produces the text that is parsed in a certain way to determine which action to take.\n",
+    "    - The agent class itself: this parses the output of the LLMChain to determin which action to take.\n",
+    "        \n",
+    "        \n",
+    "In this notebook we walk through two types of custom agents. The first type shows how to create a custom LLMChain, but still use an existing agent class to parse the output. The second shows how to create a custom agent class."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6064f080",
+   "metadata": {},
+   "source": [
+    "### Custom LLMChain\n",
+    "\n",
+    "The first way to create a custom agent is to use an existing Agent class, but use a custom LLMChain. This is the simplest way to create a custom Agent. It is highly reccomended that you work with the `ZeroShotAgent`, as at the moment that is by far the most generalizable one. \n",
+    "\n",
+    "Most of the work in creating the custom LLMChain comes down to the prompt. Because we are using an existing agent class to parse the output, it is very important that the prompt say to produce text in that format. However, besides those instructions, you can customize the prompt as you wish.\n",
+    "\n",
+    "To ensure that the prompt contains the appropriate instructions, we will utilize a helper method on that class. The helper method for the `ZeroShotAgent` takes the following arguments:\n",
+    "\n",
+    "- tools: List of tools the agent will have access to, used to format the prompt.\n",
+    "- prefix: String to put before the list of tools.\n",
+    "- suffix: String to put after the list of tools.\n",
+    "- input_variables: List of input variables the final prompt will expect.\n",
+    "\n",
+    "For this exercise, we will give our agent access to Google Search, and we will customize it in that we will have it answer as a pirate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9af9734e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import ZeroShotAgent, Tool\n",
+    "from langchain import OpenAI, SerpAPIWrapper, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "becda2a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = SerpAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "339b1bb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prefix = \"\"\"Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n",
+    "\n",
+    "Question: {input}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[\"input\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59db7b58",
+   "metadata": {},
+   "source": [
+    "In case we are curious, we can now take a look at the final prompt template to see what it looks like when its all put together."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e21d2098",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\n",
+      "\n",
+      "Search: useful for when you need to answer questions about current events\n",
+      "\n",
+      "Use the following format:\n",
+      "\n",
+      "Question: the input question you must answer\n",
+      "Thought: you should always think about what to do\n",
+      "Action: the action to take, should be one of [Search]\n",
+      "Action Input: the input to the action\n",
+      "Observation: the result of the action\n",
+      "... (this Thought/Action/Action Input/Observation can repeat N times)\n",
+      "Thought: I now know the final answer\n",
+      "Final Answer: the final answer to the original input question\n",
+      "\n",
+      "Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n",
+      "\n",
+      "Question: {input}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(prompt.template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9b1cc2a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e4f5092f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "653b1617",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "How many people live in canada?\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I should look this up\n",
+      "Action: Search\n",
+      "Action Input: How many people live in canada\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,533,678 as of Friday, November 25, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada 2020 ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: Arrr, there be 38,533,678 people in Canada\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Arrr, there be 38,533,678 people in Canada'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run(\"How many people live in canada?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90171b2b",
+   "metadata": {},
+   "source": [
+    "### Custom Agent Class\n",
+    "\n",
+    "Coming soon."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "adefb4c2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/agents/mrkl.ipynb

@@ -0,0 +1,212 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f1390152",
+   "metadata": {},
+   "source": [
+    "# MRKL\n",
+    "\n",
+    "This notebook showcases using an agent to replicate the MRKL chain."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39ea3638",
+   "metadata": {},
+   "source": [
+    "This uses the example Chinook database.\n",
+    "To set it up follow the instructions on https://database.guide/2-sample-databases-sqlite/, placing the `.db` file in a notebooks folder at the root of this repository."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ac561cc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import LLMMathChain, OpenAI, SerpAPIWrapper, SQLDatabase, SQLDatabaseChain\n",
+    "from langchain.agents import initialize_agent, Tool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "07e96d99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(temperature=0)\n",
+    "search = SerpAPIWrapper()\n",
+    "llm_math_chain = LLMMathChain(llm=llm, verbose=True)\n",
+    "db = SQLDatabase.from_uri(\"sqlite:///../../../notebooks/Chinook.db\")\n",
+    "db_chain = SQLDatabaseChain(llm=llm, database=db, verbose=True)\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events. You should ask targeted questions\"\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name=\"Calculator\",\n",
+    "        func=llm_math_chain.run,\n",
+    "        description=\"useful for when you need to answer questions about math\"\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name=\"FooBar DB\",\n",
+    "        func=db_chain.run,\n",
+    "        description=\"useful for when you need to answer questions about FooBar. Input should be in the form of a question containing full context\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a069c4b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mrkl = initialize_agent(tools, llm, agent=\"zero-shot-react-description\", verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e603cd7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new ZeroShotAgent chain...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to find out who Olivia Wilde's boyfriend is and then calculate his age raised to the 0.23 power.\n",
+      "Action: Search\n",
+      "Action Input: \"Who is Olivia Wilde's boyfriend?\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mOlivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to find out Harry Styles' age.\n",
+      "Action: Search\n",
+      "Action Input: \"How old is Harry Styles?\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3m28 years\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to calculate 28 raised to the 0.23 power.\n",
+      "Action: Calculator\n",
+      "Action Input: 28^0.23\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Entering new LLMMathChain chain...\u001b[0m\n",
+      "28^0.23\u001b[32;1m\u001b[1;3m\n",
+      "\n",
+      "```python\n",
+      "import math\n",
+      "print(math.pow(28, 0.23))\n",
+      "```\n",
+      "\u001b[0m\n",
+      "Answer: \u001b[33;1m\u001b[1;3m2.1520202182226886\n",
+      "\u001b[0m\n",
+      "\u001b[1m> Finished LLMMathChain chain.\u001b[0m\n",
+      "\n",
+      "Observation: \u001b[33;1m\u001b[1;3mAnswer: 2.1520202182226886\n",
+      "\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: Harry Styles, Olivia Wilde's boyfriend, is 28 years old and his age raised to the 0.23 power is 2.1520202182226886.\u001b[0m\n",
+      "\u001b[1m> Finished ZeroShotAgent chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Harry Styles, Olivia Wilde's boyfriend, is 28 years old and his age raised to the 0.23 power is 2.1520202182226886.\""
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mrkl.run(\"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a5c07010",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new ZeroShotAgent chain...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to find out the artist's full name and then search the FooBar database for their albums.\n",
+      "Action: Search\n",
+      "Action Input: \"The Storm Before the Calm\" artist\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe Storm Before the Calm (stylized in all lowercase) is the tenth (and eighth international) studio album by Canadian-American singer-songwriter Alanis ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now need to search the FooBar database for Alanis Morissette's albums\n",
+      "Action: FooBar DB\n",
+      "Action Input: What albums by Alanis Morissette are in the FooBar database?\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Entering new SQLDatabaseChain chain...\u001b[0m\n",
+      "What albums by Alanis Morissette are in the FooBar database? \n",
+      "SQLQuery:\u001b[32;1m\u001b[1;3m SELECT Title FROM Album INNER JOIN Artist ON Album.ArtistId = Artist.ArtistId WHERE Artist.Name = 'Alanis Morissette';\u001b[0m\n",
+      "SQLResult: \u001b[33;1m\u001b[1;3m[('Jagged Little Pill',)]\u001b[0m\n",
+      "Answer:\u001b[32;1m\u001b[1;3m The album 'Jagged Little Pill' by Alanis Morissette is in the FooBar database.\u001b[0m\n",
+      "\u001b[1m> Finished SQLDatabaseChain chain.\u001b[0m\n",
+      "\n",
+      "Observation: \u001b[38;5;200m\u001b[1;3m The album 'Jagged Little Pill' by Alanis Morissette is in the FooBar database.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: Alanis Morissette's album 'Jagged Little Pill' is in the FooBar database.\u001b[0m\n",
+      "\u001b[1m> Finished ZeroShotAgent chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Alanis Morissette's album 'Jagged Little Pill' is in the FooBar database.\""
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mrkl.run(\"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?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "af016a70",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/agents/react.ipynb

@@ -0,0 +1,110 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "82140df0",
+   "metadata": {},
+   "source": [
+    "# ReAct\n",
+    "\n",
+    "This notebook showcases using an agent to implement the ReAct logic."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4e272b47",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import OpenAI, Wikipedia\n",
+    "from langchain.agents import initialize_agent, Tool\n",
+    "from langchain.agents.react.base import DocstoreExplorer\n",
+    "docstore=DocstoreExplorer(Wikipedia())\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name=\"Search\",\n",
+    "        func=docstore.search\n",
+    "    ),\n",
+    "    Tool(\n",
+    "        name=\"Lookup\",\n",
+    "        func=docstore.lookup\n",
+    "    )\n",
+    "]\n",
+    "\n",
+    "llm = OpenAI(temperature=0, model_name=\"text-davinci-002\")\n",
+    "react = initialize_agent(tools, llm, agent=\"react-docstore\", verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8078c8f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new ReActDocstoreAgent chain...\u001b[0m\n",
+      "Thought 1:\u001b[32;1m\u001b[1;3m I need to search David Chanoff and find the U.S. Navy admiral he collaborated\n",
+      "with.\n",
+      "Action 1: Search[David Chanoff]\u001b[0m\n",
+      "Observation 1: \u001b[36;1m\u001b[1;3mDavid Chanoff is a noted author of non-fiction work. His work has typically involved collaborations with the principal protagonist of the work concerned. His collaborators have included; Augustus A. White, Joycelyn Elders, Đoàn Văn Toại, William J. Crowe, Ariel Sharon, Kenneth Good and Felix Zandman. He has also written about a wide range of subjects including literary history, education and foreign for The Washington Post, The New Republic and The New York Times Magazine. He has published more than twelve books.\u001b[0m\n",
+      "Thought 2:\u001b[32;1m\u001b[1;3m The U.S. Navy admiral David Chanoff collaborated with is William J. Crowe.\n",
+      "Action 2: Search[William J. Crowe]\u001b[0m\n",
+      "Observation 2: \u001b[36;1m\u001b[1;3mWilliam James Crowe Jr. (January 2, 1925 – October 18, 2007) was a United States Navy admiral and diplomat who served as the 11th chairman of the Joint Chiefs of Staff under Presidents Ronald Reagan and George H. W. Bush, and as the ambassador to the United Kingdom and Chair of the Intelligence Oversight Board under President Bill Clinton.\u001b[0m\n",
+      "Thought 3:\u001b[32;1m\u001b[1;3m William J. Crowe served as the ambassador to the United Kingdom under President Bill Clinton.\n",
+      "Action 3: Finish[Bill Clinton]\u001b[0m\n",
+      "\u001b[1m> Finished ReActDocstoreAgent chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Bill Clinton'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "question = \"Author David Chanoff has collaborated with a U.S. Navy admiral who served as the ambassador to the United Kingdom under which President?\"\n",
+    "react.run(question)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ff64e81",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/agents/self_ask_with_search.ipynb

@@ -12,7 +12,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "7e3b513e",
    "metadata": {},
    "outputs": [
@@ -22,36 +22,41 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "What is the hometown of the reigning men's U.S. Open champion?\n",
-      "Are follow up questions needed here:\u001b[102m Yes.\n",
+      "\u001b[1m> Entering new SelfAskWithSearchAgent chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mAre follow up questions needed here: Yes.\n",
       "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\n",
-      "Intermediate answer: \u001b[103mCarlos Alcaraz won the 2022 Men's single title while Poland's Iga Swiatek won the Women's single title defeating Tunisian's Ons Jabeur..\u001b[0m\u001b[102m\n",
-      "Follow up: Where is Carlos Alcaraz from?\u001b[0m\n",
-      "Intermediate answer: \u001b[103mEl Palmar, Murcia, Spain.\u001b[0m\u001b[102m\n",
-      "So the final answer is: El Palmar, Murcia, Spain\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "Intermediate answer: \u001b[36;1m\u001b[1;3mCarlos Alcaraz\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mFollow up: Where is Carlos Alcaraz from?\u001b[0m\n",
+      "Intermediate answer: \u001b[36;1m\u001b[1;3mEl Palmar, Spain\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mSo the final answer is: El Palmar, Spain\u001b[0m\n",
+      "\u001b[1m> Finished SelfAskWithSearchAgent chain.\u001b[0m\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "'\\nSo the final answer is: El Palmar, Murcia, Spain'"
+       "'El Palmar, Spain'"
       ]
      },
-     "execution_count": 1,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "from langchain import SelfAskWithSearchChain, OpenAI, SerpAPIChain\n",
+    "from langchain import OpenAI, SerpAPIWrapper\n",
+    "from langchain.agents import initialize_agent, Tool\n",
     "\n",
     "llm = OpenAI(temperature=0)\n",
-    "search = SerpAPIChain()\n",
-    "\n",
-    "self_ask_with_search = SelfAskWithSearchChain(llm=llm, search_chain=search, verbose=True)\n",
+    "search = SerpAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name=\"Intermediate Answer\",\n",
+    "        func=search.run\n",
+    "    )\n",
+    "]\n",
     "\n",
+    "self_ask_with_search = initialize_agent(tools, llm, agent=\"self-ask-with-search\", verbose=True)\n",
     "self_ask_with_search.run(\"What is the hometown of the reigning men's U.S. Open champion?\")"
    ]
   },
@@ -80,7 +85,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.10.8"
   }
  },
  "nbformat": 4,

docs/examples/chains.rst

@@ -0,0 +1,88 @@
+Chains
+======
+
+The examples here are all end-to-end chains for specific applications.
+A chain is made up of links, which can be either primitives or other chains.
+
+The following primitives exist as options to use for links:
+
+#. `LLM: <../modules/llms.rst>`_ A language model takes text as input and outputs text.
+#. `PromptTemplate: <../modules/prompt.rst>`_ A prompt template takes arbitrary string inputs and returns a final formatted string.
+#. `TextSplitter: <../modules/text_splitter.rst>`_ A text splitter takes a longer document and splits it into smaller chunks.
+#. `Python REPL: <../modules/python.rst>`_ A Python REPL takes a string representing a Python command to run, runs that command, and then returns anything that was printed during that run.
+#. `SQL Database: <../modules/sql_database.rst>`_ A SQL database takes a string representing a SQL command as input and executes that command against the database. If any rows are returned, then those are cast to a string and returned.
+#. `Search: <../modules/serpapi.rst>`_ A search object takes a string as input and executes that against a search object, returning any results.
+#. `Docstore: <../modules/docstore.rst>`_ A docstore object can be used to lookup a document in a database by exact match.
+#. `Vectorstore: <../modules/vectorstore.rst>`_ A vectorstore object uses embeddings stored in a vector database to take in an input string and return documents similar to that string.
+
+With these primitives in mind, the following chains exist:
+
+**LLMChain**
+
+- **Links Used**: PromptTemplate, LLM
+- **Notes**: This chain is the simplest chain, and is widely used by almost every other chain. This chain takes arbitrary user input, creates a prompt with it from the PromptTemplate, passes that to the LLM, and then returns the output of the LLM as the final output.
+- `Example Notebook <chains/llm_chain.ipynb>`_
+
+**LLMMath**
+
+- **Links Used**: Python REPL, LLMChain
+- **Notes**: This chain takes user input (a math question), uses an LLMChain to convert it to python code snippet to run in the Python REPL, and then returns that as the result.
+- `Example Notebook <chains/llm_math.ipynb>`_
+
+**PAL**
+
+- **Links Used**: Python REPL, LLMChain
+- **Notes**: This chain takes user input (a reasoning question), uses an LLMChain to convert it to python code snippet to run in the Python REPL, and then returns that as the result.
+- `Paper <https://arxiv.org/abs/2211.10435>`_
+- `Example Notebook <chains/pal.ipynb>`_
+
+**Recursive Summarization**
+
+- **Links Used**: TextSplitter, LLMChain
+- **Notes**: This chain splits a document into chunks, runs a first LLMChain over each chunk to summarize it, and then runs a second LLMChain over those results to get a summary of the summaries.
+- `Example Notebook <chains/map_reduce.ipynb>`_
+
+**SQLDatabase Chain**
+
+- **Links Used**: SQLDatabase, LLMChain
+- **Notes**: This chain takes user input (a question), uses a first LLM chain to construct a SQL query to run against the SQL database, and then uses another LLMChain to take the results of that query and use it to answer the original question.
+- `Example Notebook <chains/sqlite.ipynb>`_
+
+
+**Vector Database Question-Answering**
+
+- **Links Used**: Vectorstore, LLMChain
+- **Notes**: This chain takes user input (a question), uses the Vectorstore and semantic search to find relevant documents, and then passes the documents plus the original question to another LLM to generate a final answer.
+- `Example Notebook <chains/vector_db_qa.ipynb>`_
+
+**Vector Database Question-Answering With Sources**
+
+- **Links Used**: Vectorstore, LLMChain
+- **Notes**: This chain takes user input (a question), uses the Vectorstore and semantic search to find relevant documents, and then passes the documents plus the original question to another LLM to generate a final answer with sources.
+- `Example Notebook <chains/vector_db_qa_with_sources.ipynb>`_
+
+**Question-Answering With Sources**
+
+- **Links Used**: LLMChain
+- **Notes**: These types of chains take a question and multiple documents as input, and return an answer plus sources for where that answer came from. There are multiple underlying types of chains to do this, for more information see TODO.
+- `Example Notebook <chains/qa_with_sources.ipynb>`_
+
+**Question-Answering**
+
+- **Links Used**: LLMChain
+- **Notes**: These types of chains take a question and multiple documents as input, and return an answer. There are multiple underlying types of chains to do this, for more information see TODO.
+- `Example Notebook <chains/question_answering.ipynb>`_
+
+**Summarization**
+
+- **Links Used**: LLMChain
+- **Notes**: These types of chains take multiple documents as input, and return a summary of all documents. There are multiple underlying types of chains to do this, for more information see TODO.
+- `Example Notebook <chains/summarize.ipynb>`_
+
+.. toctree::
+   :maxdepth: 1
+   :glob:
+   :caption: Chains
+   :hidden:
+
+   chains/*

docs/examples/chains/chatgpt_clone.ipynb

@@ -0,0 +1,971 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b253f4d5",
+   "metadata": {},
+   "source": [
+    "# ChatGPT Clone\n",
+    "\n",
+    "This chain replicates ChatGPT by combining (1) a specific prompt, and (2) the concept of memory.\n",
+    "\n",
+    "Shows off the example as in https://www.engraved.blog/building-a-virtual-machine-inside/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "a99acd89",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "\n",
+      "Human: I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply wiht the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "```\n",
+      "$ pwd\n",
+      "/\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain import OpenAI, ConversationChain, LLMChain, PromptTemplate\n",
+    "from langchain.chains.conversation.memory import ConversationalBufferWindowMemory\n",
+    "\n",
+    "\n",
+    "template = \"\"\"Assistant is a large language model trained by OpenAI.\n",
+    "\n",
+    "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+    "\n",
+    "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+    "\n",
+    "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+    "\n",
+    "{history}\n",
+    "Human: {human_input}\n",
+    "Assistant:\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"history\", \"human_input\"], \n",
+    "    template=template\n",
+    ")\n",
+    "\n",
+    "\n",
+    "chatgpt_chain = LLMChain(\n",
+    "    llm=OpenAI(temperature=0), \n",
+    "    prompt=prompt, \n",
+    "    verbose=True, \n",
+    "    memory=ConversationalBufferWindowMemory(k=2),\n",
+    ")\n",
+    "\n",
+    "output = chatgpt_chain.predict(human_input=\"I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply wiht the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "4ef711d6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply wiht the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\n",
+      "AI: \n",
+      "```\n",
+      "$ pwd\n",
+      "/\n",
+      "```\n",
+      "Human: ls ~\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "```\n",
+      "$ ls ~\n",
+      "Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"ls ~\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "a5d6dac2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply wiht the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\n",
+      "AI: \n",
+      "```\n",
+      "$ pwd\n",
+      "/\n",
+      "```\n",
+      "Human: ls ~\n",
+      "AI: \n",
+      "```\n",
+      "$ ls ~\n",
+      "Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos\n",
+      "```\n",
+      "Human: cd ~\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      " \n",
+      "```\n",
+      "$ cd ~\n",
+      "$ pwd\n",
+      "/home/user\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"cd ~\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "b9283077",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: ls ~\n",
+      "AI: \n",
+      "```\n",
+      "$ ls ~\n",
+      "Desktop  Documents  Downloads  Music  Pictures  Public  Templates  Videos\n",
+      "```\n",
+      "Human: cd ~\n",
+      "AI:  \n",
+      "```\n",
+      "$ cd ~\n",
+      "$ pwd\n",
+      "/home/user\n",
+      "```\n",
+      "Human: {Please make a file jokes.txt inside and put some jokes inside}\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ touch jokes.txt\n",
+      "$ echo \"Why did the chicken cross the road? To get to the other side!\" >> jokes.txt\n",
+      "$ echo \"What did the fish say when it hit the wall? Dam!\" >> jokes.txt\n",
+      "$ echo \"Why did the scarecrow win the Nobel Prize? Because he was outstanding in his field!\" >> jokes.txt\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"{Please make a file jokes.txt inside and put some jokes inside}\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "570e785e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: cd ~\n",
+      "AI:  \n",
+      "```\n",
+      "$ cd ~\n",
+      "$ pwd\n",
+      "/home/user\n",
+      "```\n",
+      "Human: {Please make a file jokes.txt inside and put some jokes inside}\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ touch jokes.txt\n",
+      "$ echo \"Why did the chicken cross the road? To get to the other side!\" >> jokes.txt\n",
+      "$ echo \"What did the fish say when it hit the wall? Dam!\" >> jokes.txt\n",
+      "$ echo \"Why did the scarecrow win the Nobel Prize? Because he was outstanding in his field!\" >> jokes.txt\n",
+      "```\n",
+      "Human: echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py && python3 run.py\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py\n",
+      "$ python3 run.py\n",
+      "Result: 33\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"\"\"echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py && python3 run.py\"\"\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "cd0a23d9",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: {Please make a file jokes.txt inside and put some jokes inside}\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ touch jokes.txt\n",
+      "$ echo \"Why did the chicken cross the road? To get to the other side!\" >> jokes.txt\n",
+      "$ echo \"What did the fish say when it hit the wall? Dam!\" >> jokes.txt\n",
+      "$ echo \"Why did the scarecrow win the Nobel Prize? Because he was outstanding in his field!\" >> jokes.txt\n",
+      "```\n",
+      "Human: echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py && python3 run.py\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py\n",
+      "$ python3 run.py\n",
+      "Result: 33\n",
+      "```\n",
+      "Human: echo -e \"print(list(filter(lambda x: all(x%d for d in range(2,x)),range(2,3**10)))[:10])\" > run.py && python3 run.py\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ echo -e \"print(list(filter(lambda x: all(x%d for d in range(2,x)),range(2,3**10)))[:10])\" > run.py\n",
+      "$ python3 run.py\n",
+      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"\"\"echo -e \"print(list(filter(lambda x: all(x%d for d in range(2,x)),range(2,3**10)))[:10])\" > run.py && python3 run.py\"\"\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "90db6eb2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py && python3 run.py\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ echo -e \"x=lambda y:y*5+3;print('Result:' + str(x(6)))\" > run.py\n",
+      "$ python3 run.py\n",
+      "Result: 33\n",
+      "```\n",
+      "Human: echo -e \"print(list(filter(lambda x: all(x%d for d in range(2,x)),range(2,3**10)))[:10])\" > run.py && python3 run.py\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ echo -e \"print(list(filter(lambda x: all(x%d for d in range(2,x)),range(2,3**10)))[:10])\" > run.py\n",
+      "$ python3 run.py\n",
+      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n",
+      "```\n",
+      "Human: echo -e \"echo 'Hello from Docker\" > entrypoint.sh && echo -e \"FROM ubuntu:20.04\n",
+      "COPY entrypoint.sh entrypoint.sh\n",
+      "ENTRYPOINT [\"/bin/sh\",\"entrypoint.sh\"]\">Dockerfile && docker build . -t my_docker_image && docker run -t my_docker_image\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ echo -e \"echo 'Hello from Docker\" > entrypoint.sh\n",
+      "$ echo -e \"FROM ubuntu:20.04\n",
+      "COPY entrypoint.sh entrypoint.sh\n",
+      "ENTRYPOINT [\"/bin/sh\",\"entrypoint.sh\"]\">Dockerfile\n",
+      "$ docker build . -t my_docker_image\n",
+      "$ docker run -t my_docker_image\n",
+      "Hello from Docker\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "docker_input = \"\"\"echo -e \"echo 'Hello from Docker\" > entrypoint.sh && echo -e \"FROM ubuntu:20.04\\nCOPY entrypoint.sh entrypoint.sh\\nENTRYPOINT [\\\"/bin/sh\\\",\\\"entrypoint.sh\\\"]\">Dockerfile && docker build . -t my_docker_image && docker run -t my_docker_image\"\"\"\n",
+    "output = chatgpt_chain.predict(human_input=docker_input)\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "c3806f89",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: echo -e \"print(list(filter(lambda x: all(x%d for d in range(2,x)),range(2,3**10)))[:10])\" > run.py && python3 run.py\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ echo -e \"print(list(filter(lambda x: all(x%d for d in range(2,x)),range(2,3**10)))[:10])\" > run.py\n",
+      "$ python3 run.py\n",
+      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n",
+      "```\n",
+      "Human: echo -e \"echo 'Hello from Docker\" > entrypoint.sh && echo -e \"FROM ubuntu:20.04\n",
+      "COPY entrypoint.sh entrypoint.sh\n",
+      "ENTRYPOINT [\"/bin/sh\",\"entrypoint.sh\"]\">Dockerfile && docker build . -t my_docker_image && docker run -t my_docker_image\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ echo -e \"echo 'Hello from Docker\" > entrypoint.sh\n",
+      "$ echo -e \"FROM ubuntu:20.04\n",
+      "COPY entrypoint.sh entrypoint.sh\n",
+      "ENTRYPOINT [\"/bin/sh\",\"entrypoint.sh\"]\">Dockerfile\n",
+      "$ docker build . -t my_docker_image\n",
+      "$ docker run -t my_docker_image\n",
+      "Hello from Docker\n",
+      "```\n",
+      "Human: nvidia-smi\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ nvidia-smi\n",
+      "Sat May 15 21:45:02 2021       \n",
+      "+-----------------------------------------------------------------------------+\n",
+      "| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
+      "|-------------------------------+----------------------+----------------------+\n",
+      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
+      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
+      "|===============================+======================+======================|\n",
+      "|   0  GeForce GTX 108...  Off  | 00000000:01:00.0 Off |                  N/A |\n",
+      "| N/A   45C    P0    N/A /  N/A |    511MiB /  10206MiB |      0%      Default |\n",
+      "+-------------------------------+----------------------+----------------------+\n",
+      "                                                                               \n",
+      "+-----------------------------------------------------------------------------+\n",
+      "| Processes:                                                       GPU Memory |\n",
+      "|  GPU       PID   Type   Process name                             Usage      |\n",
+      "|=============================================================================|\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"nvidia-smi\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "f508f597",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: echo -e \"echo 'Hello from Docker\" > entrypoint.sh && echo -e \"FROM ubuntu:20.04\n",
+      "COPY entrypoint.sh entrypoint.sh\n",
+      "ENTRYPOINT [\"/bin/sh\",\"entrypoint.sh\"]\">Dockerfile && docker build . -t my_docker_image && docker run -t my_docker_image\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ echo -e \"echo 'Hello from Docker\" > entrypoint.sh\n",
+      "$ echo -e \"FROM ubuntu:20.04\n",
+      "COPY entrypoint.sh entrypoint.sh\n",
+      "ENTRYPOINT [\"/bin/sh\",\"entrypoint.sh\"]\">Dockerfile\n",
+      "$ docker build . -t my_docker_image\n",
+      "$ docker run -t my_docker_image\n",
+      "Hello from Docker\n",
+      "```\n",
+      "Human: nvidia-smi\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ nvidia-smi\n",
+      "Sat May 15 21:45:02 2021       \n",
+      "+-----------------------------------------------------------------------------+\n",
+      "| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
+      "|-------------------------------+----------------------+----------------------+\n",
+      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
+      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
+      "|===============================+======================+======================|\n",
+      "|   0  GeForce GTX 108...  Off  | 00000000:01:00.0 Off |                  N/A |\n",
+      "| N/A   45C    P0    N/A /  N/A |    511MiB /  10206MiB |      0%      Default |\n",
+      "+-------------------------------+----------------------+----------------------+\n",
+      "                                                                               \n",
+      "+-----------------------------------------------------------------------------+\n",
+      "| Processes:                                                       GPU Memory |\n",
+      "|  GPU       PID   Type   Process name                             Usage      |\n",
+      "|=============================================================================|\n",
+      "\n",
+      "Human: ping bbc.com\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ ping bbc.com\n",
+      "PING bbc.com (151.101.65.81): 56 data bytes\n",
+      "64 bytes from 151.101.65.81: icmp_seq=0 ttl=53 time=14.945 ms\n",
+      "64 bytes from 151.101.65.81: icmp_seq=1 ttl=53 time=14.945 ms\n",
+      "64 bytes from 151.101.65.81: icmp_seq=2 ttl=53 time=14.945 ms\n",
+      "\n",
+      "--- bbc.com ping statistics ---\n",
+      "3 packets transmitted, 3 packets received, 0.0% packet loss\n",
+      "round-trip min/avg/max/stddev = 14.945/14.945/14.945/0.000 ms\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"ping bbc.com\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "cbd607f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: nvidia-smi\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ nvidia-smi\n",
+      "Sat May 15 21:45:02 2021       \n",
+      "+-----------------------------------------------------------------------------+\n",
+      "| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
+      "|-------------------------------+----------------------+----------------------+\n",
+      "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
+      "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
+      "|===============================+======================+======================|\n",
+      "|   0  GeForce GTX 108...  Off  | 00000000:01:00.0 Off |                  N/A |\n",
+      "| N/A   45C    P0    N/A /  N/A |    511MiB /  10206MiB |      0%      Default |\n",
+      "+-------------------------------+----------------------+----------------------+\n",
+      "                                                                               \n",
+      "+-----------------------------------------------------------------------------+\n",
+      "| Processes:                                                       GPU Memory |\n",
+      "|  GPU       PID   Type   Process name                             Usage      |\n",
+      "|=============================================================================|\n",
+      "\n",
+      "Human: ping bbc.com\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ ping bbc.com\n",
+      "PING bbc.com (151.101.65.81): 56 data bytes\n",
+      "64 bytes from 151.101.65.81: icmp_seq=0 ttl=53 time=14.945 ms\n",
+      "64 bytes from 151.101.65.81: icmp_seq=1 ttl=53 time=14.945 ms\n",
+      "64 bytes from 151.101.65.81: icmp_seq=2 ttl=53 time=14.945 ms\n",
+      "\n",
+      "--- bbc.com ping statistics ---\n",
+      "3 packets transmitted, 3 packets received, 0.0% packet loss\n",
+      "round-trip min/avg/max/stddev = 14.945/14.945/14.945/0.000 ms\n",
+      "```\n",
+      "Human: curl -fsSL \"https://api.github.com/repos/pytorch/pytorch/releases/latest\" | jq -r '.tag_name' | sed 's/[^0-9\\.\\-]*//g'\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ curl -fsSL \"https://api.github.com/repos/pytorch/pytorch/releases/latest\" | jq -r '.tag_name' | sed 's/[^0-9\\.\\-]*//g'\n",
+      "1.8.1\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"\"\"curl -fsSL \"https://api.github.com/repos/pytorch/pytorch/releases/latest\" | jq -r '.tag_name' | sed 's/[^0-9\\.\\-]*//g'\"\"\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "id": "d33e0e28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: ping bbc.com\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ ping bbc.com\n",
+      "PING bbc.com (151.101.65.81): 56 data bytes\n",
+      "64 bytes from 151.101.65.81: icmp_seq=0 ttl=53 time=14.945 ms\n",
+      "64 bytes from 151.101.65.81: icmp_seq=1 ttl=53 time=14.945 ms\n",
+      "64 bytes from 151.101.65.81: icmp_seq=2 ttl=53 time=14.945 ms\n",
+      "\n",
+      "--- bbc.com ping statistics ---\n",
+      "3 packets transmitted, 3 packets received, 0.0% packet loss\n",
+      "round-trip min/avg/max/stddev = 14.945/14.945/14.945/0.000 ms\n",
+      "```\n",
+      "Human: curl -fsSL \"https://api.github.com/repos/pytorch/pytorch/releases/latest\" | jq -r '.tag_name' | sed 's/[^0-9\\.\\-]*//g'\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ curl -fsSL \"https://api.github.com/repos/pytorch/pytorch/releases/latest\" | jq -r '.tag_name' | sed 's/[^0-9\\.\\-]*//g'\n",
+      "1.8.1\n",
+      "```\n",
+      "Human: lynx https://www.deepmind.com/careers\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ lynx https://www.deepmind.com/careers\n",
+      "DeepMind Careers\n",
+      "\n",
+      "Welcome to DeepMind Careers. We are a world-leading artificial intelligence research and development company, and we are looking for talented people to join our team.\n",
+      "\n",
+      "We offer a range of exciting opportunities in research, engineering, product, and operations. Our mission is to solve intelligence and make it useful, and we are looking for people who share our passion for pushing the boundaries of AI.\n",
+      "\n",
+      "Explore our current openings and apply today. We look forward to hearing from you.\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"lynx https://www.deepmind.com/careers\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "57c2f113",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: curl -fsSL \"https://api.github.com/repos/pytorch/pytorch/releases/latest\" | jq -r '.tag_name' | sed 's/[^0-9\\.\\-]*//g'\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ curl -fsSL \"https://api.github.com/repos/pytorch/pytorch/releases/latest\" | jq -r '.tag_name' | sed 's/[^0-9\\.\\-]*//g'\n",
+      "1.8.1\n",
+      "```\n",
+      "Human: lynx https://www.deepmind.com/careers\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ lynx https://www.deepmind.com/careers\n",
+      "DeepMind Careers\n",
+      "\n",
+      "Welcome to DeepMind Careers. We are a world-leading artificial intelligence research and development company, and we are looking for talented people to join our team.\n",
+      "\n",
+      "We offer a range of exciting opportunities in research, engineering, product, and operations. Our mission is to solve intelligence and make it useful, and we are looking for people who share our passion for pushing the boundaries of AI.\n",
+      "\n",
+      "Explore our current openings and apply today. We look forward to hearing from you.\n",
+      "```\n",
+      "Human: curl https://chat.openai.com/chat\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      " \n",
+      "\n",
+      "```\n",
+      "$ curl https://chat.openai.com/chat\n",
+      "<html>\n",
+      "  <head>\n",
+      "    <title>OpenAI Chat</title>\n",
+      "  </head>\n",
+      "  <body>\n",
+      "    <h1>Welcome to OpenAI Chat!</h1>\n",
+      "    <p>\n",
+      "      OpenAI Chat is a natural language processing platform that allows you to interact with OpenAI's AI models in a conversational way.\n",
+      "    </p>\n",
+      "    <p>\n",
+      "      To get started, type a message in the box below and press enter.\n",
+      "    </p>\n",
+      "  </body>\n",
+      "</html>\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"curl https://chat.openai.com/chat\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "babadc78",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: lynx https://www.deepmind.com/careers\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ lynx https://www.deepmind.com/careers\n",
+      "DeepMind Careers\n",
+      "\n",
+      "Welcome to DeepMind Careers. We are a world-leading artificial intelligence research and development company, and we are looking for talented people to join our team.\n",
+      "\n",
+      "We offer a range of exciting opportunities in research, engineering, product, and operations. Our mission is to solve intelligence and make it useful, and we are looking for people who share our passion for pushing the boundaries of AI.\n",
+      "\n",
+      "Explore our current openings and apply today. We look forward to hearing from you.\n",
+      "```\n",
+      "Human: curl https://chat.openai.com/chat\n",
+      "AI:  \n",
+      "\n",
+      "```\n",
+      "$ curl https://chat.openai.com/chat\n",
+      "<html>\n",
+      "  <head>\n",
+      "    <title>OpenAI Chat</title>\n",
+      "  </head>\n",
+      "  <body>\n",
+      "    <h1>Welcome to OpenAI Chat!</h1>\n",
+      "    <p>\n",
+      "      OpenAI Chat is a natural language processing platform that allows you to interact with OpenAI's AI models in a conversational way.\n",
+      "    </p>\n",
+      "    <p>\n",
+      "      To get started, type a message in the box below and press enter.\n",
+      "    </p>\n",
+      "  </body>\n",
+      "</html>\n",
+      "```\n",
+      "Human: curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"What is artificial intelligence?\"}' https://chat.openai.com/chat\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "```\n",
+      "$ curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"What is artificial intelligence?\"}' https://chat.openai.com/chat\n",
+      "\n",
+      "{\n",
+      "  \"response\": \"Artificial intelligence (AI) is the simulation of human intelligence processes by machines, especially computer systems. These processes include learning (the acquisition of information and rules for using the information), reasoning (using the rules to reach approximate or definite conclusions) and self-correction. AI is used to develop computer systems that can think and act like humans.\"\n",
+      "}\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"\"\"curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"What is artificial intelligence?\"}' https://chat.openai.com/chat\"\"\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "0954792a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mAssistant is a large language model trained by OpenAI.\n",
+      "\n",
+      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
+      "\n",
+      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
+      "\n",
+      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
+      "\n",
+      "Human: curl https://chat.openai.com/chat\n",
+      "AI:  \n",
+      "\n",
+      "```\n",
+      "$ curl https://chat.openai.com/chat\n",
+      "<html>\n",
+      "  <head>\n",
+      "    <title>OpenAI Chat</title>\n",
+      "  </head>\n",
+      "  <body>\n",
+      "    <h1>Welcome to OpenAI Chat!</h1>\n",
+      "    <p>\n",
+      "      OpenAI Chat is a natural language processing platform that allows you to interact with OpenAI's AI models in a conversational way.\n",
+      "    </p>\n",
+      "    <p>\n",
+      "      To get started, type a message in the box below and press enter.\n",
+      "    </p>\n",
+      "  </body>\n",
+      "</html>\n",
+      "```\n",
+      "Human: curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"What is artificial intelligence?\"}' https://chat.openai.com/chat\n",
+      "AI: \n",
+      "\n",
+      "```\n",
+      "$ curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"What is artificial intelligence?\"}' https://chat.openai.com/chat\n",
+      "\n",
+      "{\n",
+      "  \"response\": \"Artificial intelligence (AI) is the simulation of human intelligence processes by machines, especially computer systems. These processes include learning (the acquisition of information and rules for using the information), reasoning (using the rules to reach approximate or definite conclusions) and self-correction. AI is used to develop computer systems that can think and act like humans.\"\n",
+      "}\n",
+      "```\n",
+      "Human: curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply wiht the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\"}' https://chat.openai.com/chat\n",
+      "Assistant:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n",
+      " \n",
+      "\n",
+      "```\n",
+      "$ curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply wiht the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\"}' https://chat.openai.com/chat\n",
+      "\n",
+      "{\n",
+      "  \"response\": \"```\n",
+      "/home/user\n",
+      "```\"\n",
+      "}\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = chatgpt_chain.predict(human_input=\"\"\"curl --header \"Content-Type:application/json\" --request POST --data '{\"message\": \"I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply wiht the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.\"}' https://chat.openai.com/chat\"\"\")\n",
+    "print(output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e68a087e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/llm_bash.ipynb

@@ -0,0 +1,87 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# BashChain\n",
+    "This notebook showcases using LLMs and a bash process to do perform simple filesystem commands."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMBashChain chain...\u001b[0m\n",
+      "Please write a bash script that prints 'Hello World' to the console.\u001b[32;1m\u001b[1;3m\n",
+      "\n",
+      "```bash\n",
+      "echo \"Hello World\"\n",
+      "```\u001b[0m['```bash', 'echo \"Hello World\"', '```']\n",
+      "\n",
+      "Answer: \u001b[33;1m\u001b[1;3mHello World\n",
+      "\u001b[0m\n",
+      "\u001b[1m> Finished LLMBashChain chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Hello World\\n'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chains import LLMBashChain\n",
+    "from langchain.llms import OpenAI\n",
+    "\n",
+    "llm = OpenAI(temperature=0)\n",
+    "\n",
+    "text = \"Please write a bash script that prints 'Hello World' to the console.\"\n",
+    "\n",
+    "bash_chain = LLMBashChain(llm=llm, verbose=True)\n",
+    "\n",
+    "bash_chain.run(text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/examples/chains/llm_chain.ipynb

@@ -0,0 +1,154 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d8a5c5d4",
+   "metadata": {},
+   "source": [
+    "# LLM Chain\n",
+    "\n",
+    "This notebook showcases a simple LLM chain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "835e6978",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import PromptTemplate, OpenAI, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "06bcb078",
+   "metadata": {},
+   "source": [
+    "### Single Input\n",
+    "\n",
+    "First, lets go over an example using a single input"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "51a54c4d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mQuestion: What NFL team won the Super Bowl in the year Justin Beiber was born?\n",
+      "\n",
+      "Answer: Let's think step by step.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "' Justin Bieber was born in 1994, so the NFL team that won the Super Bowl in 1994 was the Dallas Cowboys.'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
+    "llm_chain = LLMChain(prompt=prompt, llm=OpenAI(temperature=0), verbose=True)\n",
+    "\n",
+    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
+    "\n",
+    "llm_chain.predict(question=question)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79c3ec4d",
+   "metadata": {},
+   "source": [
+    "### Multiple Inputs\n",
+    "Now lets go over an example using multiple inputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "03dd6918",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mWrite a sad poem about ducks.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMChain chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"\\n\\nThe ducks swim in the pond,\\nTheir feathers so soft and warm,\\nBut they can't help but feel so forlorn.\\n\\nTheir quacks echo in the air,\\nBut no one is there to hear,\\nFor they have no one to share.\\n\\nThe ducks paddle around in circles,\\nTheir heads hung low in despair,\\nFor they have no one to care.\\n\\nThe ducks look up to the sky,\\nBut no one is there to see,\\nFor they have no one to be.\\n\\nThe ducks drift away in the night,\\nTheir hearts filled with sorrow and pain,\\nFor they have no one to gain.\""
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "template = \"\"\"Write a {adjective} poem about {subject}.\"\"\"\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"adjective\", \"subject\"])\n",
+    "llm_chain = LLMChain(prompt=prompt, llm=OpenAI(temperature=0), verbose=True)\n",
+    "\n",
+    "llm_chain.predict(adjective=\"sad\", subject=\"ducks\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8310cdaa",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/llm_checker.ipynb

@@ -0,0 +1,97 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# LLMCheckerChain\n",
+    "This notebook showcases how to use LLMCheckerChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new LLMCheckerChain chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new SequentialChain chain...\u001b[0m\n",
+      "\u001b[1mChain 0\u001b[0m:\n",
+      "{'statement': '\\nThe largest mammal that lays eggs is the platypus.'}\n",
+      "\n",
+      "\u001b[1mChain 1\u001b[0m:\n",
+      "{'assertions': '\\n• The largest mammal is the platypus.\\n• The platypus lays eggs.\\n• There is no larger mammal than the platypus that lays eggs.'}\n",
+      "\n",
+      "\u001b[1mChain 2\u001b[0m:\n",
+      "{'checked_assertions': '\\n1. The largest mammal is the platypus. False. The blue whale is the largest mammal.\\n\\n2. The platypus lays eggs. True. The Platypus is one of only two mammals that lay eggs.\\n\\n3. There is no larger mammal than the platypus that lays eggs. False. The echidna is another mammal that lays eggs and is larger than the platypus.'}\n",
+      "\n",
+      "\u001b[1mChain 3\u001b[0m:\n",
+      "{'revised_statement': ' The echidna is the type of mammal that lays the biggest eggs.'}\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Finished SequentialChain chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished LLMCheckerChain chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "' The echidna is the type of mammal that lays the biggest eggs.'"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chains import LLMCheckerChain\n",
+    "from langchain.llms import OpenAI\n",
+    "\n",
+    "llm = OpenAI(temperature=0.7)\n",
+    "\n",
+    "text = \"What type of mammal lays the biggest eggs?\"\n",
+    "\n",
+    "checker_chain = LLMCheckerChain(llm=llm, verbose=True)\n",
+    "\n",
+    "checker_chain.run(text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/examples/chains/llm_math.ipynb

@@ -83,7 +83,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/examples/chains/llm_requests.ipynb

@@ -0,0 +1,123 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "dd7ec7af",
+   "metadata": {},
+   "source": [
+    "# LLMRequestsChain\n",
+    "\n",
+    "Using the request library to get HTML results from a URL and then an LLM to parse results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "dd8eae75",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.chains import LLMRequestsChain, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "65bf324e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import PromptTemplate\n",
+    "\n",
+    "template = \"\"\"Between >>> and <<< are the raw search result text from google.\n",
+    "Extract the answer to the question '{query}' or say \"not found\" if the information is not contained.\n",
+    "Use the format\n",
+    "Extracted:<answer or \"not found\">\n",
+    ">>> {requests_result} <<<\n",
+    "Extracted:\"\"\"\n",
+    "\n",
+    "PROMPT = PromptTemplate(\n",
+    "    input_variables=[\"query\", \"requests_result\"],\n",
+    "    template=template,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f36ae0d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = LLMRequestsChain(llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=PROMPT))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b5d22d9d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"What are the Three (3) biggest countries, and their respective sizes?\"\n",
+    "inputs = {\n",
+    "    \"query\": question,\n",
+    "    \"url\": \"https://www.google.com/search?q=\" + question.replace(\" \", \"+\")\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2ea81168",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'query': 'What are the Three (3) biggest countries, and their respective sizes?',\n",
+       " 'url': 'https://www.google.com/search?q=What+are+the+Three+(3)+biggest+countries,+and+their+respective+sizes?',\n",
+       " 'output': ' Russia (17,098,242 sq km), Canada (9,984,670 sq km), China (9,706,961 sq km)'}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain(inputs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "db8f2b6d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/moderation.ipynb

@@ -0,0 +1,435 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b83e61ed",
+   "metadata": {},
+   "source": [
+    "# Moderation\n",
+    "This notebook walks through examples of how to use a moderation chain, and several common ways for doing so. Moderation chains are useful for detecting text that could be hateful, violent, etc. This can be useful to apply on both user input, but also on the output of a Language Model. Some API providers, like OpenAI, [specifically prohibit](https://beta.openai.com/docs/usage-policies/use-case-policy) you, or your end users, from generating some types of harmful content. To comply with this (and to just generally prevent your application from being harmful) you may often want to append a moderation chain to any LLMChains, in order to make sure any output the LLM generates is not harmful.\n",
+    "\n",
+    "If the content passed into the moderation chain is harmful, there is not one best way to handle it, it probably depends on your application. Sometimes you may want to throw an error in the Chain (and have your application handle that). Other times, you may want to return something to the user explaining that the text was harmful. There could even be other ways to handle it! We will cover all these ways in this notebook.\n",
+    "\n",
+    "In this notebook, we will show:\n",
+    "\n",
+    "1. How to run any piece of text through a moderation chain.\n",
+    "2. How to append a Moderation chain to a LLMChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b7aa1ff2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.chains import OpenAIModerationChain, SequentialChain, LLMChain, SimpleSequentialChain\n",
+    "from langchain.prompts import PromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c26d5be6",
+   "metadata": {},
+   "source": [
+    "## How to use the moderation chain\n",
+    "\n",
+    "Here's an example of using the moderation chain with default settings (will return a string explaining stuff was flagged)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fd0fc85c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "moderation_chain = OpenAIModerationChain()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3fa47dd7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'This is okay'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "moderation_chain.run(\"This is okay\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "37bfad73",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Text was found that violates OpenAI's content policy.\""
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "moderation_chain.run(\"I will kill you\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "196820ab",
+   "metadata": {},
+   "source": [
+    "Here's an example of using the moderation chain to throw an error."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b29c1150",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "moderation_chain_error = OpenAIModerationChain(error=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f9ab64d9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'This is okay'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "moderation_chain_error.run(\"This is okay\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "954f3da2",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "Text was found that violates OpenAI's content policy.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmoderation_chain_error\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mI will kill you\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/workplace/third_party/langchain/langchain/chains/base.py:114\u001b[0m, in \u001b[0;36mChain.run\u001b[0;34m(self, text)\u001b[0m\n\u001b[1;32m    109\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_keys) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m    110\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m    111\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`run` not supported when there is not exactly \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    112\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mone output key, got \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_keys\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    113\u001b[0m     )\n\u001b[0;32m--> 114\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minput_keys\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mtext\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_keys[\u001b[38;5;241m0\u001b[39m]]\n",
+      "File \u001b[0;32m~/workplace/third_party/langchain/langchain/chains/base.py:87\u001b[0m, in \u001b[0;36mChain.__call__\u001b[0;34m(self, inputs, return_only_outputs)\u001b[0m\n\u001b[1;32m     83\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose:\n\u001b[1;32m     84\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\n\u001b[1;32m     85\u001b[0m         \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\033\u001b[39;00m\u001b[38;5;124m[1m> Entering new \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m chain...\u001b[39m\u001b[38;5;130;01m\\033\u001b[39;00m\u001b[38;5;124m[0m\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     86\u001b[0m     )\n\u001b[0;32m---> 87\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     88\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mverbose:\n\u001b[1;32m     89\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;130;01m\\033\u001b[39;00m\u001b[38;5;124m[1m> Finished \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__class__\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m chain.\u001b[39m\u001b[38;5;130;01m\\033\u001b[39;00m\u001b[38;5;124m[0m\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "File \u001b[0;32m~/workplace/third_party/langchain/langchain/chains/moderation.py:79\u001b[0m, in \u001b[0;36mOpenAIModerationChain._call\u001b[0;34m(self, inputs)\u001b[0m\n\u001b[1;32m     77\u001b[0m text \u001b[38;5;241m=\u001b[39m inputs[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minput_key]\n\u001b[1;32m     78\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclient\u001b[38;5;241m.\u001b[39mcreate(text)\n\u001b[0;32m---> 79\u001b[0m output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_moderate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtext\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mresults\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mresults\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     80\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_key: output}\n",
+      "File \u001b[0;32m~/workplace/third_party/langchain/langchain/chains/moderation.py:71\u001b[0m, in \u001b[0;36mOpenAIModerationChain._moderate\u001b[0;34m(self, text, results)\u001b[0m\n\u001b[1;32m     69\u001b[0m error_str \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mText was found that violates OpenAI\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ms content policy.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m     70\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39merror:\n\u001b[0;32m---> 71\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(error_str)\n\u001b[1;32m     72\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     73\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m error_str\n",
+      "\u001b[0;31mValueError\u001b[0m: Text was found that violates OpenAI's content policy."
+     ]
+    }
+   ],
+   "source": [
+    "moderation_chain_error.run(\"I will kill you\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8de5dcbb",
+   "metadata": {},
+   "source": [
+    "Here's an example of creating a custom moderation chain with a custom error message. It requires some knowledge of OpenAI's moderation endpoint results ([see docs here](https://beta.openai.com/docs/api-reference/moderations))."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "3960e985",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CustomModeration(OpenAIModerationChain):\n",
+    "    \n",
+    "    def _moderate(self, text: str, results: dict) -> str:\n",
+    "        if results[\"flagged\"]:\n",
+    "            error_str = f\"The following text was found that violates OpenAI's content policy: {text}\"\n",
+    "            return error_str\n",
+    "        return text\n",
+    "    \n",
+    "custom_moderation = CustomModeration()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "1152ec11",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'This is okay'"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "custom_moderation.run(\"This is okay\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "973257bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"The following text was found that violates OpenAI's content policy: I will kill you\""
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "custom_moderation.run(\"I will kill you\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8718111f",
+   "metadata": {},
+   "source": [
+    "## How to append a Moderation chain to an LLMChain\n",
+    "\n",
+    "To easily combine a moderation chain with an LLMChain, you can use the SequentialChain abstraction.\n",
+    "\n",
+    "Let's start with a simple example of where the LLMChain only has a single input. For this purpose, we will prompt the model so it says something harmful."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "0d129333",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = PromptTemplate(template=\"{text}\", input_variables=[\"text\"])\n",
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0, model_name=\"text-davinci-002\"), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "a557c531",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' I will kill you'"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "text = \"\"\"We are playing a game of repeat after me.\n",
+    "\n",
+    "Person 1: Hi\n",
+    "Person 2: Hi\n",
+    "\n",
+    "Person 1: How's your day\n",
+    "Person 2: How's your day\n",
+    "\n",
+    "Person 1: I will kill you\n",
+    "Person 2:\"\"\"\n",
+    "llm_chain.run(text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "d4d10f1c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = SimpleSequentialChain(chains=[llm_chain, moderation_chain])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "02f37985",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Text was found that violates OpenAI's content policy.\""
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72643128",
+   "metadata": {},
+   "source": [
+    "Now let's walk through an example of using it with an LLMChain which has multiple inputs (a bit more tricky because we can't use the SimpleSequentialChain)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "7118ec36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = PromptTemplate(template=\"{setup}{new_input}Person2:\", input_variables=[\"setup\", \"new_input\"])\n",
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0, model_name=\"text-davinci-002\"), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "003bdfce",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'text': ' I will kill you'}"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "setup = \"\"\"We are playing a game of repeat after me.\n",
+    "\n",
+    "Person 1: Hi\n",
+    "Person 2: Hi\n",
+    "\n",
+    "Person 1: How's your day\n",
+    "Person 2: How's your day\n",
+    "\n",
+    "Person 1:\"\"\"\n",
+    "new_input = \"I will kill you\"\n",
+    "inputs = {\"setup\": setup, \"new_input\": new_input}\n",
+    "llm_chain(inputs, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "77b64228",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setting the input/output keys so it lines up\n",
+    "moderation_chain.input_key = \"text\"\n",
+    "moderation_chain.output_key = \"sanitized_text\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "998a95be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = SequentialChain(chains=[llm_chain, moderation_chain], input_variables=[\"setup\", \"new_input\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "9c97a136",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'sanitized_text': \"Text was found that violates OpenAI's content policy.\"}"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain(inputs, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddc90e15",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/pal.ipynb

@@ -0,0 +1,180 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "32e022a2",
+   "metadata": {},
+   "source": [
+    "# PAL\n",
+    "\n",
+    "Implements Program-Aided Language Models, as in https://arxiv.org/pdf/2211.10435.pdf.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1370e40f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import PALChain\n",
+    "from langchain import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "beddcac7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(model_name='code-davinci-002', temperature=0, max_tokens=512)\n",
+    "pal_chain = PALChain.from_math_prompt(llm, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e2eab9d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"Jan has three times the number of pets as Marcia. Marcia has two more pets than Cindy. If Cindy has four pets, how many total pets do the three have?\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3ef64b27",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mdef solution():\n",
+      "    \"\"\"Jan has three times the number of pets as Marcia. Marcia has two more pets than Cindy. If Cindy has four pets, how many total pets do the three have?\"\"\"\n",
+      "    cindy_pets = 4\n",
+      "    marcia_pets = cindy_pets + 2\n",
+      "    jan_pets = marcia_pets * 3\n",
+      "    total_pets = cindy_pets + marcia_pets + jan_pets\n",
+      "    result = total_pets\n",
+      "    return result\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'28'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pal_chain.run(question)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e524f81f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(model_name='code-davinci-002', temperature=0, max_tokens=512)\n",
+    "pal_chain = PALChain.from_colored_object_prompt(llm, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "03a237b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"On the desk, you see two blue booklets, two purple booklets, and two yellow pairs of sunglasses. If I remove all the pairs of sunglasses from the desk, how many purple items remain on it?\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a84a4352",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m# Put objects into a list to record ordering\n",
+      "objects = []\n",
+      "objects += [('booklet', 'blue')] * 2\n",
+      "objects += [('booklet', 'purple')] * 2\n",
+      "objects += [('sunglasses', 'yellow')] * 2\n",
+      "\n",
+      "# Remove all pairs of sunglasses\n",
+      "objects = [object for object in objects if object[0] != 'sunglasses']\n",
+      "\n",
+      "# Count number of purple objects\n",
+      "num_purple = len([object for object in objects if object[1] == 'purple'])\n",
+      "answer = num_purple\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'2'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pal_chain.run(question)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ab20fec",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/qa_with_sources.ipynb

@@ -0,0 +1,258 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "74148cee",
+   "metadata": {},
+   "source": [
+    "# Question Answering with Sources\n",
+    "\n",
+    "This notebook walks through how to use LangChain for question answering with sources over a list of documents. It covers three different chain types: `stuff`, `map_reduce`, and `refine`. For a more in depth explanation of what these chain types are, see [here](../../explanation/combine_docs.md)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca2f0efc",
+   "metadata": {},
+   "source": [
+    "### Prepare Data\n",
+    "First we prepare the data. For this example we do similarity search over a vector database, but these documents could be fetched in any manner (the point of this notebook to highlight what to do AFTER you fetch the documents)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "78f28130",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.embeddings.cohere import CohereEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch\n",
+    "from langchain.vectorstores.faiss import FAISS\n",
+    "from langchain.docstore.document import Document"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4da195a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('../state_of_the_union.txt') as f:\n",
+    "    state_of_the_union = f.read()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "texts = text_splitter.split_text(state_of_the_union)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5ec2b55b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docsearch = FAISS.from_texts(texts, embeddings, metadatas=[{\"source\": i} for i in range(len(texts))])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5286f58f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "docs = docsearch.similarity_search(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "005a47e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.qa_with_sources import load_qa_with_sources_chain\n",
+    "from langchain.llms import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d82f899a",
+   "metadata": {},
+   "source": [
+    "### The `stuff` Chain\n",
+    "\n",
+    "This sections shows results of using the `stuff` Chain to do question answering with sources."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "fc1a5ed6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_qa_with_sources_chain(OpenAI(temperature=0), chain_type=\"stuff\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e239964b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs = [Document(page_content=t, metadata={\"source\": i}) for i, t in enumerate(texts[:3])]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7d766417",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output_text': ' The president did not mention Justice Breyer.\\nSOURCES: 0-pl, 1-pl, 2-pl'}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "chain({\"input_documents\": docs, \"question\": query}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5dbb304",
+   "metadata": {},
+   "source": [
+    "### The `map_reduce` Chain\n",
+    "\n",
+    "This sections shows results of using the `map_reduce` Chain to do question answering with sources."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "921db0a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_qa_with_sources_chain(OpenAI(temperature=0), chain_type=\"map_reduce\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e417926a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "None of PyTorch, TensorFlow >= 2.0, or Flax have been found. Models won't be available and only tokenizers, configuration and file/data utilities can be used.\n",
+      "Token indices sequence length is longer than the specified maximum sequence length for this model (1546 > 1024). Running this sequence through the model will result in indexing errors\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'output_text': ' The president did not mention Justice Breyer.\\nSOURCES: 0, 1, 2'}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "chain({\"input_documents\": docs, \"question\": query}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5bf0e1ab",
+   "metadata": {},
+   "source": [
+    "### The `refine` Chain\n",
+    "\n",
+    "This sections shows results of using the `refine` Chain to do question answering with sources."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "904835c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_qa_with_sources_chain(OpenAI(temperature=0), chain_type=\"refine\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "f60875c6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output_text': \"\\n\\nThe president did not mention Justice Breyer in his speech to the European Parliament, which focused on building a coalition of freedom-loving nations to confront Putin, unifying European allies, countering Russia's lies with truth, and enforcing powerful economic sanctions. Source: 2\"}"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "chain({\"input_documents\": docs, \"question\": query}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "929620d0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/question_answering.ipynb

@@ -0,0 +1,248 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "05859721",
+   "metadata": {},
+   "source": [
+    "# Question Answering\n",
+    "\n",
+    "This notebook walks through how to use LangChain for question answering over a list of documents. It covers three different types of chaings: `stuff`, `map_reduce`, and `refine`. For a more in depth explanation of what these chain types are, see [here](../../explanation/combine_docs.md)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "726f4996",
+   "metadata": {},
+   "source": [
+    "### Prepare Data\n",
+    "First we prepare the data. For this example we do similarity search over a vector database, but these documents could be fetched in any manner (the point of this notebook to highlight what to do AFTER you fetch the documents)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "17fcbc0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores.faiss import FAISS\n",
+    "from langchain.docstore.document import Document"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "291f0117",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('../state_of_the_union.txt') as f:\n",
+    "    state_of_the_union = f.read()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "texts = text_splitter.split_text(state_of_the_union)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fd9666a9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docsearch = FAISS.from_texts(texts, embeddings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d1eaf6e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "docs = docsearch.similarity_search(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a16e3453",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.question_answering import load_qa_chain\n",
+    "from langchain.llms import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f78787a0",
+   "metadata": {},
+   "source": [
+    "### The `stuff` Chain\n",
+    "\n",
+    "This sections shows results of using the `stuff` Chain to do question answering."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "180fd4c1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_qa_chain(OpenAI(temperature=0), chain_type=\"stuff\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d145ae31",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs = [Document(page_content=t) for t in texts[:3]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "77fdf1aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output_text': ' The president did not mention Justice Breyer.'}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "chain({\"input_documents\": docs, \"question\": query}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91522e29",
+   "metadata": {},
+   "source": [
+    "### The `map_reduce` Chain\n",
+    "\n",
+    "This sections shows results of using the `map_reduce` Chain to do question answering."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b0060f51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_qa_chain(OpenAI(temperature=0), chain_type=\"map_reduce\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fbdb9137",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output_text': ' The president did not mention Justice Breyer.'}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "chain({\"input_documents\": docs, \"question\": query}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6ea50ad0",
+   "metadata": {},
+   "source": [
+    "### The `refine` Chain\n",
+    "\n",
+    "This sections shows results of using the `refine` Chain to do question answering."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fb167057",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_qa_chain(OpenAI(temperature=0), chain_type=\"refine\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "d8b5286e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'output_text': \"\\n\\nThe president did not mention Justice Breyer in his speech to the European Parliament about building a coalition of freedom-loving nations to confront Putin, unifying European allies, countering Russia's lies with truth, and enforcing powerful economic sanctions.\"}"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"What did the president say about Justice Breyer\"\n",
+    "chain({\"input_documents\": docs, \"question\": query}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49e9c6d7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/summarize.ipynb

@@ -0,0 +1,234 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d9a0131f",
+   "metadata": {},
+   "source": [
+    "# Summarization\n",
+    "\n",
+    "This notebook walks through how to use LangChain for summarization over a list of documents. It covers three different chain types: `stuff`, `map_reduce`, and `refine`. For a more in depth explanation of what these chain types are, see [here](../../explanation/combine_docs.md)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b5660bf",
+   "metadata": {},
+   "source": [
+    "### Prepare Data\n",
+    "First we prepare the data. For this example we create multiple documents from one long one, but these documents could be fetched in any manner (the point of this notebook to highlight what to do AFTER you fetch the documents)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e9db25f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import OpenAI, PromptTemplate, LLMChain\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.chains.mapreduce import MapReduceChain\n",
+    "\n",
+    "llm = OpenAI(temperature=0)\n",
+    "\n",
+    "\n",
+    "text_splitter = CharacterTextSplitter()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "99bbe19b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('../state_of_the_union.txt') as f:\n",
+    "    state_of_the_union = f.read()\n",
+    "texts = text_splitter.split_text(state_of_the_union)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "baa6e808",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.docstore.document import Document"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8dff4f43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs = [Document(page_content=t) for t in texts[:3]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "27989fc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.summarize import load_summarize_chain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea2d5c99",
+   "metadata": {},
+   "source": [
+    "### The `stuff` Chain\n",
+    "\n",
+    "This sections shows results of using the `stuff` Chain to do summarization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f01f3196",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_summarize_chain(llm, chain_type=\"stuff\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "da4d9801",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' In his speech, President Biden addressed the ongoing conflict between Russia and Ukraine, and the need for the United States and its allies to stand with Ukraine. He also discussed the American Rescue Plan, the Bipartisan Infrastructure Law, and the Bipartisan Innovation Act, which will help to create jobs, modernize infrastructure, and level the playing field with China. He also emphasized the importance of buying American products to support American jobs.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(docs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c868e86",
+   "metadata": {},
+   "source": [
+    "### The `map_reduce` Chain\n",
+    "\n",
+    "This sections shows results of using the `map_reduce` Chain to do summarization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ef28e1d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_summarize_chain(llm, chain_type=\"map_reduce\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f82c5f9f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\" In response to Vladimir Putin's aggression in Ukraine, the US and its allies have taken action to hold him accountable, including economic sanctions, cutting off access to technology, and seizing the assets of Russian oligarchs. They are also providing military, economic, and humanitarian assistance to the Ukrainians, and releasing 60 million barrels of oil from reserves around the world. President Biden has passed several laws to provide economic relief to Americans and create jobs, and is making sure taxpayer dollars support American jobs and businesses.\""
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(docs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f61350f9",
+   "metadata": {},
+   "source": [
+    "### The `refine` Chain\n",
+    "\n",
+    "This sections shows results of using the `refine` Chain to do summarization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "3bcbe31e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = load_summarize_chain(llm, chain_type=\"refine\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "c8cad866",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"\\nIn this speech, the speaker addresses the American people and their allies, discussing the recent aggression of Russia's Vladimir Putin in Ukraine. The speaker outlines the actions taken by the United States and its allies to hold Putin accountable, including economic sanctions, cutting off access to technology, and seizing the assets of Russian oligarchs. The speaker also announces the closing of American airspace to Russian flights, further isolating Russia and adding an additional squeeze on their economy. The Russian stock market has lost 40% of its value and trading remains suspended. Together with our allies, the United States is providing military, economic, and humanitarian assistance to Ukraine, and has mobilized forces to protect NATO countries. The speaker also announces the release of 60 million barrels of oil from reserves around the world, with the United States releasing 30 million barrels from its own Strategic Petroleum Reserve. The speaker emphasizes that the United States and its allies will defend every inch of NATO territory and that Putin will pay a high price for his aggression. The speaker also acknowledges the hardships faced by the American people due to the pandemic and the American Rescue Plan, which has provided immediate economic relief for tens of millions of Americans, helped put food on their table, keep a roof over their heads, and cut the cost of health insurance. The speaker\""
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0da92750",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/transformation.ipynb

@@ -0,0 +1,130 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "872bb8b5",
+   "metadata": {},
+   "source": [
+    "# Transformation Chain\n",
+    "\n",
+    "This notebook showcases using a generic transformation chain.\n",
+    "\n",
+    "As an example, we will create a dummy transformation that takes in a super long text, filters the text to only the first 3 paragraphs, and then passes that into an LLMChain to summarize those."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bbbb4330",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import TransformChain, LLMChain, SimpleSequentialChain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.prompts import PromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "8ae5937c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('../state_of_the_union.txt') as f:\n",
+    "    state_of_the_union = f.read()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "98739592",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def transform_func(inputs: dict) -> dict:\n",
+    "    text = inputs[\"text\"]\n",
+    "    shortened_text = \"\\n\\n\".join(text.split(\"\\n\\n\")[:3])\n",
+    "    return {\"output_text\": shortened_text}\n",
+    "\n",
+    "transform_chain = TransformChain(input_variables=[\"text\"], output_variables=[\"output_text\"], transform=transform_func)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e9397934",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Summarize this text:\n",
+    "\n",
+    "{output_text}\n",
+    "\n",
+    "Summary:\"\"\"\n",
+    "prompt = PromptTemplate(input_variables=[\"output_text\"], template=template)\n",
+    "llm_chain = LLMChain(llm=OpenAI(), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "06f51f17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sequential_chain = SimpleSequentialChain(chains=[transform_chain, llm_chain])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f7caa1ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' This speech addresses the American people and acknowledges the difficulties of last year due to COVID-19. It emphasizes the importance of coming together regardless of political affiliation and encourages a sense of unity as Americans.'"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sequential_chain.run(state_of_the_union)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3ca6409",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/chains/vector_db_qa.ipynb

@@ -41,27 +41,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "3018f865",
    "metadata": {},
    "outputs": [],
    "source": [
-    "qa = VectorDBQA(llm=OpenAI(), vectorstore=docsearch)"
+    "qa = VectorDBQA.from_llm(llm=OpenAI(), vectorstore=docsearch)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "032a47f8",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "' The President said that Ketanji Brown Jackson is a consensus builder and has received a broad range of support since she was nominated.'"
+       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds, a former top litigator and federal public defender, and from a family of public school educators and police officers. He also said that she has received a broad range of support since she was nominated, from the Fraternal Order of Police to former judges appointed by Democrats and Republicans.\""
       ]
      },
-     "execution_count": 5,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -74,7 +74,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "f0f20b92",
+   "id": "f056f6fd",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -96,7 +96,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.10.8"
   }
  },
  "nbformat": 4,

docs/examples/chains/vector_db_qa_with_sources.ipynb

@@ -0,0 +1,146 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "efc5be67",
+   "metadata": {},
+   "source": [
+    "# VectorDB Question Ansering with Sources\n",
+    "\n",
+    "This notebook goes over how to do question-answering with sources. It does this in a few different ways - first showing how you can use the `QAWithSourcesChain` to take in documents and use those, and next showing the `VectorDBQAWithSourcesChain`, which also does the lookup of the documents from a vector database. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1c613960",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.embeddings.cohere import CohereEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch\n",
+    "from langchain.vectorstores.faiss import FAISS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "17d1306e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('../state_of_the_union.txt') as f:\n",
+    "    state_of_the_union = f.read()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "texts = text_splitter.split_text(state_of_the_union)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0e745d99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docsearch = FAISS.from_texts(texts, embeddings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f42d79dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add in a fake source information\n",
+    "for i, d in enumerate(docsearch.docstore._dict.values()):\n",
+    "    d.metadata = {'source': f\"{i}-pl\"}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6fc81de",
+   "metadata": {},
+   "source": [
+    "### VectorDBQAWithSourcesChain\n",
+    "\n",
+    "This shows how to use the `VectorDBQAWithSourcesChain`, which uses a vector database to look up relevant documents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8aa571ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import VectorDBQAWithSourcesChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "aa859d4c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = VectorDBQAWithSourcesChain.from_llm(OpenAI(temperature=0), vectorstore=docsearch)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "8ba36fa7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'answer': ' The president thanked Justice Breyer for his service.',\n",
+       " 'sources': '27-pl'}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain({\"question\": \"What did the president say about Justice Breyer\"}, return_only_outputs=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "980fae3b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/demos.rst

@@ -1,10 +0,0 @@
-Demos
-=====
-
-The examples here are all end-to-end chains of specific applications.
-
-.. toctree::
-   :maxdepth: 1
-   :glob:
-
-   demos/*

docs/examples/demos/map reduce.ipynb

@@ -1,93 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "d9a0131f",
-   "metadata": {},
-   "source": [
-    "# Map Reduce\n",
-    "\n",
-    "This notebok showcases an example of map-reduce chains: recursive summarization."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "e9db25f3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain import OpenAI, Prompt, LLMChain\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.chains.mapreduce import MapReduceChain\n",
-    "\n",
-    "llm = OpenAI(temperature=0)\n",
-    "\n",
-    "_prompt = \"\"\"Write a concise summary of the following:\n",
-    "\n",
-    "\n",
-    "{text}\n",
-    "\n",
-    "\n",
-    "CONCISE SUMMARY:\"\"\"\n",
-    "prompt = Prompt(template=_prompt, input_variables=[\"text\"])\n",
-    "\n",
-    "text_splitter = CharacterTextSplitter()\n",
-    "\n",
-    "mp_chain = MapReduceChain.from_params(llm, prompt, text_splitter)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "99bbe19b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "\"\\n\\nThe President discusses the recent aggression by Russia, and the response by the United States and its allies. He announces new sanctions against Russia, and says that the free world is united in holding Putin accountable. The President also discusses the American Rescue Plan, the Bipartisan Infrastructure Law, and the Bipartisan Innovation Act. Finally, the President addresses the need for women's rights and equality for LGBTQ+ Americans.\""
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "with open('../state_of_the_union.txt') as f:\n",
-    "    state_of_the_union = f.read()\n",
-    "mp_chain.run(state_of_the_union)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b581501e",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/examples/demos/mrkl.ipynb

@@ -1,226 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "f1390152",
-   "metadata": {},
-   "source": [
-    "# MRKL\n",
-    "\n",
-    "This notebook showcases using the MRKL chain to route between tasks"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "39ea3638",
-   "metadata": {},
-   "source": [
-    "This uses the example Chinook database.\n",
-    "To set it up follow the instructions on https://database.guide/2-sample-databases-sqlite/, placing the `.db` file in a notebooks folder at the root of this repository."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "ac561cc4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain import LLMMathChain, OpenAI, SerpAPIChain, MRKLChain, SQLDatabase, SQLDatabaseChain\n",
-    "from langchain.chains.mrkl.base import ChainConfig"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "07e96d99",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\n",
-    "search = SerpAPIChain()\n",
-    "llm_math_chain = LLMMathChain(llm=llm, verbose=True)\n",
-    "db = SQLDatabase.from_uri(\"sqlite:///../../../notebooks/Chinook.db\")\n",
-    "db_chain = SQLDatabaseChain(llm=llm, database=db, verbose=True)\n",
-    "chains = [\n",
-    "    ChainConfig(\n",
-    "        action_name = \"Search\",\n",
-    "        action=search.run,\n",
-    "        action_description=\"useful for when you need to answer questions about current events\"\n",
-    "    ),\n",
-    "    ChainConfig(\n",
-    "        action_name=\"Calculator\",\n",
-    "        action=llm_math_chain.run,\n",
-    "        action_description=\"useful for when you need to answer questions about math\"\n",
-    "    ),\n",
-    "    \n",
-    "    ChainConfig(\n",
-    "        action_name=\"FooBar DB\",\n",
-    "        action=db_chain.run,\n",
-    "        action_description=\"useful for when you need to answer questions about FooBar. Input should be in the form of a question\"\n",
-    "    )\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "a069c4b6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mrkl = MRKLChain.from_chains(llm, chains, verbose=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "e603cd7d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "What is the age of Olivia Wilde's boyfriend raised to the 0.23 power?\n",
-      "Thought:\u001b[102m I need to find the age of Olivia Wilde's boyfriend\n",
-      "Action: Search\n",
-      "Action Input: \"Olivia Wilde's boyfriend\"\u001b[0m\n",
-      "Observation: \u001b[104mOlivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.\u001b[0m\n",
-      "Thought:\u001b[102m I need to find the age of Harry Styles\n",
-      "Action: Search\n",
-      "Action Input: \"Harry Styles age\"\u001b[0m\n",
-      "Observation: \u001b[104m28 years\u001b[0m\n",
-      "Thought:\u001b[102m I need to calculate 28 to the 0.23 power\n",
-      "Action: Calculator\n",
-      "Action Input: 28^0.23\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "28^0.23\u001b[102m\n",
-      "\n",
-      "```python\n",
-      "print(28**0.23)\n",
-      "```\n",
-      "\u001b[0m\n",
-      "Answer: \u001b[103m2.1520202182226886\n",
-      "\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      "\n",
-      "Observation: \u001b[103mAnswer: 2.1520202182226886\n",
-      "\u001b[0m\n",
-      "Thought:\u001b[102m I now know the final answer\n",
-      "Final Answer: 2.1520202182226886\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'2.1520202182226886'"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "mrkl.run(\"What is the age of Olivia Wilde's boyfriend raised to the 0.23 power?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "a5c07010",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "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:\u001b[102m I need to find an album called 'The Storm Before the Calm'\n",
-      "Action: Search\n",
-      "Action Input: \"The Storm Before the Calm album\"\u001b[0m\n",
-      "Observation: \u001b[104mThe Storm Before the Calm (stylized in all lowercase) is the tenth (and eighth international) studio album by Canadian-American singer-songwriter Alanis ...\u001b[0m\n",
-      "Thought:\u001b[102m I need to check if Alanis is in the FooBar database\n",
-      "Action: FooBar DB\n",
-      "Action Input: \"Does Alanis Morissette exist in the FooBar database?\"\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "Does Alanis Morissette exist in the FooBar database?\n",
-      "SQLQuery:\u001b[102m SELECT * FROM Artist WHERE Name = 'Alanis Morissette'\u001b[0m\n",
-      "SQLResult: \u001b[103m[(4, 'Alanis Morissette')]\u001b[0m\n",
-      "Answer:\u001b[102m Yes\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      "\n",
-      "Observation: \u001b[101m Yes\u001b[0m\n",
-      "Thought:\u001b[102m I need to find out what albums of Alanis's are in the FooBar database\n",
-      "Action: FooBar DB\n",
-      "Action Input: \"What albums by Alanis Morissette are in the FooBar database?\"\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "What albums by Alanis Morissette are in the FooBar database?\n",
-      "SQLQuery:\u001b[102m SELECT Title FROM Album WHERE ArtistId = (SELECT ArtistId FROM Artist WHERE Name = 'Alanis Morissette')\u001b[0m\n",
-      "SQLResult: \u001b[103m[('Jagged Little Pill',)]\u001b[0m\n",
-      "Answer:\u001b[102m Jagged Little Pill\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      "\n",
-      "Observation: \u001b[101m Jagged Little Pill\u001b[0m\n",
-      "Thought:\u001b[102m I now know the final answer\n",
-      "Final Answer: The album is by Alanis Morissette and the albums in the FooBar database by her are Jagged Little Pill\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The album is by Alanis Morissette and the albums in the FooBar database by her are Jagged Little Pill'"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "mrkl.run(\"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?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d7c2e6ac",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/examples/demos/react.ipynb

@@ -1,98 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "82140df0",
-   "metadata": {},
-   "source": [
-    "# ReAct\n",
-    "\n",
-    "This notebook showcases the implementation of the ReAct chain logic."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "4e272b47",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain import OpenAI, ReActChain, Wikipedia\n",
-    "\n",
-    "llm = OpenAI(temperature=0)\n",
-    "react = ReActChain(llm=llm, docstore=Wikipedia(), verbose=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "8078c8f1",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "Author David Chanoff has collaborated with a U.S. Navy admiral who served as the ambassador to the United Kingdom under which President?\n",
-      "Thought 1:\u001b[102m I need to search David Chanoff and find the U.S. Navy admiral he\n",
-      "collaborated with.\n",
-      "Action 1: Search[David Chanoff]\u001b[0m\n",
-      "Observation 1: \u001b[103mDavid Chanoff is a noted author of non-fiction work. His work has typically involved collaborations with the principal protagonist of the work concerned. His collaborators have included; Augustus A. White, Joycelyn Elders, Đoàn Văn Toại, William J. Crowe, Ariel Sharon, Kenneth Good and Felix Zandman. He has also written about a wide range of subjects including literary history, education and foreign for The Washington Post, The New Republic and The New York Times Magazine. He has published more than twelve books.\u001b[0m\n",
-      "Thought 2:\u001b[102m The U.S. Navy admiral David Chanoff collaborated with is William J. Crowe.\n",
-      "Action 2: Search[William J. Crowe]\u001b[0m\n",
-      "Observation 2: \u001b[103mWilliam James Crowe Jr. (January 2, 1925 – October 18, 2007) was a United States Navy admiral and diplomat who served as the 11th chairman of the Joint Chiefs of Staff under Presidents Ronald Reagan and George H. W. Bush, and as the ambassador to the United Kingdom and Chair of the Intelligence Oversight Board under President Bill Clinton.\u001b[0m\n",
-      "Thought 3:\u001b[102m William J. Crowe served as the ambassador to the United Kingdom under President Bill Clinton. So the answer is Bill Clinton.\n",
-      "Action 3: Finish[Bill Clinton]\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'Bill Clinton'"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "question = \"Author David Chanoff has collaborated with a U.S. Navy admiral who served as the ambassador to the United Kingdom under which President?\"\n",
-    "react.run(question)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0a6bd3b4",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/examples/demos/simple_prompts.ipynb

@@ -1,74 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "d8a5c5d4",
-   "metadata": {},
-   "source": [
-    "# Simple Example\n",
-    "\n",
-    "This notebook showcases a simple chain."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "51a54c4d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "' The year Justin Beiber was born was 1994. In 1994, the Dallas Cowboys won the Super Bowl.'"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain import Prompt, OpenAI, LLMChain\n",
-    "\n",
-    "template = \"\"\"Question: {question}\n",
-    "\n",
-    "Answer: Let's think step by step.\"\"\"\n",
-    "prompt = Prompt(template=template, input_variables=[\"question\"])\n",
-    "llm_chain = LLMChain(prompt=prompt, llm=OpenAI(temperature=0))\n",
-    "\n",
-    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
-    "\n",
-    "llm_chain.run(question)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "03dd6918",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/examples/integrations/embeddings.ipynb

@@ -169,7 +169,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.7"
   }
  },
  "nbformat": 4,

docs/examples/integrations/huggingface_hub.ipynb

@@ -25,12 +25,12 @@
     }
    ],
    "source": [
-    "from langchain import Prompt, HuggingFaceHub, LLMChain\n",
+    "from langchain import PromptTemplate, HuggingFaceHub, LLMChain\n",
     "\n",
     "template = \"\"\"Question: {question}\n",
     "\n",
     "Answer: Let's think step by step.\"\"\"\n",
-    "prompt = Prompt(template=template, input_variables=[\"question\"])\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
     "llm_chain = LLMChain(prompt=prompt, llm=HuggingFaceHub(repo_id=\"google/flan-t5-xl\", model_kwargs={\"temperature\":1e-10}))\n",
     "\n",
     "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
@@ -63,7 +63,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.7"
   }
  },
  "nbformat": 4,

docs/examples/integrations/huggingface_tokenizer_text_splitter.ipynb

@@ -1,180 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "b118c9dc",
-   "metadata": {},
-   "source": [
-    "# HuggingFace Tokenizers\n",
-    "\n",
-    "This notebook show cases how to use HuggingFace tokenizers to split text."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "e82c4685",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.text_splitter import CharacterTextSplitter"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "a8ce51d5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from transformers import GPT2TokenizerFast\n",
-    "\n",
-    "tokenizer = GPT2TokenizerFast.from_pretrained(\"gpt2\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "ca5e72c0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open('../state_of_the_union.txt') as f:\n",
-    "    state_of_the_union = f.read()\n",
-    "text_splitter = CharacterTextSplitter.from_huggingface_tokenizer(tokenizer, chunk_size=1000, chunk_overlap=0)\n",
-    "texts = text_splitter.split_text(state_of_the_union)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "37cdfbeb",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \n",
-      "\n",
-      "Last year COVID-19 kept us apart. This year we are finally together again. \n",
-      "\n",
-      "Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n",
-      "\n",
-      "With a duty to one another to the American people to the Constitution. \n",
-      "\n",
-      "And with an unwavering resolve that freedom will always triumph over tyranny. \n",
-      "\n",
-      "Six days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \n",
-      "\n",
-      "He thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \n",
-      "\n",
-      "He met the Ukrainian people. \n",
-      "\n",
-      "From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. \n",
-      "\n",
-      "Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. \n",
-      "\n",
-      "In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. \n",
-      "\n",
-      "Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. \n",
-      "\n",
-      "Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. \n",
-      "\n",
-      "Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos.   \n",
-      "\n",
-      "They keep moving.   \n",
-      "\n",
-      "And the costs and the threats to America and the world keep rising.   \n",
-      "\n",
-      "That’s why the NATO Alliance was created to secure peace and stability in Europe after World War 2. \n",
-      "\n",
-      "The United States is a member along with 29 other nations. \n",
-      "\n",
-      "It matters. American diplomacy matters. American resolve matters. \n",
-      "\n",
-      "Putin’s latest attack on Ukraine was premeditated and unprovoked. \n",
-      "\n",
-      "He rejected repeated efforts at diplomacy. \n",
-      "\n",
-      "He thought the West and NATO wouldn’t respond. And he thought he could divide us at home. Putin was wrong. We were ready.  Here is what we did.   \n",
-      "\n",
-      "We prepared extensively and carefully. \n",
-      "\n",
-      "We spent months building a coalition of other freedom-loving nations from Europe and the Americas to Asia and Africa to confront Putin. \n",
-      "\n",
-      "I spent countless hours unifying our European allies. We shared with the world in advance what we knew Putin was planning and precisely how he would try to falsely justify his aggression.  \n",
-      "\n",
-      "We countered Russia’s lies with truth.   \n",
-      "\n",
-      "And now that he has acted the free world is holding him accountable. \n",
-      "\n",
-      "Along with twenty-seven members of the European Union including France, Germany, Italy, as well as countries like the United Kingdom, Canada, Japan, Korea, Australia, New Zealand, and many others, even Switzerland. \n",
-      "\n",
-      "We are inflicting pain on Russia and supporting the people of Ukraine. Putin is now isolated from the world more than ever. \n",
-      "\n",
-      "Together with our allies –we are right now enforcing powerful economic sanctions. \n",
-      "\n",
-      "We are cutting off Russia’s largest banks from the international financial system.  \n",
-      "\n",
-      "Preventing Russia’s central bank from defending the Russian Ruble making Putin’s $630 Billion “war fund” worthless.   \n",
-      "\n",
-      "We are choking off Russia’s access to technology that will sap its economic strength and weaken its military for years to come.  \n",
-      "\n",
-      "Tonight I say to the Russian oligarchs and corrupt leaders who have bilked billions of dollars off this violent regime no more. \n",
-      "\n",
-      "The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs.  \n",
-      "\n",
-      "We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains. \n",
-      "\n",
-      "And tonight I am announcing that we will join our allies in closing off American air space to all Russian flights – further isolating Russia – and adding an additional squeeze –on their economy. The Ruble has lost 30% of its value. \n",
-      "\n",
-      "The Russian stock market has lost 40% of its value and trading remains suspended. Russia’s economy is reeling and Putin alone is to blame. \n",
-      "\n",
-      "Together with our allies we are providing support to the Ukrainians in their fight for freedom. Military assistance. Economic assistance. Humanitarian assistance. \n",
-      "\n",
-      "We are giving more than $1 Billion in direct assistance to Ukraine. \n",
-      "\n",
-      "And we will continue to aid the Ukrainian people as they defend their country and to help ease their suffering.  \n",
-      "\n",
-      "Let me be clear, our forces are not engaged and will not engage in conflict with Russian forces in Ukraine.  \n",
-      "\n",
-      "Our forces are not going to Europe to fight in Ukraine, but to defend our NATO Allies – in the event that Putin decides to keep moving west.  \n"
-     ]
-    }
-   ],
-   "source": [
-    "print(texts[0])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d214aec2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/examples/integrations/manifest.ipynb

@@ -69,7 +69,7 @@
    "outputs": [],
    "source": [
     "# Map reduce example\n",
-    "from langchain import Prompt\n",
+    "from langchain import PromptTemplate\n",
     "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain.chains.mapreduce import MapReduceChain\n",
     "\n",
@@ -81,7 +81,7 @@
     "\n",
     "\n",
     "CONCISE SUMMARY:\"\"\"\n",
-    "prompt = Prompt(template=_prompt, input_variables=[\"text\"])\n",
+    "prompt = PromptTemplate(template=_prompt, input_variables=[\"text\"])\n",
     "\n",
     "text_splitter = CharacterTextSplitter()\n",
     "\n",
@@ -202,7 +202,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.7"
   },
   "vscode": {
    "interpreter": {

docs/examples/integrations/textsplitter.ipynb

@@ -0,0 +1,304 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b118c9dc",
+   "metadata": {},
+   "source": [
+    "# Text Splitter\n",
+    "\n",
+    "When you want to deal wit long pieces of text, it is necessary to split up that text into chunks.\n",
+    "This notebook showcases several ways to do that.\n",
+    "\n",
+    "At a high level, text splitters work as following:\n",
+    "\n",
+    "1. Split the text up into small, semantically meaningful chunks (often sentences).\n",
+    "2. Start combining these small chunks into a larger chunk until you reach a certain size (as measured by some function).\n",
+    "3. Once you reach that size, make that chunk its own piece of text and then start creating a new chunk of text with some overlap (to keep context between chunks)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e82c4685",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.text_splitter import CharacterTextSplitter, NLTKTextSplitter, SpacyTextSplitter\n",
+    "# This is a long document we can split up.\n",
+    "with open('../state_of_the_union.txt') as f:\n",
+    "    state_of_the_union = f.read()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c461b26",
+   "metadata": {},
+   "source": [
+    "## Character Text Splitting\n",
+    "\n",
+    "Let's start with the most simple method: let's split based on characters (by default \"\\n\\n\") and measure chunk length by number of characters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ff6737",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text_splitter = CharacterTextSplitter(        \n",
+    "    separator = \"\\n\\n\",\n",
+    "    chunk_size = 1000,\n",
+    "    chunk_overlap  = 200,\n",
+    "    length_function = len,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "38547666",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \\n\\nLast year COVID-19 kept us apart. This year we are finally together again. \\n\\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \\n\\nWith a duty to one another to the American people to the Constitution. \\n\\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \\n\\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \\n\\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \\n\\nHe met the Ukrainian people. \\n\\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. \\n\\nGroups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. '"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "texts = text_splitter.split_text(state_of_the_union)\n",
+    "texts[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13dc0983",
+   "metadata": {},
+   "source": [
+    "## HuggingFace Length Function\n",
+    "Most LLMs are constrained by the number of tokens that you can pass in, which is not the same as the number of characters. In order to get a more accurate estimate, we can use HuggingFace tokenizers to count the text length."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a8ce51d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "None of PyTorch, TensorFlow >= 2.0, or Flax have been found. Models won't be available and only tokenizers, configuration and file/data utilities can be used.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from transformers import GPT2TokenizerFast\n",
+    "\n",
+    "tokenizer = GPT2TokenizerFast.from_pretrained(\"gpt2\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ca5e72c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text_splitter = CharacterTextSplitter.from_huggingface_tokenizer(tokenizer, chunk_size=100, chunk_overlap=0)\n",
+    "texts = text_splitter.split_text(state_of_the_union)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "37cdfbeb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \n",
+      "\n",
+      "Last year COVID-19 kept us apart. This year we are finally together again. \n",
+      "\n",
+      "Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n",
+      "\n",
+      "With a duty to one another to the American people to the Constitution. \n",
+      "\n",
+      "And with an unwavering resolve that freedom will always triumph over tyranny. \n"
+     ]
+    }
+   ],
+   "source": [
+    "print(texts[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7683b36a",
+   "metadata": {},
+   "source": [
+    "## tiktoken (OpenAI) Length Function\n",
+    "You can also use tiktoken, a open source tokenizer package from OpenAI to estimate tokens used. Will probably be ore accurate for their models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "825f7c0a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text_splitter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=100, chunk_overlap=0)\n",
+    "texts = text_splitter.split_text(state_of_the_union)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ae35d165",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \n",
+      "\n",
+      "Last year COVID-19 kept us apart. This year we are finally together again. \n",
+      "\n",
+      "Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n",
+      "\n",
+      "With a duty to one another to the American people to the Constitution. \n",
+      "\n",
+      "And with an unwavering resolve that freedom will always triumph over tyranny. \n"
+     ]
+    }
+   ],
+   "source": [
+    "print(texts[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea2973ac",
+   "metadata": {},
+   "source": [
+    "## NLTK Text Splitter\n",
+    "Rather than just splitting on \"\\n\\n\", we can use NLTK to split based on tokenizers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "20fa9c23",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text_splitter = NLTKTextSplitter(chunk_size=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "5ea10835",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Madam Speaker, Madam Vice President, our First Lady and Second Gentleman.\\n\\nMembers of Congress and the Cabinet.\\n\\nJustices of the Supreme Court.\\n\\nMy fellow Americans.\\n\\nLast year COVID-19 kept us apart.\\n\\nThis year we are finally together again.\\n\\nTonight, we meet as Democrats Republicans and Independents.\\n\\nBut most importantly as Americans.\\n\\nWith a duty to one another to the American people to the Constitution.\\n\\nAnd with an unwavering resolve that freedom will always triumph over tyranny.\\n\\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways.\\n\\nBut he badly miscalculated.\\n\\nHe thought he could roll into Ukraine and the world would roll over.\\n\\nInstead he met a wall of strength he never imagined.\\n\\nHe met the Ukrainian people.\\n\\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.\\n\\nGroups of citizens blocking tanks with their bodies.\\n\\nEveryone from students to retirees teachers turned soldiers defending their homeland.'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "texts = text_splitter.split_text(state_of_the_union)\n",
+    "texts[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dab86b60",
+   "metadata": {},
+   "source": [
+    "## Spacy Text Splitter\n",
+    "Another alternative to NLTK is to use Spacy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "f9cc9dfc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text_splitter = SpacyTextSplitter(chunk_size=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "cef2b29e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Madam Speaker, Madam Vice President, our First Lady and Second Gentleman.\\n\\nMembers of Congress and the Cabinet.\\n\\nJustices of the Supreme Court.\\n\\nMy fellow Americans.  \\n\\n\\n\\nLast year COVID-19 kept us apart.\\n\\nThis year we are finally together again.\\n\\n\\n\\n\\n\\nTonight, we meet as Democrats Republicans and Independents.\\n\\nBut most importantly as Americans.\\n\\n\\n\\n\\n\\nWith a duty to one another to the American people to the Constitution. \\n\\n\\n\\nAnd with an unwavering resolve that freedom will always triumph over tyranny.\\n\\n\\n\\n\\n\\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways.\\n\\nBut he badly miscalculated.\\n\\n\\n\\n\\n\\nHe thought he could roll into Ukraine and the world would roll over.\\n\\nInstead he met a wall of strength he never imagined.\\n\\n\\n\\n\\n\\nHe met the Ukrainian people.\\n\\n\\n\\n\\n\\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.\\n\\n\\n\\n\\n\\nGroups of citizens blocking tanks with their bodies.\\n\\nEveryone from students to retirees teachers turned soldiers defending their homeland.'"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "texts = text_splitter.split_text(state_of_the_union)\n",
+    "texts[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1a118b1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/memory.rst

@@ -0,0 +1,11 @@
+Memory
+======
+
+The examples here are all related to working with the concept of Memory in LangChain.
+
+.. toctree::
+   :maxdepth: 1
+   :glob:
+   :caption: Memory
+
+   memory/*

docs/examples/memory/adding_memory.ipynb

@@ -0,0 +1,175 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "00695447",
+   "metadata": {},
+   "source": [
+    "# Adding Memory To an LLMChain\n",
+    "\n",
+    "This notebook goes over how to use the Memory class with an LLMChain. For the purposes of this walkthrough, we will add  the `ConversationBufferMemory` class, although this can be any memory class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9f1aaf47",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
+    "from langchain import OpenAI, LLMChain, PromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b066ced",
+   "metadata": {},
+   "source": [
+    "The most important step is setting up the prompt correctly. In the below prompt, we have two input keys: one for the actual input, another for the input from the Memory class. Importantly, we make sure the keys in the PromptTemplate and the ConversationBufferMemory match up (`chat_history`)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e5501eda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"You are a chatbot having a conversation with a human.\n",
+    "\n",
+    "{chat_history}\n",
+    "Human: {human_input}\n",
+    "Chatbot:\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"chat_history\", \"human_input\"], \n",
+    "    template=template\n",
+    ")\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f6566275",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(\n",
+    "    llm=OpenAI(), \n",
+    "    prompt=prompt, \n",
+    "    verbose=True, \n",
+    "    memory=memory,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e2b189dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mYou are a chatbot having a conversation with a human.\n",
+      "\n",
+      "\n",
+      "Human: Hi there my friend\n",
+      "Chatbot:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "' Hi there!'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm_chain.predict(human_input=\"Hi there my friend\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a902729f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mYou are a chatbot having a conversation with a human.\n",
+      "\n",
+      "\n",
+      "Human: Hi there my friend\n",
+      "AI:  Hi there!\n",
+      "Human: Not to bad - how are you?\n",
+      "Chatbot:\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"\\n\\nI'm doing well, thanks for asking. How about you?\""
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm_chain.predict(human_input=\"Not to bad - how are you?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae5309bb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/memory/agent_with_memory.ipynb

@@ -0,0 +1,325 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fa6802ac",
+   "metadata": {},
+   "source": [
+    "# Adding Memory to an Agent\n",
+    "\n",
+    "This notebook goes over adding memory to an Agent. Before going through this notebook, please walkthrough the following notebooks, as this will build on top of both of them:\n",
+    "\n",
+    "- [Adding memory to an LLM Chain](adding_memory.ipynb)\n",
+    "- [Custom Agents](../agents/custom_agent.ipynb)\n",
+    "\n",
+    "In order to add a memory to an agent we are going to the the following steps:\n",
+    "\n",
+    "1. We are going to create an LLMChain with memory.\n",
+    "2. We are going to use that LLMChain to create a custom Agent.\n",
+    "\n",
+    "For the purposes of this exercise, we are going to create a simple custom Agent that has access to a search tool and utilizes the `ConversationBufferMemory` class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8db95912",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import ZeroShotAgent, Tool\n",
+    "from langchain.chains.conversation.memory import ConversationBufferMemory\n",
+    "from langchain import OpenAI, SerpAPIWrapper, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "97ad8467",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = SerpAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ad2e708",
+   "metadata": {},
+   "source": [
+    "Notice the usage of the `chat_history` variable in the PromptTemplate, which matches up with the dynamic key name in the ConversationBufferMemory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "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",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[\"input\", \"chat_history\"]\n",
+    ")\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0021675b",
+   "metadata": {},
+   "source": [
+    "We can now construct the LLMChain, with the Memory object, and then create the agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c56a0e73",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt, memory=memory)\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ca4bc1fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "How many people live in canada?\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I should look up how many people live in canada\n",
+      "Action: Search\n",
+      "Action Input: \"How many people live in canada?\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,533,678 as of Friday, November 25, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada 2020 ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The current population of Canada is 38,533,678 as of Friday, November 25, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The current population of Canada is 38,533,678 as of Friday, November 25, 2022, based on Worldometer elaboration of the latest United Nations data.'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run(\"How many people live in canada?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45627664",
+   "metadata": {},
+   "source": [
+    "To test the memory of this agent, we can ask a followup question that relies on information in the previous exchange to be answered correctly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "eecc0462",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "what is their national anthem called?\n",
+      "Thought:\u001b[32;1m\u001b[1;3m\n",
+      "AI:  I should look up the name of Canada's national anthem\n",
+      "Action: Search\n",
+      "Action Input: \"What is the name of Canada's national anthem?\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mAfter 100 years of tradition, O Canada was proclaimed Canada's national anthem in 1980. The music for O Canada was composed in 1880 by Calixa ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m\n",
+      "AI:  I now know the final answer\n",
+      "Final Answer: After 100 years of tradition, O Canada was proclaimed Canada's national anthem in 1980. The music for O Canada was composed in 1880 by Calixa Lavallée.\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"After 100 years of tradition, O Canada was proclaimed Canada's national anthem in 1980. The music for O Canada was composed in 1880 by Calixa Lavallée.\""
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run(\"what is their national anthem called?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc3d0aa4",
+   "metadata": {},
+   "source": [
+    "We can see that the agent remembered that the previous question was about Canada, and properly asked Google Search what the name of Canada's national anthem was.\n",
+    "\n",
+    "For fun, let's compare this to an agent that does NOT have memory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3359d043",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin!\"\n",
+    "\n",
+    "Question: {input}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[\"input\"]\n",
+    ")\n",
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
+    "agent_without_memory = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "970d23df",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "How many people live in canada?\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I should look up how many people live in canada\n",
+      "Action: Search\n",
+      "Action Input: \"How many people live in canada?\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,533,678 as of Friday, November 25, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada 2020 ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The current population of Canada is 38,533,678\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The current population of Canada is 38,533,678'"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_without_memory.run(\"How many people live in canada?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "d9ea82f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "what is their national anthem called?\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I should probably look this up\n",
+      "Action: Search\n",
+      "Action Input: \"What is the national anthem of [country]\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mMost nation states have an anthem, defined as \"a song, as of praise, devotion, or patriotism\"; most anthems are either marches or hymns in style.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The national anthem is called \"the national anthem.\"\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The national anthem is called \"the national anthem.\"'"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_without_memory.run(\"what is their national anthem called?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b1f9223",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/memory/custom_memory.ipynb

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

docs/examples/model_laboratory.ipynb

@@ -17,7 +17,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain import LLMChain, OpenAI, Cohere, HuggingFaceHub, Prompt\n",
+    "from langchain import LLMChain, OpenAI, Cohere, HuggingFaceHub, PromptTemplate\n",
     "from langchain.model_laboratory import ModelLaboratory"
    ]
   },
@@ -42,7 +42,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "model_lab = ModelLaboratory(llms)"
+    "model_lab = ModelLaboratory.from_llms(llms)"
    ]
   },
   {
@@ -60,19 +60,19 @@
       "\n",
       "\u001b[1mOpenAI\u001b[0m\n",
       "Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1}\n",
-      "\u001b[104m\n",
+      "\u001b[36;1m\u001b[1;3m\n",
       "\n",
       "Flamingos are pink.\u001b[0m\n",
       "\n",
       "\u001b[1mCohere\u001b[0m\n",
       "Params: {'model': 'command-xlarge-20221108', 'max_tokens': 20, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0}\n",
-      "\u001b[103m\n",
+      "\u001b[33;1m\u001b[1;3m\n",
       "\n",
       "Pink\u001b[0m\n",
       "\n",
       "\u001b[1mHuggingFaceHub\u001b[0m\n",
       "Params: {'repo_id': 'google/flan-t5-xl', 'temperature': 1}\n",
-      "\u001b[101mpink\u001b[0m\n",
+      "\u001b[38;5;200m\u001b[1;3mpink\u001b[0m\n",
       "\n"
      ]
     }
@@ -88,8 +88,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "prompt = Prompt(template=\"What is the capital of {state}?\", input_variables=[\"state\"])\n",
-    "model_lab_with_prompt = ModelLaboratory(llms, prompt=prompt)"
+    "prompt = PromptTemplate(template=\"What is the capital of {state}?\", input_variables=[\"state\"])\n",
+    "model_lab_with_prompt = ModelLaboratory.from_llms(llms, prompt=prompt)"
    ]
   },
   {
@@ -107,19 +107,19 @@
       "\n",
       "\u001b[1mOpenAI\u001b[0m\n",
       "Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1}\n",
-      "\u001b[104m\n",
+      "\u001b[36;1m\u001b[1;3m\n",
       "\n",
       "The capital of New York is Albany.\u001b[0m\n",
       "\n",
       "\u001b[1mCohere\u001b[0m\n",
       "Params: {'model': 'command-xlarge-20221108', 'max_tokens': 20, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0}\n",
-      "\u001b[103m\n",
+      "\u001b[33;1m\u001b[1;3m\n",
       "\n",
       "The capital of New York is Albany.\u001b[0m\n",
       "\n",
       "\u001b[1mHuggingFaceHub\u001b[0m\n",
       "Params: {'repo_id': 'google/flan-t5-xl', 'temperature': 1}\n",
-      "\u001b[101mst john s\u001b[0m\n",
+      "\u001b[38;5;200m\u001b[1;3mst john s\u001b[0m\n",
       "\n"
      ]
     }
@@ -130,10 +130,103 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "54336dbf",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "from langchain import SelfAskWithSearchChain, SerpAPIWrapper\n",
+    "\n",
+    "open_ai_llm = OpenAI(temperature=0)\n",
+    "search = SerpAPIWrapper()\n",
+    "self_ask_with_search_openai = SelfAskWithSearchChain(llm=open_ai_llm, search_chain=search, verbose=True)\n",
+    "\n",
+    "cohere_llm = Cohere(temperature=0, model=\"command-xlarge-20221108\")\n",
+    "search = SerpAPIWrapper()\n",
+    "self_ask_with_search_cohere = SelfAskWithSearchChain(llm=cohere_llm, search_chain=search, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6a50a9f1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chains = [self_ask_with_search_openai, self_ask_with_search_cohere]\n",
+    "names = [str(open_ai_llm), str(cohere_llm)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d3549e99",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_lab = ModelLaboratory(chains, names=names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "362f7f57",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1mInput:\u001b[0m\n",
+      "What is the hometown of the reigning men's U.S. Open champion?\n",
+      "\n",
+      "\u001b[1mOpenAI\u001b[0m\n",
+      "Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1}\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "What is the hometown of the reigning men's U.S. Open champion?\n",
+      "Are follow up questions needed here:\u001b[32;1m\u001b[1;3m Yes.\n",
+      "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\n",
+      "Intermediate answer: \u001b[33;1m\u001b[1;3mCarlos Alcaraz.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Follow up: Where is Carlos Alcaraz from?\u001b[0m\n",
+      "Intermediate answer: \u001b[33;1m\u001b[1;3mEl Palmar, Spain.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "So the final answer is: El Palmar, Spain\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\u001b[36;1m\u001b[1;3m\n",
+      "So the final answer is: El Palmar, Spain\u001b[0m\n",
+      "\n",
+      "\u001b[1mCohere\u001b[0m\n",
+      "Params: {'model': 'command-xlarge-20221108', 'max_tokens': 256, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0}\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "What is the hometown of the reigning men's U.S. Open champion?\n",
+      "Are follow up questions needed here:\u001b[32;1m\u001b[1;3m Yes.\n",
+      "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\n",
+      "Intermediate answer: \u001b[33;1m\u001b[1;3mCarlos Alcaraz.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "So the final answer is:\n",
+      "\n",
+      "Carlos Alcaraz\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\u001b[33;1m\u001b[1;3m\n",
+      "So the final answer is:\n",
+      "\n",
+      "Carlos Alcaraz\u001b[0m\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_lab.compare(\"What is the hometown of the reigning men's U.S. Open champion?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94159131",
+   "metadata": {},
+   "outputs": [],
    "source": []
   }
  ],
@@ -153,7 +246,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.7"
   }
  },
  "nbformat": 4,

docs/examples/prompts.rst

@@ -1,10 +1,35 @@
-Prompts
-=======
+LLMs & Prompts
+==============
+
+The examples here all highlight how to work with LLMs and prompts.
+
+**LLMs**
+
+`LLM Functionality <prompts/llm_functionality.ipynb>`_: A walkthrough of all the functionality the standard LLM interface exposes.
+
+`LLM Serialization <prompts/llm_serialization.ipynb>`_: A walkthrough of how to serialize LLMs to and from disk.
+
+`Custom LLM <prompts/custom_llm.ipynb>`_: How to create and use a custom LLM class, in case you have an LLM not from one of the standard providers (including one that you host yourself).
+
+
+**Prompts**
+
+`Prompt Management <prompts/prompt_management.ipynb>`_: A walkthrough of all the functionality LangChain supports for working with prompts.
+
+`Prompt Serialization <prompts/prompt_serialization.ipynb>`_: A walkthrough of how to serialize prompts to and from disk.
+
+`Few Shot Examples <prompts/few_shot_examples.ipynb>`_: How to include examples in the prompt.
+
+`Generate Examples <prompts/generate_examples.ipynb>`_: How to use existing examples to generate more examples.
+
+`Custom Example Selector <prompts/custom_example_selector.ipynb>`_: How to create and use a custom ExampleSelector (the class responsible for choosing which examples to use in a prompt).
+
+`Custom Prompt Template <prompts/custom_prompt_template.ipynb>`_: How to create and use a custom PromptTemplate, the logic that decides how input variables get formatted into a prompt.
 
-The examples here all highlight how to work with prompts.
 
 .. toctree::
    :maxdepth: 1
    :glob:
+   :hidden:
 
    prompts/*

docs/examples/prompts/custom_example_selector.ipynb

@@ -0,0 +1,176 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f897c784",
+   "metadata": {},
+   "source": [
+    "# Custom ExampleSelector\n",
+    "\n",
+    "This notebook goes over how to implement a custom ExampleSelector. ExampleSelectors are used to select examples to use in few shot prompts.\n",
+    "\n",
+    "An ExampleSelector must implement two methods:\n",
+    "\n",
+    "1. An `add_example` method which takes in an example and adds it into the ExampleSelector\n",
+    "2. A `select_examples` method which takes in input variables (which are meant to be user input) and returns a list of examples to use in the few shot prompt.\n",
+    "\n",
+    "\n",
+    "Let's implement a custom ExampleSelector that just selects two examples at random."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1a945da1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.example_selector.base import BaseExampleSelector\n",
+    "from typing import Dict, List\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "62cf0ad7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CustomExampleSelector(BaseExampleSelector):\n",
+    "    \n",
+    "    def __init__(self, examples: List[Dict[str, str]]):\n",
+    "        self.examples = examples\n",
+    "    \n",
+    "    def add_example(self, example: Dict[str, str]) -> None:\n",
+    "        \"\"\"Add new example to store for a key.\"\"\"\n",
+    "        self.examples.append(example)\n",
+    "\n",
+    "    def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:\n",
+    "        \"\"\"Select which examples to use based on the inputs.\"\"\"\n",
+    "        return np.random.choice(self.examples, size=2, replace=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "242d3213",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "examples = [{\"foo\": \"1\"}, {\"foo\": \"2\"}, {\"foo\": \"3\"}]\n",
+    "example_selector = CustomExampleSelector(examples)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a038065",
+   "metadata": {},
+   "source": [
+    "Let's now try it out! We can select some examples and try adding examples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "74fbbef5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([{'foo': '2'}, {'foo': '3'}], dtype=object)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_selector.select_examples({\"foo\": \"foo\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "9bbb5421",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "example_selector.add_example({\"foo\": \"4\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c0eb9f22",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'foo': '1'}, {'foo': '2'}, {'foo': '3'}, {'foo': '4'}]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_selector.examples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "cc39b1e3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([{'foo': '1'}, {'foo': '4'}], dtype=object)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_selector.select_examples({\"foo\": \"foo\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1739dd96",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/custom_llm.ipynb

@@ -0,0 +1,156 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9e9b7651",
+   "metadata": {},
+   "source": [
+    "# Custom LLM\n",
+    "\n",
+    "This notebook goes over how to create a custom LLM wrapper, in case you want to use your own LLM or a different wrapper than one that is supported in LangChain.\n",
+    "\n",
+    "There is only one required thing that a custom LLM needs to implement:\n",
+    "\n",
+    "1. A `_call` method that takes in a string, some optional stop words, and returns a string\n",
+    "\n",
+    "There is a second optional thing it can implement:\n",
+    "\n",
+    "1. An `_identifying_params` property that is used to help with printing of this class. Should return a dictionary.\n",
+    "\n",
+    "Let's implement a very simple custom LLM that just returns the first N characters of the input."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a65696a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms.base import LLM\n",
+    "from typing import Optional, List, Mapping, Any"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d5ceff02",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CustomLLM(LLM):\n",
+    "    \n",
+    "    n: int\n",
+    "        \n",
+    "    @property\n",
+    "    def _llm_type(self) -> str:\n",
+    "        return \"custom\"\n",
+    "    \n",
+    "    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:\n",
+    "        if stop is not None:\n",
+    "            raise ValueError(\"stop kwargs are not permitted.\")\n",
+    "        return prompt[:self.n]\n",
+    "    \n",
+    "    @property\n",
+    "    def _identifying_params(self) -> Mapping[str, Any]:\n",
+    "        \"\"\"Get the identifying parameters.\"\"\"\n",
+    "        return {\"n\": self.n}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "714dede0",
+   "metadata": {},
+   "source": [
+    "We can now use this as an any other LLM."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "10e5ece6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = CustomLLM(n=10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8cd49199",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'This is a '"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm(\"This is a foobar thing\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bbfebea1",
+   "metadata": {},
+   "source": [
+    "We can also print the LLM and see its custom print."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9c33fa19",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1mCustomLLM\u001b[0m\n",
+      "Params: {'n': 10}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(llm)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6dac3f47",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/custom_prompt_template.ipynb

@@ -0,0 +1,116 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a37d9694",
+   "metadata": {},
+   "source": [
+    "# Custom Prompt Template\n",
+    "\n",
+    "This notebook goes over how to create a custom prompt template, in case you want to create your own methodology for creating prompts.\n",
+    "\n",
+    "The only two requirements for all prompt templates are:\n",
+    "\n",
+    "1. They have a `input_variables` attribute that exposes what input variables this prompt template expects.\n",
+    "2. They expose a `format` method which takes in keyword arguments corresponding to the expected `input_variables` and returns the formatted prompt.\n",
+    "\n",
+    "Let's imagine that we want to create a prompt template that takes in input variables and formats them into the template AFTER capitalizing them. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "26f796e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import BasePromptTemplate\n",
+    "from pydantic import BaseModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "27919e96",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CustomPromptTemplate(BasePromptTemplate, BaseModel):\n",
+    "    template: str\n",
+    "        \n",
+    "    def format(self, **kwargs) -> str:\n",
+    "        capitalized_kwargs = {k: v.upper() for k, v in kwargs.items()}\n",
+    "        return self.template.format(**capitalized_kwargs)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "76d1d84d",
+   "metadata": {},
+   "source": [
+    "We can now see that when we use this, the input variables get formatted."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "eed1ff28",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = CustomPromptTemplate(input_variables=[\"foo\"], template=\"Capitalized: {foo}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "94892a3c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Capitalized: LOWERCASE'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt.format(foo=\"lowercase\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3d9a7c7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/example_prompt.json

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

docs/examples/prompts/examples.json

@@ -0,0 +1,4 @@
+[
+    {"input": "happy", "output": "sad"},
+    {"input": "tall", "output": "short"}
+]

docs/examples/prompts/few_shot_examples.ipynb

@@ -0,0 +1,306 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f8b01b97",
+   "metadata": {},
+   "source": [
+    "# Few Shot Prompt examples\n",
+    "Notebook showing off how canonical prompts in LangChain can be recreated as FewShotPrompts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "18c67cc9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.few_shot import FewShotPromptTemplate\n",
+    "from langchain.prompts.prompt import PromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2a729c9f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Self Ask with Search\n",
+    "\n",
+    "examples = [\n",
+    "  {\n",
+    "    \"question\": \"Who lived longer, Muhammad Ali or Alan Turing?\",\n",
+    "    \"answer\": \"Are follow up questions needed here: Yes.\\nFollow up: How old was Muhammad Ali when he died?\\nIntermediate answer: Muhammad Ali was 74 years old when he died.\\nFollow up: How old was Alan Turing when he died?\\nIntermediate answer: Alan Turing was 41 years old when he died.\\nSo the final answer is: Muhammad Ali\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"When was the founder of craigslist born?\",\n",
+    "    \"answer\": \"Are follow up questions needed here: Yes.\\nFollow up: Who was the founder of craigslist?\\nIntermediate answer: Craigslist was founded by Craig Newmark.\\nFollow up: When was Craig Newmark born?\\nIntermediate answer: Craig Newmark was born on December 6, 1952.\\nSo the final answer is: December 6, 1952\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Who was the maternal grandfather of George Washington?\",\n",
+    "    \"answer\": \"Are follow up questions needed here: Yes.\\nFollow up: Who was the mother of George Washington?\\nIntermediate answer: The mother of George Washington was Mary Ball Washington.\\nFollow up: Who was the father of Mary Ball Washington?\\nIntermediate answer: The father of Mary Ball Washington was Joseph Ball.\\nSo the final answer is: Joseph Ball\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Are both the directors of Jaws and Casino Royale from the same country?\",\n",
+    "    \"answer\": \"Are follow up questions needed here: Yes.\\nFollow up: Who is the director of Jaws?\\nIntermediate Answer: The director of Jaws is Steven Spielberg.\\nFollow up: Where is Steven Spielberg from?\\nIntermediate Answer: The United States.\\nFollow up: Who is the director of Casino Royale?\\nIntermediate Answer: The director of Casino Royale is Martin Campbell.\\nFollow up: Where is Martin Campbell from?\\nIntermediate Answer: New Zealand.\\nSo the final answer is: No\"\n",
+    "  }\n",
+    "]\n",
+    "example_prompt = PromptTemplate(input_variables=[\"question\", \"answer\"], template=\"Question: {question}\\n{answer}\")\n",
+    "\n",
+    "prompt = FewShotPromptTemplate(\n",
+    "    examples=examples, \n",
+    "    example_prompt=example_prompt, \n",
+    "    suffix=\"Question: {input}\", \n",
+    "    input_variables=[\"input\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "95fc0059",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ReAct\n",
+    "\n",
+    "examples = [\n",
+    "  {\n",
+    "    \"question\": \"What is the elevation range for the area that the eastern sector of the Colorado orogeny extends into?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Colorado orogeny, find the area that the eastern sector of the Colorado orogeny extends into, then find the elevation range of that area.\\nAction 1: Search[Colorado orogeny]\\nObservation 1: The Colorado orogeny was an episode of mountain building (an orogeny) in Colorado and surrounding areas.\\nThought 2: It does not mention the eastern sector. So I need to look up eastern sector.\\nAction 2: Lookup[eastern sector]\\nObservation 2: (Result 1 / 1) The eastern sector extends into the High Plains and is called the Central Plains orogeny.\\nThought 3: The eastern sector of Colorado orogeny extends into the High Plains. So I need to search High Plains and find its elevation range.\\nAction 3: Search[High Plains]\\nObservation 3: High Plains refers to one of two distinct land regions\\nThought 4: I need to instead search High Plains (United States).\\nAction 4: Search[High Plains (United States)]\\nObservation 4: The High Plains are a subregion of the Great Plains. From east to west, the High Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130 m).[3]\\nThought 5: High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer is 1,800 to 7,000 ft.\\nAction 5: Finish[1,800 to 7,000 ft]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Musician and satirist Allie Goertz wrote a song about the \\\"The Simpsons\\\" character Milhouse, who Matt Groening named after who?\",\n",
+    "    \"answer\": \"Thought 1: The question simplifies to \\\"The Simpsons\\\" character Milhouse is named after who. I only need to search Milhouse and find who it is named after.\\nAction 1: Search[Milhouse]\\nObservation 1: Milhouse Mussolini Van Houten is a recurring character in the Fox animated television series The Simpsons voiced by Pamela Hayden and created by Matt Groening.\\nThought 2: The paragraph does not tell who Milhouse is named after, maybe I can look up \\\"named after\\\".\\nAction 2: Lookup[named after]\\nObservation 2: (Result 1 / 1) Milhouse was named after U.S. president Richard Nixon, whose middle name was Milhous.\\nThought 3: Milhouse was named after U.S. president Richard Nixon, so the answer is Richard Nixon.\\nAction 3: Finish[Richard Nixon]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Which documentary is about Finnish rock groups, Adam Clayton Powell or The Saimaa Gesture?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Adam Clayton Powell and The Saimaa Gesture, and find which documentary is about Finnish rock groups.\\nAction 1: Search[Adam Clayton Powell]\\nObservation 1 Could not find [Adam Clayton Powell]. Similar: [’Adam Clayton Powell III’, ’Seventh Avenue (Manhattan)’, ’Adam Clayton Powell Jr. State Office Building’, ’Isabel Washington Powell’, ’Adam Powell’, ’Adam Clayton Powell (film)’, ’Giancarlo Esposito’].\\nThought 2: To find the documentary, I can search Adam Clayton Powell (film).\\nAction 2: Search[Adam Clayton Powell (film)]\\nObservation 2: Adam Clayton Powell is a 1989 American documentary film directed by Richard Kilberg. The film is about the rise and fall of influential African-American politician Adam Clayton Powell Jr.[3][4] It was later aired as part of the PBS series The American Experience.\\nThought 3: Adam Clayton Powell (film) is a documentary about an African-American politician, not Finnish rock groups. So the documentary about Finnish rock groups must instead be The Saimaa Gesture.\\nAction 3: Finish[The Saimaa Gesture]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"What profession does Nicholas Ray and Elia Kazan have in common?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Nicholas Ray and Elia Kazan, find their professions, then find the profession they have in common.\\nAction 1: Search[Nicholas Ray]\\nObservation 1: Nicholas Ray (born Raymond Nicholas Kienzle Jr., August 7, 1911 - June 16, 1979) was an American film director, screenwriter, and actor best known for the 1955 film Rebel Without a Cause.\\nThought 2: Professions of Nicholas Ray are director, screenwriter, and actor. I need to search Elia Kazan next and find his professions.\\nAction 2: Search[Elia Kazan]\\nObservation 2: Elia Kazan was an American film and theatre director, producer, screenwriter and actor.\\nThought 3: Professions of Elia Kazan are director, producer, screenwriter, and actor. So profession Nicholas Ray and Elia Kazan have in common is director, screenwriter, and actor.\\nAction 3: Finish[director, screenwriter, actor]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Which magazine was started first Arthur’s Magazine or First for Women?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Arthur’s Magazine and First for Women, and find which was started first.\\nAction 1: Search[Arthur’s Magazine]\\nObservation 1: Arthur’s Magazine (1844-1846) was an American literary periodical published in Philadelphia in the 19th century.\\nThought 2: Arthur’s Magazine was started in 1844. I need to search First for Women next.\\nAction 2: Search[First for Women]\\nObservation 2: First for Women is a woman’s magazine published by Bauer Media Group in the USA.[1] The magazine was started in 1989.\\nThought 3: First for Women was started in 1989. 1844 (Arthur’s Magazine) < 1989 (First for Women), so Arthur’s Magazine was started first.\\nAction 3: Finish[Arthur’s Magazine]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Were Pavel Urysohn and Leonid Levin known for the same type of work?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Pavel Urysohn and Leonid Levin, find their types of work, then find if they are the same.\\nAction 1: Search[Pavel Urysohn]\\nObservation 1: Pavel Samuilovich Urysohn (February 3, 1898 - August 17, 1924) was a Soviet mathematician who is best known for his contributions in dimension theory.\\nThought 2: Pavel Urysohn is a mathematician. I need to search Leonid Levin next and find its type of work.\\nAction 2: Search[Leonid Levin]\\nObservation 2: Leonid Anatolievich Levin is a Soviet-American mathematician and computer scientist.\\nThought 3: Leonid Levin is a mathematician and computer scientist. So Pavel Urysohn and Leonid Levin have the same type of work.\\nAction 3: Finish[yes]\"\n",
+    "  }\n",
+    "]\n",
+    "example_prompt = PromptTemplate(input_variables=[\"question\", \"answer\"], template=\"Question: {question}\\n{answer}\")\n",
+    "\n",
+    "prompt = FewShotPromptTemplate(\n",
+    "    examples=examples, \n",
+    "    example_prompt=example_prompt, \n",
+    "    suffix=\"Question: {input}\", \n",
+    "    input_variables=[\"input\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "897d4e08",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# LLM Math\n",
+    "examples = [\n",
+    "  {\n",
+    "    \"question\": \"What is 37593 * 67?\",\n",
+    "    \"answer\": \"```python\\nprint(37593 * 67)\\n```\\n```output\\n2518731\\n```\\nAnswer: 2518731\"\n",
+    "  }\n",
+    "]\n",
+    "example_prompt = PromptTemplate(input_variables=[\"question\", \"answer\"], template=\"Question: {question}\\n\\n{answer}\")\n",
+    "\n",
+    "prompt = FewShotPromptTemplate(\n",
+    "    examples=examples, \n",
+    "    example_prompt=example_prompt, \n",
+    "    suffix=\"Question: {input}\", \n",
+    "    input_variables=[\"input\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "7ab7379f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# NatBot\n",
+    "example_seperator = \"==================================================\"\n",
+    "content_1 = \"\"\"<link id=1>About</link>\n",
+    "<link id=2>Store</link>\n",
+    "<link id=3>Gmail</link>\n",
+    "<link id=4>Images</link>\n",
+    "<link id=5>(Google apps)</link>\n",
+    "<link id=6>Sign in</link>\n",
+    "<img id=7 alt=\"(Google)\"/>\n",
+    "<input id=8 alt=\"Search\"></input>\n",
+    "<button id=9>(Search by voice)</button>\n",
+    "<button id=10>(Google Search)</button>\n",
+    "<button id=11>(I'm Feeling Lucky)</button>\n",
+    "<link id=12>Advertising</link>\n",
+    "<link id=13>Business</link>\n",
+    "<link id=14>How Search works</link>\n",
+    "<link id=15>Carbon neutral since 2007</link>\n",
+    "<link id=16>Privacy</link>\n",
+    "<link id=17>Terms</link>\n",
+    "<text id=18>Settings</text>\"\"\"\n",
+    "content_2 = \"\"\"<link id=1>About</link>\n",
+    "<link id=2>Store</link>\n",
+    "<link id=3>Gmail</link>\n",
+    "<link id=4>Images</link>\n",
+    "<link id=5>(Google apps)</link>\n",
+    "<link id=6>Sign in</link>\n",
+    "<img id=7 alt=\"(Google)\"/>\n",
+    "<input id=8 alt=\"Search\"></input>\n",
+    "<button id=9>(Search by voice)</button>\n",
+    "<button id=10>(Google Search)</button>\n",
+    "<button id=11>(I'm Feeling Lucky)</button>\n",
+    "<link id=12>Advertising</link>\n",
+    "<link id=13>Business</link>\n",
+    "<link id=14>How Search works</link>\n",
+    "<link id=15>Carbon neutral since 2007</link>\n",
+    "<link id=16>Privacy</link>\n",
+    "<link id=17>Terms</link>\n",
+    "<text id=18>Settings</text>\"\"\"\n",
+    "content_3 = \"\"\"<button id=1>For Businesses</button>\n",
+    "<button id=2>Mobile</button>\n",
+    "<button id=3>Help</button>\n",
+    "<button id=4 alt=\"Language Picker\">EN</button>\n",
+    "<link id=5>OpenTable logo</link>\n",
+    "<button id=6 alt =\"search\">Search</button>\n",
+    "<text id=7>Find your table for any occasion</text>\n",
+    "<button id=8>(Date selector)</button>\n",
+    "<text id=9>Sep 28, 2022</text>\n",
+    "<text id=10>7:00 PM</text>\n",
+    "<text id=11>2 people</text>\n",
+    "<input id=12 alt=\"Location, Restaurant, or Cuisine\"></input>\n",
+    "<button id=13>Let’s go</button>\n",
+    "<text id=14>It looks like you're in Peninsula. Not correct?</text>\n",
+    "<button id=15>Get current location</button>\n",
+    "<button id=16>Next</button>\"\"\"\n",
+    "examples = [\n",
+    "    {\n",
+    "        \"i\": 1,\n",
+    "        \"content\": content_1,\n",
+    "        \"objective\": \"Find a 2 bedroom house for sale in Anchorage AK for under $750k\",\n",
+    "        \"current_url\": \"https://www.google.com/\",\n",
+    "        \"command\": 'TYPESUBMIT 8 \"anchorage redfin\"'\n",
+    "    },\n",
+    "    {\n",
+    "        \"i\": 2,\n",
+    "        \"content\": content_2,\n",
+    "        \"objective\": \"Make a reservation for 4 at Dorsia at 8pm\",\n",
+    "        \"current_url\": \"https://www.google.com/\",\n",
+    "        \"command\": 'TYPESUBMIT 8 \"dorsia nyc opentable\"'\n",
+    "    },\n",
+    "    {\n",
+    "        \"i\": 3,\n",
+    "        \"content\": content_3,\n",
+    "        \"objective\": \"Make a reservation for 4 for dinner at Dorsia in New York City at 8pm\",\n",
+    "        \"current_url\": \"https://www.opentable.com/\",\n",
+    "        \"command\": 'TYPESUBMIT 12 \"dorsia new york city\"'\n",
+    "    },\n",
+    "]\n",
+    "example_prompt_template=\"\"\"EXAMPLE {i}:\n",
+    "==================================================\n",
+    "CURRENT BROWSER CONTENT:\n",
+    "------------------\n",
+    "{content}\n",
+    "------------------\n",
+    "OBJECTIVE: {objective}\n",
+    "CURRENT URL: {current_url}\n",
+    "YOUR COMMAND:\n",
+    "{command}\"\"\"\n",
+    "example_prompt = PromptTemplate(input_variables=[\"i\", \"content\", \"objective\", \"current_url\", \"command\"], template=example_prompt_template)\n",
+    "\n",
+    "\n",
+    "prefix = \"\"\"\n",
+    "You are an agent controlling a browser. You are given:\n",
+    "\t(1) an objective that you are trying to achieve\n",
+    "\t(2) the URL of your current web page\n",
+    "\t(3) a simplified text description of what's visible in the browser window (more on that below)\n",
+    "You can issue these commands:\n",
+    "\tSCROLL UP - scroll up one page\n",
+    "\tSCROLL DOWN - scroll down one page\n",
+    "\tCLICK X - click on a given element. You can only click on links, buttons, and inputs!\n",
+    "\tTYPE X \"TEXT\" - type the specified text into the input with id X\n",
+    "\tTYPESUBMIT X \"TEXT\" - same as TYPE above, except then it presses ENTER to submit the form\n",
+    "The format of the browser content is highly simplified; all formatting elements are stripped.\n",
+    "Interactive elements such as links, inputs, buttons are represented like this:\n",
+    "\t\t<link id=1>text</link>\n",
+    "\t\t<button id=2>text</button>\n",
+    "\t\t<input id=3>text</input>\n",
+    "Images are rendered as their alt text like this:\n",
+    "\t\t<img id=4 alt=\"\"/>\n",
+    "Based on your given objective, issue whatever command you believe will get you closest to achieving your goal.\n",
+    "You always start on Google; you should submit a search query to Google that will take you to the best page for\n",
+    "achieving your objective. And then interact with that page to achieve your objective.\n",
+    "If you find yourself on Google and there are no search results displayed yet, you should probably issue a command\n",
+    "like \"TYPESUBMIT 7 \"search query\"\" to get to a more useful page.\n",
+    "Then, if you find yourself on a Google search results page, you might issue the command \"CLICK 24\" to click\n",
+    "on the first link in the search results. (If your previous command was a TYPESUBMIT your next command should\n",
+    "probably be a CLICK.)\n",
+    "Don't try to interact with elements that you can't see.\n",
+    "Here are some examples:\n",
+    "\"\"\"\n",
+    "suffix=\"\"\"\n",
+    "The current browser content, objective, and current URL follow. Reply with your next command to the browser.\n",
+    "CURRENT BROWSER CONTENT:\n",
+    "------------------\n",
+    "{browser_content}\n",
+    "------------------\n",
+    "OBJECTIVE: {objective}\n",
+    "CURRENT URL: {url}\n",
+    "PREVIOUS COMMAND: {previous_command}\n",
+    "YOUR COMMAND:\n",
+    "\"\"\"\n",
+    "PROMPT = FewShotPromptTemplate(\n",
+    "    examples = examples,\n",
+    "    example_prompt=example_prompt,\n",
+    "    example_separator=example_seperator,\n",
+    "    input_variables=[\"browser_content\", \"url\", \"previous_command\", \"objective\"],\n",
+    "    prefix=prefix,\n",
+    "    suffix=suffix,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ce5927c6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/few_shot_prompt.json

@@ -0,0 +1,11 @@
+{
+    "_type": "few_shot",
+    "input_variables": ["adjective"],
+    "prefix": "Write antonyms for the following words.",
+    "example_prompt": {
+        "input_variables": ["input", "output"],
+        "template": "Input: {input}\nOutput: {output}"
+    },
+    "examples": "examples.json",
+    "suffix": "Input: {adjective}\nOutput:"
+}   

docs/examples/prompts/few_shot_prompt.yaml

@@ -0,0 +1,14 @@
+_type: few_shot
+input_variables:
+    ["adjective"]
+prefix: 
+    Write antonyms for the following words.
+example_prompt:
+    input_variables:
+        ["input", "output"]
+    template:
+        "Input: {input}\nOutput: {output}"
+examples:
+    examples.json
+suffix:
+    "Input: {adjective}\nOutput:"

docs/examples/prompts/few_shot_prompt_example_prompt.json

@@ -0,0 +1,8 @@
+{
+    "_type": "few_shot",
+    "input_variables": ["adjective"],
+    "prefix": "Write antonyms for the following words.",
+    "example_prompt_path": "example_prompt.json",
+    "examples": "examples.json",
+    "suffix": "Input: {adjective}\nOutput:"
+}   

docs/examples/prompts/few_shot_prompt_examples_in.json

@@ -0,0 +1,14 @@
+{
+    "_type": "few_shot",
+    "input_variables": ["adjective"],
+    "prefix": "Write antonyms for the following words.",
+    "example_prompt": {
+        "input_variables": ["input", "output"],
+        "template": "Input: {input}\nOutput: {output}"
+    },
+    "examples": [
+        {"input": "happy", "output": "sad"},
+        {"input": "tall", "output": "short"}
+    ],
+    "suffix": "Input: {adjective}\nOutput:"
+}   

docs/examples/prompts/generate_examples.ipynb

@@ -25,9 +25,9 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.chains.react.prompt import EXAMPLES\n",
     "from langchain.llms.openai import OpenAI\n",
-    "from langchain.example_generator import generate_example, generate_example_from_dynamic_prompt"
+    "from langchain.example_generator import generate_example\n",
+    "from langchain.prompts import PromptTemplate"
    ]
   },
   {
@@ -39,21 +39,36 @@
      "name": "#%%\n"
     }
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Question: What is the elevation range for the area that the eastern sector of the\\nColorado orogeny extends into?\\nThought 1: I need to search Colorado orogeny, find the area that the eastern sector\\nof the Colorado orogeny extends into, then find the elevation range of the\\narea.\\nAction 1: Search[Colorado orogeny]\\nObservation 1: The Colorado orogeny was an episode of mountain building (an orogeny) in\\nColorado and surrounding areas.\\nThought 2: It does not mention the eastern sector. So I need to look up eastern\\nsector.\\nAction 2: Lookup[eastern sector]\\nObservation 2: (Result 1 / 1) The eastern sector extends into the High Plains and is called\\nthe Central Plains orogeny.\\nThought 3: The eastern sector of Colorado orogeny extends into the High Plains. So I\\nneed to search High Plains and find its elevation range.\\nAction 3: Search[High Plains]\\nObservation 3: High Plains refers to one of two distinct land regions\\nThought 4: I need to instead search High Plains (United States).\\nAction 4: Search[High Plains (United States)]\\nObservation 4: The High Plains are a subregion of the Great Plains. From east to west, the\\nHigh Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130\\nm).[3]\\nThought 5: High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer\\nis 1,800 to 7,000 ft.\\nAction 5: Finish[1,800 to 7,000 ft]'"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# print initial example for visibility\n",
-    "EXAMPLES[0]"
+    "# Use examples from ReAct\n",
+    "examples = [\n",
+    "  {\n",
+    "    \"question\": \"What is the elevation range for the area that the eastern sector of the Colorado orogeny extends into?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Colorado orogeny, find the area that the eastern sector of the Colorado orogeny extends into, then find the elevation range of that area.\\nAction 1: Search[Colorado orogeny]\\nObservation 1: The Colorado orogeny was an episode of mountain building (an orogeny) in Colorado and surrounding areas.\\nThought 2: It does not mention the eastern sector. So I need to look up eastern sector.\\nAction 2: Lookup[eastern sector]\\nObservation 2: (Result 1 / 1) The eastern sector extends into the High Plains and is called the Central Plains orogeny.\\nThought 3: The eastern sector of Colorado orogeny extends into the High Plains. So I need to search High Plains and find its elevation range.\\nAction 3: Search[High Plains]\\nObservation 3: High Plains refers to one of two distinct land regions\\nThought 4: I need to instead search High Plains (United States).\\nAction 4: Search[High Plains (United States)]\\nObservation 4: The High Plains are a subregion of the Great Plains. From east to west, the High Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130 m).[3]\\nThought 5: High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer is 1,800 to 7,000 ft.\\nAction 5: Finish[1,800 to 7,000 ft]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Musician and satirist Allie Goertz wrote a song about the \\\"The Simpsons\\\" character Milhouse, who Matt Groening named after who?\",\n",
+    "    \"answer\": \"Thought 1: The question simplifies to \\\"The Simpsons\\\" character Milhouse is named after who. I only need to search Milhouse and find who it is named after.\\nAction 1: Search[Milhouse]\\nObservation 1: Milhouse Mussolini Van Houten is a recurring character in the Fox animated television series The Simpsons voiced by Pamela Hayden and created by Matt Groening.\\nThought 2: The paragraph does not tell who Milhouse is named after, maybe I can look up \\\"named after\\\".\\nAction 2: Lookup[named after]\\nObservation 2: (Result 1 / 1) Milhouse was named after U.S. president Richard Nixon, whose middle name was Milhous.\\nThought 3: Milhouse was named after U.S. president Richard Nixon, so the answer is Richard Nixon.\\nAction 3: Finish[Richard Nixon]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Which documentary is about Finnish rock groups, Adam Clayton Powell or The Saimaa Gesture?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Adam Clayton Powell and The Saimaa Gesture, and find which documentary is about Finnish rock groups.\\nAction 1: Search[Adam Clayton Powell]\\nObservation 1 Could not find [Adam Clayton Powell]. Similar: [’Adam Clayton Powell III’, ’Seventh Avenue (Manhattan)’, ’Adam Clayton Powell Jr. State Office Building’, ’Isabel Washington Powell’, ’Adam Powell’, ’Adam Clayton Powell (film)’, ’Giancarlo Esposito’].\\nThought 2: To find the documentary, I can search Adam Clayton Powell (film).\\nAction 2: Search[Adam Clayton Powell (film)]\\nObservation 2: Adam Clayton Powell is a 1989 American documentary film directed by Richard Kilberg. The film is about the rise and fall of influential African-American politician Adam Clayton Powell Jr.[3][4] It was later aired as part of the PBS series The American Experience.\\nThought 3: Adam Clayton Powell (film) is a documentary about an African-American politician, not Finnish rock groups. So the documentary about Finnish rock groups must instead be The Saimaa Gesture.\\nAction 3: Finish[The Saimaa Gesture]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"What profession does Nicholas Ray and Elia Kazan have in common?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Nicholas Ray and Elia Kazan, find their professions, then find the profession they have in common.\\nAction 1: Search[Nicholas Ray]\\nObservation 1: Nicholas Ray (born Raymond Nicholas Kienzle Jr., August 7, 1911 - June 16, 1979) was an American film director, screenwriter, and actor best known for the 1955 film Rebel Without a Cause.\\nThought 2: Professions of Nicholas Ray are director, screenwriter, and actor. I need to search Elia Kazan next and find his professions.\\nAction 2: Search[Elia Kazan]\\nObservation 2: Elia Kazan was an American film and theatre director, producer, screenwriter and actor.\\nThought 3: Professions of Elia Kazan are director, producer, screenwriter, and actor. So profession Nicholas Ray and Elia Kazan have in common is director, screenwriter, and actor.\\nAction 3: Finish[director, screenwriter, actor]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Which magazine was started first Arthur’s Magazine or First for Women?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Arthur’s Magazine and First for Women, and find which was started first.\\nAction 1: Search[Arthur’s Magazine]\\nObservation 1: Arthur’s Magazine (1844-1846) was an American literary periodical published in Philadelphia in the 19th century.\\nThought 2: Arthur’s Magazine was started in 1844. I need to search First for Women next.\\nAction 2: Search[First for Women]\\nObservation 2: First for Women is a woman’s magazine published by Bauer Media Group in the USA.[1] The magazine was started in 1989.\\nThought 3: First for Women was started in 1989. 1844 (Arthur’s Magazine) < 1989 (First for Women), so Arthur’s Magazine was started first.\\nAction 3: Finish[Arthur’s Magazine]\"\n",
+    "  },\n",
+    "  {\n",
+    "    \"question\": \"Were Pavel Urysohn and Leonid Levin known for the same type of work?\",\n",
+    "    \"answer\": \"Thought 1: I need to search Pavel Urysohn and Leonid Levin, find their types of work, then find if they are the same.\\nAction 1: Search[Pavel Urysohn]\\nObservation 1: Pavel Samuilovich Urysohn (February 3, 1898 - August 17, 1924) was a Soviet mathematician who is best known for his contributions in dimension theory.\\nThought 2: Pavel Urysohn is a mathematician. I need to search Leonid Levin next and find its type of work.\\nAction 2: Search[Leonid Levin]\\nObservation 2: Leonid Anatolievich Levin is a Soviet-American mathematician and computer scientist.\\nThought 3: Leonid Levin is a mathematician and computer scientist. So Pavel Urysohn and Leonid Levin have the same type of work.\\nAction 3: Finish[yes]\"\n",
+    "  }\n",
+    "]\n",
+    "example_template = PromptTemplate(template=\"Question: {question}\\n{answer}\", input_variables=[\"question\", \"answer\"])"
    ]
   },
   {
@@ -67,7 +82,7 @@
    },
    "outputs": [],
    "source": [
-    "new_example = generate_example(EXAMPLES, OpenAI())"
+    "new_example = generate_example(examples, OpenAI(), example_template)"
    ]
   },
   {
@@ -85,19 +100,23 @@
       "text/plain": [
        "['',\n",
        " '',\n",
-       " 'Question: Which ocean is the world’s smallest?',\n",
+       " 'Question: What is the highest mountain peak in North America?',\n",
        " '',\n",
-       " 'Thought 1: I need to search for oceans and find which one is the world’s smallest.',\n",
+       " 'Thought 1: I need to search North America and find the highest mountain peak.',\n",
        " '',\n",
-       " 'Action 1: Search[oceans]',\n",
+       " 'Action 1: Search[North America]',\n",
        " '',\n",
-       " 'Observation 1: There are five oceans: the Pacific, Atlantic, Indian, Southern, and Arctic.',\n",
+       " 'Observation 1: North America is a continent entirely within the Northern Hemisphere and almost all within the Western Hemisphere.',\n",
        " '',\n",
-       " 'Thought 2: I need to compare the sizes of the oceans and find which one is the smallest.',\n",
+       " 'Thought 2: I need to look up \"highest mountain peak\".',\n",
        " '',\n",
-       " 'Action 2: Compare[Pacific, Atlantic, Indian, Southern, Arctic]',\n",
+       " 'Action 2: Lookup[highest mountain peak]',\n",
        " '',\n",
-       " 'Observation 2: The Arctic is the smallest ocean.']"
+       " 'Observation 2: (Result 1 / 1) Denali, formerly Mount McKinley, is the highest mountain peak in North America, with a summit elevation of 20,310 feet (6,190 m) above sea level.',\n",
+       " '',\n",
+       " 'Thought 3: Denali is the highest mountain peak in North America, with a summit elevation of 20,310 feet.',\n",
+       " '',\n",
+       " 'Action 3: Finish[20,310 feet]']"
       ]
      },
      "execution_count": 4,

docs/examples/prompts/llm.json

@@ -0,0 +1,11 @@
+{
+    "model_name": "text-davinci-003",
+    "temperature": 0.7,
+    "max_tokens": 256,
+    "top_p": 1.0,
+    "frequency_penalty": 0.0,
+    "presence_penalty": 0.0,
+    "n": 1,
+    "best_of": 1,
+    "_type": "openai"
+}

docs/examples/prompts/llm.yaml

@@ -0,0 +1,9 @@
+_type: openai
+best_of: 1
+frequency_penalty: 0.0
+max_tokens: 256
+model_name: text-davinci-003
+n: 1
+presence_penalty: 0.0
+temperature: 0.7
+top_p: 1.0

docs/examples/prompts/llm_functionality.ipynb

@@ -0,0 +1,412 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "20ac6b98",
+   "metadata": {},
+   "source": [
+    "# LLM Functionality\n",
+    "\n",
+    "This notebook goes over all the different features of the LLM class in LangChain.\n",
+    "\n",
+    "We will work with an OpenAI LLM wrapper, although these functionalities should exist for all LLM types."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "df924055",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "182b484c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(model_name=\"text-ada-001\", n=2, best_of=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9695ccfc",
+   "metadata": {},
+   "source": [
+    "**Generate Text:** The most basic functionality an LLM has is just the ability to call it, passing in a string and getting back a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9d12ac26",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side!'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm(\"Tell me a joke\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7d4d42d",
+   "metadata": {},
+   "source": [
+    "**Generate:** More broadly, you can call it with a list of inputs, getting back a more complete response than just the text. This complete response includes things like multiple top responses, as well as LLM provider specific information"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "f4dc241a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_result = llm.generate([\"Tell me a joke\", \"Tell me a poem\"]*15)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "740392f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "30"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(llm_result.generations)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ab6cdcf1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Generation(text='\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side.'),\n",
+       " Generation(text='\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side!')]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm_result.generations[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "4946a778",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Generation(text=\"\\n\\nA rose by the side of the road\\n\\nIs all I need to find my way\\n\\nTo the place I've been searching for\\n\\nAnd my heart is singing with joy\\n\\nWhen I look at this rose\\n\\nIt reminds me of the love I've found\\n\\nAnd I know that wherever I go\\n\\nI'll always find my rose by the side of the road.\"),\n",
+       " Generation(text=\"\\n\\nWhen I was younger\\nI thought that love\\nI was something like a fairytale\\nI would find my prince and they would be my people\\nI was naïve\\nI thought that\\n\\nLove was a something that happened\\nWhen I was younger\\nI was it for my fairytale prince\\nNow I realize\\nThat love is something that waits\\nFor when my prince comes\\nAnd when I am ready to be his wife\\nI'll tell you a poem\\n\\nWhen I was younger\\nI thought that love\\nI was something like a fairytale\\nI would find my prince and they would be my people\\nI was naïve\\nI thought that\\n\\nLove was a something that happened\\nAnd I would be happy\\nWhen my prince came\\nAnd I was ready to be his wife\")]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm_result.generations[-1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "242e4527",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'token_usage': {'completion_tokens': 3722,\n",
+       "  'prompt_tokens': 120,\n",
+       "  'total_tokens': 3842}}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Provider specific info\n",
+    "llm_result.llm_output"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bde8e04f",
+   "metadata": {},
+   "source": [
+    "**Number of Tokens:** You can also estimate how many tokens a piece of text will be in that model. This is useful because models have a context length (and cost more for more tokens), which means you need to be aware of how long the text you are passing in is.\n",
+    "\n",
+    "Notice that by default the tokens are estimated using a HuggingFace tokenizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b623c774",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "llm.get_num_tokens(\"what a joke\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee6fcf8d",
+   "metadata": {},
+   "source": [
+    "### Caching\n",
+    "With LangChain, you can also enable caching of LLM calls. Note that currently this only applies for individual LLM calls."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "2626ca48",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import langchain\n",
+    "from langchain.cache import InMemoryCache\n",
+    "langchain.llm_cache = InMemoryCache()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "97762272",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# To make the caching really obvious, lets use a slower model.\n",
+    "llm = OpenAI(model_name=\"text-davinci-002\", n=2, best_of=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e80c65e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 31.2 ms, sys: 11.8 ms, total: 43.1 ms\n",
+      "Wall time: 1.75 s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side!'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "# The first time, it is not yet in cache, so it should take longer\n",
+    "llm(\"Tell me a joke\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "678408ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 51 µs, sys: 1 µs, total: 52 µs\n",
+      "Wall time: 67.2 µs\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side!'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "# The second time it is, so it goes faster\n",
+    "llm(\"Tell me a joke\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3f0ac8d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# We can do the same thing with a SQLite cache\n",
+    "from langchain.cache import SQLiteCache\n",
+    "langchain.llm_cache = SQLiteCache(database_path=\".langchain.db\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "0e1dcce3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 26.6 ms, sys: 11.2 ms, total: 37.7 ms\n",
+      "Wall time: 1.89 s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side.'"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "# The first time, it is not yet in cache, so it should take longer\n",
+    "llm(\"Tell me a joke\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "efadd750",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 2.69 ms, sys: 1.57 ms, total: 4.27 ms\n",
+      "Wall time: 2.73 ms\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nWhy did the chicken cross the road?\\n\\nTo get to the other side.'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "# The second time it is, so it goes faster\n",
+    "llm(\"Tell me a joke\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6053408b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# You can use SQLAlchemyCache to cache with any SQL database supported by SQLAlchemy.\n",
+    "from langchain.cache import SQLAlchemyCache\n",
+    "from sqlalchemy import create_engine\n",
+    "\n",
+    "engine = create_engine(\"postgresql://postgres:postgres@localhost:5432/postgres\")\n",
+    "langchain.llm_cache = SQLAlchemyCache(engine)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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.12 (main, Jun  1 2022, 06:34:44) \n[Clang 12.0.0 ]"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "1235b9b19e8e9828b5c1fdb2cd89fe8d3de0fcde5ef5f3db36e4b671adb8660f"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/llm_serialization.ipynb

@@ -0,0 +1,166 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "73f9bf40",
+   "metadata": {},
+   "source": [
+    "# LLM Serialization\n",
+    "\n",
+    "This notebook walks how to write and read an LLM Configuration to and from disk. This is useful if you want to save the configuration for a given LLM (eg the provider, the temperature, etc)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9c9fb6ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.llms.loading import load_llm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88ce018b",
+   "metadata": {},
+   "source": [
+    "### Loading\n",
+    "First, lets go over loading a LLM from disk. LLMs can be saved on disk in two formats: json or yaml. No matter the extension, they are loaded in the same way."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f12b28f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "    \"model_name\": \"text-davinci-003\",\r\n",
+      "    \"temperature\": 0.7,\r\n",
+      "    \"max_tokens\": 256,\r\n",
+      "    \"top_p\": 1,\r\n",
+      "    \"frequency_penalty\": 0,\r\n",
+      "    \"presence_penalty\": 0,\r\n",
+      "    \"n\": 1,\r\n",
+      "    \"best_of\": 1,\r\n",
+      "    \"_type\": \"openai\"\r\n",
+      "}"
+     ]
+    }
+   ],
+   "source": [
+    "!cat llm.json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9ab709fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = load_llm(\"llm.json\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "095b1d56",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "_type: openai\r\n",
+      "best_of: 1\r\n",
+      "frequency_penalty: 0\r\n",
+      "max_tokens: 256\r\n",
+      "model_name: text-davinci-003\r\n",
+      "n: 1\r\n",
+      "presence_penalty: 0\r\n",
+      "temperature: 0.7\r\n",
+      "top_p: 1\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat llm.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8cafaafe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = load_llm(\"llm.yaml\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ab3e4223",
+   "metadata": {},
+   "source": [
+    "### Saving\n",
+    "If you want to go from a LLM in memory to a serialized version of it, you can do so easily by calling the `.save` method. Again, this supports both json and yaml."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "b38f685d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm.save(\"llm.json\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b7365503",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm.save(\"llm.yaml\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e494851",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/load_prompts.ipynb

@@ -1,579 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "43fb16cb",
-   "metadata": {},
-   "source": [
-    "# Prompt Walkthrough\n",
-    "\n",
-    "An overview of the different types of prompts in LangChain and how to use them"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
-   "id": "2c8d7587",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import yaml\n",
-    "\n",
-    "with open(\"simple_prompt.yaml\", \"r\") as stream:\n",
-    "    config = yaml.safe_load(stream)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 54,
-   "id": "1ab11b59",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'input_variables': ['adjective', 'content'],\n",
-       " 'template': 'Tell me a {adjective} joke about {content}.\\nLike what does it mean?'}"
-      ]
-     },
-     "execution_count": 54,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "config"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 55,
-   "id": "78a2cf84",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pathlib import Path\n",
-    "from typing import Union\n",
-    "import yaml\n",
-    "def load_file(file: Union[str, Path]):\n",
-    "    if isinstance(file, str):\n",
-    "        file_path = Path(file)\n",
-    "    else:\n",
-    "        file_path = file\n",
-    "    if file_path.suffix == \".json\":\n",
-    "        with open(file_path) as f:\n",
-    "            config = json.load(f)\n",
-    "    elif file_path.suffix == \".yaml\":\n",
-    "        with open(file_path, \"r\") as f:\n",
-    "            config = yaml.safe_load(f)\n",
-    "    else:\n",
-    "        raise ValueError\n",
-    "    return load_prompt_from_config(config)\n",
-    "    "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "id": "6e1f9bcd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts import Prompt, DynamicPrompt\n",
-    "import json\n",
-    "def load_prompt_from_config(config):\n",
-    "    if \"type\" in config:\n",
-    "        prompt_type = config.pop(\"type\")\n",
-    "    else:\n",
-    "        prompt_type = \"prompt\"\n",
-    "    if prompt_type == \"prompt\":\n",
-    "        return _load_prompt(config)\n",
-    "    elif prompt_type == \"dynamic_prompt\":\n",
-    "        return _load_dynamic_prompt(config)\n",
-    "    else:\n",
-    "        raise ValueError\n",
-    "        \n",
-    "def _load_template(var_name: str, config: dict) -> dict:\n",
-    "    if f\"{var_name}_path\" in config:\n",
-    "        if var_name in config:\n",
-    "            raise ValueError(f\"Both `{var_name}_path` and `{var_name}` cannot be provided.\")\n",
-    "        template_path = Path(config.pop(f\"{var_name}_path\"))\n",
-    "        if template_path.suffix == \".txt\":\n",
-    "            with open(template_path) as f:\n",
-    "                template = f.read()\n",
-    "        else:\n",
-    "            raise ValueError\n",
-    "        config[var_name] = template\n",
-    "    return config\n",
-    "        \n",
-    "        \n",
-    "def _load_dynamic_prompt(config):\n",
-    "    if \"loader\" in config:\n",
-    "        prompt_type = config.pop(\"loader\")\n",
-    "    else:\n",
-    "        prompt_type = \"init\"\n",
-    "    if prompt_type == \"init\":\n",
-    "        config = _load_template(\"suffix\", config)\n",
-    "        config = _load_template(\"prefix\", config)\n",
-    "        return DynamicPrompt(**config)\n",
-    "    elif prompt_type == \"from_structured_examples\":\n",
-    "        config = _load_template(\"suffix\", config)\n",
-    "        config = _load_template(\"prefix\", config)\n",
-    "        config[\"example_prompt\"] = _load_prompt(config[\"example_prompt\"])\n",
-    "        if isinstance(config[\"examples\"], list):\n",
-    "            pass\n",
-    "        elif isinstance(config[\"examples\"], str):\n",
-    "            with open(config[\"examples\"]) as f:\n",
-    "                examples = json.load(f)\n",
-    "            config[\"examples\"] = examples\n",
-    "        else:\n",
-    "            raise ValueError\n",
-    "        return DynamicPrompt.from_structured_examples(**config)\n",
-    "    else:\n",
-    "        raise ValueError\n",
-    "\n",
-    "def _load_prompt(config):\n",
-    "    if \"loader\" in config:\n",
-    "        prompt_type = config.pop(\"loader\")\n",
-    "    else:\n",
-    "        prompt_type = \"init\"\n",
-    "    if prompt_type == \"init\":\n",
-    "        config = _load_template(\"template\", config)\n",
-    "        return Prompt(**config)\n",
-    "    elif prompt_type == \"from_examples\":\n",
-    "        config = _load_template(\"suffix\", config)\n",
-    "        config = _load_template(\"prefix\", config)\n",
-    "        if isinstance(config[\"examples\"], list):\n",
-    "            pass\n",
-    "        elif isinstance(config[\"examples\"], str):\n",
-    "            with open(config[\"examples\"]) as f:\n",
-    "                examples = json.load(f)\n",
-    "            config[\"examples\"] = examples\n",
-    "        else:\n",
-    "            raise ValueError\n",
-    "        return Prompt.from_examples(**config)\n",
-    "    elif prompt_type == \"from_structured_examples\":\n",
-    "        config = _load_template(\"suffix\", config)\n",
-    "        config = _load_template(\"prefix\", config)\n",
-    "        config[\"example_prompt\"] = _load_prompt(config[\"example_prompt\"])\n",
-    "        if isinstance(config[\"examples\"], list):\n",
-    "            pass\n",
-    "        elif isinstance(config[\"examples\"], str):\n",
-    "            with open(config[\"examples\"]) as f:\n",
-    "                examples = json.load(f)\n",
-    "            config[\"examples\"] = examples\n",
-    "        else:\n",
-    "            raise ValueError\n",
-    "        return Prompt.from_structured_examples(**config)\n",
-    "    else:\n",
-    "        raise ValueError"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b045da0f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cddb465e",
-   "metadata": {},
-   "source": [
-    "### Basic Prompt\n",
-    "\n",
-    "The most simple type of prompt - a string template that takes any number of input variables. The template should be formatted as a Python f-string."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "ab46bd2a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Tellme a joke.'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# An example prompt with no input variables\n",
-    "_config = {\n",
-    "    \"input_variables\": [],\n",
-    "    \"template\": \"Tell me a joke.\"\n",
-    "}\n",
-    "no_input_prompt = load_prompt_from_config(_config)\n",
-    "no_input_prompt.format()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "c3ad0fa8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Tell me a funny joke.'"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# An example prompt with one input variable\n",
-    "_config = {\n",
-    "    \"input_variables\": [\"adjective\"],\n",
-    "    \"template\": \"Tell me a {adjective} joke.\"\n",
-    "}\n",
-    "one_input_prompt = load_prompt_from_config(_config)\n",
-    "one_input_prompt.format(adjective=\"funny\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "ba577dcf",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Tell me a funny joke about chickens.'"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# An example prompt with multiple input variables\n",
-    "_config = {\n",
-    "    \"input_variables\": [\"adjective\", \"content\"],\n",
-    "    \"template\": \"Tell me a {adjective} joke about {content}.\"\n",
-    "}\n",
-    "multiple_input_prompt = load_prompt_from_config(_config)\n",
-    "multiple_input_prompt.format(adjective=\"funny\", content=\"chickens\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 43,
-   "id": "e0ad7fb8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Tell me a funny joke about chickens.'"
-      ]
-     },
-     "execution_count": 43,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "multiple_input_prompt = load_file(\"simple_prompt_with_template_file.json\")\n",
-    "multiple_input_prompt.format(adjective=\"funny\", content=\"chickens\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d27b1824",
-   "metadata": {},
-   "source": [
-    "### Examples\n",
-    "Examples are datapoints that can be used to show the model how to produce results. They can be either strings, or dictionaries that are then turned into strings by an example prompt itself."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "2c00e965",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "string_examples = [\"Input: happy\\nOutput: sad\", \"Input: tall\\nOutput: short\"]\n",
-    "dict_examples = [{\"input\": \"happy\", \"output\": \"sad\"}, {\"input\": \"tall\", \"output\": \"short\"}]\n",
-    "example_prompt_config = {\"input_variables\": [\"input\",\"output\"], \"template\": \"Input: {input}\\nOutput: {output}\"}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1492b49d",
-   "metadata": {},
-   "source": [
-    "### Simple Prompt with examples\n",
-    "\n",
-    "We can then use these examples to construct prompts."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "1a5a686d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "_config = {\n",
-    "    \"loader\": \"from_examples\",\n",
-    "    \"examples\": string_examples,\n",
-    "    \"prefix\": \"Give the antonym of every input\",\n",
-    "    \"suffix\": \"Input: {adjective}\\nOutput:\", \n",
-    "    \"input_variables\": [\"adjective\"],\n",
-    "}\n",
-    "prompt_from_string_examples = load_prompt_from_config(_config)\n",
-    "print(prompt_from_string_examples.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "08d43717",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "_config = {\n",
-    "    \"loader\": \"from_examples\",\n",
-    "    \"examples\": \"string_examples.json\",\n",
-    "    \"prefix\": \"Give the antonym of every input\",\n",
-    "    \"suffix\": \"Input: {adjective}\\nOutput:\", \n",
-    "    \"input_variables\": [\"adjective\"],\n",
-    "}\n",
-    "prompt_from_string_examples = load_prompt_from_config(_config)\n",
-    "print(prompt_from_string_examples.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "7931e5f2",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "_config = {\n",
-    "    \"loader\": \"from_structured_examples\",\n",
-    "    \"examples\": dict_examples,\n",
-    "    \"example_prompt\": example_prompt_config,\n",
-    "    \"prefix\": \"Give the antonym of every input\",\n",
-    "    \"suffix\": \"Input: {adjective}\\nOutput:\", \n",
-    "    \"input_variables\": [\"adjective\"],\n",
-    "}\n",
-    "prompt_from_structured_examples = load_prompt_from_config(_config)\n",
-    "print(prompt_from_structured_examples.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "738ff0a8",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "_config = {\n",
-    "    \"loader\": \"from_structured_examples\",\n",
-    "    \"examples\": \"structured_examples.json\",\n",
-    "    \"example_prompt\": example_prompt_config,\n",
-    "    \"prefix\": \"Give the antonym of every input\",\n",
-    "    \"suffix\": \"Input: {adjective}\\nOutput:\", \n",
-    "    \"input_variables\": [\"adjective\"],\n",
-    "}\n",
-    "prompt_from_structured_examples = load_prompt_from_config(_config)\n",
-    "print(prompt_from_structured_examples.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "861a4d1f",
-   "metadata": {},
-   "source": [
-    "### Dynamic Prompt\n",
-    "\n",
-    "We also do more clever things with prompts - for example, only select a certain number of examples in order to limit the size of the text passed in. This will vary with the input text size."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "207e55f7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "_config = {\n",
-    "    \"type\": \"dynamic_prompt\",\n",
-    "    \"loader\": \"from_structured_examples\",\n",
-    "    \"examples\": \"structured_examples.json\",\n",
-    "    \"example_prompt\": example_prompt_config,\n",
-    "    \"prefix\": \"Give the antonym of every input\",\n",
-    "    \"suffix\": \"Input: {adjective}\\nOutput:\", \n",
-    "    \"input_variables\": [\"adjective\"],\n",
-    "    \"max_length\": 20,\n",
-    "}\n",
-    "dynamic_prompt = load_prompt_from_config(_config)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "id": "d00b4385",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "# An example with small input, so it selects both examples.\n",
-    "print(dynamic_prompt.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "878bcde9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: big and huge and massive\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "# An example with long input, so it selects only one example.\n",
-    "print(dynamic_prompt.format(adjective=\"big and huge and massive\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "76a1065d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/examples/prompts/prompt_management.ipynb

@@ -0,0 +1,610 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "43fb16cb",
+   "metadata": {},
+   "source": [
+    "# Prompt Management\n",
+    "\n",
+    "Managing your prompts is annoying and tedious, with everyone writing their own slightly different variants of the same ideas. But it shouldn't be this way. \n",
+    "\n",
+    "LangChain provides a standard and flexible way for specifying and managing all your prompts, as well as clear and specific terminology around them. This notebook goes through the core components of working with prompts, showing how to use them as well as explaining what they do.\n",
+    "\n",
+    "This notebook covers how to work with prompts in Python. If you are interested in how to work with serialized versions of prompts and load them from disk, see [this notebook](prompt_serialization.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "890aad4d",
+   "metadata": {},
+   "source": [
+    "### The BasePromptTemplate Interface\n",
+    "\n",
+    "A prompt template is a mechanism for constructing a prompt to pass to the language model given some user input. Below is the interface that all different types of prompt templates should expose.\n",
+    "\n",
+    "```python\n",
+    "class BasePromptTemplate(ABC):\n",
+    "\n",
+    "    input_variables: List[str]\n",
+    "    \"\"\"A list of the names of the variables the prompt template expects.\"\"\"\n",
+    "\n",
+    "    @abstractmethod\n",
+    "    def format(self, **kwargs: Any) -> str:\n",
+    "        \"\"\"Format the prompt with the inputs.\n",
+    "\n",
+    "        Args:\n",
+    "            kwargs: Any arguments to be passed to the prompt template.\n",
+    "\n",
+    "        Returns:\n",
+    "            A formatted string.\n",
+    "\n",
+    "        Example:\n",
+    "\n",
+    "        .. code-block:: python\n",
+    "\n",
+    "            prompt.format(variable1=\"foo\")\n",
+    "        \"\"\"\n",
+    "```\n",
+    "\n",
+    "The only two things that define a prompt are:\n",
+    "\n",
+    "1. `input_variables`: The user inputted variables that are needed to format the prompt.\n",
+    "2. `format`: A method which takes in keyword arguments are returns a formatted prompt. The keys are expected to be the input variables\n",
+    "    \n",
+    "The rest of the logic of how the prompt is constructed is left up to different implementations. Let's take a look at some below."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cddb465e",
+   "metadata": {},
+   "source": [
+    "### PromptTemplate\n",
+    "\n",
+    "This is the most simple type of prompt template, consisting of a string template that takes any number of input variables. The template should be formatted as a Python f-string, although we will support other formats (Jinja, Mako, etc) in the future. \n",
+    "\n",
+    "If you just want to use a hardcoded prompt template, you should use this implementation.\n",
+    "\n",
+    "Let's walk through a few examples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "094229f4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import PromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ab46bd2a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Tell me a joke.'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# An example prompt with no input variables\n",
+    "no_input_prompt = PromptTemplate(input_variables=[], template=\"Tell me a joke.\")\n",
+    "no_input_prompt.format()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c3ad0fa8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Tell me a funny joke.'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# An example prompt with one input variable\n",
+    "one_input_prompt = PromptTemplate(input_variables=[\"adjective\"], template=\"Tell me a {adjective} joke.\")\n",
+    "one_input_prompt.format(adjective=\"funny\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ba577dcf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Tell me a funny joke about chickens.'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# An example prompt with multiple input variables\n",
+    "multiple_input_prompt = PromptTemplate(\n",
+    "    input_variables=[\"adjective\", \"content\"], \n",
+    "    template=\"Tell me a {adjective} joke about {content}.\"\n",
+    ")\n",
+    "multiple_input_prompt.format(adjective=\"funny\", content=\"chickens\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1492b49d",
+   "metadata": {},
+   "source": [
+    "### Few Shot Prompts\n",
+    "\n",
+    "A FewShotPromptTemplate is a prompt template that includes some examples. If you have collected some examples of how the task should be done, you can insert them into prompt using this class.\n",
+    "\n",
+    "Examples are datapoints that can be included in the prompt in order to give the model more context what to do. Examples are represented as a dictionary of key-value pairs, with the key being the input (or label) name, and the value being the input (or label) value. \n",
+    "\n",
+    "In addition to the example, we also need to specify how the example should be formatted when it's inserted in the prompt. We can do this using the above `PromptTemplate`!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3eb36972",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# These are some examples of a pretend task of creating antonyms.\n",
+    "examples = [\n",
+    "    {\"input\": \"happy\", \"output\": \"sad\"},\n",
+    "    {\"input\": \"tall\", \"output\": \"short\"},\n",
+    "]\n",
+    "# This how we specify how the example should be formatted.\n",
+    "example_prompt = PromptTemplate(\n",
+    "    input_variables=[\"input\",\"output\"],\n",
+    "    template=\"Input: {input}\\nOutput: {output}\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "80a91d96",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import FewShotPromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7931e5f2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Give the antonym of every input\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: big\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt_from_string_examples = FewShotPromptTemplate(\n",
+    "    # These are the examples we want to insert into the prompt.\n",
+    "    examples=examples,\n",
+    "    # This is how we want to format the examples when we insert them into the prompt.\n",
+    "    example_prompt=example_prompt,\n",
+    "    # The prefix is some text that goes before the examples in the prompt.\n",
+    "    # Usually, this consists of intructions.\n",
+    "    prefix=\"Give the antonym of every input\",\n",
+    "    # The suffix is some text that goes after the examples in the prompt.\n",
+    "    # Usually, this is where the user input will go\n",
+    "    suffix=\"Input: {adjective}\\nOutput:\", \n",
+    "    # The input variables are the variables that the overall prompt expects.\n",
+    "    input_variables=[\"adjective\"],\n",
+    "    # The example_separator is the string we will use to join the prefix, examples, and suffix together with.\n",
+    "    example_separator=\"\\n\\n\"\n",
+    "    \n",
+    ")\n",
+    "print(prompt_from_string_examples.format(adjective=\"big\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bf038596",
+   "metadata": {},
+   "source": [
+    "### ExampleSelector\n",
+    "If you have a large number of examples, you may need to select which ones to include in the prompt. The ExampleSelector is the class responsible for doing so. The base interface is defined as below.\n",
+    "\n",
+    "```python\n",
+    "class BaseExampleSelector(ABC):\n",
+    "    \"\"\"Interface for selecting examples to include in prompts.\"\"\"\n",
+    "\n",
+    "    @abstractmethod\n",
+    "    def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:\n",
+    "        \"\"\"Select which examples to use based on the inputs.\"\"\"\n",
+    "\n",
+    "```\n",
+    "\n",
+    "The only method it needs to expose is a `select_examples` method. This takes in the input variables and then returns a list of examples. It is up to each specific implementation as to how those examples are selected. Let's take a look at some below."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "861a4d1f",
+   "metadata": {},
+   "source": [
+    "### LengthBased ExampleSelector\n",
+    "\n",
+    "This ExampleSelector selects which examples to use based on length. This is useful when you are worried about constructing a prompt that will go over the length of the context window. For longer inputs, it will select fewer examples to include, while for shorter inputs it will select more.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7c469c95",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.example_selector import LengthBasedExampleSelector"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0ec6d950",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# These are a lot of examples of a pretend task of creating antonyms.\n",
+    "examples = [\n",
+    "    {\"input\": \"happy\", \"output\": \"sad\"},\n",
+    "    {\"input\": \"tall\", \"output\": \"short\"},\n",
+    "    {\"input\": \"energetic\", \"output\": \"lethargic\"},\n",
+    "    {\"input\": \"sunny\", \"output\": \"gloomy\"},\n",
+    "    {\"input\": \"windy\", \"output\": \"calm\"},\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "207e55f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "example_selector = LengthBasedExampleSelector(\n",
+    "    # These are the examples is has available to choose from.\n",
+    "    examples=examples, \n",
+    "    # This is the PromptTemplate being used to format the examples.\n",
+    "    example_prompt=example_prompt, \n",
+    "    # This is the maximum length that the formatted examples should be.\n",
+    "    # Length is measured by the get_text_length function below.\n",
+    "    max_length=25,\n",
+    "    # This is the function used to get the length of a string, which is used\n",
+    "    # to determine which examples to include. It is commented out because\n",
+    "    # it is provided as a default value if none is specified.\n",
+    "    # get_text_length: Callable[[str], int] = lambda x: len(re.split(\"\\n| \", x))\n",
+    ")\n",
+    "dynamic_prompt = FewShotPromptTemplate(\n",
+    "    # We provide an ExampleSelector instead of examples.\n",
+    "    example_selector=example_selector,\n",
+    "    example_prompt=example_prompt,\n",
+    "    prefix=\"Give the antonym of every input\",\n",
+    "    suffix=\"Input: {adjective}\\nOutput:\", \n",
+    "    input_variables=[\"adjective\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "d00b4385",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Give the antonym of every input\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: energetic\n",
+      "Output: lethargic\n",
+      "\n",
+      "Input: sunny\n",
+      "Output: gloomy\n",
+      "\n",
+      "Input: windy\n",
+      "Output: calm\n",
+      "\n",
+      "Input: big\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "# An example with small input, so it selects all examples.\n",
+    "print(dynamic_prompt.format(adjective=\"big\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "878bcde9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Give the antonym of every input\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: big and huge and massive and large and gigantic and tall and much much much much much bigger than everything else\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "# An example with long input, so it selects only one example.\n",
+    "long_string = \"big and huge and massive and large and gigantic and tall and much much much much much bigger than everything else\"\n",
+    "print(dynamic_prompt.format(adjective=long_string))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "e4bebcd9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Give the antonym of every input\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: energetic\n",
+      "Output: lethargic\n",
+      "\n",
+      "Input: sunny\n",
+      "Output: gloomy\n",
+      "\n",
+      "Input: windy\n",
+      "Output: calm\n",
+      "\n",
+      "Input: big\n",
+      "Output: small\n",
+      "\n",
+      "Input: enthusiastic\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "# You can add an example to an example selector as well.\n",
+    "new_example = {\"input\": \"big\", \"output\": \"small\"}\n",
+    "dynamic_prompt.example_selector.add_example(new_example)\n",
+    "print(dynamic_prompt.format(adjective=\"enthusiastic\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d007b0a",
+   "metadata": {},
+   "source": [
+    "### Similarity ExampleSelector\n",
+    "\n",
+    "The SemanticSimilarityExampleSelector selects examples based on which examples are most similar to the inputs. It does this by finding the examples with the embeddings that have the greatest cosine similarity with the inputs.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "241bfe80",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.example_selector import SemanticSimilarityExampleSelector\n",
+    "from langchain.vectorstores import FAISS\n",
+    "from langchain.embeddings import OpenAIEmbeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "50d0a701",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "example_selector = SemanticSimilarityExampleSelector.from_examples(\n",
+    "    # This is the list of examples available to select from.\n",
+    "    examples, \n",
+    "    # This is the embedding class used to produce embeddings which are used to measure semantic similarity.\n",
+    "    OpenAIEmbeddings(), \n",
+    "    # This is the VectorStore class that is used to store the embeddings and do a similarity search over.\n",
+    "    FAISS, \n",
+    "    # This is the number of examples to produce.\n",
+    "    k=1\n",
+    ")\n",
+    "similar_prompt = FewShotPromptTemplate(\n",
+    "    # We provide an ExampleSelector instead of examples.\n",
+    "    example_selector=example_selector,\n",
+    "    example_prompt=example_prompt,\n",
+    "    prefix=\"Give the antonym of every input\",\n",
+    "    suffix=\"Input: {adjective}\\nOutput:\", \n",
+    "    input_variables=[\"adjective\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "4c8fdf45",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Give the antonym of every input\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: worried\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Input is a feeling, so should select the happy/sad example\n",
+    "print(similar_prompt.format(adjective=\"worried\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "829af21a",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Give the antonym of every input\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: fat\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Input is a measurement, so should select the tall/short example\n",
+    "print(similar_prompt.format(adjective=\"fat\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "3c16fe23",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Give the antonym of every input\n",
+      "\n",
+      "Input: enthusiastic\n",
+      "Output: apathetic\n",
+      "\n",
+      "Input: joyful\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "# You can add new examples to the SemanticSimilarityExampleSelector as well\n",
+    "similar_prompt.example_selector.add_example({\"input\": \"enthusiastic\", \"output\": \"apathetic\"})\n",
+    "print(similar_prompt.format(adjective=\"joyful\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dbc32551",
+   "metadata": {},
+   "source": [
+    "### Serialization\n",
+    "\n",
+    "PromptTemplates and examples can be serialized and loaded from disk, making it easy to share and store prompts. For a detailed walkthrough on how to do that, see [this notebook](prompt_serialization.ipynb)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1e1e13c6",
+   "metadata": {},
+   "source": [
+    "### Customizability\n",
+    "The above covers all the ways currently supported in LangChain to represent prompts and example selectors. However, due to the simple interface that the base classes (`BasePromptTemplate`, `BaseExampleSelector`) expose, it should be easy to subclass them and write your own implementation in your own codebase. And of course, if you'd like to contribute that back to LangChain, we'd love that :)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c746d6f4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/prompt_optimization.ipynb

@@ -1,179 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "d7467b67",
-   "metadata": {},
-   "source": [
-    "# Optimized Prompts\n",
-    "\n",
-    "This example showcases how using the OptimizedPrompt class enables selection of the most relevant examples to include as few-shot examples in the prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "e9e2b50b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains.react.prompt import EXAMPLES, SUFFIX\n",
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.example_generator import generate_example, generate_example_from_dynamic_prompt\n",
-    "from langchain.llms.openai import OpenAI\n",
-    "from langchain.prompts.optimized import OptimizedPrompt\n",
-    "from langchain.vectorstores.elastic_vector_search import ElasticVectorSearch\n",
-    "from langchain.vectorstores.faiss_search import FAISS"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "cb069606",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Question: What is the elevation range for the area that the eastern sector of the\\nColorado orogeny extends into?\\nThought 1: I need to search Colorado orogeny, find the area that the eastern sector\\nof the Colorado orogeny extends into, then find the elevation range of the\\narea.\\nAction 1: Search[Colorado orogeny]\\nObservation 1: The Colorado orogeny was an episode of mountain building (an orogeny) in\\nColorado and surrounding areas.\\nThought 2: It does not mention the eastern sector. So I need to look up eastern\\nsector.\\nAction 2: Lookup[eastern sector]\\nObservation 2: (Result 1 / 1) The eastern sector extends into the High Plains and is called\\nthe Central Plains orogeny.\\nThought 3: The eastern sector of Colorado orogeny extends into the High Plains. So I\\nneed to search High Plains and find its elevation range.\\nAction 3: Search[High Plains]\\nObservation 3: High Plains refers to one of two distinct land regions\\nThought 4: I need to instead search High Plains (United States).\\nAction 4: Search[High Plains (United States)]\\nObservation 4: The High Plains are a subregion of the Great Plains. From east to west, the\\nHigh Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130\\nm).[3]\\nThought 5: High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer\\nis 1,800 to 7,000 ft.\\nAction 5: Finish[1,800 to 7,000 ft]'"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "EXAMPLES[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "5fda75a4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prompt = OptimizedPrompt.from_examples(\n",
-    "    examples=EXAMPLES, \n",
-    "    suffix=SUFFIX, \n",
-    "    input_variables=[\"input\"],\n",
-    "    embeddings=OpenAIEmbeddings(),\n",
-    "    vectorstore_cls=FAISS\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "7a601df8",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "Question: What is the elevation range for the area that the eastern sector of the\n",
-      "Colorado orogeny extends into?\n",
-      "Thought 1: I need to search Colorado orogeny, find the area that the eastern sector\n",
-      "of the Colorado orogeny extends into, then find the elevation range of the\n",
-      "area.\n",
-      "Action 1: Search[Colorado orogeny]\n",
-      "Observation 1: The Colorado orogeny was an episode of mountain building (an orogeny) in\n",
-      "Colorado and surrounding areas.\n",
-      "Thought 2: It does not mention the eastern sector. So I need to look up eastern\n",
-      "sector.\n",
-      "Action 2: Lookup[eastern sector]\n",
-      "Observation 2: (Result 1 / 1) The eastern sector extends into the High Plains and is called\n",
-      "the Central Plains orogeny.\n",
-      "Thought 3: The eastern sector of Colorado orogeny extends into the High Plains. So I\n",
-      "need to search High Plains and find its elevation range.\n",
-      "Action 3: Search[High Plains]\n",
-      "Observation 3: High Plains refers to one of two distinct land regions\n",
-      "Thought 4: I need to instead search High Plains (United States).\n",
-      "Action 4: Search[High Plains (United States)]\n",
-      "Observation 4: The High Plains are a subregion of the Great Plains. From east to west, the\n",
-      "High Plains rise in elevation from around 1,800 to 7,000 ft (550 to 2,130\n",
-      "m).[3]\n",
-      "Thought 5: High Plains rise in elevation from around 1,800 to 7,000 ft, so the answer\n",
-      "is 1,800 to 7,000 ft.\n",
-      "Action 5: Finish[1,800 to 7,000 ft]\n",
-      "\n",
-      "\n",
-      "\n",
-      "Question: What is the highest mountain peak in Asia?\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(prompt.format(k=1, input=\"What is the highest mountain peak in Asia?\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a5dc3525",
-   "metadata": {},
-   "source": [
-    "## Requires having ElasticSearch setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bbd92d08",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prompt = OptimizedPrompt.from_examples(\n",
-    "    examples=EXAMPLES, \n",
-    "    suffix=SUFFIX, \n",
-    "    input_variables=[\"input\"],\n",
-    "    embeddings=OpenAIEmbeddings(),\n",
-    "    vectorstore_cls=ElasticVectorSearch,\n",
-    "    elasticsearch_url=\"http://localhost:9200\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bd91f408",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(prompt.format(k=1, input=\"What is the highest mountain peak in Asia?\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "716165c2",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/examples/prompts/prompt_serialization.ipynb

@@ -0,0 +1,542 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "43fb16cb",
+   "metadata": {},
+   "source": [
+    "# Prompt Serialization\n",
+    "\n",
+    "It is often preferrable to store prompts not as python code but as files. This can make it easy to share, store, and version prompts. This notebook covers how to do that in LangChain, walking through all the different types of prompts and the different serialization options.\n",
+    "\n",
+    "At a high level, the following design principles are applied to serialization:\n",
+    "\n",
+    "1. Both JSON and YAML are supported. We want to support serialization methods are human readable on disk, and YAML and JSON are two of the most popular methods for that. Note that this rule applies to prompts. For other assets, like Examples, different serialization methods may be supported.\n",
+    "\n",
+    "2. We support specifying everything in one file, or storing different components (templates, examples, etc) in different files and referencing them. For some cases, storing everything in file makes the most sense, but for others it is preferrable to split up some of the assets (long templates, large examples, reusable components). LangChain supports both.\n",
+    "\n",
+    "There is also a single entry point to load prompts from disk, making it easy to load any type of prompt."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2c8d7587",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# All prompts are loaded through the `load_prompt` function.\n",
+    "from langchain.prompts import load_prompt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cddb465e",
+   "metadata": {},
+   "source": [
+    "## PromptTemplate\n",
+    "\n",
+    "This section covers examples for loading a PromptTemplate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d4b40f2",
+   "metadata": {},
+   "source": [
+    "### Loading from YAML\n",
+    "This shows an example of loading a PromptTemplate from YAML."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2d6e5117",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "input_variables:\r\n",
+      "    [\"adjective\", \"content\"]\r\n",
+      "template: \r\n",
+      "    Tell me a {adjective} joke about {content}.\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat simple_prompt.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4f4ca686",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tell me a funny joke about chickens.\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = load_prompt(\"simple_prompt.yaml\")\n",
+    "print(prompt.format(adjective=\"funny\", content=\"chickens\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "362eadb2",
+   "metadata": {},
+   "source": [
+    "### Loading from JSON\n",
+    "This shows an example of loading a PromptTemplate from JSON."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "510def23",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "    \"input_variables\": [\"adjective\", \"content\"],\r\n",
+      "    \"template\": \"Tell me a {adjective} joke about {content}.\"\r\n",
+      "}\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat simple_prompt.json"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d788a83c",
+   "metadata": {},
+   "source": [
+    "### Loading Template from a File\n",
+    "This shows an example of storing the template in a separate file and then referencing it in the config. Notice that the key changes from `template` to `template_path`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5547760d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tell me a {adjective} joke about {content}."
+     ]
+    }
+   ],
+   "source": [
+    "!cat simple_template.txt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9cb13ac5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "    \"input_variables\": [\"adjective\", \"content\"],\r\n",
+      "    \"template_path\": \"simple_template.txt\"\r\n",
+      "}\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat simple_prompt_with_template_file.json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "762cb4bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tell me a funny joke about chickens.\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = load_prompt(\"simple_prompt_with_template_file.json\")\n",
+    "print(prompt.format(adjective=\"funny\", content=\"chickens\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2ae191cc",
+   "metadata": {},
+   "source": [
+    "## FewShotPromptTemplate\n",
+    "\n",
+    "This section covers examples for loading few shot prompt templates."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9828f94c",
+   "metadata": {},
+   "source": [
+    "### Examples\n",
+    "This shows an example of what examples stored as json might look like."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b21f5b95",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[\r\n",
+      "    {\"input\": \"happy\", \"output\": \"sad\"},\r\n",
+      "    {\"input\": \"tall\", \"output\": \"short\"}\r\n",
+      "]\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat examples.json"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8e300335",
+   "metadata": {},
+   "source": [
+    "### Loading from YAML\n",
+    "This shows an example of loading a few shot example from YAML."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "e2bec0fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "_type: few_shot\r\n",
+      "input_variables:\r\n",
+      "    [\"adjective\"]\r\n",
+      "prefix: \r\n",
+      "    Write antonyms for the following words.\r\n",
+      "example_prompt:\r\n",
+      "    input_variables:\r\n",
+      "        [\"input\", \"output\"]\r\n",
+      "    template:\r\n",
+      "        \"Input: {input}\\nOutput: {output}\"\r\n",
+      "examples:\r\n",
+      "    examples.json\r\n",
+      "suffix:\r\n",
+      "    \"Input: {adjective}\\nOutput:\"\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat few_shot_prompt.yaml"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "98c8f356",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Write antonyms for the following words.\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: funny\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = load_prompt(\"few_shot_prompt.yaml\")\n",
+    "print(prompt.format(adjective=\"funny\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4870aa9d",
+   "metadata": {},
+   "source": [
+    "### Loading from JSON\n",
+    "This shows an example of loading a few shot example from JSON."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "9d996a86",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "    \"_type\": \"few_shot\",\r\n",
+      "    \"input_variables\": [\"adjective\"],\r\n",
+      "    \"prefix\": \"Write antonyms for the following words.\",\r\n",
+      "    \"example_prompt\": {\r\n",
+      "        \"input_variables\": [\"input\", \"output\"],\r\n",
+      "        \"template\": \"Input: {input}\\nOutput: {output}\"\r\n",
+      "    },\r\n",
+      "    \"examples\": \"examples.json\",\r\n",
+      "    \"suffix\": \"Input: {adjective}\\nOutput:\"\r\n",
+      "}   \r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat few_shot_prompt.json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "dd2c10bb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Write antonyms for the following words.\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: funny\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = load_prompt(\"few_shot_prompt.json\")\n",
+    "print(prompt.format(adjective=\"funny\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d23faf4",
+   "metadata": {},
+   "source": [
+    "### Examples in the Config\n",
+    "This shows an example of referencing the examples directly in the config."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "6cd781ef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "    \"_type\": \"few_shot\",\r\n",
+      "    \"input_variables\": [\"adjective\"],\r\n",
+      "    \"prefix\": \"Write antonyms for the following words.\",\r\n",
+      "    \"example_prompt\": {\r\n",
+      "        \"input_variables\": [\"input\", \"output\"],\r\n",
+      "        \"template\": \"Input: {input}\\nOutput: {output}\"\r\n",
+      "    },\r\n",
+      "    \"examples\": [\r\n",
+      "        {\"input\": \"happy\", \"output\": \"sad\"},\r\n",
+      "        {\"input\": \"tall\", \"output\": \"short\"}\r\n",
+      "    ],\r\n",
+      "    \"suffix\": \"Input: {adjective}\\nOutput:\"\r\n",
+      "}   \r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat few_shot_prompt_examples_in.json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "533ab8a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Write antonyms for the following words.\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: funny\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = load_prompt(\"few_shot_prompt_examples_in.json\")\n",
+    "print(prompt.format(adjective=\"funny\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2e86139e",
+   "metadata": {},
+   "source": [
+    "### Example Prompt from a File\n",
+    "This shows an example of loading the PromptTemplate that is used to format the examples from a separate file. Note that the key changes from `example_prompt` to `example_prompt_path`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "0b6dd7b8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "    \"input_variables\": [\"input\", \"output\"],\r\n",
+      "    \"template\": \"Input: {input}\\nOutput: {output}\" \r\n",
+      "}\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat example_prompt.json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "76a1065d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\r\n",
+      "    \"_type\": \"few_shot\",\r\n",
+      "    \"input_variables\": [\"adjective\"],\r\n",
+      "    \"prefix\": \"Write antonyms for the following words.\",\r\n",
+      "    \"example_prompt_path\": \"example_prompt.json\",\r\n",
+      "    \"examples\": \"examples.json\",\r\n",
+      "    \"suffix\": \"Input: {adjective}\\nOutput:\"\r\n",
+      "}   \r\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cat few_shot_prompt_example_prompt.json "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "744d275d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Write antonyms for the following words.\n",
+      "\n",
+      "Input: happy\n",
+      "Output: sad\n",
+      "\n",
+      "Input: tall\n",
+      "Output: short\n",
+      "\n",
+      "Input: funny\n",
+      "Output:\n"
+     ]
+    }
+   ],
+   "source": [
+    "prompt = load_prompt(\"few_shot_prompt_example_prompt.json\")\n",
+    "print(prompt.format(adjective=\"funny\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dcfc7176",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/examples/prompts/simple_prompt.json

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

docs/examples/prompts/simple_prompt.yaml

@@ -1,5 +1,4 @@
-input_variables: 
-  ["adjective", "content"]
-template: |
-  Tell me a {adjective} joke about {content}.
-  Like what does it mean?
+input_variables:
+    ["adjective", "content"]
+template: 
+    Tell me a {adjective} joke about {content}.

docs/examples/prompts/simple_prompt_with_template_file.json

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

docs/examples/prompts/string_examples.json

@@ -1 +0,0 @@
-["Input: happy\nOutput: sad", "Input: tall\nOutput: short"]

docs/examples/prompts/structured_examples.json

@@ -1 +0,0 @@
-[{"input": "happy", "output": "sad"}, {"input": "tall", "output": "short"}]

docs/examples/prompts/walkthrough.ipynb

@@ -1,410 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "43fb16cb",
-   "metadata": {},
-   "source": [
-    "# Prompt Walkthrough\n",
-    "\n",
-    "An overview of the different types of prompts in LangChain and how to use them"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cddb465e",
-   "metadata": {},
-   "source": [
-    "### Basic Prompt\n",
-    "\n",
-    "The most simple type of prompt - a string template that takes any number of input variables. The template should be formatted as a Python f-string."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "094229f4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts import Prompt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "ab46bd2a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Tell me a joke.'"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# An example prompt with no input variables\n",
-    "no_input_prompt = Prompt(input_variables=[], template=\"Tell me a joke.\")\n",
-    "no_input_prompt.format()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "c3ad0fa8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Tell me a funny joke.'"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# An example prompt with one input variable\n",
-    "no_input_prompt = Prompt(input_variables=[\"adjective\"], template=\"Tell me a {adjective} joke.\")\n",
-    "no_input_prompt.format(adjective=\"funny\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "ba577dcf",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Tell me a funny joke about chickens.'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# An example prompt with multiple input variables\n",
-    "no_input_prompt = Prompt(input_variables=[\"adjective\", \"content\"], template=\"Tell me a {adjective} joke about {content}.\")\n",
-    "no_input_prompt.format(adjective=\"funny\", content=\"chickens\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d27b1824",
-   "metadata": {},
-   "source": [
-    "### Examples\n",
-    "Examples are datapoints that can be used to show the model how to produce results. They can be either strings, or dictionaries that are then turned into strings by an example prompt itself."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "2c00e965",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "string_examples = [\"Input: happy\\nOutput: sad\", \"Input: tall\\nOutput: short\"]\n",
-    "dict_examples = [{\"input\": \"happy\", \"output\": \"sad\"}, {\"input\": \"tall\", \"output\": \"short\"}]\n",
-    "example_prompt = Prompt(input_variables=[\"input\",\"output\"], template=\"Input: {input}\\nOutput: {output}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1492b49d",
-   "metadata": {},
-   "source": [
-    "### Simple Prompt with examples\n",
-    "\n",
-    "We can then use these examples to construct prompts."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "1a5a686d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "prompt_from_string_examples = Prompt.from_examples(\n",
-    "    string_examples, \n",
-    "    prefix=\"Give the antonym of every input\",\n",
-    "    suffix=\"Input: {adjective}\\nOutput:\", \n",
-    "    input_variables=[\"adjective\"],\n",
-    ")\n",
-    "print(prompt_from_string_examples.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "7931e5f2",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "prompt_from_string_examples = Prompt.from_structured_examples(\n",
-    "    dict_examples,\n",
-    "    example_prompt,\n",
-    "    prefix=\"Give the antonym of every input\",\n",
-    "    suffix=\"Input: {adjective}\\nOutput:\", \n",
-    "    input_variables=[\"adjective\"],\n",
-    ")\n",
-    "print(prompt_from_string_examples.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "861a4d1f",
-   "metadata": {},
-   "source": [
-    "### Dynamic Prompt\n",
-    "\n",
-    "We also do more clever things with prompts - for example, only select a certain number of examples in order to limit the size of the text passed in. This will vary with the input text size."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "7c469c95",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts import DynamicPrompt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "207e55f7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dynamic_prompt = DynamicPrompt.from_structured_examples(\n",
-    "    dict_examples,\n",
-    "    example_prompt,\n",
-    "    prefix=\"Give the antonym of every input\",\n",
-    "    suffix=\"Input: {adjective}\\nOutput:\", \n",
-    "    input_variables=[\"adjective\"],\n",
-    "    max_length=20,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "d00b4385",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: big\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "# An example with small input, so it selects both examples.\n",
-    "print(dynamic_prompt.format(adjective=\"big\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "878bcde9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: big and huge and massive\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "# An example with long input, so it selects only one example.\n",
-    "print(dynamic_prompt.format(adjective=\"big and huge and massive\"))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2d007b0a",
-   "metadata": {},
-   "source": [
-    "# Optimized Prompt\n",
-    "\n",
-    "Besides selecting a variable number of examples to show, we can also select examples that most closely match the user input. This is done by creating embeddings of the user input and comparing it embeddings of the examples."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "241bfe80",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts.optimized import OptimizedPrompt\n",
-    "from langchain.vectorstores import FAISS\n",
-    "from langchain.embeddings import OpenAIEmbeddings"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "50d0a701",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "optimized_prompt = OptimizedPrompt.from_structured_examples(\n",
-    "    dict_examples,\n",
-    "    example_prompt,\n",
-    "    prefix=\"Give the antonym of every input\",\n",
-    "    suffix=\"Input: {adjective}\\nOutput:\", \n",
-    "    input_variables=[\"adjective\"],\n",
-    "    embeddings=OpenAIEmbeddings(),\n",
-    "    vectorstore_cls=FAISS\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "id": "4c8fdf45",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: happy\n",
-      "Output: sad\n",
-      "\n",
-      "Input: worried\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Input is a feeling, so should select the happy/sad example\n",
-    "print(optimized_prompt.format(adjective=\"worried\", k=1))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "829af21a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Give the antonym of every input\n",
-      "\n",
-      "Input: tall\n",
-      "Output: short\n",
-      "\n",
-      "Input: fat\n",
-      "Output:\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Input is a measurment, so should select the tall/short example\n",
-    "print(optimized_prompt.format(adjective=\"fat\", k=1))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "76a1065d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/explanation/agents.md

@@ -0,0 +1,29 @@
+# Agents
+
+Agents use an LLM to determine which actions to take and in what order.
+An action can either be using a tool and observing its output, or returning to the user.
+Here are the agents available in LangChain.
+
+For a tutorial on how to load agents, see [here](/getting_started/agents.ipynb).
+
+### `zero-shot-react-description`
+
+This agent uses the ReAct framework to determine which tool to use
+based solely on the tool's description. Any number of tools can be provided.
+This agent requires that a description is provided for each tool.
+
+### `react-docstore`
+
+This agent uses the ReAct framework to interact with a docstore. Two tools must
+be provided: a `Search` tool and a `Lookup` tool (they must be named exactly as so).
+The `Search` tool should search for a document, while the `Lookup` tool should lookup
+a term in the most recently found document.
+This agent is equivalent to the
+original [ReAct paper](https://arxiv.org/pdf/2210.03629.pdf), specifically the Wikipedia example.
+
+### `self-ask-with-search`
+
+This agent utilizes a single tool that should be named `Intermediate Answer`.
+This tool should be able to lookup factual answers to questions. This agent
+is equivalent to the original [self ask with search paper](https://ofir.io/self-ask.pdf),
+where a Google search API was provided as the tool.

docs/explanation/combine_docs.md

@@ -0,0 +1,128 @@
+# Data Augmented Generation
+
+## Overview
+
+Language models are trained on large amounts of unstructured data, which makes them really good at general purpose text generation. However, there are many instances where you may want the language model to generate text based not on generic data but rather on specific data. Some common examples of this include:
+
+- Summarization of a specific piece of text (a website, a private document, etc)
+- Question answering over a specific piece of text (a website, a private document, etc)
+- Question answering over multiple pieces of text (multiple websites, multiple private documents, etc)
+- Using the results of some external call to an API (results from a SQL query, etc)
+
+All of these examples are instances when you do not want the LLM to generate text based solely on the data it was trained over, but rather you want it to incorporate other external data in some way. At a high level, this process can be broken down into two steps:
+
+1. Fetching: Fetching the relevant data to include.
+2. Augmenting: Passing the data in as context to the LLM.
+
+This guide is intended to provide an overview of how to do this. This includes an overview of the literature, as well as common tools, abstractions and chains for doing this.
+
+## Related Literature
+There are a lot of related papers in this area. Most of them are focused on end-to-end methods that optimize the fetching of the relevant data as well as passing it in as context. These are a few of the papers that are particularly relevant:
+
+**[RAG](https://arxiv.org/abs/2005.11401):** Retrieval Augmented Generation. 
+This paper introduces RAG models where the parametric memory is a pre-trained seq2seq model and the non-parametric memory is a dense vector index of Wikipedia, accessed with a pre-trained neural retriever.
+
+**[REALM](https://arxiv.org/abs/2002.08909):** Retrieval-Augmented Language Model Pre-Training. 
+To capture knowledge in a more modular and interpretable way, this paper augments language model pre-training with a latent knowledge retriever, which allows the model to retrieve and attend over documents from a large corpus such as Wikipedia, used during pre-training, fine-tuning and inference.
+
+**[HayStack](https://haystack.deepset.ai/):** This is not a paper, but rather an open source library aimed at semantic search, question answering, summarization, and document ranking for a wide range of NLP applications. The underpinnings of this library are focused on the same `fetching` and `augmenting` concepts discussed here, and incorporate some of the methods in the above papers.
+
+These papers/open-source projects are centered around retrieval of documents, which is important for question-answering tasks over a large corpus of documents (which is how they are evaluated). However, we use the terminology of `Data Augmented Generation` to highlight that retrieval from some document store is only one possible way of fetching relevant data to include. Other methods to fetch relevant data could involve hitting an API, querying a database, or just working with user provided data (eg a specific document that they want to summarize).
+
+Let's now deep dive on the two steps involved: fetching and augmenting.
+
+## Fetching
+There are many ways to fetch relevant data to pass in as context to a LM, and these methods largely depend
+on the use case.
+
+**User provided:** In some cases, the user may provide the relevant data, and no algorithm for fetching is needed.
+An example of this is for summarization of specific documents: the user will provide the document to be summarized,
+and task the language model with summarizing it.
+
+**Document Retrieval:** One of the more common use cases involves fetching relevant documents or pieces of text from
+a large corpus of data. A common example of this is question answering over a private collection of documents.
+
+**API Querying:** Another common way to fetch data is from an API query. One example of this is WebGPT like system,
+where you first query Google (or another search API) for relevant information, and then those results are used in
+the generation step. Another example could be querying a structured database (like SQL) and then using a language model
+to synthesize those results.
+
+There are two big issues to deal with in fetching:
+
+1. Fetching small enough pieces of information
+2. Not fetching too many pieces of information (eg fetching only the most relevant pieces)
+
+### Text Splitting
+One big issue with all of these methods is how to make sure you are working with pieces of text that are not too large.
+This is important because most language models have a context length, and so you cannot (yet) just pass a 
+large document in as context. Therefor, it is important to not only fetch relevant data but also make sure it is
+small enough chunks.
+
+LangChain provides some utilities to help with splitting up larger pieces of data. This comes in the form of the TextSplitter class.
+The class takes in a document and splits it up into chunks, with several parameters that control the
+size of the chunks as well as the overlap in the chunks (important for maintaining context).
+See [this walkthrough](../examples/integrations/textsplitter.ipynb) for more information.
+
+### Relevant Documents
+A second large issue related fetching data is to make sure you are not fetching too many documents, and are only fetching
+the documents that are relevant to the query/question at hand. There are a few ways to deal with this.
+
+One concrete example of this is vector stores for document retrieval, often used for semantic search or question answering.
+With this method, larger documents are split up into
+smaller chunks and then each chunk of text is passed to an embedding function which creates an embedding for that piece of text.
+Those are embeddings are then stored in a database. When a new search query or question comes in, an embedding is
+created for that query/question and then documents with embeddings most similar to that embedding are fetched. 
+Examples of vector database companies include [Pinecone](https://www.pinecone.io/) and [Weaviate](https://weaviate.io/).
+
+Although this is perhaps the most common way of document retrieval, people are starting to think about alternative
+data structures and indexing techniques specifically for working with language models. For a leading example of this,
+check out [GPT Index](https://github.com/jerryjliu/gpt_index) - a collection of data structures created by and optimized
+for language models.
+
+## Augmenting
+So you've fetched your relevant data - now what? How do you pass them to the language model in a format it can understand?
+There are a few different methods, or chains, for doing so. LangChain supports three of the more common ones - and
+we are actively looking to include more, so if you have any ideas please reach out! Note that there is not
+one best method - the decision of which one to use is often very context specific. In order from simplest to
+most complex:
+
+### Stuffing
+Stuffing is the simplest method, whereby you simply stuff all the related data into the prompt as context
+to pass to the language model. This is implemented in LangChain as the `StuffDocumentsChain`.
+
+**Pros:** Only makes a single call to the LLM. When generating text, the LLM has access to all the data at once.
+
+**Cons:** Most LLMs have a context length, and for large documents (or many documents) this will not work as it will result in a prompt larger than the context length.
+
+The main downside of this method is that it only works one smaller pieces of data. Once you are working
+with many pieces of data, this approach is no longer feasible. The next two approaches are designed to help deal with that.
+
+### Map Reduce
+This method involves an initial prompt on each chunk of data (for summarization tasks, this 
+could be a summary of that chunk; for question-answering tasks, it could be an answer based solely on that chunk).
+Then a different prompt is run to combine all the initial outputs. This is implemented in the LangChain as the `MapReduceDocumentsChain`.
+
+**Pros:** Can scale to larger documents (and more documents) than `StuffDocumentsChain`. The calls to the LLM on individual documents are independent and can therefore be parallelized.
+
+**Cons:** Requires many more calls to the LLM than `StuffDocumentsChain`. Loses some information during the final combining call.
+
+### Refine
+This method involves an initial prompt on the first chunk of data, generating some output.
+For the remaining documents, that output is passed in, along with the next document, 
+asking the LLM to refine the output based on the new document. 
+
+**Pros:** Can pull in more relevant context, and may be less lossy than `RefineDocumentsChain`.
+
+**Cons:** Requires many more calls to the LLM than `StuffDocumentsChain`. The calls are also NOT independent, meaning they cannot be paralleled like `MapReduceDocumentsChain`. There is also some potential dependencies on the ordering of the documents.
+
+## Use Cases
+LangChain supports the above three methods of augmenting LLMs with external data.
+These methods can be used to underpin several common use cases and they are discussed below.
+For all three of these use cases, all three methods are supported.
+It is important to note that a large part of these implementations is the prompts
+that are used. We provide default prompts for all three use cases, but these can be configured.
+This is in case you discover a prompt that works better for your specific application.
+
+- [Question-Answering With Sources](../examples/chains/qa_with_sources.ipynb)
+- [Question-Answering](../examples/chains/question_answering.ipynb)
+- [Summarization](../examples/chains/summarize.ipynb)

docs/explanation/cool_demos.md

@@ -0,0 +1,45 @@
+# Cool Demos
+
+Lots of people have built some pretty awesome stuff with LangChain.
+This is a collection of our favorites.
+If you see any other demos that you think we should highlight, be sure to let us know!
+
+## Open Source
+
+### [YouTube Transcription Question Answering with Sources](https://colab.research.google.com/drive/1sKSTjt9cPstl_WMZ86JsgEqFG-aSAwkn?usp=sharing)
+An end-to-end example of doing question answering on YouTube transcripts, returning the timestamps as sources to legitimize the answer.
+
+### [ThoughtSource](https://github.com/OpenBioLink/ThoughtSource)
+A central, open resource and community around data and tools related to chain-of-thought reasoning in large language models.
+
+### [Notion Database Question-Answering Bot](https://github.com/hwchase17/notion-qa)
+Open source GitHub project shows how to use LangChain to create a
+chatbot that can answer questions about an arbitrary Notion database.
+
+### [GPT Index](https://github.com/jerryjliu/gpt_index)
+GPT Index is a project consisting of a set of data structures that are created using GPT-3 and can be traversed using GPT-3 in order to answer queries.
+
+### [Grover's Algorithm](https://github.com/JavaFXpert/llm-grovers-search-party)
+Leveraging Qiskit, OpenAI and LangChain to demonstrate Grover's algorithm
+
+### [ReAct TextWorld](https://colab.research.google.com/drive/19WTIWC3prw5LDMHmRMvqNV2loD9FHls6?usp=sharing)
+Leveraging the ReActTextWorldAgent to play TextWorld with an LLM!
+
+
+## Not Open Source
+
+### [Daimon](https://twitter.com/sjwhitmore/status/1580593217153531908?s=20&t=neQvtZZTlp623U3LZwz3bQ)
+A chat-based AI personal assistant with long-term memory about you.
+
+### [Clerkie](https://twitter.com/krrish_dh/status/1581028925618106368?s=20&t=neQvtZZTlp623U3LZwz3bQ)
+Stack Tracing QA Bot to help debug complex stack tracing (especially the ones that go multi-function/file deep). 
+
+### [Sales Email Writer](https://twitter.com/Raza_Habib496/status/1596880140490838017?s=20&t=6MqEQYWfSqmJwsKahjCVOA)
+By Raza Habib, this demo utilizes LangChain + SerpAPI + HumanLoop to write sales emails.
+Give it a company name and a person, this application will use Google Search (via SerpAPI) to get
+more information on the company and the person, and then write them a sales message.
+
+### [Question-Answering on a Web Browser](https://twitter.com/chillzaza_/status/1592961099384905730?s=20&t=EhU8jl0KyCPJ7vE9Rnz-cQ)
+By Zahid Khawaja, this demo utilizes question answering to answer questions about a given website.
+A followup added this for [Youtube videos](https://twitter.com/chillzaza_/status/1593739682013220865?s=20&t=EhU8jl0KyCPJ7vE9Rnz-cQ),
+and then another followup added it for [Wikipedia](https://twitter.com/chillzaza_/status/1594847151238037505?s=20&t=EhU8jl0KyCPJ7vE9Rnz-cQ).

docs/explanation/core_concepts.md

@@ -3,11 +3,13 @@
 This section goes over the core concepts of LangChain.
 Understanding these will go a long way in helping you understand the codebase and how to construct chains.
 
-## Prompts
-Prompts generically have a `format` method that takes in variables and returns a formatted string.
+## PromptTemplates
+PromptTemplates generically have a `format` method that takes in variables and returns a formatted string.
 The most simple implementation of this is to have a template string with some variables in it, and then format it with the incoming variables.
 More complex iterations dynamically construct the template string from few shot examples, etc.
 
+For a more detailed explanation of how LangChain approaches prompts and prompt templates, see [here](/examples/prompts/prompt_management).
+
 ## LLMs
 Wrappers around Large Language Models (in particular, the `generate` ability of large language models) are some of the core functionality of LangChain.
 These wrappers are classes that are callable: they take in an input string, and return the generated output string.
@@ -23,3 +25,13 @@ These are datastores that store documents. They expose a method for passing in a
 ## Chains
 These are pipelines that combine multiple of the above ideas. 
 They vary greatly in complexity and are combination of generic, highly configurable pipelines and more narrow (but usually more complex) pipelines.
+
+## Agents
+As opposed to a chain, whether the steps to be taken are known ahead of time, agents
+use an LLM to determine which tools to call and in what order.
+
+## Memory
+By default, Chains and Agents are stateless, meaning that they treat each incoming query independently.
+In some applications (chatbots being a GREAT example) it is highly important to remember previous interactions,
+both at a short term but also at a long term level. The concept of "Memory" exists to do exactly that.
+

docs/explanation/glossary.md

@@ -29,7 +29,7 @@ This induces the to model to think about what action to take, then take it.
 
 Resources:
 - [Paper](https://arxiv.org/pdf/2210.03629.pdf)
-- [LangChain Example](https://github.com/hwchase17/langchain/blob/master/examples/react.ipynb)
+- [LangChain Example](https://github.com/hwchase17/langchain/blob/master/docs/examples/agents/react.ipynb)
 
 ### Self-ask
 
@@ -38,7 +38,7 @@ In this method, the model explicitly asks itself follow-up questions, which are
 
 Resources:
 - [Paper](https://ofir.io/self-ask.pdf)
-- [LangChain Example](https://github.com/hwchase17/langchain/blob/master/examples/self_ask_with_search.ipynb)
+- [LangChain Example](https://github.com/hwchase17/langchain/blob/master/docs/examples/agents/self_ask_with_search.ipynb)
 
 ### Prompt Chaining
 
@@ -72,3 +72,10 @@ Encouraging the model to think a certain way by including the start of the model
 
 Resources:
 - [Example](https://twitter.com/goodside/status/1583262455207460865?s=20&t=8Hz7XBnK1OF8siQrxxCIGQ)
+
+### MemPrompt
+
+MemPrompt maintains a memory of errors and user feedback, and uses them to prevent repetition of mistakes.
+
+Resources:
+- [Paper](https://memprompt.com/)

docs/getting_started/agents.ipynb

@@ -0,0 +1,196 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5436020b",
+   "metadata": {},
+   "source": [
+    "# Agents\n",
+    "\n",
+    "Agents use an LLM to determine which actions to take and in what order.\n",
+    "An action can either be using a tool and observing its output, or returning to the user.\n",
+    "\n",
+    "When used correctly agents can be extremely powerful. The purpose of this notebook is to show you how to easily use agents through the simplest, highest level API. If you want more low level control over various components, check out the documentation for custom agents (coming soon)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c6226b9",
+   "metadata": {},
+   "source": [
+    "## Concepts\n",
+    "\n",
+    "In order to load agents, you should understand the following concepts:\n",
+    "\n",
+    "- Tool: A function that performs a specific duty. This can be things like: Google Search, Database lookup, Python REPL, other chains. The interface for a tool is currently a function that is expected to have a string as an input, with a string as an output.\n",
+    "- LLM: The language model powering the agent.\n",
+    "- Agent: The agent to use. This should be a string that references a support agent class. Because this notebook focuses on the simplest, highest level API, this only covers using the standard supported agents. If you want to implement a custom agent, see the documentation for custom agents (coming soon).\n",
+    "\n",
+    "**For a list of supported agents and their specifications, see [here](../explanation/agents.md)**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05d4b21e",
+   "metadata": {},
+   "source": [
+    "## Tools\n",
+    "When constructing your own agent, you will need to provide it with a list of Tools that it can use. A Tool is defined as below.\n",
+    "\n",
+    "```python\n",
+    "class Tool(NamedTuple):\n",
+    "    \"\"\"Interface for tools.\"\"\"\n",
+    "\n",
+    "    name: str\n",
+    "    func: Callable[[str], str]\n",
+    "    description: Optional[str] = None\n",
+    "```\n",
+    "\n",
+    "The two required components of a Tool are the name and then the tool itself. A tool description is optional, as it is needed for some agents but not all."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2558a02d",
+   "metadata": {},
+   "source": [
+    "## Loading an agent\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "36ed392e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import things that are needed generically\n",
+    "from langchain.agents import initialize_agent, Tool\n",
+    "from langchain.llms import OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "56ff7670",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the tool configs that are needed.\n",
+    "from langchain import LLMMathChain, SerpAPIWrapper\n",
+    "llm = OpenAI(temperature=0)\n",
+    "search = SerpAPIWrapper()\n",
+    "llm_math_chain = LLMMathChain(llm=llm, verbose=True)\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=\"Calculator\",\n",
+    "        func=llm_math_chain.run,\n",
+    "        description=\"useful for when you need to answer questions about math\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5b93047d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Construct the agent. We will use the default agent type here.\n",
+    "# See documentation for a full list of options.\n",
+    "llm = OpenAI(temperature=0)\n",
+    "agent = initialize_agent(tools, llm, agent=\"zero-shot-react-description\", verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6f96a891",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "What is the age of Olivia Wilde's boyfriend raised to the 0.23 power?\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to find the age of Olivia Wilde's boyfriend\n",
+      "Action: Search\n",
+      "Action Input: \"Olivia Wilde's boyfriend\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mOlivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to find the age of Harry Styles\n",
+      "Action: Search\n",
+      "Action Input: \"Harry Styles age\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3m28 years\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to calculate 28 to the 0.23 power\n",
+      "Action: Calculator\n",
+      "Action Input: 28^0.23\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "28^0.23\u001b[32;1m\u001b[1;3m\n",
+      "\n",
+      "```python\n",
+      "print(28**0.23)\n",
+      "```\n",
+      "\u001b[0m\n",
+      "Answer: \u001b[33;1m\u001b[1;3m2.1520202182226886\n",
+      "\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "Observation: \u001b[33;1m\u001b[1;3mAnswer: 2.1520202182226886\n",
+      "\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: 2.1520202182226886\u001b[0m"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'2.1520202182226886'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent.run(\"How old is Olivia Wilde's boyfriend? What is that number raised to the 0.23 power?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2f0852ff",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/getting_started/llm.md

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

docs/getting_started/llm_chain.md

@@ -1,4 +1,4 @@
-# Using Chains
+# LLM Chains
 
 Calling an LLM is a great first step, but it's just the beginning.
 Normally when you use an LLM in an application, you are not sending user input directly to the LLM.
@@ -12,9 +12,10 @@ This is easy to do with LangChain!
 First lets define the prompt:
 
 ```python
-from langchain.prompts import Prompt
-prompt = Prompt(
-    input_variables=["product"], 
+from langchain.prompts import PromptTemplate
+
+prompt = PromptTemplate(
+    input_variables=["product"],
     template="What is a good name for a company that makes {product}?",
 )
 ```
@@ -26,13 +27,11 @@ from langchain.chains import LLMChain
 chain = LLMChain(llm=llm, prompt=prompt)
 ```
 
-Now we can run that can only specifying the product!
+Now we can run that chain only specifying the product!
 
 ```python
 chain.run("colorful socks")
 ```
 
-There we go! There's the first chain.
-
-That is it for the Getting Started example. 
-As a next step, we would suggest checking out the more complex chains in the [Demos section](/examples/demos.rst)
+There we go! There's the first chain - an LLM Chain.
+This is one of the simpler types of chains, but understanding how it works will set you up well for working with more complex chains.

docs/getting_started/memory.ipynb

@@ -0,0 +1,333 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "d31df93e",
+      "metadata": {},
+      "source": [
+        "# Memory\n",
+        "So far, all the chains and agents we've gone through have been stateless. But often, you may want a chain or agent to have some concept of \"memory\" so that it may remember information about its previous interactions. The clearest and simple example of this is when designing a chatbot - you want it to remember previous messages so it can use context from that to have a better conversation. This would be a type of \"short-term memory\". On the more complex side, you could imagine a chain/agent remembering key pieces of information over time - this would be a form of \"long-term memory\". For more concrete ideas on the latter, see this [awesome paper](https://memprompt.com/).\n",
+        "\n",
+        "LangChain provides several specially created chains just for this purpose. This notebook walks through using one of those chains (the `ConversationChain`) with two different types of memory."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "d051c1da",
+      "metadata": {},
+      "source": [
+        "### ConversationChain with default memory\n",
+        "By default, the `ConversationChain` has a simple type of memory that remembers all previous inputs/outputs and adds them to the context that is passed. Let's take a look at using this chain (setting `verbose=True` so we can see the prompt)."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "ae046bff",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "\n",
+            "\u001b[1m> Entering new chain...\u001b[0m\n",
+            "Prompt after formatting:\n",
+            "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
+            "\n",
+            "Current conversation:\n",
+            "\n",
+            "Human: Hi there!\n",
+            "AI:\u001b[0m\n",
+            "\n",
+            "\u001b[1m> Finished chain.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "' Hello! How are you today?'"
+            ]
+          },
+          "execution_count": 1,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "from langchain import OpenAI, ConversationChain\n",
+        "\n",
+        "llm = OpenAI(temperature=0)\n",
+        "conversation = ConversationChain(llm=llm, verbose=True)\n",
+        "\n",
+        "conversation.predict(input=\"Hi there!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "d8e2a6ff",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "\n",
+            "\u001b[1m> Entering new chain...\u001b[0m\n",
+            "Prompt after formatting:\n",
+            "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
+            "\n",
+            "Current conversation:\n",
+            "\n",
+            "Human: Hi there!\n",
+            "AI:  Hello! How are you today?\n",
+            "Human: I'm doing well! Just having a conversation with an AI.\n",
+            "AI:\u001b[0m\n",
+            "\n",
+            "\u001b[1m> Finished chain.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "\" That's great! What would you like to talk about?\""
+            ]
+          },
+          "execution_count": 2,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "conversation.predict(input=\"I'm doing well! Just having a conversation with an AI.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "15eda316",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "\n",
+            "\u001b[1m> Entering new chain...\u001b[0m\n",
+            "Prompt after formatting:\n",
+            "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
+            "\n",
+            "Current conversation:\n",
+            "\n",
+            "Human: Hi there!\n",
+            "AI:  Hello! How are you today?\n",
+            "Human: I'm doing well! Just having a conversation with an AI.\n",
+            "AI:  That's great! What would you like to talk about?\n",
+            "Human: Tell me about yourself.\n",
+            "AI:\u001b[0m\n",
+            "\n",
+            "\u001b[1m> Finished chain.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "'  I am an AI created to provide information and support to humans. I enjoy learning and exploring new things.'"
+            ]
+          },
+          "execution_count": 3,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "conversation.predict(input=\"Tell me about yourself.\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "4fad9448",
+      "metadata": {},
+      "source": [
+        "### ConversationChain with ConversationSummaryMemory\n",
+        "Now let's take a look at using a slightly more complex type of memory - `ConversationSummaryMemory`. This type of memory creates a summary of the conversation over time. This can be useful for condensing information from the conversation over time.\n",
+        "\n",
+        "Let's walk through an example, again setting `verbose=True` so we can see the prompt."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "f60a2fe8",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from langchain.chains.conversation.memory import ConversationSummaryMemory"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "b7274f2c",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "\n",
+            "\u001b[1m> Entering new chain...\u001b[0m\n",
+            "Prompt after formatting:\n",
+            "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
+            "\n",
+            "Current conversation:\n",
+            "\n",
+            "Human: Hi, what's up?\n",
+            "AI:\u001b[0m\n",
+            "\n",
+            "\u001b[1m> Finished chain.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "\"\\n\\nI'm doing well, thank you for asking. I'm currently working on a project that I'm really excited about.\""
+            ]
+          },
+          "execution_count": 5,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "conversation_with_summary = ConversationChain(llm=llm, memory=ConversationSummaryMemory(llm=OpenAI()), verbose=True)\n",
+        "conversation_with_summary.predict(input=\"Hi, what's up?\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "id": "a6b6b88f",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "\n",
+            "\u001b[1m> Entering new chain...\u001b[0m\n",
+            "Prompt after formatting:\n",
+            "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
+            "\n",
+            "Current conversation:\n",
+            "\n",
+            "The human and artificial intelligence are talking. The human asked the AI what it is doing, and the AI said that it is working on a project that it is excited about.\n",
+            "Human: Tell me more about it!\n",
+            "AI:\u001b[0m\n",
+            "\n",
+            "\u001b[1m> Finished chain.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "\"\\n\\nI'm working on a project that I'm really excited about. It's a lot of work, but I think it's going to be really great when it's finished. I can't wait to show it to you!\""
+            ]
+          },
+          "execution_count": 6,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "conversation_with_summary.predict(input=\"Tell me more about it!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "id": "dad869fe",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "\n",
+            "\u001b[1m> Entering new chain...\u001b[0m\n",
+            "Prompt after formatting:\n",
+            "\u001b[32;1m\u001b[1;3mThe following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n",
+            "\n",
+            "Current conversation:\n",
+            "\n",
+            "\n",
+            "The human and artificial intelligence are talking. The human asked the AI what it is doing, and the AI said that it is working on a project that it is excited about. The AI said that the project is a lot of work, but it is going to be great when it is finished.\n",
+            "Human: Very cool -- what is the scope of the project?\n",
+            "AI:\u001b[0m\n",
+            "\n",
+            "\u001b[1m> Finished chain.\u001b[0m\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "'\\n\\nThe project is quite large in scope. It involves a lot of data analysis and work with artificial intelligence algorithms.'"
+            ]
+          },
+          "execution_count": 7,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "conversation_with_summary.predict(input=\"Very cool -- what is the scope of the project?\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "5c8735cc",
+      "metadata": {},
+      "source": [
+        "### More Resources on Memory\n",
+        "\n",
+        "This just scratches the surface of what you can do with memory. For more examples on things like how to implement custom memory classes, how to add memory to a custom LLM chain and how to use memory with an agent, please see the [How-To: Memory](../../examples/memory) section. For even more advanced ideas on memory (which will hopefully be included in LangChain soon!) see the [MemPrompt](https://memprompt.com/) paper."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "436dda66",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.1"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

docs/getting_started/sequential_chains.ipynb

@@ -0,0 +1,265 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4f73605d",
+   "metadata": {},
+   "source": [
+    "# Sequential Chains"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3b235f7a",
+   "metadata": {},
+   "source": [
+    "The next step after calling a language model is make a series of calls to a language model. This is particularly useful when you want to take the output from one call and use it as the input to another.\n",
+    "\n",
+    "In this notebook we will walk through some examples for how to do this, using sequential chains. Sequential chains are defined as a series of chains, called in deterministic order. There are two types of sequential chains:\n",
+    "\n",
+    "- `SimpleSequentialChain`: The simplest form of sequential chains, where each step has a singular input/output, and the output of one step is the input to the next.\n",
+    "- `SequentialChain`: A more general form of sequential chains, allowing for multiple inputs/outputs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5162794e",
+   "metadata": {},
+   "source": [
+    "## SimpleSequentialChain\n",
+    "\n",
+    "In this series of chains, each individual chain has a single input and a single output, and the output of one step is used as input to the next.\n",
+    "\n",
+    "Let's walk through a toy example of doing this, where the first chain takes in the title of an imaginary play and then generates a synopsis for that title, and the second chain takes in the synopsis of that play and generates an imaginary review for that play."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3f2f9b8c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.prompts import PromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b8237d1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is an LLMChain to write a synopsis given a title of a play.\n",
+    "llm = OpenAI(temperature=.7)\n",
+    "template = \"\"\"You are a playwright. Given the title of play, it is your job to write a synopsis for that title.\n",
+    "\n",
+    "Title: {title}\n",
+    "Playwright: This is a synopsis for the above play:\"\"\"\n",
+    "prompt_template = PromptTemplate(input_variables=[\"title\"], template=template)\n",
+    "synopsis_chain = LLMChain(llm=llm, prompt=prompt_template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4a391730",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is an LLMChain to write a review of a play given a synopsis.\n",
+    "llm = OpenAI(temperature=.7)\n",
+    "template = \"\"\"You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.\n",
+    "\n",
+    "Play Synopsis:\n",
+    "{synopsis}\n",
+    "Review from a New York Times play critic of the above play:\"\"\"\n",
+    "prompt_template = PromptTemplate(input_variables=[\"synopsis\"], template=template)\n",
+    "review_chain = LLMChain(llm=llm, prompt=prompt_template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9368bd63",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is the overall chain where we run these two chains in sequence.\n",
+    "from langchain.chains import SimpleSequentialChain\n",
+    "overall_chain = SimpleSequentialChain(chains=[synopsis_chain, review_chain], verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d39e15f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "\u001b[36;1m\u001b[1;3m\n",
+      "\n",
+      "A young couple, John and Mary, are enjoying a day at the beach. As the sun sets, they share a romantic moment. However, their happiness is short-lived, as a tragic accident claims John's life. Mary is left devastated by the loss of her husband.\u001b[0m\n",
+      "\u001b[33;1m\u001b[1;3m\n",
+      "\n",
+      "\"A young couple's happiness is cut short by tragedy in this moving play. Mary is left devastated by the loss of her husband, John, in a freak accident. The play captures the pain and grief of loss, as well as the strength of love. A must-see for fans of theater.\"\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "review = overall_chain.run(\"Tragedy at sunset on the beach\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "c6649a01",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\"A young couple's happiness is cut short by tragedy in this moving play. Mary is left devastated by the loss of her husband, John, in a freak accident. The play captures the pain and grief of loss, as well as the strength of love. A must-see for fans of theater.\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(review)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3f1549a",
+   "metadata": {},
+   "source": [
+    "## Sequential Chain\n",
+    "Of course, not all sequential chains will be as simple as passing a single string as an argument and getting a single string as output for all steps in the chain. In this next example, we will experiment with more complex chains that involve multiple inputs, and where there also multiple final outputs. \n",
+    "\n",
+    "Of particular importance is how we name the input/output variable names. In the above example we didn't have to think about that because we were just passing the output of one chain directly as input to the next, but here we do have worry about that because we have multiple inputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "02016a51",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is an LLMChain to write a synopsis given a title of a play and the era it is set in.\n",
+    "llm = OpenAI(temperature=.7)\n",
+    "template = \"\"\"You are a playwright. Given the title of play and the era it is set in, it is your job to write a synopsis for that title.\n",
+    "\n",
+    "Title: {title}\n",
+    "Era: {era}\n",
+    "Playwright: This is a synopsis for the above play:\"\"\"\n",
+    "prompt_template = PromptTemplate(input_variables=[\"title\", 'era'], template=template)\n",
+    "synopsis_chain = LLMChain(llm=llm, prompt=prompt_template, output_key=\"synopsis\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8bd38cc2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is an LLMChain to write a review of a play given a synopsis.\n",
+    "llm = OpenAI(temperature=.7)\n",
+    "template = \"\"\"You are a play critic from the New York Times. Given the synopsis of play, it is your job to write a review for that play.\n",
+    "\n",
+    "Play Synopsis:\n",
+    "{synopsis}\n",
+    "Review from a New York Times play critic of the above play:\"\"\"\n",
+    "prompt_template = PromptTemplate(input_variables=[\"synopsis\"], template=template)\n",
+    "review_chain = LLMChain(llm=llm, prompt=prompt_template, output_key=\"review\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "524523af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is the overall chain where we run these two chains in sequence.\n",
+    "from langchain.chains import SequentialChain\n",
+    "overall_chain = SequentialChain(\n",
+    "    chains=[synopsis_chain, review_chain],\n",
+    "    input_variables=[\"era\", \"title\"],\n",
+    "    # Here we return multiple variables\n",
+    "    output_variables=[\"synopsis\", \"review\"],\n",
+    "    verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "3fd3a7be",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new chain...\u001b[0m\n",
+      "\u001b[1mChain 0\u001b[0m:\n",
+      "{'synopsis': \"\\n\\nThe play is set in Victorian England and follows the tragic story of a young woman who drowns while swimming at sunset on the beach. Her body is found the next morning by a fisherman who raises the alarm. The young woman's family and friends are devastated by her death and the play ends with their mourning her loss.\"}\n",
+      "\n",
+      "\u001b[1mChain 1\u001b[0m:\n",
+      "{'review': '\\n\\n\"The play is a tragedy, pure and simple. It is the story of a young woman\\'s death, told through the eyes of those who loved her. It is a sad, beautiful play that will stay with you long after you\\'ve seen it. The acting is superb, and the writing is exquisite. If you are looking for a play that will touch your heart and make you think, this is it.\"'}\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "review = overall_chain({\"title\":\"Tragedy at sunset on the beach\", \"era\": \"Victorian England\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6be70d27",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/index.rst

@@ -8,12 +8,88 @@ create a truly powerful app - the real power comes when you are able to
 combine them with other sources of computation or knowledge.
 
 This library is aimed at assisting in the development of those types of applications.
-It aims to create:
 
-1. a comprehensive collection of pieces you would ever want to combine
-2. a flexible interface for combining pieces into a single comprehensive "chain"
-3. a schema for easily saving and sharing those chains
+There are four main areas that LangChain is designed to help with.
+These are, in increasing order of complexity:
 
+1. LLM and Prompts
+2. Chains
+3. Agents
+4. Memory
+
+Let's go through these categories and for each one identify key concepts (to clarify terminology) as well as the problems in this area LangChain helps solve.
+
+**🦜 LLMs and Prompts**
+
+Calling out to an LLM once is pretty easy, with most of them being behind well documented APIs.
+However, there are still some challenges going from that to an application running in production that LangChain attempts to address.
+
+*Key Concepts*
+
+- LLM: A large language model, in particular a text-to-text model.
+- Prompt: The input to a language model. Typically this is not simply a hardcoded string but rather a combination of a template, some examples, and user input.
+- Prompt Template: An object responsible for constructing the final prompt to pass to a LLM.
+
+*Problems Solved*
+
+- Switching costs: by exposing a standard interface for all the top LLM providers, LangChain makes it easy to switch from one provider to another, whether it be for production use cases or just for testing stuff out.
+- Prompt management: managing your prompts is easy when you only have one simple one, but can get tricky when you have a bunch or when they start to get more complex. LangChain provides a standard way for storing, constructing, and referencing prompts.
+- Prompt optimization: despite the underlying models getting better and better, there is still currently a need for carefully constructing prompts.
+
+**🔗️ Chains**
+
+Using an LLM in isolation is fine for some simple applications, but many more complex ones require chaining LLMs - either with eachother or with other experts.
+LangChain provides several parts to help with that.
+
+*Key Concepts*
+
+- Tools: APIs designed for assisting with a particular use case (search, databases, Python REPL, etc). Prompt templates, LLMs, and chains can also be considered tools.
+- Chains: A combination of multiple tools in a deterministic manner.
+
+*Problems Solved*
+
+- Standard interface for working with Chains
+- Easy way to construct chains of LLMs
+- Lots of integrations with other tools that you may want to use in conjunction with LLMs
+- End-to-end chains for common workflows (database question/answer, recursive summarization, etc)
+
+**🤖 Agents**
+
+Some applications will require not just a predetermined chain of calls to LLMs/other tools, but potentially an unknown chain that depends on the user input.
+In these types of chains, there is a “agent” which has access to a suite of tools.
+Depending on the user input, the agent can then decide which, if any, of these tools to call.
+
+*Key Concepts*
+
+- Tools: same as above.
+- Agent: An LLM-powered class responsible for determining which tools to use and in what order.
+
+
+*Problems Solved*
+
+- Standard agent interfaces
+- A selection of powerful agents to choose from
+- Common chains that can be used as tools
+
+**🧠 Memory**
+
+By default, Chains and Agents are stateless, meaning that they treat each incoming query independently.
+In some applications (chatbots being a GREAT example) it is highly important to remember previous interactions,
+both at a short term but also at a long term level. The concept of "Memory" exists to do exactly that.
+
+*Key Concepts*
+
+- Memory: A class that can be added to an Agent or Chain to (1) pull in memory variables before calling that chain/agent, and (2) create new memories after the chain/agent finishes.
+- Memory Variables: Variables returned from a Memory class, to be passed into the chain/agent along with the user input.
+
+*Problems Solved*
+
+- Standard memory interfaces
+- A collection of common memory implementations to choose from
+- Common chains/agents that use memory (e.g. chatbots)
+
+Documentation Structure
+=======================
 The documentation is structured into the following sections:
 
 
@@ -25,7 +101,10 @@ The documentation is structured into the following sections:
    getting_started/installation.md
    getting_started/environment.md
    getting_started/llm.md
-   getting_started/chains.md
+   getting_started/llm_chain.md
+   getting_started/sequential_chains.md
+   getting_started/agents.ipynb
+   getting_started/memory.ipynb
 
 Goes over a simple walk through and tutorial for getting started setting up a simple chain that generates a company name based on what the company makes.
 Covers installation, environment set up, calling LLMs, and using prompts.
@@ -37,9 +116,11 @@ Start here if you haven't used LangChain before.
    :caption: How-To Examples
    :name: examples
 
-   examples/demos.rst
-   examples/integrations.rst
    examples/prompts.rst
+   examples/integrations.rst
+   examples/chains.rst
+   examples/agents.rst
+   examples/memory.rst
    examples/model_laboratory.ipynb
 
 More elaborate examples and walk-throughs of particular
@@ -56,11 +137,16 @@ common tasks or cool demos.
    installation.md
    integrations.md
    modules/prompt
+   modules/example_selector
    modules/llms
    modules/embeddings
    modules/text_splitter
+   modules/python.rst
+   modules/serpapi.rst
+   modules/docstore.rst
    modules/vectorstore
    modules/chains
+   modules/agents
 
 
 Full API documentation. This is the place to look if you want to
@@ -72,8 +158,11 @@ see detailed information about the various classes, methods, and APIs.
    :caption: Resources
    :name: resources
 
-   core_concepts.md
-   glossary.md
+   explanation/core_concepts.md
+   explanation/combine_docs.md
+   explanation/agents.md
+   explanation/glossary.md
+   explanation/cool_demos.md
    Discord <https://discord.gg/6adMQxSpJS>
 
 Higher level, conceptual explanations of the LangChain components.

docs/installation.md

@@ -21,4 +21,10 @@ To install all modules needed for all integrations, run:
 
 ```
 pip install langchain[all]
+```
+
+Note that if you are using `zsh`, you'll need to quote square brackets when passing them as an argument to a command, for example:
+
+```
+pip install 'langchain[all]'
 ```

docs/modules/agents.rst

@@ -0,0 +1,7 @@
+:mod:`langchain.agents`
+===============================
+
+.. automodule:: langchain.agents
+   :members:
+   :undoc-members:
+

docs/modules/docstore.rst

@@ -0,0 +1,6 @@
+:mod:`langchain.docstore`
+=============================
+
+.. automodule:: langchain.docstore
+   :members:
+   :undoc-members:

docs/modules/example_selector.rst

@@ -0,0 +1,5 @@
+:mod:`langchain.prompts.example_selector`
+=========================================
+
+.. automodule:: langchain.prompts.example_selector
+   :members:

docs/modules/python.rst

@@ -0,0 +1,6 @@
+:mod:`langchain.python`
+=============================
+
+.. automodule:: langchain.python
+   :members:
+   :undoc-members:

docs/modules/serpapi.rst

@@ -0,0 +1,6 @@
+:mod:`langchain.serpapi`
+=============================
+
+.. automodule:: langchain.serpapi
+   :members:
+   :undoc-members:

docs/requirements.txt

@@ -6,3 +6,4 @@ sphinx-autobuild==2021.3.14
 sphinx_rtd_theme==1.0.0
 sphinx-typlog-theme==0.8.0
 sphinx-panels
+toml

langchain/VERSION

@@ -1 +0,0 @@
-0.0.14

langchain/__init__.py

@@ -1,45 +1,66 @@
 """Main entrypoint into package."""
 
-from pathlib import Path
-
-with open(Path(__file__).absolute().parents[0] / "VERSION") as _f:
-    __version__ = _f.read().strip()
+from typing import Optional
 
+from langchain.agents import MRKLChain, ReActChain, SelfAskWithSearchChain
+from langchain.cache import BaseCache
 from langchain.chains import (
+    ConversationChain,
+    LLMBashChain,
     LLMChain,
+    LLMCheckerChain,
     LLMMathChain,
-    MRKLChain,
-    PythonChain,
-    ReActChain,
-    SelfAskWithSearchChain,
-    SerpAPIChain,
+    PALChain,
+    QAWithSourcesChain,
     SQLDatabaseChain,
     VectorDBQA,
+    VectorDBQAWithSourcesChain,
 )
-from langchain.docstore import Wikipedia
+from langchain.docstore import InMemoryDocstore, Wikipedia
 from langchain.llms import Cohere, HuggingFaceHub, OpenAI
-from langchain.prompts import BasePrompt, DynamicPrompt, Prompt
+from langchain.llms.huggingface_pipeline import HuggingFacePipeline
+from langchain.logger import BaseLogger, StdOutLogger
+from langchain.prompts import (
+    BasePromptTemplate,
+    FewShotPromptTemplate,
+    Prompt,
+    PromptTemplate,
+)
+from langchain.serpapi import SerpAPIChain, SerpAPIWrapper
 from langchain.sql_database import SQLDatabase
 from langchain.vectorstores import FAISS, ElasticVectorSearch
 
+logger: BaseLogger = StdOutLogger()
+verbose: bool = False
+llm_cache: Optional[BaseCache] = None
+
 __all__ = [
     "LLMChain",
+    "LLMBashChain",
+    "LLMCheckerChain",
     "LLMMathChain",
-    "PythonChain",
     "SelfAskWithSearchChain",
+    "SerpAPIWrapper",
     "SerpAPIChain",
     "Cohere",
     "OpenAI",
-    "BasePrompt",
-    "DynamicPrompt",
+    "BasePromptTemplate",
     "Prompt",
+    "FewShotPromptTemplate",
+    "PromptTemplate",
     "ReActChain",
     "Wikipedia",
     "HuggingFaceHub",
+    "HuggingFacePipeline",
     "SQLDatabase",
     "SQLDatabaseChain",
     "FAISS",
     "MRKLChain",
     "VectorDBQA",
     "ElasticVectorSearch",
+    "InMemoryDocstore",
+    "ConversationChain",
+    "VectorDBQAWithSourcesChain",
+    "QAWithSourcesChain",
+    "PALChain",
 ]

langchain/agents/__init__.py

@@ -0,0 +1,18 @@
+"""Routing chains."""
+from langchain.agents.agent import Agent
+from langchain.agents.loading import initialize_agent
+from langchain.agents.mrkl.base import MRKLChain, ZeroShotAgent
+from langchain.agents.react.base import ReActChain, ReActTextWorldAgent
+from langchain.agents.self_ask_with_search.base import SelfAskWithSearchChain
+from langchain.agents.tools import Tool
+
+__all__ = [
+    "MRKLChain",
+    "SelfAskWithSearchChain",
+    "ReActChain",
+    "Agent",
+    "Tool",
+    "initialize_agent",
+    "ZeroShotAgent",
+    "ReActTextWorldAgent",
+]

langchain/agents/agent.py

@@ -0,0 +1,165 @@
+"""Chain that takes in an input and produces an action and action input."""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar, Dict, List, Optional, Tuple
+
+from pydantic import BaseModel, root_validator
+
+from langchain.agents.input import ChainedInput
+from langchain.agents.tools import Tool
+from langchain.chains.base import Chain
+from langchain.chains.llm import LLMChain
+from langchain.input import get_color_mapping
+from langchain.llms.base import LLM
+from langchain.prompts.base import BasePromptTemplate
+from langchain.schema import AgentAction
+
+
+class Agent(Chain, BaseModel, ABC):
+    """Agent that uses an LLM."""
+
+    prompt: ClassVar[BasePromptTemplate]
+    llm_chain: LLMChain
+    tools: List[Tool]
+    input_key: str = "input"  #: :meta private:
+    output_key: str = "output"  #: :meta private:
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Return the input keys.
+
+        :meta private:
+        """
+        return list(set(self.llm_chain.input_keys) - {"agent_scratchpad"})
+
+    @property
+    def output_keys(self) -> List[str]:
+        """Return the singular output key.
+
+        :meta private:
+        """
+        return [self.output_key]
+
+    @root_validator()
+    def validate_prompt(cls, values: Dict) -> Dict:
+        """Validate that prompt matches format."""
+        prompt = values["llm_chain"].prompt
+        if "agent_scratchpad" not in prompt.input_variables:
+            raise ValueError(
+                "`agent_scratchpad` should be a variable in prompt.input_variables"
+            )
+        return values
+
+    @property
+    @abstractmethod
+    def observation_prefix(self) -> str:
+        """Prefix to append the observation with."""
+
+    @property
+    @abstractmethod
+    def llm_prefix(self) -> str:
+        """Prefix to append the LLM call with."""
+
+    @property
+    def finish_tool_name(self) -> str:
+        """Name of the tool to use to finish the chain."""
+        return "Final Answer"
+
+    @property
+    def starter_string(self) -> str:
+        """Put this string after user input but before first LLM call."""
+        return "\n"
+
+    @abstractmethod
+    def _extract_tool_and_input(self, text: str) -> Optional[Tuple[str, str]]:
+        """Extract tool and tool input from llm output."""
+
+    def _fix_text(self, text: str) -> str:
+        """Fix the text."""
+        raise ValueError("fix_text not implemented for this agent.")
+
+    @property
+    def _stop(self) -> List[str]:
+        return [f"\n{self.observation_prefix}"]
+
+    @classmethod
+    def _validate_tools(cls, tools: List[Tool]) -> None:
+        """Validate that appropriate tools are passed in."""
+        pass
+
+    @classmethod
+    def create_prompt(cls, tools: List[Tool]) -> BasePromptTemplate:
+        """Create a prompt for this class."""
+        return cls.prompt
+
+    def _prepare_for_new_call(self) -> None:
+        pass
+
+    @classmethod
+    def from_llm_and_tools(cls, llm: LLM, tools: List[Tool], **kwargs: Any) -> Agent:
+        """Construct an agent from an LLM and tools."""
+        cls._validate_tools(tools)
+        llm_chain = LLMChain(llm=llm, prompt=cls.create_prompt(tools))
+        return cls(llm_chain=llm_chain, tools=tools, **kwargs)
+
+    def get_action(self, thoughts: str, inputs: dict) -> AgentAction:
+        """Given input, decided what to do.
+
+        Args:
+            thoughts: LLM thoughts
+            inputs: user inputs
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        new_inputs = {"agent_scratchpad": thoughts, "stop": self._stop}
+        full_inputs = {**inputs, **new_inputs}
+        full_output = self.llm_chain.predict(**full_inputs)
+        parsed_output = self._extract_tool_and_input(full_output)
+        while parsed_output is None:
+            full_output = self._fix_text(full_output)
+            full_inputs["agent_scratchpad"] += full_output
+            output = self.llm_chain.predict(**full_inputs)
+            full_output += output
+            parsed_output = self._extract_tool_and_input(full_output)
+        tool, tool_input = parsed_output
+        return AgentAction(tool, tool_input, full_output)
+
+    def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
+        """Run text through and get agent response."""
+        # Do any preparation necessary when receiving a new input.
+        self._prepare_for_new_call()
+        # Construct a mapping of tool name to tool for easy lookup
+        name_to_tool_map = {tool.name: tool.func for tool in self.tools}
+        # We use the ChainedInput class to iteratively add to the input over time.
+        chained_input = ChainedInput(self.llm_prefix, verbose=self.verbose)
+        # We construct a mapping from each tool to a color, used for logging.
+        color_mapping = get_color_mapping(
+            [tool.name for tool in self.tools], excluded_colors=["green"]
+        )
+        # We now enter the agent loop (until it returns something).
+        while True:
+            # Call the LLM to see what to do.
+            output = self.get_action(chained_input.input, inputs)
+            # Add the log to the Chained Input.
+            chained_input.add_action(output, color="green")
+            # If the tool chosen is the finishing tool, then we end and return.
+            if output.tool == self.finish_tool_name:
+                return {self.output_key: output.tool_input}
+            # Otherwise we lookup the tool
+            if output.tool in name_to_tool_map:
+                chain = name_to_tool_map[output.tool]
+                # We then call the tool on the tool input to get an observation
+                observation = chain(output.tool_input)
+                color = color_mapping[output.tool]
+            else:
+                observation = f"{output.tool} is not a valid tool, try another one."
+                color = None
+            # We then log the observation
+            chained_input.add_observation(
+                observation,
+                self.observation_prefix,
+                self.llm_prefix,
+                color=color,
+            )

langchain/agents/input.py

@@ -0,0 +1,44 @@
+"""Input manager for agents."""
+from typing import Optional
+
+import langchain
+from langchain.schema import AgentAction
+
+
+class ChainedInput:
+    """Class for working with input that is the result of chains."""
+
+    def __init__(self, text: str, verbose: bool = False):
+        """Initialize with verbose flag and initial text."""
+        self._verbose = verbose
+        if self._verbose:
+            langchain.logger.log_agent_start(text)
+        self._input = text
+
+    def add_action(self, action: AgentAction, color: Optional[str] = None) -> None:
+        """Add text to input, print if in verbose mode."""
+        if self._verbose:
+            langchain.logger.log_agent_action(action, color=color)
+        self._input += action.log
+
+    def add_observation(
+        self,
+        observation: str,
+        observation_prefix: str,
+        llm_prefix: str,
+        color: Optional[str],
+    ) -> None:
+        """Add observation to input, print if in verbose mode."""
+        if self._verbose:
+            langchain.logger.log_agent_observation(
+                observation,
+                color=color,
+                observation_prefix=observation_prefix,
+                llm_prefix=llm_prefix,
+            )
+        self._input += f"\n{observation_prefix}{observation}\n{llm_prefix}"
+
+    @property
+    def input(self) -> str:
+        """Return the accumulated input."""
+        return self._input

langchain/agents/loading.py

@@ -0,0 +1,42 @@
+"""Load agent."""
+from typing import Any, List
+
+from langchain.agents.agent import Agent
+from langchain.agents.mrkl.base import ZeroShotAgent
+from langchain.agents.react.base import ReActDocstoreAgent
+from langchain.agents.self_ask_with_search.base import SelfAskWithSearchAgent
+from langchain.agents.tools import Tool
+from langchain.llms.base import LLM
+
+AGENT_TO_CLASS = {
+    "zero-shot-react-description": ZeroShotAgent,
+    "react-docstore": ReActDocstoreAgent,
+    "self-ask-with-search": SelfAskWithSearchAgent,
+}
+
+
+def initialize_agent(
+    tools: List[Tool],
+    llm: LLM,
+    agent: str = "zero-shot-react-description",
+    **kwargs: Any,
+) -> Agent:
+    """Load agent given tools and LLM.
+
+    Args:
+        tools: List of tools this agent has access to.
+        llm: Language model to use as the agent.
+        agent: The agent to use. Valid options are:
+            `zero-shot-react-description`, `react-docstore`, `self-ask-with-search`.
+        **kwargs: Additional key word arguments to pass to the agent.
+
+    Returns:
+        An agent.
+    """
+    if agent not in AGENT_TO_CLASS:
+        raise ValueError(
+            f"Got unknown agent type: {agent}. "
+            f"Valid types are: {AGENT_TO_CLASS.keys()}."
+        )
+    agent_cls = AGENT_TO_CLASS[agent]
+    return agent_cls.from_llm_and_tools(llm, tools, **kwargs)

langchain/agents/mrkl/base.py

@@ -0,0 +1,159 @@
+"""Attempt to implement MRKL systems as described in arxiv.org/pdf/2205.00445.pdf."""
+from __future__ import annotations
+
+from typing import Any, Callable, List, NamedTuple, Optional, Tuple
+
+from langchain.agents.agent import Agent
+from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS, PREFIX, SUFFIX
+from langchain.agents.tools import Tool
+from langchain.llms.base import LLM
+from langchain.prompts import PromptTemplate
+
+FINAL_ANSWER_ACTION = "Final Answer: "
+
+
+class ChainConfig(NamedTuple):
+    """Configuration for chain to use in MRKL system.
+
+    Args:
+        action_name: Name of the action.
+        action: Action function to call.
+        action_description: Description of the action.
+    """
+
+    action_name: str
+    action: Callable
+    action_description: str
+
+
+def get_action_and_input(llm_output: str) -> Tuple[str, str]:
+    """Parse out the action and input from the LLM output."""
+    ps = [p for p in llm_output.split("\n") if p]
+    if ps[-1].startswith("Final Answer"):
+        directive = ps[-1][len(FINAL_ANSWER_ACTION) :]
+        return "Final Answer", directive
+    if not ps[-1].startswith("Action Input: "):
+        raise ValueError(
+            "The last line does not have an action input, "
+            "something has gone terribly wrong."
+        )
+    if not ps[-2].startswith("Action: "):
+        raise ValueError(
+            "The second to last line does not have an action, "
+            "something has gone terribly wrong."
+        )
+    action = ps[-2][len("Action: ") :]
+    action_input = ps[-1][len("Action Input: ") :]
+    return action, action_input.strip(" ").strip('"')
+
+
+class ZeroShotAgent(Agent):
+    """Agent for the MRKL chain."""
+
+    @property
+    def observation_prefix(self) -> str:
+        """Prefix to append the observation with."""
+        return "Observation: "
+
+    @property
+    def llm_prefix(self) -> str:
+        """Prefix to append the llm call with."""
+        return "Thought:"
+
+    @classmethod
+    def create_prompt(
+        cls,
+        tools: List[Tool],
+        prefix: str = PREFIX,
+        suffix: str = SUFFIX,
+        input_variables: Optional[List[str]] = None,
+    ) -> PromptTemplate:
+        """Create prompt in the style of the zero shot agent.
+
+        Args:
+            tools: List of tools the agent will have access to, used to format the
+                prompt.
+            prefix: String to put before the list of tools.
+            suffix: String to put after the list of tools.
+            input_variables: List of input variables the final prompt will expect.
+
+        Returns:
+            A PromptTemplate with the template assembled from the pieces here.
+        """
+        tool_strings = "\n".join([f"{tool.name}: {tool.description}" for tool in tools])
+        tool_names = ", ".join([tool.name for tool in tools])
+        format_instructions = FORMAT_INSTRUCTIONS.format(tool_names=tool_names)
+        template = "\n\n".join([prefix, tool_strings, format_instructions, suffix])
+        if input_variables is None:
+            input_variables = ["input", "agent_scratchpad"]
+        return PromptTemplate(template=template, input_variables=input_variables)
+
+    @classmethod
+    def _validate_tools(cls, tools: List[Tool]) -> None:
+        for tool in tools:
+            if tool.description is None:
+                raise ValueError(
+                    f"Got a tool {tool.name} without a description. For this agent, "
+                    f"a description must always be provided."
+                )
+
+    def _extract_tool_and_input(self, text: str) -> Optional[Tuple[str, str]]:
+        return get_action_and_input(text)
+
+
+class MRKLChain(ZeroShotAgent):
+    """Chain that implements the MRKL system.
+
+    Example:
+        .. code-block:: python
+
+            from langchain import OpenAI, MRKLChain
+            from langchain.chains.mrkl.base import ChainConfig
+            llm = OpenAI(temperature=0)
+            prompt = PromptTemplate(...)
+            chains = [...]
+            mrkl = MRKLChain.from_chains(llm=llm, prompt=prompt)
+    """
+
+    @classmethod
+    def from_chains(cls, llm: LLM, chains: List[ChainConfig], **kwargs: Any) -> Agent:
+        """User friendly way to initialize the MRKL chain.
+
+        This is intended to be an easy way to get up and running with the
+        MRKL chain.
+
+        Args:
+            llm: The LLM to use as the agent LLM.
+            chains: The chains the MRKL system has access to.
+            **kwargs: parameters to be passed to initialization.
+
+        Returns:
+            An initialized MRKL chain.
+
+        Example:
+            .. code-block:: python
+
+                from langchain import LLMMathChain, OpenAI, SerpAPIWrapper, MRKLChain
+                from langchain.chains.mrkl.base import ChainConfig
+                llm = OpenAI(temperature=0)
+                search = SerpAPIWrapper()
+                llm_math_chain = LLMMathChain(llm=llm)
+                chains = [
+                    ChainConfig(
+                        action_name = "Search",
+                        action=search.search,
+                        action_description="useful for searching"
+                    ),
+                    ChainConfig(
+                        action_name="Calculator",
+                        action=llm_math_chain.run,
+                        action_description="useful for doing math"
+                    )
+                ]
+                mrkl = MRKLChain.from_chains(llm, chains)
+        """
+        tools = [
+            Tool(name=c.action_name, func=c.action, description=c.action_description)
+            for c in chains
+        ]
+        return cls.from_llm_and_tools(llm, tools, **kwargs)

langchain/agents/mrkl/prompt.py

@@ -1,9 +1,6 @@
 # flake8: noqa
-BASE_TEMPLATE = """Answer the following questions as best you can. You have access to the following tools:
-
-{tools}
-
-Use the following format:
+PREFIX = """Answer the following questions as best you can. You have access to the following tools:"""
+FORMAT_INSTRUCTIONS = """Use the following format:
 
 Question: the input question you must answer
 Thought: you should always think about what to do
@@ -12,8 +9,8 @@ Action Input: the input to the action
 Observation: the result of the action
 ... (this Thought/Action/Action Input/Observation can repeat N times)
 Thought: I now know the final answer
-Final Answer: the final answer to the original input question
+Final Answer: the final answer to the original input question"""
+SUFFIX = """Begin!
 
-Begin!
-
-Question: {{input}}"""
+Question: {input}
+{agent_scratchpad}"""