Address comments, remove older docs

Co-authored-by: Nuno Campos <nuno@boringbits.io>

MIGRATE.md

@@ -43,6 +43,10 @@ Now:
 
 `from langchain_experimental.sql import SQLDatabaseChain`
 
+Alternatively, if you are just interested in using the query generation part of the SQL chain, you can check out [`create_sql_query_chain`](https://github.com/langchain-ai/langchain/blob/master/docs/extras/use_cases/tabular/sql_query.ipynb)
+
+`from langchain.chains import create_sql_query_chain`
+
 ## `load_prompt` for Python files
 
 Note: this only applies if you want to load Python files as prompts.

docs/docs_skeleton/docs/guides/expression_language/index.mdx

@@ -0,0 +1,9 @@
+# LangChain Expression Language
+
+import DocCardList from "@theme/DocCardList";
+
+LangChain Expression Language is a declarative way to easily compose chains together.
+Any chain constructed this way will automatically have full sync, async, and streaming support.
+See guides below for how to interact with chains constructed this way as well as cookbook examples.
+
+<DocCardList />

docs/docs_skeleton/generate_api_reference_links.py

@@ -5,6 +5,7 @@ import logging
 import os
 import re
 from pathlib import Path
+import argparse
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -14,7 +15,12 @@ _BASE_URL = "https://api.python.langchain.com/en/latest/"
 # Regular expression to match Python code blocks
 code_block_re = re.compile(r"^(```python\n)(.*?)(```\n)", re.DOTALL | re.MULTILINE)
 # Regular expression to match langchain import lines
-_IMPORT_RE = re.compile(r"(from\s+(langchain\.\w+(\.\w+)*?)\s+import\s+)(\w+)")
+_IMPORT_RE = re.compile(
+    r"from\s+(langchain\.\w+(\.\w+)*?)\s+import\s+"
+    r"((?:\w+(?:,\s*)?)*"  # Match zero or more words separated by a comma+optional ws
+    r"(?:\s*\(.*?\))?)",  # Match optional parentheses block
+    re.DOTALL,  # Match newlines as well
+)
 
 _CURRENT_PATH = Path(__file__).parent.absolute()
 # Directory where generated markdown files are stored
@@ -24,6 +30,10 @@ _JSON_PATH = _CURRENT_PATH.parent / "api_reference" / "guide_imports.json"
 
 def find_files(path):
     """Find all MDX files in the given path"""
+    # Check if is file first
+    if os.path.isfile(path):
+        yield path
+        return
     for root, _, files in os.walk(path):
         for file in files:
             if file.endswith(".mdx") or file.endswith(".md"):
@@ -37,20 +47,33 @@ def get_full_module_name(module_path, class_name):
     return inspect.getmodule(class_).__name__
 
 
+def get_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--docs_dir",
+        type=str,
+        default=_DOCS_DIR,
+        help="Directory where generated markdown files are stored",
+    )
+    return parser.parse_args()
+
+
 def main():
     """Main function"""
+    args = get_args()
     global_imports = {}
 
-    for file in find_files(_DOCS_DIR):
+    for file in find_files(args.docs_dir):
         print(f"Adding links for imports in {file}")
-
-        # replace_imports now returns the import information rather than writing it to a file
         file_imports = replace_imports(file)
 
         if file_imports:
             # Use relative file path as key
-            relative_path = os.path.relpath(file, _DOCS_DIR)
-            doc_url = f"https://python.langchain.com/docs/{relative_path.replace('.mdx', '').replace('.md', '')}"
+            relative_path = (
+                os.path.relpath(file, _DOCS_DIR).replace(".mdx", "").replace(".md", "")
+            )
+
+            doc_url = f"https://python.langchain.com/docs/{relative_path}"
             for import_info in file_imports:
                 doc_title = import_info["title"]
                 class_name = import_info["imported"]
@@ -77,7 +100,8 @@ def _get_doc_title(data: str, file_name: str) -> str:
 
 
 def replace_imports(file):
-    """Replace imports in each Python code block with links to their documentation and append the import info in a comment"""
+    """Replace imports in each Python code block with links to their
+    documentation and append the import info in a comment"""
     all_imports = []
     with open(file, "r") as f:
         data = f.read()
@@ -97,37 +121,45 @@ def replace_imports(file):
         # Process imports in the code block
         imports = []
         for import_match in _IMPORT_RE.finditer(code):
-            class_name = import_match.group(4)
-            try:
-                module_path = get_full_module_name(import_match.group(2), class_name)
-            except AttributeError as e:
-                logger.warning(f"Could not find module for {class_name}, {e}")
-                continue
-            except ImportError as e:
-                # Some CentOS OpenSSL issues can cause this to fail
-                logger.warning(f"Failed to load for class {class_name}, {e}")
-                continue
+            module = import_match.group(1)
+            imports_str = (
+                import_match.group(3).replace("(\n", "").replace("\n)", "")
+            )  # Handle newlines within parentheses
+            # remove any newline and spaces, then split by comma
+            imported_classes = [
+                imp.strip()
+                for imp in re.split(r",\s*", imports_str.replace("\n", ""))
+                if imp.strip()
+            ]
+            for class_name in imported_classes:
+                try:
+                    module_path = get_full_module_name(module, class_name)
+                except AttributeError as e:
+                    logger.warning(f"Could not find module for {class_name}, {e}")
+                    continue
+                except ImportError as e:
+                    logger.warning(f"Failed to load for class {class_name}, {e}")
+                    continue
 
-            url = (
-                _BASE_URL
-                + "/"
-                + module_path.split(".")[1]
-                + "/"
-                + module_path
-                + "."
-                + class_name
-                + ".html"
-            )
+                url = (
+                    _BASE_URL
+                    + module_path.split(".")[1]
+                    + "/"
+                    + module_path
+                    + "."
+                    + class_name
+                    + ".html"
+                )
 
-            # Add the import information to our list
-            imports.append(
-                {
-                    "imported": class_name,
-                    "source": import_match.group(2),
-                    "docs": url,
-                    "title": _DOC_TITLE,
-                }
-            )
+                # Add the import information to our list
+                imports.append(
+                    {
+                        "imported": class_name,
+                        "source": module,
+                        "docs": url,
+                        "title": _DOC_TITLE,
+                    }
+                )
 
         if imports:
             all_imports.extend(imports)

docs/docs_skeleton/vercel.json

@@ -3476,6 +3476,10 @@
       "source": "/en/latest/modules/prompts/output_parsers/examples/retry.html",
       "destination": "/docs/modules/model_io/output_parsers/retry"
     },
+    {
+      "source": "/en/latest/modules/prompts/example_selectors.html",
+      "destination": "/docs/modules/model_io/example_selectors"
+    },
     {
       "source": "/en/latest/modules/prompts/example_selectors/examples/custom_example_selector.html",
       "destination": "/docs/modules/model_io/prompts/example_selectors/custom_example_selector"
@@ -3488,6 +3492,10 @@
       "source": "/en/latest/modules/prompts/example_selectors/examples/ngram_overlap.html",
       "destination": "/docs/modules/model_io/prompts/example_selectors/ngram_overlap"
     },
+    {
+      "source": "/en/latest/modules/prompts/prompt_templates.html",
+      "destination": "/docs/modules/model_io/prompt_templates"
+    },
     {
       "source": "/en/latest/modules/prompts/prompt_templates/examples/connecting_to_a_feature_store.html",
       "destination": "/docs/modules/model_io/prompts/prompt_templates/connecting_to_a_feature_store"
@@ -3740,6 +3748,10 @@
       "source": "/docs/modules/evaluation/:path*(/?)",
       "destination": "/docs/guides/evaluation/:path*"
     },
+    {
+      "source": "/en/latest/modules/indexes.html",
+      "destination": "/docs/modules/data_connection"
+    },
     {
       "source": "/en/latest/modules/indexes/:path*",
       "destination": "/docs/modules/data_connection/:path*"

docs/extras/guides/expression_language/interface.ipynb

@@ -0,0 +1,269 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9a9acd2e",
+   "metadata": {},
+   "source": [
+    "# Interface\n",
+    "\n",
+    "In an effort to make it as easy as possible to create custom chains, we've implemented a [\"Runnable\"](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.Runnable.html#langchain.schema.runnable.Runnable) protocol that most components implement. This is a standard interface with a few different methods, which makes it easy to define custom chains as well as making it possible to invoke them in a standard way. The standard interface exposed includes:\n",
+    "\n",
+    "- `stream`: stream back chunks of the response\n",
+    "- `invoke`: call the chain on an input\n",
+    "- `batch`: call the chain on a list of inputs\n",
+    "\n",
+    "These also have corresponding async methods:\n",
+    "\n",
+    "- `astream`: stream back chunks of the response async\n",
+    "- `ainvoke`: call the chain on an input async\n",
+    "- `abatch`: call the chain on a list of inputs async\n",
+    "\n",
+    "The type of the input varies by component. For a prompt it is a dictionary, for a retriever it is a single string, for a model either a single string, a list of chat messages, or a PromptValue.\n",
+    "\n",
+    "The output type also varies by component. For an LLM it is a string, for a ChatModel it's a ChatMessage, for a prompt it's a PromptValue, for a retriever it's a list of documents.\n",
+    "\n",
+    "Let's take a look at these methods! To do so, we'll create a super simple PromptTemplate + ChatModel chain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "466b65b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.chat_models import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3c634ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ChatOpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d1850a1f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prompt = ChatPromptTemplate.from_template(\"tell me a joke about {topic}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "56d0669f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = prompt | model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "daf2b2b2",
+   "metadata": {},
+   "source": [
+    "## Stream"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "bea9639d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Sure, here's a bear-themed joke for you:\n",
+      "\n",
+      "Why don't bears wear shoes?\n",
+      "\n",
+      "Because they have bear feet!"
+     ]
+    }
+   ],
+   "source": [
+    "for s in chain.stream({\"topic\": \"bears\"}):\n",
+    "    print(s.content, end=\"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cbf1c782",
+   "metadata": {},
+   "source": [
+    "## Invoke"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "470e483f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"Why don't bears wear shoes?\\n\\nBecause they already have bear feet!\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"topic\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88f0c279",
+   "metadata": {},
+   "source": [
+    "## Batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "9685de67",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[AIMessage(content=\"Why don't bears ever wear shoes?\\n\\nBecause they have bear feet!\", additional_kwargs={}, example=False),\n",
+       " AIMessage(content=\"Why don't cats play poker in the wild?\\n\\nToo many cheetahs!\", additional_kwargs={}, example=False)]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.batch([{\"topic\": \"bears\"}, {\"topic\": \"cats\"}])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b960cbfe",
+   "metadata": {},
+   "source": [
+    "## Async Stream"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "ea35eee4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Why don't bears wear shoes?\n",
+      "\n",
+      "Because they have bear feet!"
+     ]
+    }
+   ],
+   "source": [
+    "async for s in chain.astream({\"topic\": \"bears\"}):\n",
+    "    print(s.content, end=\"\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04cb3324",
+   "metadata": {},
+   "source": [
+    "## Async Invoke"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ef8c9b20",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"Sure, here you go:\\n\\nWhy don't bears wear shoes?\\n\\nBecause they have bear feet!\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "await chain.ainvoke({\"topic\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3da288d5",
+   "metadata": {},
+   "source": [
+    "## Async Batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "eba2a103",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[AIMessage(content=\"Why don't bears wear shoes?\\n\\nBecause they have bear feet!\", additional_kwargs={}, example=False)]"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "await chain.abatch([{\"topic\": \"bears\"}])"
+   ]
+  }
+ ],
+ "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/extras/integrations/chat/anthropic_functions.ipynb

@@ -0,0 +1,287 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5125a1e3",
+   "metadata": {},
+   "source": [
+    "# Anthropic Functions\n",
+    "\n",
+    "This notebook shows how to use an experimental wrapper around Anthropic that gives it the same API as OpenAI Functions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "378be79b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/harrisonchase/.pyenv/versions/3.9.1/envs/langchain/lib/python3.9/site-packages/deeplake/util/check_latest_version.py:32: UserWarning: A newer version of deeplake (3.6.14) is available. It's recommended that you update to the latest version using `pip install -U deeplake`.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_experimental.llms.anthropic_functions import AnthropicFunctions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65499965",
+   "metadata": {},
+   "source": [
+    "## Initialize Model\n",
+    "\n",
+    "You can initialize this wrapper the same way you'd initialize ChatAnthropic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e1d535f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = AnthropicFunctions(model='claude-2')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fcc9eaf4",
+   "metadata": {},
+   "source": [
+    "## Passing in functions\n",
+    "\n",
+    "You can now pass in functions in a similar way"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "0779c320",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "functions=[\n",
+    "    {\n",
+    "      \"name\": \"get_current_weather\",\n",
+    "      \"description\": \"Get the current weather in a given location\",\n",
+    "      \"parameters\": {\n",
+    "        \"type\": \"object\",\n",
+    "        \"properties\": {\n",
+    "          \"location\": {\n",
+    "            \"type\": \"string\",\n",
+    "            \"description\": \"The city and state, e.g. San Francisco, CA\"\n",
+    "          },\n",
+    "          \"unit\": {\n",
+    "            \"type\": \"string\",\n",
+    "            \"enum\": [\"celsius\", \"fahrenheit\"]\n",
+    "          }\n",
+    "        },\n",
+    "        \"required\": [\"location\"]\n",
+    "      }\n",
+    "    }\n",
+    "  ]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ad75a933",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema import HumanMessage"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "fc703085",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "response = model.predict_messages(\n",
+    "    [HumanMessage(content=\"whats the weater in boston?\")], \n",
+    "    functions=functions\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "04d7936a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' ', additional_kwargs={'function_call': {'name': 'get_current_weather', 'arguments': '{\"location\": \"Boston, MA\", \"unit\": \"fahrenheit\"}'}}, example=False)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "response"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0072fdba",
+   "metadata": {},
+   "source": [
+    "## Using for extraction\n",
+    "\n",
+    "You can now use this for extraction."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "7af5c567",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import create_extraction_chain\n",
+    "schema = {\n",
+    "    \"properties\": {\n",
+    "        \"name\": {\"type\": \"string\"},\n",
+    "        \"height\": {\"type\": \"integer\"},\n",
+    "        \"hair_color\": {\"type\": \"string\"},\n",
+    "    },\n",
+    "    \"required\": [\"name\", \"height\"],\n",
+    "}\n",
+    "inp = \"\"\"\n",
+    "Alex is 5 feet tall. Claudia is 1 feet taller Alex and jumps higher than him. Claudia is a brunette and Alex is blonde.\n",
+    "        \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "bd01082a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = create_extraction_chain(schema, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b5a23e9f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'name': 'Alex', 'height': '5', 'hair_color': 'blonde'},\n",
+       " {'name': 'Claudia', 'height': '6', 'hair_color': 'brunette'}]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(inp)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90ec959e",
+   "metadata": {},
+   "source": [
+    "## Using for tagging\n",
+    "\n",
+    "You can now use this for tagging"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "03c1eb0d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import create_tagging_chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "581c0ece",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "schema = {\n",
+    "    \"properties\": {\n",
+    "        \"sentiment\": {\"type\": \"string\"},\n",
+    "        \"aggressiveness\": {\"type\": \"integer\"},\n",
+    "        \"language\": {\"type\": \"string\"},\n",
+    "    }\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d9a8570e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = create_tagging_chain(schema, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "cf37d679",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'sentiment': 'positive', 'aggressiveness': '0', 'language': 'english'}"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(\"this is really cool\")"
+   ]
+  }
+ ],
+ "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/extras/integrations/llms/jsonformer_experimental.ipynb

@@ -216,7 +216,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.experimental.llms import JsonFormer\n",
+    "from langchain_experimental.llms import JsonFormer\n",
     "\n",
     "json_former = JsonFormer(json_schema=decoder_schema, pipeline=hf_model)"
    ]

docs/extras/integrations/llms/rellm_experimental.ipynb

@@ -162,7 +162,7 @@
     }
    ],
    "source": [
-    "from langchain.experimental.llms import RELLM\n",
+    "from langchain_experimental.llms import RELLM\n",
     "\n",
     "model = RELLM(pipeline=hf_model, regex=pattern, max_new_tokens=200)\n",
     "\n",

docs/extras/integrations/providers/dataforseo.mdx

@@ -13,7 +13,7 @@ This page provides instructions on how to use the DataForSEO search APIs within
 The DataForSEO utility wraps the API. To import this utility, use:
 
 ```python
-from langchain.utilities import DataForSeoAPIWrapper
+from langchain.utilities.dataforseo_api_search import DataForSeoAPIWrapper
 ```
 
 For a detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/dataforseo.ipynb).

docs/extras/integrations/providers/rebuff.ipynb

@@ -177,8 +177,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains import TransformChain, SQLDatabaseChain, SimpleSequentialChain\n",
-    "from langchain.sql_database import SQLDatabase"
+    "from langchain.chains import TransformChain, SimpleSequentialChain\n",
+    "from langchain.sql_database import SQLDatabase\n",
+    "from langchain_experimental.sql import SQLDatabaseChain"
    ]
   },
   {

docs/extras/integrations/providers/rockset.mdx

@@ -15,7 +15,7 @@ pip install rockset
 See a [usage example](/docs/integrations/vectorstores/rockset).
 
 ```python
-from langchain.vectorstores import RocksetDB
+from langchain.vectorstores import Rockset 
 ```
 
 ## Document Loader

docs/extras/integrations/providers/spacy.mdx

@@ -16,5 +16,5 @@ pip install spacy
 See a [usage example](/docs/modules/data_connection/document_transformers/text_splitters/split_by_token.html#spacy).
 
 ```python
-from langchain.llms import SpacyTextSplitter
+from langchain.text_splitter import SpacyTextSplitter
 ```

docs/extras/integrations/text_embedding/localai.ipynb

@@ -77,7 +77,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.embeddings.openai import LocalAIEmbeddings"
+    "from langchain.embeddings import LocalAIEmbeddings"
    ]
   },
   {

docs/extras/integrations/tools/dataforseo.ipynb

@@ -15,7 +15,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.utilities import DataForSeoAPIWrapper"
+    "from langchain.utilities.dataforseo_api_search import DataForSeoAPIWrapper"
    ]
   },
   {

docs/extras/integrations/vectorstores/chroma.ipynb

@@ -215,10 +215,23 @@
     "Chroma has the ability to handle multiple `Collections` of documents, but the LangChain interface expects one, so we need to specify the collection name. The default collection name used by LangChain is \"langchain\".\n",
     "\n",
     "Here is how to clone, build, and run the Docker Image:\n",
-    "```\n",
+    "```sh\n",
     "git clone git@github.com:chroma-core/chroma.git\n",
-    "docker-compose up -d --build\n",
-    "```"
+    "```\n",
+    "\n",
+    "Edit the `docker-compose.yml` file and add `ALLOW_RESET=TRUE` under `environment`\n",
+    "```yaml\n",
+    "    ...\n",
+    "    command: uvicorn chromadb.app:app --reload --workers 1 --host 0.0.0.0 --port 8000 --log-config log_config.yml\n",
+    "    environment:\n",
+    "      - IS_PERSISTENT=TRUE\n",
+    "      - ALLOW_RESET=TRUE\n",
+    "    ports:\n",
+    "      - 8000:8000\n",
+    "    ...\n",
+    "```\n",
+    "\n",
+    "Then run `docker-compose up -d --build`"
    ]
   },
   {

docs/extras/integrations/vectorstores/faiss.ipynb

@@ -23,9 +23,9 @@
    },
    "outputs": [],
    "source": [
-    "#!pip install faiss\n",
+    "!pip install faiss-gpu # For CUDA 7.5+ Supported GPU's.\n",
     "# OR\n",
-    "!pip install faiss-cpu"
+    "!pip install faiss-cpu # For CPU Installation"
    ]
   },
   {

docs/extras/integrations/vectorstores/opensearch.ipynb

@@ -1,436 +1,440 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "683953b3",
-   "metadata": {},
-   "source": [
-    "# OpenSearch\n",
-    "\n",
-    "> [OpenSearch](https://opensearch.org/) is a scalable, flexible, and extensible open-source software suite for search, analytics, and observability applications licensed under Apache 2.0. `OpenSearch` is a distributed search and analytics engine based on `Apache Lucene`.\n",
-    "\n",
-    "\n",
-    "This notebook shows how to use functionality related to the `OpenSearch` database.\n",
-    "\n",
-    "To run, you should have an OpenSearch instance up and running: [see here for an easy Docker installation](https://hub.docker.com/r/opensearchproject/opensearch).\n",
-    "\n",
-    "`similarity_search` by default performs the Approximate k-NN Search which uses one of the several algorithms like lucene, nmslib, faiss recommended for\n",
-    "large datasets. To perform brute force search we have other search methods known as Script Scoring and Painless Scripting.\n",
-    "Check [this](https://opensearch.org/docs/latest/search-plugins/knn/index/) for more details."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "94963977-9dfc-48b7-872a-53f2947f46c6",
-   "metadata": {},
-   "source": [
-    "## Installation\n",
-    "Install the Python client."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6e606066-9386-4427-8a87-1b93f435c57e",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "!pip install opensearch-py"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b1fa637e-4fbf-4d5a-9188-2cad826a193e",
-   "metadata": {},
-   "source": [
-    "We want to use OpenAIEmbeddings so we have to get the OpenAI API Key."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "28e5455e-322d-4010-9e3b-491d522ef5db",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import getpass\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "aac9563e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.vectorstores import OpenSearchVectorSearch\n",
-    "from langchain.document_loaders import TextLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a3c3999a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.document_loaders import TextLoader\n",
-    "\n",
-    "loader = TextLoader(\"../../../state_of_the_union.txt\")\n",
-    "documents = loader.load()\n",
-    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
-    "docs = text_splitter.split_documents(documents)\n",
-    "\n",
-    "embeddings = OpenAIEmbeddings()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "01a9a035",
-   "metadata": {},
-   "source": [
-    "## similarity_search using Approximate k-NN\n",
-    "\n",
-    "`similarity_search` using `Approximate k-NN` Search with Custom Parameters"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "803fe12b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "docsearch = OpenSearchVectorSearch.from_documents(\n",
-    "    docs, embeddings, opensearch_url=\"http://localhost:9200\"\n",
-    ")\n",
-    "\n",
-    "# If using the default Docker installation, use this instantiation instead:\n",
-    "# docsearch = OpenSearchVectorSearch.from_documents(\n",
-    "#     docs,\n",
-    "#     embeddings,\n",
-    "#     opensearch_url=\"https://localhost:9200\",\n",
-    "#     http_auth=(\"admin\", \"admin\"),\n",
-    "#     use_ssl = False,\n",
-    "#     verify_certs = False,\n",
-    "#     ssl_assert_hostname = False,\n",
-    "#     ssl_show_warn = False,\n",
-    "# )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "db3fa309",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = docsearch.similarity_search(query, k=10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c160d5bb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(docs[0].page_content)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "96215c90",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "docsearch = OpenSearchVectorSearch.from_documents(\n",
-    "    docs,\n",
-    "    embeddings,\n",
-    "    opensearch_url=\"http://localhost:9200\",\n",
-    "    engine=\"faiss\",\n",
-    "    space_type=\"innerproduct\",\n",
-    "    ef_construction=256,\n",
-    "    m=48,\n",
-    ")\n",
-    "\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = docsearch.similarity_search(query)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "62a7cea0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(docs[0].page_content)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0d0cd877",
-   "metadata": {},
-   "source": [
-    "## similarity_search using Script Scoring\n",
-    "\n",
-    "`similarity_search` using `Script Scoring` with Custom Parameters"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0a8e3c0e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "docsearch = OpenSearchVectorSearch.from_documents(\n",
-    "    docs, embeddings, opensearch_url=\"http://localhost:9200\", is_appx_search=False\n",
-    ")\n",
-    "\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = docsearch.similarity_search(\n",
-    "    \"What did the president say about Ketanji Brown Jackson\",\n",
-    "    k=1,\n",
-    "    search_type=\"script_scoring\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "92bc40db",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(docs[0].page_content)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a4af96cc",
-   "metadata": {},
-   "source": [
-    "## similarity_search using Painless Scripting\n",
-    "\n",
-    "`similarity_search` using `Painless Scripting` with Custom Parameters"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6d9f436e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "docsearch = OpenSearchVectorSearch.from_documents(\n",
-    "    docs, embeddings, opensearch_url=\"http://localhost:9200\", is_appx_search=False\n",
-    ")\n",
-    "filter = {\"bool\": {\"filter\": {\"term\": {\"text\": \"smuggling\"}}}}\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = docsearch.similarity_search(\n",
-    "    \"What did the president say about Ketanji Brown Jackson\",\n",
-    "    search_type=\"painless_scripting\",\n",
-    "    space_type=\"cosineSimilarity\",\n",
-    "    pre_filter=filter,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8ca50bce",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(docs[0].page_content)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4f8fb0d0",
-   "metadata": {},
-   "source": [
-    "## Maximum marginal relevance search (MMR)\n",
-    "If you’d like to look up for some similar documents, but you’d also like to receive diverse results, MMR is method you should consider. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ba85e092",
-   "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "683953b3",
+      "metadata": {},
+      "source": [
+        "# OpenSearch\n",
+        "\n",
+        "> [OpenSearch](https://opensearch.org/) is a scalable, flexible, and extensible open-source software suite for search, analytics, and observability applications licensed under Apache 2.0. `OpenSearch` is a distributed search and analytics engine based on `Apache Lucene`.\n",
+        "\n",
+        "\n",
+        "This notebook shows how to use functionality related to the `OpenSearch` database.\n",
+        "\n",
+        "To run, you should have an OpenSearch instance up and running: [see here for an easy Docker installation](https://hub.docker.com/r/opensearchproject/opensearch).\n",
+        "\n",
+        "`similarity_search` by default performs the Approximate k-NN Search which uses one of the several algorithms like lucene, nmslib, faiss recommended for\n",
+        "large datasets. To perform brute force search we have other search methods known as Script Scoring and Painless Scripting.\n",
+        "Check [this](https://opensearch.org/docs/latest/search-plugins/knn/index/) for more details."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "94963977-9dfc-48b7-872a-53f2947f46c6",
+      "metadata": {},
+      "source": [
+        "## Installation\n",
+        "Install the Python client."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "6e606066-9386-4427-8a87-1b93f435c57e",
+      "metadata": {
+        "tags": []
+      },
+      "outputs": [],
+      "source": [
+        "!pip install opensearch-py"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "b1fa637e-4fbf-4d5a-9188-2cad826a193e",
+      "metadata": {},
+      "source": [
+        "We want to use OpenAIEmbeddings so we have to get the OpenAI API Key."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "28e5455e-322d-4010-9e3b-491d522ef5db",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import os\n",
+        "import getpass\n",
+        "\n",
+        "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "aac9563e",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+        "from langchain.text_splitter import CharacterTextSplitter\n",
+        "from langchain.vectorstores import OpenSearchVectorSearch\n",
+        "from langchain.document_loaders import TextLoader"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "a3c3999a",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from langchain.document_loaders import TextLoader\n",
+        "\n",
+        "loader = TextLoader(\"../../../state_of_the_union.txt\")\n",
+        "documents = loader.load()\n",
+        "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+        "docs = text_splitter.split_documents(documents)\n",
+        "\n",
+        "embeddings = OpenAIEmbeddings()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "01a9a035",
+      "metadata": {},
+      "source": [
+        "## similarity_search using Approximate k-NN\n",
+        "\n",
+        "`similarity_search` using `Approximate k-NN` Search with Custom Parameters"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "803fe12b",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "docsearch = OpenSearchVectorSearch.from_documents(\n",
+        "    docs, embeddings, opensearch_url=\"http://localhost:9200\"\n",
+        ")\n",
+        "\n",
+        "# If using the default Docker installation, use this instantiation instead:\n",
+        "# docsearch = OpenSearchVectorSearch.from_documents(\n",
+        "#     docs,\n",
+        "#     embeddings,\n",
+        "#     opensearch_url=\"https://localhost:9200\",\n",
+        "#     http_auth=(\"admin\", \"admin\"),\n",
+        "#     use_ssl = False,\n",
+        "#     verify_certs = False,\n",
+        "#     ssl_assert_hostname = False,\n",
+        "#     ssl_show_warn = False,\n",
+        "# )"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "db3fa309",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+        "docs = docsearch.similarity_search(query, k=10)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "c160d5bb",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(docs[0].page_content)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "96215c90",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "docsearch = OpenSearchVectorSearch.from_documents(\n",
+        "    docs,\n",
+        "    embeddings,\n",
+        "    opensearch_url=\"http://localhost:9200\",\n",
+        "    engine=\"faiss\",\n",
+        "    space_type=\"innerproduct\",\n",
+        "    ef_construction=256,\n",
+        "    m=48,\n",
+        ")\n",
+        "\n",
+        "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+        "docs = docsearch.similarity_search(query)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "62a7cea0",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(docs[0].page_content)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "0d0cd877",
+      "metadata": {},
+      "source": [
+        "## similarity_search using Script Scoring\n",
+        "\n",
+        "`similarity_search` using `Script Scoring` with Custom Parameters"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "0a8e3c0e",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "docsearch = OpenSearchVectorSearch.from_documents(\n",
+        "    docs, embeddings, opensearch_url=\"http://localhost:9200\", is_appx_search=False\n",
+        ")\n",
+        "\n",
+        "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+        "docs = docsearch.similarity_search(\n",
+        "    \"What did the president say about Ketanji Brown Jackson\",\n",
+        "    k=1,\n",
+        "    search_type=\"script_scoring\",\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "92bc40db",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(docs[0].page_content)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "a4af96cc",
+      "metadata": {},
+      "source": [
+        "## similarity_search using Painless Scripting\n",
+        "\n",
+        "`similarity_search` using `Painless Scripting` with Custom Parameters"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "6d9f436e",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "docsearch = OpenSearchVectorSearch.from_documents(\n",
+        "    docs, embeddings, opensearch_url=\"http://localhost:9200\", is_appx_search=False\n",
+        ")\n",
+        "filter = {\"bool\": {\"filter\": {\"term\": {\"text\": \"smuggling\"}}}}\n",
+        "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+        "docs = docsearch.similarity_search(\n",
+        "    \"What did the president say about Ketanji Brown Jackson\",\n",
+        "    search_type=\"painless_scripting\",\n",
+        "    space_type=\"cosineSimilarity\",\n",
+        "    pre_filter=filter,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "8ca50bce",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "print(docs[0].page_content)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "4f8fb0d0",
+      "metadata": {},
+      "source": [
+        "## Maximum marginal relevance search (MMR)\n",
+        "If you\u2019d like to look up for some similar documents, but you\u2019d also like to receive diverse results, MMR is method you should consider. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "ba85e092",
+      "metadata": {
+        "collapsed": false,
+        "jupyter": {
+          "outputs_hidden": false
+        }
+      },
+      "outputs": [],
+      "source": [
+        "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+        "docs = docsearch.max_marginal_relevance_search(query, k=2, fetch_k=10, lambda_param=0.5)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "id": "73264864",
+      "metadata": {},
+      "source": [
+        "## Using a preexisting OpenSearch instance\n",
+        "\n",
+        "It's also possible to use a preexisting OpenSearch instance with documents that already have vectors present."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "82a23440",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# this is just an example, you would need to change these values to point to another opensearch instance\n",
+        "docsearch = OpenSearchVectorSearch(\n",
+        "    index_name=\"index-*\",\n",
+        "    embedding_function=embeddings,\n",
+        "    opensearch_url=\"http://localhost:9200\",\n",
+        ")\n",
+        "\n",
+        "# you can specify custom field names to match the fields you're using to store your embedding, document text value, and metadata\n",
+        "docs = docsearch.similarity_search(\n",
+        "    \"Who was asking about getting lunch today?\",\n",
+        "    search_type=\"script_scoring\",\n",
+        "    space_type=\"cosinesimil\",\n",
+        "    vector_field=\"message_embedding\",\n",
+        "    text_field=\"message\",\n",
+        "    metadata_field=\"message_metadata\",\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Using AOSS (Amazon OpenSearch Service Serverless)"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "pycharm": {
+          "name": "#%% md\n"
+        }
+      },
+      "id": "a82b55d5"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# This is just an example to show how to use AOSS with faiss engine and efficient_filter, you need to set proper values.\n",
+        "\n",
+        "service = 'aoss' # must set the service as 'aoss'\n",
+        "region = 'us-east-2'\n",
+        "credentials = boto3.Session(aws_access_key_id='xxxxxx',aws_secret_access_key='xxxxx').get_credentials()\n",
+        "awsauth = AWS4Auth('xxxxx', 'xxxxxx', region,service, session_token=credentials.token)\n",
+        "\n",
+        "docsearch = OpenSearchVectorSearch.from_documents(\n",
+        "    docs,\n",
+        "    embeddings,\n",
+        "    opensearch_url=\"host url\",\n",
+        "    http_auth=awsauth,\n",
+        "    timeout = 300,\n",
+        "    use_ssl = True,\n",
+        "    verify_certs = True,\n",
+        "    connection_class = RequestsHttpConnection,\n",
+        "    index_name=\"test-index-using-aoss\",\n",
+        "    engine=\"faiss\",\n",
+        ")\n",
+        "\n",
+        "docs = docsearch.similarity_search(\n",
+        "    \"What is feature selection\",\n",
+        "     efficient_filter=filter,\n",
+        "     k=200,\n",
+        ")"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "id": "923508b2"
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Using AOS (Amazon OpenSearch Service)"
+      ],
+      "metadata": {
+        "collapsed": false
+      },
+      "id": "ae8bb0b8"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "outputs": [],
+      "source": [
+        "# This is just an example to show how to use AOS , you need to set proper values.\n",
+        "\n",
+        "service = 'es' # must set the service as 'es'\n",
+        "region = 'us-east-2'\n",
+        "credentials = boto3.Session(aws_access_key_id='xxxxxx',aws_secret_access_key='xxxxx').get_credentials()\n",
+        "awsauth = AWS4Auth('xxxxx', 'xxxxxx', region,service, session_token=credentials.token)\n",
+        "\n",
+        "docsearch = OpenSearchVectorSearch.from_documents(\n",
+        "    docs,\n",
+        "    embeddings,\n",
+        "    opensearch_url=\"host url\",\n",
+        "    http_auth=awsauth,\n",
+        "    timeout = 300,\n",
+        "    use_ssl = True,\n",
+        "    verify_certs = True,\n",
+        "    connection_class = RequestsHttpConnection,\n",
+        "    index_name=\"test-index\",\n",
+        ")\n",
+        "\n",
+        "docs = docsearch.similarity_search(\n",
+        "    \"What is feature selection\",\n",
+        "     k=200,\n",
+        ")"
+      ],
+      "metadata": {
+        "collapsed": false,
+        "pycharm": {
+          "name": "#%%\n"
+        }
+      },
+      "id": "3211e17b"
     }
-   },
-   "outputs": [],
-   "source": [
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = docsearch.max_marginal_relevance_search(query, k=2, fetch_k=10, lambda_param=0.5)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "73264864",
-   "metadata": {},
-   "source": [
-    "## Using a preexisting OpenSearch instance\n",
-    "\n",
-    "It's also possible to use a preexisting OpenSearch instance with documents that already have vectors present."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "82a23440",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# this is just an example, you would need to change these values to point to another opensearch instance\n",
-    "docsearch = OpenSearchVectorSearch(\n",
-    "    index_name=\"index-*\",\n",
-    "    embedding_function=embeddings,\n",
-    "    opensearch_url=\"http://localhost:9200\",\n",
-    ")\n",
-    "\n",
-    "# you can specify custom field names to match the fields you're using to store your embedding, document text value, and metadata\n",
-    "docs = docsearch.similarity_search(\n",
-    "    \"Who was asking about getting lunch today?\",\n",
-    "    search_type=\"script_scoring\",\n",
-    "    space_type=\"cosinesimil\",\n",
-    "    vector_field=\"message_embedding\",\n",
-    "    text_field=\"message\",\n",
-    "    metadata_field=\"message_metadata\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## Using AOSS (Amazon OpenSearch Service Serverless)"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
+  ],
+  "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.6"
     }
-   }
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# This is just an example to show how to use AOSS with faiss engine and efficient_filter, you need to set proper values.\n",
-    "\n",
-    "service = 'aoss' # must set the service as 'aoss'\n",
-    "region = 'us-east-2'\n",
-    "credentials = boto3.Session(aws_access_key_id='xxxxxx',aws_secret_access_key='xxxxx').get_credentials()\n",
-    "awsauth = AWS4Auth('xxxxx', 'xxxxxx', region,service, session_token=credentials.token)\n",
-    "\n",
-    "docsearch = OpenSearchVectorSearch.from_documents(\n",
-    "    docs,\n",
-    "    embeddings,\n",
-    "    opensearch_url=\"host url\",\n",
-    "    http_auth=awsauth,\n",
-    "    timeout = 300,\n",
-    "    use_ssl = True,\n",
-    "    verify_certs = True,\n",
-    "    connection_class = RequestsHttpConnection,\n",
-    "    index_name=\"test-index-using-aoss\",\n",
-    "    engine=\"faiss\",\n",
-    ")\n",
-    "\n",
-    "docs = docsearch.similarity_search(\n",
-    "    \"What is feature selection\",\n",
-    "     efficient_filter=filter,\n",
-    "     k=200,\n",
-    ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "markdown",
-   "source": [
-    "## Using AOS (Amazon OpenSearch Service)"
-   ],
-   "metadata": {
-    "collapsed": false
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [
-    "# This is just an example to show how to use AOS , you need to set proper values.\n",
-    "\n",
-    "service = 'es' # must set the service as 'es'\n",
-    "region = 'us-east-2'\n",
-    "credentials = boto3.Session(aws_access_key_id='xxxxxx',aws_secret_access_key='xxxxx').get_credentials()\n",
-    "awsauth = AWS4Auth('xxxxx', 'xxxxxx', region,service, session_token=credentials.token)\n",
-    "\n",
-    "docsearch = OpenSearchVectorSearch.from_documents(\n",
-    "    docs,\n",
-    "    embeddings,\n",
-    "    opensearch_url=\"host url\",\n",
-    "    http_auth=awsauth,\n",
-    "    timeout = 300,\n",
-    "    use_ssl = True,\n",
-    "    verify_certs = True,\n",
-    "    connection_class = RequestsHttpConnection,\n",
-    "    index_name=\"test-index\",\n",
-    ")\n",
-    "\n",
-    "docs = docsearch.similarity_search(\n",
-    "    \"What is feature selection\",\n",
-    "     k=200,\n",
-    ")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  }
- ],
- "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.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
+  "nbformat": 4,
+  "nbformat_minor": 5
 }

docs/extras/integrations/vectorstores/qdrant.ipynb

@@ -202,7 +202,7 @@
         "qdrant = Qdrant.from_documents(\n",
         "    docs,\n",
         "    embeddings,\n",
-        "    url,\n",
+        "    url=url,\n",
         "    prefer_grpc=True,\n",
         "    collection_name=\"my_documents\",\n",
         ")"
@@ -236,7 +236,7 @@
         "qdrant = Qdrant.from_documents(\n",
         "    docs,\n",
         "    embeddings,\n",
-        "    url,\n",
+        "    url=url,\n",
         "    prefer_grpc=True,\n",
         "    api_key=api_key,\n",
         "    collection_name=\"my_documents\",\n",
@@ -270,7 +270,7 @@
         "qdrant = Qdrant.from_documents(\n",
         "    docs,\n",
         "    embeddings,\n",
-        "    url,\n",
+        "    url=url,\n",
         "    prefer_grpc=True,\n",
         "    collection_name=\"my_documents\",\n",
         "    force_recreate=True,\n",

docs/extras/integrations/vectorstores/rockset.ipynb

@@ -2,131 +2,141 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "20b588b4",
+   "id": "9787b308",
    "metadata": {},
    "source": [
     "# Rockset\n",
     "\n",
-    ">[Rockset](https://rockset.com/product/) is a real-time analytics database service for serving low latency, high concurrency analytical queries at scale. It builds a Converged Index™ on structured and semi-structured data with an efficient store for vector embeddings. Its support for running SQL on schemaless data makes it a perfect choice for running vector search with metadata filters. \n",
+    ">[Rockset](https://rockset.com/) is a real-time search and analytics database built for the cloud. Rockset uses a [Converged Index™](https://rockset.com/blog/converged-indexing-the-secret-sauce-behind-rocksets-fast-queries/) with an efficient store for vector embeddings to serve low latency, high concurrency search queries at scale. Rockset has full support for metadata filtering and  handles real-time ingestion for constantly updating, streaming data.\n",
     "\n",
-    "This notebook demonstrates how to use `Rockset` as a vectorstore in langchain. To get started, make sure you have a `Rockset` account and an API key available."
+    "This notebook demonstrates how to use `Rockset` as a vector store in LangChain. Before getting started, make sure you have access to a `Rockset` account and an API key available. [Start your free trial today.](https://rockset.com/create/)\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "e290ddc0",
+   "id": "b823d64a",
    "metadata": {},
    "source": [
-    "## Setting up environment\n",
+    "## Setting Up Your Environment[](https://python.langchain.com/docs/modules/data_connection/vectorstores/integrations/rockset#setting-up-environment)\n",
     "\n",
-    "1. Make sure you have Rockset account and go to the web console to get the API key. Details can be found on [the website](https://rockset.com/docs/rest-api/). For the purpose of this notebook, we will assume you're using Rockset from `Oregon(us-west-2)`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7d77bbbe",
-   "metadata": {},
-   "source": [
-    "2. Now you will need to create a Rockset collection to write to, use the Rockset web console to do this. For the purpose of this exercise, we will create a collection called `langchain_demo`. Since Rockset supports schemaless ingest, you don't need to inform us of the shape of metadata for your texts. However, you do need to decide on two columns upfront:\n",
-    "- Where to store the text. We will use the column `description` for this.\n",
-    "- Where to store the vector-embedding for the text. We will use the column `description_embedding` for this.\n",
-    "\n",
-    "Also you will need to inform Rockset that `description_embedding` is a vector-embedding, so that we can optimize its format. You can do this using a **Rockset ingest transformation** while creating your collection:"
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "id": "3daa76ba",
-   "metadata": {},
-   "source": [
-    "SELECT\n",
-    "    _input.* EXCEPT(_meta),\n",
-    "    VECTOR_ENFORCE(_input.description_embedding, #length_of_vector_embedding, 'float') as description_embedding\n",
-    "FROM\n",
-    "    _input\n",
+    "1. Leverage the `Rockset` console to create a [collection](https://rockset.com/docs/collections/) with the Write API as your source. In this walkthrough, we create a collection named `langchain_demo`. \n",
     "    \n",
-    "// We used OpenAI `text-embedding-ada-002` for this examples, where #length_of_vector_embedding = 1536"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7951c9cd",
-   "metadata": {},
-   "source": [
-    "3. Now let's install the [rockset-python-client](https://github.com/rockset/rockset-python-client). This is used by langchain to talk to the Rockset database."
+    "    Configure the following [ingest transformation](https://rockset.com/docs/ingest-transformation/) to mark your embeddings field and take advantage of performance and storage optimizations:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "2aac7ae6",
-   "metadata": {},
+   "id": "aac58387",
+   "metadata": {
+    "vscode": {
+     "languageId": "sql"
+    }
+   },
    "outputs": [],
    "source": [
-    "!pip install rockset"
+    "SELECT _input.* EXCEPT(_meta), \n",
+    "VECTOR_ENFORCE(_input.description_embedding, #length_of_vector_embedding, 'float') as description_embedding \n",
+    "FROM _input"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "8600900d",
+   "id": "df380e1c",
    "metadata": {},
    "source": [
-    "This is it! Now you're ready to start writing some python code to store vector embeddings in Rockset, and querying the database to find texts similar to your query! We support 3 distance functions: `COSINE_SIM`, `EUCLIDEAN_DIST` and `DOT_PRODUCT`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3bf2f818",
-   "metadata": {},
-   "source": [
-    "## Example"
+    "2. After creating your collection, use the console to retrieve an [API key](https://rockset.com/docs/iam/#users-api-keys-and-roles). For the purpose of this notebook, we assume you are using the `Oregon(us-west-2)` region.\n",
+    "\n",
+    "3. Install the [rockset-python-client](https://github.com/rockset/rockset-python-client) to enable LangChain to communicate directly with `Rockset`."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "a7b39626",
+   "id": "00d16b83",
    "metadata": {},
    "outputs": [],
+   "source": [
+    "pip install rockset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e79550eb",
+   "metadata": {},
+   "source": [
+    "## LangChain Tutorial\n",
+    "\n",
+    "Follow along in your own Python notebook to generate and store vector embeddings in Rockset.\n",
+    "Start using Rockset to search for documents similar to your search queries.\n",
+    "\n",
+    "### 1. Define Key Variables"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "29505c1e",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "InitializationException",
+     "evalue": "The rockset client was initialized incorrectly: An api key must be provided as a parameter to the RocksetClient or the Configuration object.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mInitializationException\u001b[0m                   Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[5], line 6\u001b[0m\n\u001b[1;32m      4\u001b[0m ROCKSET_API_KEY \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39menviron\u001b[39m.\u001b[39mget(\u001b[39m\"\u001b[39m\u001b[39mROCKSET_API_KEY\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39m# Verify ROCKSET_API_KEY environment variable\u001b[39;00m\n\u001b[1;32m      5\u001b[0m ROCKSET_API_SERVER \u001b[39m=\u001b[39m rockset\u001b[39m.\u001b[39mRegions\u001b[39m.\u001b[39musw2a1 \u001b[39m# Verify Rockset region\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m rockset_client \u001b[39m=\u001b[39m rockset\u001b[39m.\u001b[39;49mRocksetClient(ROCKSET_API_SERVER, ROCKSET_API_KEY)\n\u001b[1;32m      8\u001b[0m COLLECTION_NAME\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mlangchain_demo\u001b[39m\u001b[39m'\u001b[39m\n\u001b[1;32m      9\u001b[0m TEXT_KEY\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mdescription\u001b[39m\u001b[39m'\u001b[39m\n",
+      "File \u001b[0;32m~/Library/Python/3.9/lib/python/site-packages/rockset/rockset_client.py:242\u001b[0m, in \u001b[0;36mRocksetClient.__init__\u001b[0;34m(self, host, api_key, max_workers, config)\u001b[0m\n\u001b[1;32m    239\u001b[0m     config\u001b[39m.\u001b[39mhost \u001b[39m=\u001b[39m host\n\u001b[1;32m    241\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m config\u001b[39m.\u001b[39mapi_key:\n\u001b[0;32m--> 242\u001b[0m     \u001b[39mraise\u001b[39;00m InitializationException(\n\u001b[1;32m    243\u001b[0m         \u001b[39m\"\u001b[39m\u001b[39mAn api key must be provided as a parameter to the RocksetClient or the Configuration object.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    244\u001b[0m     )\n\u001b[1;32m    246\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mapi_client \u001b[39m=\u001b[39m ApiClient(config, max_workers\u001b[39m=\u001b[39mmax_workers)\n\u001b[1;32m    248\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mAliases \u001b[39m=\u001b[39m AliasesApiWrapper(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mapi_client)\n",
+      "\u001b[0;31mInitializationException\u001b[0m: The rockset client was initialized incorrectly: An api key must be provided as a parameter to the RocksetClient or the Configuration object."
+     ]
+    }
+   ],
    "source": [
     "import os\n",
     "import rockset\n",
     "\n",
-    "# Make sure env variable ROCKSET_API_KEY is set\n",
-    "ROCKSET_API_KEY = os.environ.get(\"ROCKSET_API_KEY\")\n",
-    "ROCKSET_API_SERVER = (\n",
-    "    rockset.Regions.usw2a1\n",
-    ")  # Make sure this points to the correct Rockset region\n",
+    "ROCKSET_API_KEY = os.environ.get(\"ROCKSET_API_KEY\") # Verify ROCKSET_API_KEY environment variable\n",
+    "ROCKSET_API_SERVER = rockset.Regions.usw2a1 # Verify Rockset region\n",
     "rockset_client = rockset.RocksetClient(ROCKSET_API_SERVER, ROCKSET_API_KEY)\n",
     "\n",
-    "COLLECTION_NAME = \"langchain_demo\"\n",
-    "TEXT_KEY = \"description\"\n",
-    "EMBEDDING_KEY = \"description_embedding\""
+    "COLLECTION_NAME='langchain_demo'\n",
+    "TEXT_KEY='description'\n",
+    "EMBEDDING_KEY='description_embedding'"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "474636a2",
+   "id": "07625be2",
    "metadata": {},
    "source": [
-    "Now let's use this client to create a Rockset Langchain Vectorstore!\n",
-    "\n",
-    "### 1. Inserting texts"
+    "### 2. Prepare Documents"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "0d73c5bb",
+   "id": "9740d8c4",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mRunning cells with '/opt/local/bin/python3.11' requires the ipykernel package.\n",
+      "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n",
+      "\u001b[1;31mCommand: '/opt/local/bin/python3.11 -m pip install ipykernel -U --user --force-reinstall'"
+     ]
+    }
+   ],
    "source": [
     "from langchain.embeddings.openai import OpenAIEmbeddings\n",
     "from langchain.text_splitter import CharacterTextSplitter\n",
     "from langchain.document_loaders import TextLoader\n",
-    "from langchain.vectorstores.rocksetdb import RocksetDB\n",
+    "from langchain.vectorstores import Rockset\n",
     "\n",
-    "loader = TextLoader(\"../../../state_of_the_union.txt\")\n",
+    "loader = TextLoader('../../../state_of_the_union.txt')\n",
     "documents = loader.load()\n",
     "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
     "docs = text_splitter.split_documents(documents)"
@@ -134,23 +144,33 @@
   },
   {
    "cell_type": "markdown",
-   "id": "1404cada",
+   "id": "a068be18",
    "metadata": {},
    "source": [
-    "Now we have the documents we want to insert. Let's create a Rockset vectorstore and insert these docs into the Rockset collection. We will use `OpenAIEmbeddings` to create embeddings for the texts, but you're free to use whatever you want."
+    "### 3. Insert Documents"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "63c98bac",
+   "id": "85b6a6c5",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31mRunning cells with '/opt/local/bin/python3.11' requires the ipykernel package.\n",
+      "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n",
+      "\u001b[1;31mCommand: '/opt/local/bin/python3.11 -m pip install ipykernel -U --user --force-reinstall'"
+     ]
+    }
+   ],
    "source": [
-    "# Make sure the environment variable OPENAI_API_KEY is set up\n",
-    "embeddings = OpenAIEmbeddings()\n",
+    "embeddings = OpenAIEmbeddings() # Verify OPENAI_KEY environment variable\n",
     "\n",
-    "docsearch = RocksetDB(\n",
+    "docsearch = Rockset(\n",
     "    client=rockset_client,\n",
     "    embeddings=embeddings,\n",
     "    collection_name=COLLECTION_NAME,\n",
@@ -158,38 +178,46 @@
     "    embedding_key=EMBEDDING_KEY,\n",
     ")\n",
     "\n",
-    "ids = docsearch.add_texts(\n",
+    "ids=docsearch.add_texts(\n",
     "    texts=[d.page_content for d in docs],\n",
     "    metadatas=[d.metadata for d in docs],\n",
-    ")\n",
-    "\n",
-    "## If you go to the Rockset console now, you should be able to see this docs along with the metadata `source`"
+    ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f1290844",
+   "id": "56eef48d",
    "metadata": {},
    "source": [
-    "### 2. Searching similar texts\n",
-    "\n",
-    "Now let's try to search Rockset to find strings similar to our query string!"
+    "### 4. Search for Similar Documents"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "96e73ac1",
+   "execution_count": 1,
+   "id": "0bbf3df0",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'docsearch' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m query \u001b[39m=\u001b[39m \u001b[39m\"\u001b[39m\u001b[39mWhat did the president say about Ketanji Brown Jackson?\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m----> 2\u001b[0m output \u001b[39m=\u001b[39m docsearch\u001b[39m.\u001b[39msimilarity_search_with_relevance_scores(query, \u001b[39m4\u001b[39m, Rockset\u001b[39m.\u001b[39mDistanceFunction\u001b[39m.\u001b[39mCOSINE_SIM)\n\u001b[1;32m      4\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39moutput length:\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mlen\u001b[39m(output))\n\u001b[1;32m      5\u001b[0m \u001b[39mfor\u001b[39;00m d, dist \u001b[39min\u001b[39;00m output:\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'docsearch' is not defined"
+     ]
+    }
+   ],
    "source": [
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
     "output = docsearch.similarity_search_with_relevance_scores(\n",
-    "    query, 4, RocksetDB.DistanceFunction.COSINE_SIM\n",
+    "    query, 4, Rockset.DistanceFunction.COSINE_SIM\n",
     ")\n",
     "print(\"output length:\", len(output))\n",
     "for d, dist in output:\n",
-    "    print(dist, d.metadata, d.page_content[:20] + \"...\")\n",
+    "    print(dist, d.metadata, d.page_content[:20] + '...')\n",
     "\n",
     "##\n",
     "# output length: 4\n",
@@ -201,32 +229,28 @@
   },
   {
    "cell_type": "markdown",
-   "id": "5e15d630",
+   "id": "7037a22f",
    "metadata": {},
    "source": [
-    "You can also use a where filter to prune your search space. You can add filters on text key, or any of the metadata fields. \n",
-    "\n",
-    "> **Note**: Since Rockset stores each metadata field as a separate column internally, these filters are much faster than other vector databases which store all metadata as a single JSON.\n",
-    "\n",
-    "For eg, to find all texts NOT containing the substring \"and\", you can use the following code:"
+    "### 5. Search for Similar Documents with Filtering"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "c1c44d41",
+   "id": "b64a290f",
    "metadata": {},
    "outputs": [],
    "source": [
     "output = docsearch.similarity_search_with_relevance_scores(\n",
     "    query,\n",
     "    4,\n",
-    "    RocksetDB.DistanceFunction.COSINE_SIM,\n",
+    "    Rockset.DistanceFunction.COSINE_SIM,\n",
     "    where_str=\"{} NOT LIKE '%citizens%'\".format(TEXT_KEY),\n",
     ")\n",
     "print(\"output length:\", len(output))\n",
     "for d, dist in output:\n",
-    "    print(dist, d.metadata, d.page_content[:20] + \"...\")\n",
+    "    print(dist, d.metadata, d.page_content[:20] + '...')\n",
     "\n",
     "##\n",
     "# output length: 4\n",
@@ -237,21 +261,23 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
-   "id": "0765b822",
+   "id": "13a52b38",
    "metadata": {},
    "source": [
-    "### 3. [Optional] Drop all inserted documents\n",
+    "### 6. [Optional] Delete Inserted Documents\n",
     "\n",
-    "In order to delete texts from the Rockset collection, you need to know the unique ID associated with each document inside Rockset. These ids can either be supplied directly by the user while inserting the texts (in the `RocksetDB.add_texts()` function), else Rockset will generate a unique ID or each document. Either way, `Rockset.add_texts()` returns the ids for the inserted documents.\n",
+    "You must have the unique ID associated with each document to delete them from your collection.\n",
+    "Define IDs when inserting documents with `Rockset.add_texts()`. Rockset will otherwise generate a unique ID for each document. Regardless, `Rockset.add_texts()` returns the IDs of inserted documents.\n",
     "\n",
-    "To delete these docs, simply use the `RocksetDB.delete_texts()` function."
+    "To delete these docs, simply use the `Rockset.delete_texts()` function."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "31738966",
+   "id": "1f755924",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -260,23 +286,15 @@
   },
   {
    "cell_type": "markdown",
-   "id": "03fa12a9",
+   "id": "d468f431",
    "metadata": {},
    "source": [
-    "## Congratulations!\n",
+    "## Summary\n",
     "\n",
-    "Voila! In this example you successfuly created a Rockset collection, inserted documents along with their OpenAI vector embeddings, and searched for similar docs both with and without any metadata filters.\n",
+    "In this tutorial, we successfully created a `Rockset` collection, `inserted` documents with  OpenAI embeddings, and searched for similar documents with and without metadata filters.\n",
     "\n",
-    "Keep an eye on https://rockset.com/blog/introducing-vector-search-on-rockset/ for future updates in this space!"
+    "Keep an eye on https://rockset.com/ for future updates in this space."
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2763dddb-e87d-4d3b-b0bf-c246b0573d87",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -295,7 +313,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,

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

@@ -0,0 +1,149 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "3c284df8",
+   "metadata": {},
+   "source": [
+    "# XML Agent\n",
+    "\n",
+    "Some language models (like Anthropic's Claude) are particularly good at reasoning/writing XML. This goes over how to use an agent that uses XML when prompting. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "f9d2ead2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import XMLAgent, tool, AgentExecutor\n",
+    "from langchain.chat_models import ChatAnthropic\n",
+    "from langchain.chains import LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ebadf04f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ChatAnthropic(model=\"claude-2\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6ce9f9a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@tool\n",
+    "def search(query: str) -> str:\n",
+    "    \"\"\"Search things about current events.\"\"\"\n",
+    "    return \"32 degrees\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "c589944e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tool_list = [search]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "2d8454be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = LLMChain(\n",
+    "    llm=model,\n",
+    "    prompt=XMLAgent.get_default_prompt(),\n",
+    "    output_parser=XMLAgent.get_default_output_parser()\n",
+    ")\n",
+    "agent = XMLAgent(tools=tool_list, llm_chain=chain)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "bca6096f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "71b872b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m <tool>search</tool>\n",
+      "<tool_input>weather in New York\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "\n",
+      "<final_answer>The weather in New York is 32 degrees\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The weather in New York is 32 degrees'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.run(\"whats the weather in New york?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cca87246",
+   "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/extras/modules/chains/how_to/custom_chain.ipynb

@@ -15,10 +15,7 @@
    "execution_count": 11,
    "id": "c19c736e-ca74-4726-bb77-0a849bcc2960",
    "metadata": {
-    "tags": [],
-    "vscode": {
-     "languageId": "python"
-    }
+    "tags": []
    },
    "outputs": [],
    "source": [
@@ -28,7 +25,7 @@
     "\n",
     "from pydantic import Extra\n",
     "\n",
-    "from langchain.schema import BaseLanguageModel\n",
+    "from langchain.schema.language_model import BaseLanguageModel\n",
     "from langchain.callbacks.manager import (\n",
     "    AsyncCallbackManagerForChainRun,\n",
     "    CallbackManagerForChainRun,\n",
@@ -130,11 +127,7 @@
    "cell_type": "code",
    "execution_count": 12,
    "id": "18361f89",
-   "metadata": {
-    "vscode": {
-     "languageId": "python"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",

docs/extras/modules/model_io/prompts/prompt_templates/few_shot_examples_chat.ipynb

@@ -35,19 +35,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 2,
    "id": "91f1ca7f-a748-44c7-a1c6-a89a2d1414ba",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain.schema import SystemMessage\n",
     "from langchain.prompts import (\n",
     "    FewShotChatMessagePromptTemplate,\n",
-    "    HumanMessagePromptTemplate,\n",
-    "    AIMessagePromptTemplate,\n",
-    "    SystemMessagePromptTemplate,\n",
+    "    ChatPromptTemplate,\n",
     ")"
    ]
   },
@@ -61,7 +58,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 3,
    "id": "0fc5a02a-6249-4e92-95c3-30fff9671e8b",
    "metadata": {
     "tags": []
@@ -84,7 +81,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 4,
    "id": "65e72ad1-9060-47d0-91a1-bc130c8b98ac",
    "metadata": {
     "tags": []
@@ -103,9 +100,12 @@
    ],
    "source": [
     "# This is a prompt template used to format each individual example.\n",
-    "example_prompt = HumanMessagePromptTemplate.from_template(\n",
-    "    \"{input}\"\n",
-    ") + AIMessagePromptTemplate.from_template(\"{output}\")\n",
+    "example_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"human\", \"{input}\"),\n",
+    "        (\"ai\", \"{output}\"),\n",
+    "    ]\n",
+    ")\n",
     "few_shot_prompt = FewShotChatMessagePromptTemplate(\n",
     "    example_prompt=example_prompt,\n",
     "    examples=examples,\n",
@@ -124,23 +124,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 5,
    "id": "9f86d6d9-50de-41b6-b6c7-0f9980cc0187",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "final_prompt = (\n",
-    "    SystemMessagePromptTemplate.from_template(\"You are wonderous wizard of math.\")\n",
-    "    + few_shot_prompt\n",
-    "    + HumanMessagePromptTemplate.from_template(\"{input}\")\n",
+    "final_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"You are wonderous wizard of math.\"),\n",
+    "        few_shot_prompt,\n",
+    "        (\"human\", \"{input}\"),\n",
+    "    ]\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 6,
    "id": "97d443b1-6fae-4b36-bede-3ff7306288a3",
    "metadata": {
     "tags": []
@@ -149,10 +151,10 @@
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=' Triangles do not have a \"square\". A square refers to a shape with 4 equal sides and 4 right angles. Triangles have 3 sides and 3 angles.\\n\\nThe area of a triangle can be calculated using the formula:\\n\\nA = 1/2 * b * h\\n\\nWhere:\\n\\nA is the area \\nb is the base (the length of one of the sides)\\nh is the height (the length from the base to the opposite vertex)\\n\\nSo the area depends on the specific dimensions of the triangle. There is no single \"square of a triangle\". The area can vary greatly between different triangles.', additional_kwargs={}, example=False)"
+       "AIMessage(content=' Triangles do not have a \"square\". A square refers to a shape with 4 equal sides and 4 right angles. Triangles have 3 sides and 3 angles.\\n\\nThe area of a triangle can be calculated using the formula:\\n\\nA = 1/2 * b * h\\n\\nWhere:\\n\\nA is the area \\nb is the base (the length of one of the sides)\\nh is the height (the length from the base to the opposite vertex)\\n\\nSo the area depends on the specific dimensions of the triangle. There is no single \"square of a triangle\". The area can vary greatly depending on the base and height measurements.', additional_kwargs={}, example=False)"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -182,7 +184,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 7,
    "id": "6f7b5e86-4ca7-4edd-bf2b-9663030b2393",
    "metadata": {
     "tags": []
@@ -204,7 +206,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 8,
    "id": "ad66f06a-66fd-4fcc-8166-5d0e3c801e57",
    "metadata": {
     "tags": []
@@ -239,7 +241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 9,
    "id": "7790303a-f722-452e-8921-b14bdf20bdff",
    "metadata": {
     "tags": []
@@ -252,7 +254,7 @@
        " {'input': '2+4', 'output': '6'}]"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -279,17 +281,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 10,
    "id": "253c255e-41d7-45f6-9d88-c7a0ced4b1bd",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain.schema import SystemMessage\n",
-    "from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate\n",
-    "from langchain.prompts.few_shot import FewShotChatMessagePromptTemplate\n",
-    "\n",
+    "from langchain.prompts import (\n",
+    "    FewShotChatMessagePromptTemplate,\n",
+    "    ChatPromptTemplate,\n",
+    ")\n",
     "\n",
     "# Define the few-shot prompt.\n",
     "few_shot_prompt = FewShotChatMessagePromptTemplate(\n",
@@ -299,9 +301,8 @@
     "    # Define how each example will be formatted.\n",
     "    # In this case, each example will become 2 messages:\n",
     "    # 1 human, and 1 AI\n",
-    "    example_prompt=(\n",
-    "        HumanMessagePromptTemplate.from_template(\"{input}\")\n",
-    "        + AIMessagePromptTemplate.from_template(\"{output}\")\n",
+    "    example_prompt=ChatPromptTemplate.from_messages(\n",
+    "        [(\"human\", \"{input}\"), (\"ai\", \"{output}\")]\n",
     "    ),\n",
     ")"
    ]
@@ -316,7 +317,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 11,
    "id": "860bf682-c469-40e9-b657-27bfe7026099",
    "metadata": {
     "tags": []
@@ -347,23 +348,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 12,
    "id": "e731cb45-f0ea-422c-be37-42af2a6cb2c4",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "final_prompt = (\n",
-    "    SystemMessagePromptTemplate.from_template(\"You are wonderous wizard of math.\")\n",
-    "    + few_shot_prompt\n",
-    "    + HumanMessagePromptTemplate.from_template(\"{input}\")\n",
+    "final_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"You are wonderous wizard of math.\"),\n",
+    "        few_shot_prompt,\n",
+    "        (\"human\", \"{input}\"),\n",
+    "    ]\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 13,
    "id": "e6cc4199-8947-42d7-91f0-375de1e15bd9",
    "metadata": {
     "tags": []
@@ -396,7 +399,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 14,
    "id": "0568cbc6-5354-47f1-ab4d-dfcc616cf583",
    "metadata": {
     "tags": []
@@ -408,7 +411,7 @@
        "AIMessage(content=' 3 + 3 = 6', additional_kwargs={}, example=False)"
       ]
      },
-     "execution_count": 26,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }

docs/extras/use_cases/agent_simulations/characters.ipynb

@@ -101,7 +101,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.experimental.generative_agents import (\n",
+    "from langchain_experimental.generative_agents import (\n",
     "    GenerativeAgent,\n",
     "    GenerativeAgentMemory,\n",
     ")"

docs/extras/use_cases/autonomous_agents/autogpt.ipynb

@@ -100,7 +100,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.experimental import AutoGPT\n",
+    "from langchain_experimental.autonomous_agents import AutoGPT\n",
     "from langchain.chat_models import ChatOpenAI"
    ]
   },
@@ -124,43 +124,47 @@
   },
   {
    "cell_type": "markdown",
+   "id": "f0f208d9",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Run an example\n",
     "\n",
     "Here we will make it write a weather report for SF"
-   ],
-   "metadata": {
-    "collapsed": false
-   },
-   "id": "f0f208d9"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "outputs": [],
-   "source": [
-    "agent.run([\"write a weather report for SF today\"])"
-   ],
+   "id": "d119d788",
    "metadata": {
     "collapsed": false
    },
-   "id": "d119d788"
+   "outputs": [],
+   "source": [
+    "agent.run([\"write a weather report for SF today\"])"
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "f13f8322",
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
     "## Chat History Memory\n",
     "\n",
     "In addition to the memory that holds the agent immediate steps, we also have a chat history memory. By default, the agent will use 'ChatMessageHistory' and it can be changed. This is useful when you want to use a different type of memory for example 'FileChatHistoryMemory'"
-   ],
-   "metadata": {
-    "collapsed": false
-   },
-   "id": "f13f8322"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "2a81f5ad",
+   "metadata": {
+    "collapsed": false
+   },
    "outputs": [],
    "source": [
     "from langchain.memory.chat_message_histories import FileChatMessageHistory\n",
@@ -173,19 +177,15 @@
     "    memory=vectorstore.as_retriever(),\n",
     "    chat_history_memory=FileChatMessageHistory(\"chat_history.txt\"),\n",
     ")"
-   ],
-   "metadata": {
-    "collapsed": false
-   },
-   "id": "2a81f5ad"
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [],
+   "id": "b1403008",
    "metadata": {
     "collapsed": false
    },
-   "id": "b1403008"
+   "source": []
   }
  ],
  "metadata": {
@@ -209,4 +209,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

docs/extras/use_cases/autonomous_agents/baby_agi.ipynb

@@ -39,7 +39,7 @@
     "from langchain.vectorstores.base import VectorStore\n",
     "from pydantic import BaseModel, Field\n",
     "from langchain.chains.base import Chain\n",
-    "from langchain.experimental import BabyAGI"
+    "from langchain_experimental.autonomous_agents import BabyAGI"
    ]
   },
   {

docs/extras/use_cases/autonomous_agents/baby_agi_with_agent.ipynb

@@ -35,7 +35,7 @@
     "from langchain.vectorstores.base import VectorStore\n",
     "from pydantic import BaseModel, Field\n",
     "from langchain.chains.base import Chain\n",
-    "from langchain.experimental import BabyAGI"
+    "from langchain_experimental.autonomous_agents import BabyAGI"
    ]
   },
   {

docs/extras/use_cases/autonomous_agents/marathon_times.ipynb

@@ -36,7 +36,7 @@
     "# General\n",
     "import os\n",
     "import pandas as pd\n",
-    "from langchain.experimental.autonomous_agents.autogpt.agent import AutoGPT\n",
+    "from langchain_experimental.autonomous_agents import AutoGPT\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "\n",
     "from langchain.agents.agent_toolkits.pandas.base import create_pandas_dataframe_agent\n",

docs/extras/use_cases/chatbots.ipynb

@@ -0,0 +1,745 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ee7f95e4",
+   "metadata": {},
+   "source": [
+    "# Chatbots\n",
+    "\n",
+    "[![Open In Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/extras/use_cases/chatbots/chatbots.ipynb)\n",
+    "\n",
+    "## Use case\n",
+    "\n",
+    "Chat is one of the central LLM use-cases. \n",
+    "\n",
+    "Aside from the base prompts and LLMs, memory is an important concept in Chatbots. \n",
+    "\n",
+    "Chat based applications rely on remembering what happened in previous interactions using memory."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56615b45",
+   "metadata": {},
+   "source": [
+    "![Image description](/img/chat_use_case.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff48f490",
+   "metadata": {},
+   "source": [
+    "## Overview\n",
+    "\n",
+    "The chat model interface is based around messages rather than raw text. \n",
+    "\n",
+    "Several components are important to consider for chat:\n",
+    "\n",
+    "* `chat_model`: See [here](/docs/integrations/chat) for a list of chat model integrations and [here](/docs/modules/model_io/models/chat) for documentation on chat models\n",
+    "* `prompt`: Chat prompt can supply a system message to the LLM along with user and AI keys\n",
+    "* `memory`: [See here](/docs/modules/memory/) for in-depth documentation on memory types\n",
+    "\n",
+    "## Quickstart"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5070a1fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install langchain openai \n",
+    "\n",
+    "# Set env var OPENAI_API_KEY or load from a .env file:\n",
+    "# import dotenv\n",
+    "# dotenv.load_env()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd13e398",
+   "metadata": {},
+   "source": [
+    "Here we pass a prompt to an LLM:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "850eb5b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"\\n\\nJ'adore la programmation.\""
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "\n",
+    "llm = OpenAI() \n",
+    "llm(\"Translate this sentence from English to French: I love programming.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88197b95",
+   "metadata": {},
+   "source": [
+    "With a chat model, we can get chat completions by [passing one or more messages](/docs/modules/model_io/models/chat). \n",
+    "\n",
+    "The chat model will respond with a message."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "5b0d84ae",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"J'adore la programmation.\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "\n",
+    "chat = ChatOpenAI()\n",
+    "chat([HumanMessage(content=\"Translate this sentence from English to French: I love programming.\")])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7935d9a5",
+   "metadata": {},
+   "source": [
+    "We can also pass a set of chat messages."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "afd27a9f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"J'adore la programmation.\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "messages = [\n",
+    "    SystemMessage(content=\"You are a helpful assistant that translates English to French.\"),\n",
+    "    HumanMessage(content=\"I love programming.\")\n",
+    "]\n",
+    "chat(messages)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c7a1d169",
+   "metadata": {},
+   "source": [
+    "We can use a `ConversationChain`, which has built-in memory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "fdb05d74",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Je adore la programmation.'"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chains import ConversationChain  \n",
+    "  \n",
+    "conversation = ConversationChain(llm=chat)  \n",
+    "conversation.run(\"Translate this sentence from English to French: I love programming.\")  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "d801a173",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Ich liebe Programmieren.'"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation.run(\"Translate it to German.\")  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e86788c",
+   "metadata": {},
+   "source": [
+    "## Memory \n",
+    "\n",
+    "[See here](/docs/modules/memory/) for in-depth documentation on memory types.\n",
+    "\n",
+    "But, `ConversationBufferMemory` is a simple and commonly used form of memory:\n",
+    "\n",
+    "* This memory allows for storing of messages\n",
+    "* It extracts the messages in a variable\n",
+    "* It can messagess into the prompt template"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1380a4ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationBufferMemory\n",
+    "memory = ConversationBufferMemory()\n",
+    "memory.chat_memory.add_user_message(\"hi!\")\n",
+    "memory.chat_memory.add_ai_message(\"whats up?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a3d5d1f8",
+   "metadata": {},
+   "source": [
+    "See the history."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "982467e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': 'Human: hi!\\nAI: whats up?'}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c1b20d4",
+   "metadata": {},
+   "source": [
+    "We can also keep a sliding window of the most recent `K` interactions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f72b9ff7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': 'Human: not much you\\nAI: not much'}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.memory import ConversationBufferWindowMemory\n",
+    "memory = ConversationBufferWindowMemory( k=1)\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"output\": \"whats up\"})\n",
+    "memory.save_context({\"input\": \"not much you\"}, {\"output\": \"not much\"})\n",
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b84f90a",
+   "metadata": {},
+   "source": [
+    "`ConversationSummaryMemory` is an extension of this theme.\n",
+    "\n",
+    "It creates a summary of the conversation over time. \n",
+    "\n",
+    "This memory is most useful for longer conversations where the full message history would consume many tokens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "ca2596ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "from langchain.memory import ConversationSummaryMemory\n",
+    "llm=OpenAI(temperature=0)\n",
+    "memory = ConversationSummaryMemory(llm=llm)\n",
+    "memory.save_context({\"input\": \"hi\"},{\"output\": \"whats up\"})\n",
+    "memory.save_context({\"input\": \"im working on better docs for chatbots\"},{\"output\": \"oh, that sounds like a lot of work\"})\n",
+    "memory.save_context({\"input\": \"yes, but it's worth the effort\"},{\"output\": \"agreed, good docs are important!\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "060f69b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': '\\nThe human greets the AI, to which the AI responds. The human then mentions they are working on better docs for chatbots, to which the AI responds that it sounds like a lot of work. The human agrees that it is worth the effort, and the AI agrees that good docs are important.'}"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4bf036f6",
+   "metadata": {},
+   "source": [
+    "`ConversationSummaryBufferMemory` extends this a bit further:\n",
+    "\n",
+    "It uses token length rather than number of interactions to determine when to flush interactions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "38b42728",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationSummaryBufferMemory\n",
+    "memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10)\n",
+    "memory.save_context({\"input\": \"hi\"}, {\"output\": \"whats up\"})\n",
+    "memory.save_context({\"input\": \"not much you\"}, {\"output\": \"not much\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff0db09f",
+   "metadata": {},
+   "source": [
+    "## Chat \n",
+    "\n",
+    "We can unpack what goes under the hood with `ConversationChain`. \n",
+    "\n",
+    "We can specify our memory, `ConversationSummaryMemory` and we can specify the prompt. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "fccd6995",
+   "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;3mSystem: You are a nice chatbot having a conversation with a human.\n",
+      "Human: hi\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'hi',\n",
+       " 'chat_history': [HumanMessage(content='hi', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Hello! How can I assist you today?', additional_kwargs={}, example=False)],\n",
+       " 'text': 'Hello! How can I assist you today?'}"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.prompts import (\n",
+    "    ChatPromptTemplate,\n",
+    "    MessagesPlaceholder,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.chains import LLMChain\n",
+    "\n",
+    "# LLM\n",
+    "llm = ChatOpenAI()\n",
+    "\n",
+    "# Prompt \n",
+    "prompt = ChatPromptTemplate(\n",
+    "    messages=[\n",
+    "        SystemMessagePromptTemplate.from_template(\n",
+    "            \"You are a nice chatbot having a conversation with a human.\"\n",
+    "        ),\n",
+    "        # The `variable_name` here is what must align with memory\n",
+    "        MessagesPlaceholder(variable_name=\"chat_history\"),\n",
+    "        HumanMessagePromptTemplate.from_template(\"{question}\")\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "# Notice that we `return_messages=True` to fit into the MessagesPlaceholder\n",
+    "# Notice that `\"chat_history\"` aligns with the MessagesPlaceholder name\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\",return_messages=True)\n",
+    "conversation = LLMChain(\n",
+    "    llm=llm,\n",
+    "    prompt=prompt,\n",
+    "    verbose=True,\n",
+    "    memory=memory\n",
+    ")\n",
+    "\n",
+    "# Notice that we just pass in the `question` variables - `chat_history` gets populated by memory\n",
+    "conversation({\"question\": \"hi\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "eb0cadfd",
+   "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;3mSystem: You are a nice chatbot having a conversation with a human.\n",
+      "Human: hi\n",
+      "AI: Hello! How can I assist you today?\n",
+      "Human: Translate this sentence from English to French: I love programming.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'Translate this sentence from English to French: I love programming.',\n",
+       " 'chat_history': [HumanMessage(content='hi', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Hello! How can I assist you today?', additional_kwargs={}, example=False),\n",
+       "  HumanMessage(content='Translate this sentence from English to French: I love programming.', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Sure! The translation of \"I love programming\" from English to French is \"J\\'adore programmer.\"', additional_kwargs={}, example=False)],\n",
+       " 'text': 'Sure! The translation of \"I love programming\" from English to French is \"J\\'adore programmer.\"'}"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation({\"question\": \"Translate this sentence from English to French: I love programming.\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "c56d6219",
+   "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;3mSystem: You are a nice chatbot having a conversation with a human.\n",
+      "Human: hi\n",
+      "AI: Hello! How can I assist you today?\n",
+      "Human: Translate this sentence from English to French: I love programming.\n",
+      "AI: Sure! The translation of \"I love programming\" from English to French is \"J'adore programmer.\"\n",
+      "Human: Now translate the sentence to German.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'Now translate the sentence to German.',\n",
+       " 'chat_history': [HumanMessage(content='hi', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Hello! How can I assist you today?', additional_kwargs={}, example=False),\n",
+       "  HumanMessage(content='Translate this sentence from English to French: I love programming.', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Sure! The translation of \"I love programming\" from English to French is \"J\\'adore programmer.\"', additional_kwargs={}, example=False),\n",
+       "  HumanMessage(content='Now translate the sentence to German.', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Certainly! The translation of \"I love programming\" from English to German is \"Ich liebe das Programmieren.\"', additional_kwargs={}, example=False)],\n",
+       " 'text': 'Certainly! The translation of \"I love programming\" from English to German is \"Ich liebe das Programmieren.\"'}"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversation({\"question\": \"Now translate the sentence to German.\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "43858489",
+   "metadata": {},
+   "source": [
+    "We can see the chat history preserved in the prompt using the [LangSmith trace](https://smith.langchain.com/public/dce34c57-21ca-4283-9020-a8e0d78a59de/r).\n",
+    "\n",
+    "![Image description](/img/chat_use_case_2.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f35cc16",
+   "metadata": {},
+   "source": [
+    "## Chat Retrieval\n",
+    "\n",
+    "Now, suppose we want to [chat with documents](https://twitter.com/mayowaoshin/status/1640385062708424708?s=20).\n",
+    "\n",
+    "This is popular use case, combining chat with [document retrieval](docs/use_cases/question_answering/).\n",
+    "\n",
+    "It allows us to chat with specific information that the model was not trained on."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1a01e7b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install tiktoken chromadb"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88e220de",
+   "metadata": {},
+   "source": [
+    "Load a blog post."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "1b99b36c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import WebBaseLoader\n",
+    "\n",
+    "loader = WebBaseLoader(\"https://lilianweng.github.io/posts/2023-06-23-agent/\")\n",
+    "data = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3662ce79",
+   "metadata": {},
+   "source": [
+    "Split and store this in a vector."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "058f1541",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "\n",
+    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)\n",
+    "all_splits = text_splitter.split_documents(data)\n",
+    "\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import Chroma\n",
+    "\n",
+    "vectorstore = Chroma.from_documents(documents=all_splits, embedding=OpenAIEmbeddings())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "603d9441",
+   "metadata": {},
+   "source": [
+    "Create our memory, as before, but's let's use `ConversationSummaryMemory`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "f89fd3f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationSummaryMemory(llm=llm,memory_key=\"chat_history\",return_messages=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "28503423",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.chains import ConversationalRetrievalChain\n",
+    "\n",
+    "llm = ChatOpenAI()\n",
+    "retriever = vectorstore.as_retriever()\n",
+    "qa = ConversationalRetrievalChain.from_llm(llm, retriever=retriever, memory=memory)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "a9c3bd5e",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'How do agents use Task decomposition?',\n",
+       " 'chat_history': [SystemMessage(content='', additional_kwargs={})],\n",
+       " 'answer': 'Agents can use task decomposition in several ways:\\n\\n1. Simple prompting: Agents can use Language Model based prompting to break down tasks into subgoals. For example, by providing prompts like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\", the agent can generate a sequence of smaller steps that lead to the completion of the overall task.\\n\\n2. Task-specific instructions: Agents can be given task-specific instructions to guide their planning process. For example, if the task is to write a novel, the agent can be instructed to \"Write a story outline.\" This provides a high-level structure for the task and helps in breaking it down into smaller components.\\n\\n3. Human inputs: Agents can also take inputs from humans to decompose tasks. This can be done through direct communication or by leveraging human expertise. Humans can provide guidance and insights to help the agent break down complex tasks into manageable subgoals.\\n\\nOverall, task decomposition allows agents to break down large tasks into smaller, more manageable subgoals, enabling them to plan and execute complex tasks efficiently.'}"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qa(\"How do agents use Task decomposition?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "a29a7713",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'What are the various ways to implemet memory to support it?',\n",
+       " 'chat_history': [SystemMessage(content='The human asks how agents use task decomposition. The AI explains that agents can use task decomposition in several ways, including simple prompting, task-specific instructions, and human inputs. Task decomposition allows agents to break down large tasks into smaller, more manageable subgoals, enabling them to plan and execute complex tasks efficiently.', additional_kwargs={})],\n",
+       " 'answer': 'There are several ways to implement memory to support task decomposition:\\n\\n1. Long-Term Memory Management: This involves storing and organizing information in a long-term memory system. The agent can retrieve past experiences, knowledge, and learned strategies to guide the task decomposition process.\\n\\n2. Internet Access: The agent can use internet access to search for relevant information and gather resources to aid in task decomposition. This allows the agent to access a vast amount of information and utilize it in the decomposition process.\\n\\n3. GPT-3.5 Powered Agents: The agent can delegate simple tasks to GPT-3.5 powered agents. These agents can perform specific tasks or provide assistance in task decomposition, allowing the main agent to focus on higher-level planning and decision-making.\\n\\n4. File Output: The agent can store the results of task decomposition in files or documents. This allows for easy retrieval and reference during the execution of the task.\\n\\nThese memory resources help the agent in organizing and managing information, making informed decisions, and effectively decomposing complex tasks into smaller, manageable subgoals.'}"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "qa(\"What are the various ways to implemet memory to support it?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5e8d5f4",
+   "metadata": {},
+   "source": [
+    "Again, we can use the [LangSmith trace](https://smith.langchain.com/public/9ed55734-8cda-428e-99c4-c9f810270841/r) to explore the prompt structure."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/use_cases/chatbots/index.mdx

@@ -1,20 +0,0 @@
----
-sidebar_position: 4
----
-
-# Chatbots
-
-Since language models are good at producing text, that makes them ideal for creating chatbots.
-Aside from the base prompts/LLMs, an important concept to know for Chatbots is `memory`.
-Most chat based applications rely on remembering what happened in previous interactions, which `memory` is designed to help with.
-
-The following resources exist:
-- [ChatGPT Clone](/docs/modules/agents/how_to/chatgpt_clone.html): A notebook walking through how to recreate a ChatGPT-like experience with LangChain.
-- [Conversation Agent](/docs/modules/agents/agent_types/chat_conversation_agent.html): A notebook walking through how to create an agent optimized for conversation.
-
-
-Additional related resources include:
-- [Memory concepts and examples](/docs/modules/memory/): Explanation of key concepts related to memory along with how-to's and examples.
-
-More end-to-end examples include:
-- [Voice Assistant](./voice_assistant.html): A notebook walking through how to create a voice assistant using LangChain.

docs/extras/use_cases/chatbots/voice_assistant.ipynb

@@ -1,482 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Voice Assistant\n",
-    "\n",
-    "This chain creates a clone of ChatGPT with a few modifications to make it a voice assistant. \n",
-    "It uses the `pyttsx3` and `speech_recognition` libraries to convert text to speech and speech to text respectively. The prompt template is also changed to make it more suitable for voice assistant use."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain import OpenAI, LLMChain, PromptTemplate\n",
-    "from langchain.memory import ConversationBufferWindowMemory\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",
-    "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-    "\n",
-    "{history}\n",
-    "Human: {human_input}\n",
-    "Assistant:\"\"\"\n",
-    "\n",
-    "prompt = PromptTemplate(input_variables=[\"history\", \"human_input\"], template=template)\n",
-    "\n",
-    "\n",
-    "chatgpt_chain = LLMChain(\n",
-    "    llm=OpenAI(temperature=0),\n",
-    "    prompt=prompt,\n",
-    "    verbose=True,\n",
-    "    memory=ConversationBufferWindowMemory(k=2),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import speech_recognition as sr\n",
-    "import pyttsx3\n",
-    "\n",
-    "engine = pyttsx3.init()\n",
-    "\n",
-    "\n",
-    "def listen():\n",
-    "    r = sr.Recognizer()\n",
-    "    with sr.Microphone() as source:\n",
-    "        print(\"Calibrating...\")\n",
-    "        r.adjust_for_ambient_noise(source, duration=5)\n",
-    "        # optional parameters to adjust microphone sensitivity\n",
-    "        # r.energy_threshold = 200\n",
-    "        # r.pause_threshold=0.5\n",
-    "\n",
-    "        print(\"Okay, go!\")\n",
-    "        while 1:\n",
-    "            text = \"\"\n",
-    "            print(\"listening now...\")\n",
-    "            try:\n",
-    "                audio = r.listen(source, timeout=5, phrase_time_limit=30)\n",
-    "                print(\"Recognizing...\")\n",
-    "                # whisper model options are found here: https://github.com/openai/whisper#available-models-and-languages\n",
-    "                # other speech recognition models are also available.\n",
-    "                text = r.recognize_whisper(\n",
-    "                    audio,\n",
-    "                    model=\"medium.en\",\n",
-    "                    show_dict=True,\n",
-    "                )[\"text\"]\n",
-    "            except Exception as e:\n",
-    "                unrecognized_speech_text = (\n",
-    "                    f\"Sorry, I didn't catch that. Exception was: {e}s\"\n",
-    "                )\n",
-    "                text = unrecognized_speech_text\n",
-    "            print(text)\n",
-    "\n",
-    "            response_text = chatgpt_chain.predict(human_input=text)\n",
-    "            print(response_text)\n",
-    "            engine.say(response_text)\n",
-    "            engine.runAndWait()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Calibrating...\n",
-      "Okay, go!\n",
-      "listening now...\n",
-      "Recognizing...\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "C:\\Users\\jaden\\AppData\\Roaming\\Python\\Python310\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Hello, Assistant. What's going on?\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "\n",
-      "Human:  Hello, Assistant. What's going on?\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " Hi there! It's great to hear from you. I'm doing well. How can I help you today?\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " That's cool. Isn't that neat? Yeah, I'm doing great.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Hello, Assistant. What's going on?\n",
-      "AI:  Hi there! It's great to hear from you. I'm doing well. How can I help you today?\n",
-      "Human:  That's cool. Isn't that neat? Yeah, I'm doing great.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      "  That's great to hear! What can I do for you today?\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Thank you.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Hello, Assistant. What's going on?\n",
-      "AI:  Hi there! It's great to hear from you. I'm doing well. How can I help you today?\n",
-      "Human:  That's cool. Isn't that neat? Yeah, I'm doing great.\n",
-      "AI:   That's great to hear! What can I do for you today?\n",
-      "Human:  Thank you.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " You're welcome! Is there anything else I can help you with?\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " I'd like to learn more about neural networks.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  That's cool. Isn't that neat? Yeah, I'm doing great.\n",
-      "AI:   That's great to hear! What can I do for you today?\n",
-      "Human:  Thank you.\n",
-      "AI:  You're welcome! Is there anything else I can help you with?\n",
-      "Human:  I'd like to learn more about neural networks.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " Sure! Neural networks are a type of artificial intelligence that use a network of interconnected nodes to process data and make decisions. They are used in a variety of applications, from image recognition to natural language processing. Neural networks are often used to solve complex problems that are too difficult for traditional algorithms.\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Tell me a fun fact about neural networks.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Thank you.\n",
-      "AI:  You're welcome! Is there anything else I can help you with?\n",
-      "Human:  I'd like to learn more about neural networks.\n",
-      "AI:  Sure! Neural networks are a type of artificial intelligence that use a network of interconnected nodes to process data and make decisions. They are used in a variety of applications, from image recognition to natural language processing. Neural networks are often used to solve complex problems that are too difficult for traditional algorithms.\n",
-      "Human:  Tell me a fun fact about neural networks.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " Neural networks are inspired by the way the human brain works. They are composed of interconnected nodes that process data and make decisions, just like neurons in the brain. Neural networks can learn from their mistakes and improve their performance over time, just like humans do.\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Tell me about a brand new discovered bird species.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  I'd like to learn more about neural networks.\n",
-      "AI:  Sure! Neural networks are a type of artificial intelligence that use a network of interconnected nodes to process data and make decisions. They are used in a variety of applications, from image recognition to natural language processing. Neural networks are often used to solve complex problems that are too difficult for traditional algorithms.\n",
-      "Human:  Tell me a fun fact about neural networks.\n",
-      "AI:  Neural networks are inspired by the way the human brain works. They are composed of interconnected nodes that process data and make decisions, just like neurons in the brain. Neural networks can learn from their mistakes and improve their performance over time, just like humans do.\n",
-      "Human:  Tell me about a brand new discovered bird species.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " A new species of bird was recently discovered in the Amazon rainforest. The species, called the Spix's Macaw, is a small, blue parrot that is believed to be extinct in the wild. It is the first new species of bird to be discovered in the Amazon in over 100 years.\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Tell me a children's story about the importance of honesty and trust.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Tell me a fun fact about neural networks.\n",
-      "AI:  Neural networks are inspired by the way the human brain works. They are composed of interconnected nodes that process data and make decisions, just like neurons in the brain. Neural networks can learn from their mistakes and improve their performance over time, just like humans do.\n",
-      "Human:  Tell me about a brand new discovered bird species.\n",
-      "AI:  A new species of bird was recently discovered in the Amazon rainforest. The species, called the Spix's Macaw, is a small, blue parrot that is believed to be extinct in the wild. It is the first new species of bird to be discovered in the Amazon in over 100 years.\n",
-      "Human:  Tell me a children's story about the importance of honesty and trust.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " Once upon a time, there was a young boy named Jack who lived in a small village. Jack was always honest and trustworthy, and his friends and family knew they could always count on him. One day, Jack was walking through the forest when he stumbled upon a magical tree. The tree told Jack that if he was honest and trustworthy, he would be rewarded with a special gift. Jack was so excited, and he promised to always be honest and trustworthy. Sure enough, the tree rewarded Jack with a beautiful golden apple. From that day forward, Jack was always honest and trustworthy, and he was rewarded with many more magical gifts. The moral of the story is that honesty and trust are the most important things in life.\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Wow, Assistant, that was a really good story. Congratulations!\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Tell me about a brand new discovered bird species.\n",
-      "AI:  A new species of bird was recently discovered in the Amazon rainforest. The species, called the Spix's Macaw, is a small, blue parrot that is believed to be extinct in the wild. It is the first new species of bird to be discovered in the Amazon in over 100 years.\n",
-      "Human:  Tell me a children's story about the importance of honesty and trust.\n",
-      "AI:  Once upon a time, there was a young boy named Jack who lived in a small village. Jack was always honest and trustworthy, and his friends and family knew they could always count on him. One day, Jack was walking through the forest when he stumbled upon a magical tree. The tree told Jack that if he was honest and trustworthy, he would be rewarded with a special gift. Jack was so excited, and he promised to always be honest and trustworthy. Sure enough, the tree rewarded Jack with a beautiful golden apple. From that day forward, Jack was always honest and trustworthy, and he was rewarded with many more magical gifts. The moral of the story is that honesty and trust are the most important things in life.\n",
-      "Human:  Wow, Assistant, that was a really good story. Congratulations!\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " Thank you! I'm glad you enjoyed it.\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Thank you.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Tell me a children's story about the importance of honesty and trust.\n",
-      "AI:  Once upon a time, there was a young boy named Jack who lived in a small village. Jack was always honest and trustworthy, and his friends and family knew they could always count on him. One day, Jack was walking through the forest when he stumbled upon a magical tree. The tree told Jack that if he was honest and trustworthy, he would be rewarded with a special gift. Jack was so excited, and he promised to always be honest and trustworthy. Sure enough, the tree rewarded Jack with a beautiful golden apple. From that day forward, Jack was always honest and trustworthy, and he was rewarded with many more magical gifts. The moral of the story is that honesty and trust are the most important things in life.\n",
-      "Human:  Wow, Assistant, that was a really good story. Congratulations!\n",
-      "AI:  Thank you! I'm glad you enjoyed it.\n",
-      "Human:  Thank you.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " You're welcome!\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way? Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way?\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Wow, Assistant, that was a really good story. Congratulations!\n",
-      "AI:  Thank you! I'm glad you enjoyed it.\n",
-      "Human:  Thank you.\n",
-      "AI:  You're welcome!\n",
-      "Human:  Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way? Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way?\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " Yes, there are several online brands that offer photo editing and other creative tools without the need to download any software. Adobe Photoshop Express, Pixlr, and Fotor are some of the most popular online photo editing tools. Freq is an online music production platform that allows users to create and share music without downloading any software.\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " Our whole process of awesome is free.\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Thank you.\n",
-      "AI:  You're welcome!\n",
-      "Human:  Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way? Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way?\n",
-      "AI:  Yes, there are several online brands that offer photo editing and other creative tools without the need to download any software. Adobe Photoshop Express, Pixlr, and Fotor are some of the most popular online photo editing tools. Freq is an online music production platform that allows users to create and share music without downloading any software.\n",
-      "Human:  Our whole process of awesome is free.\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " That's great! It's always nice to have access to free tools and resources.\n",
-      "listening now...\n",
-      "Recognizing...\n",
-      " No, I meant to ask, are those options that you mentioned free? No, I meant to ask, are those options that you mentioned free?\n",
-      "\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",
-      "Assistant is aware that human input is being transcribed from audio and as such there may be some errors in the transcription. It will attempt to account for some words being swapped with similar-sounding words or phrases. Assistant will also keep responses concise, because human attention spans are more limited over the audio channel since it takes time to listen to a response.\n",
-      "\n",
-      "Human:  Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way? Do you know of online brands like Photoshop and Freq that you don't have to download in some sort of way?\n",
-      "AI:  Yes, there are several online brands that offer photo editing and other creative tools without the need to download any software. Adobe Photoshop Express, Pixlr, and Fotor are some of the most popular online photo editing tools. Freq is an online music production platform that allows users to create and share music without downloading any software.\n",
-      "Human:  Our whole process of awesome is free.\n",
-      "AI:  That's great! It's always nice to have access to free tools and resources.\n",
-      "Human:  No, I meant to ask, are those options that you mentioned free? No, I meant to ask, are those options that you mentioned free?\n",
-      "Assistant:\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      " Yes, the online brands I mentioned are all free to use. Adobe Photoshop Express, Pixlr, and Fotor are all free to use, and Freq is a free music production platform.\n",
-      "listening now...\n"
-     ]
-    },
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[6], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m listen(\u001b[39mNone\u001b[39;49;00m)\n",
-      "Cell \u001b[1;32mIn[5], line 20\u001b[0m, in \u001b[0;36mlisten\u001b[1;34m(command_queue)\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mlistening now...\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m     19\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m---> 20\u001b[0m     audio \u001b[39m=\u001b[39m r\u001b[39m.\u001b[39;49mlisten(source, timeout\u001b[39m=\u001b[39;49m\u001b[39m5\u001b[39;49m, phrase_time_limit\u001b[39m=\u001b[39;49m\u001b[39m30\u001b[39;49m)\n\u001b[0;32m     21\u001b[0m     \u001b[39m# audio = r.record(source,duration = 5)\u001b[39;00m\n\u001b[0;32m     22\u001b[0m     \u001b[39mprint\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mRecognizing...\u001b[39m\u001b[39m'\u001b[39m)\n",
-      "File \u001b[1;32mc:\\ProgramData\\miniconda3\\envs\\lang\\lib\\site-packages\\speech_recognition\\__init__.py:523\u001b[0m, in \u001b[0;36mRecognizer.listen\u001b[1;34m(self, source, timeout, phrase_time_limit, snowboy_configuration)\u001b[0m\n\u001b[0;32m    520\u001b[0m \u001b[39mif\u001b[39;00m phrase_time_limit \u001b[39mand\u001b[39;00m elapsed_time \u001b[39m-\u001b[39m phrase_start_time \u001b[39m>\u001b[39m phrase_time_limit:\n\u001b[0;32m    521\u001b[0m     \u001b[39mbreak\u001b[39;00m\n\u001b[1;32m--> 523\u001b[0m buffer \u001b[39m=\u001b[39m source\u001b[39m.\u001b[39;49mstream\u001b[39m.\u001b[39;49mread(source\u001b[39m.\u001b[39;49mCHUNK)\n\u001b[0;32m    524\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(buffer) \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m: \u001b[39mbreak\u001b[39;00m  \u001b[39m# reached end of the stream\u001b[39;00m\n\u001b[0;32m    525\u001b[0m frames\u001b[39m.\u001b[39mappend(buffer)\n",
-      "File \u001b[1;32mc:\\ProgramData\\miniconda3\\envs\\lang\\lib\\site-packages\\speech_recognition\\__init__.py:199\u001b[0m, in \u001b[0;36mMicrophone.MicrophoneStream.read\u001b[1;34m(self, size)\u001b[0m\n\u001b[0;32m    198\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mread\u001b[39m(\u001b[39mself\u001b[39m, size):\n\u001b[1;32m--> 199\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mpyaudio_stream\u001b[39m.\u001b[39;49mread(size, exception_on_overflow\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m)\n",
-      "File \u001b[1;32mc:\\ProgramData\\miniconda3\\envs\\lang\\lib\\site-packages\\pyaudio\\__init__.py:570\u001b[0m, in \u001b[0;36mPyAudio.Stream.read\u001b[1;34m(self, num_frames, exception_on_overflow)\u001b[0m\n\u001b[0;32m    567\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_is_input:\n\u001b[0;32m    568\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mIOError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mNot input stream\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[0;32m    569\u001b[0m                   paCanNotReadFromAnOutputOnlyStream)\n\u001b[1;32m--> 570\u001b[0m \u001b[39mreturn\u001b[39;00m pa\u001b[39m.\u001b[39;49mread_stream(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_stream, num_frames,\n\u001b[0;32m    571\u001b[0m                       exception_on_overflow)\n",
-      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
-     ]
-    }
-   ],
-   "source": [
-    "listen(None)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "lang",
-   "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.10"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/extras/use_cases/graph/neptune_cypher_qa.ipynb

@@ -10,11 +10,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.graphs.neptune_graph import NeptuneGraph\n",
+    "from langchain.graphs import NeptuneGraph\n",
     "\n",
     "\n",
     "host = \"<neptune-host>\"\n",
@@ -26,12 +26,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The Austin airport has 98 outgoing routes.'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.chains.graph_qa.neptune_cypher import NeptuneOpenCypherQAChain\n",
+    "from langchain.chains import NeptuneOpenCypherQAChain\n",
     "\n",
     "llm = ChatOpenAI(temperature=0, model=\"gpt-4\")\n",
     "\n",
@@ -42,8 +53,22 @@
   }
  ],
  "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
   "language_info": {
-   "name": "python"
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
   },
   "orig_nbformat": 4
  },

docs/extras/use_cases/graph/tot.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Tree of Thought (ToT) example\n",
     "\n",
-    "The Tree of Thought (ToT) is a chain that allows you to query a Large Language Model (LLM) using the Tree of Thought technique. This is based on the papaer [\"Large Language Model Guided Tree-of-Thought\"](https://arxiv.org/pdf/2305.08291.pdf)"
+    "The Tree of Thought (ToT) is a chain that allows you to query a Large Language Model (LLM) using the Tree of Thought technique. This is based on the paper [\"Large Language Model Guided Tree-of-Thought\"](https://arxiv.org/pdf/2305.08291.pdf)"
    ]
   },
   {

docs/extras/use_cases/tabular/sql_query.ipynb

@@ -0,0 +1,125 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c04293ac",
+   "metadata": {},
+   "source": [
+    "# SQL Query\n",
+    "\n",
+    "This notebook walks through how to load and run a chain that constructs SQL queries that can be run against your database to answer a question. Note that this ONLY constructs the query and does not run it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e9063a93",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import create_sql_query_chain\n",
+    "\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.utilities import SQLDatabase"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "a1ff5cee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db = SQLDatabase.from_uri(\"sqlite:///../../../../notebooks/Chinook.db\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "cb04579f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = create_sql_query_chain(ChatOpenAI(temperature=0), db)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "744e6210",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "response = chain.invoke({\"question\":\"How many employees are there\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "28f984f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SELECT COUNT(*) FROM Employee\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(response)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "08de511c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'[(8,)]'"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "db.run(response)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3a006a7",
+   "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/snippets/modules/agents/agent_types/plan_and_execute.mdx

@@ -3,7 +3,7 @@
 
 ```python
 from langchain.chat_models import ChatOpenAI
-from langchain.experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner
+from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner
 from langchain.llms import OpenAI
 from langchain import SerpAPIWrapper
 from langchain.agents.tools import Tool

libs/experimental/langchain_experimental/llms/anthropic_functions.py

@@ -0,0 +1,206 @@
+import json
+from collections import defaultdict
+from html.parser import HTMLParser
+from typing import Any, DefaultDict, Dict, List, Optional
+
+from langchain.callbacks.manager import (
+    CallbackManagerForLLMRun,
+    Callbacks,
+)
+from langchain.chat_models.anthropic import ChatAnthropic
+from langchain.chat_models.base import BaseChatModel
+from langchain.schema import (
+    ChatGeneration,
+    ChatResult,
+    LLMResult,
+)
+from langchain.schema.messages import (
+    AIMessage,
+    BaseMessage,
+    SystemMessage,
+)
+from pydantic import root_validator
+
+prompt = """In addition to responding, you can use tools. \
+You have access to the following tools.
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> to specify the name, \
+and the <tool_input></tool_input> tags to specify the parameters. \
+Each parameter should be passed in as <$param_name>$value</$param_name>, \
+Where $param_name is the name of the specific parameter, and $value \
+is the value for that parameter.
+
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that accepts a single \
+parameter 'query' that could run a google search, in order to search \
+for the weather in SF you would respond:
+
+<tool>search</tool><tool_input><query>weather in SF</query></tool_input>
+<observation>64 degrees</observation>"""
+
+
+class TagParser(HTMLParser):
+    def __init__(self) -> None:
+        """A heavy-handed solution, but it's fast for prototyping.
+
+        Might be re-implemented later to restrict scope to the limited grammar, and
+        more efficiency.
+
+        Uses an HTML parser to parse a limited grammar that allows
+        for syntax of the form:
+
+            INPUT -> JUNK? VALUE*
+            JUNK -> JUNK_CHARACTER+
+            JUNK_CHARACTER -> whitespace | ,
+            VALUE -> <IDENTIFIER>DATA</IDENTIFIER> | OBJECT
+            OBJECT -> <IDENTIFIER>VALUE+</IDENTIFIER>
+            IDENTIFIER -> [a-Z][a-Z0-9_]*
+            DATA -> .*
+
+        Interprets the data to allow repetition of tags and recursion
+        to support representation of complex types.
+
+        ^ Just another approximately wrong grammar specification.
+        """
+        super().__init__()
+
+        self.parse_data: DefaultDict[str, List[Any]] = defaultdict(list)
+        self.stack: List[DefaultDict[str, List[str]]] = [self.parse_data]
+        self.success = True
+        self.depth = 0
+        self.data: Optional[str] = None
+
+    def handle_starttag(self, tag: str, attrs: Any) -> None:
+        """Hook when a new tag is encountered."""
+        self.depth += 1
+        self.stack.append(defaultdict(list))
+        self.data = None
+
+    def handle_endtag(self, tag: str) -> None:
+        """Hook when a tag is closed."""
+        self.depth -= 1
+        top_of_stack = dict(self.stack.pop(-1))  # Pop the dictionary we don't need it
+
+        # If a lead node
+        is_leaf = self.data is not None
+        # Annoying to type here, code is tested, hopefully OK
+        value = self.data if is_leaf else top_of_stack
+        # Difficult to type this correctly with mypy (maybe impossible?)
+        # Can be nested indefinitely, so requires self referencing type
+        self.stack[-1][tag].append(value)  # type: ignore
+        # Reset the data so we if we encounter a sequence of end tags, we
+        # don't confuse an outer end tag for belonging to a leaf node.
+        self.data = None
+
+    def handle_data(self, data: str) -> None:
+        """Hook when handling data."""
+        stripped_data = data.strip()
+        # The only data that's allowed is whitespace or a comma surrounded by whitespace
+        if self.depth == 0 and stripped_data not in (",", ""):
+            # If this is triggered the parse should be considered invalid.
+            self.success = False
+        if stripped_data:  # ignore whitespace-only strings
+            self.data = stripped_data
+
+
+def _destrip(tool_input: Any) -> Any:
+    if isinstance(tool_input, dict):
+        return {k: _destrip(v) for k, v in tool_input.items()}
+    elif isinstance(tool_input, list):
+        if isinstance(tool_input[0], str):
+            if len(tool_input) == 1:
+                return tool_input[0]
+            else:
+                raise ValueError
+        elif isinstance(tool_input[0], dict):
+            return [_destrip(v) for v in tool_input]
+        else:
+            raise ValueError
+    else:
+        raise ValueError
+
+
+class AnthropicFunctions(BaseChatModel):
+    model: ChatAnthropic
+
+    @root_validator(pre=True)
+    def validate_environment(cls, values: Dict) -> Dict:
+        return {"model": ChatAnthropic(**values)}
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        forced = False
+        function_call = ""
+        if "functions" in kwargs:
+            content = prompt.format(tools=json.dumps(kwargs["functions"], indent=2))
+            system = SystemMessage(content=content)
+            messages = [system] + messages
+            del kwargs["functions"]
+            if stop is None:
+                stop = ["</tool_input>"]
+            else:
+                stop.append("</tool_input>")
+            if "function_call" in kwargs:
+                forced = True
+                function_call = kwargs["function_call"]["name"]
+                AIMessage(content=f"<tool>{function_call}</tool>")
+                del kwargs["function_call"]
+        else:
+            if "function_call" in kwargs:
+                raise ValueError(
+                    "if `function_call` provided, `functions` must also be"
+                )
+        response = self.model.predict_messages(
+            messages, stop=stop, callbacks=run_manager, **kwargs
+        )
+        completion = response.content
+        if forced:
+            tag_parser = TagParser()
+            tag_parser.feed(completion.strip() + "</tool_input>")
+            v1 = tag_parser.parse_data["tool_input"][0]
+            kwargs = {
+                "function_call": {
+                    "name": function_call,
+                    "arguments": json.dumps(_destrip(v1)),
+                }
+            }
+            message = AIMessage(content="", additional_kwargs=kwargs)
+            return ChatResult(generations=[ChatGeneration(message=message)])
+        elif "<tool>" in completion:
+            tag_parser = TagParser()
+            tag_parser.feed(completion.strip() + "</tool_input>")
+            msg = completion.split("<tool>")[0]
+            v1 = tag_parser.parse_data["tool_input"][0]
+            kwargs = {
+                "function_call": {
+                    "name": tag_parser.parse_data["tool"][0],
+                    "arguments": json.dumps(_destrip(v1)),
+                }
+            }
+            message = AIMessage(content=msg, additional_kwargs=kwargs)
+            return ChatResult(generations=[ChatGeneration(message=message)])
+        else:
+            return ChatResult(generations=[ChatGeneration(message=response)])
+
+    async def agenerate(
+        self,
+        messages: List[List[BaseMessage]],
+        stop: Optional[List[str]] = None,
+        callbacks: Callbacks = None,
+        *,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> LLMResult:
+        raise NotImplementedError
+
+    @property
+    def _llm_type(self) -> str:
+        return "anthropic_functions"

libs/experimental/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-experimental"
-version = "0.0.7"
+version = "0.0.8"
 description = "Building applications with LLMs through composability"
 authors = []
 license = "MIT"

libs/langchain/langchain/agents/__init__.py

@@ -39,6 +39,7 @@ from langchain.agents.react.base import ReActChain, ReActTextWorldAgent
 from langchain.agents.self_ask_with_search.base import SelfAskWithSearchChain
 from langchain.agents.structured_chat.base import StructuredChatAgent
 from langchain.agents.tools import Tool, tool
+from langchain.agents.xml.base import XMLAgent
 
 __all__ = [
     "Agent",
@@ -78,4 +79,5 @@ __all__ = [
     "load_tools",
     "tool",
     "create_xorbits_agent",
+    "XMLAgent",
 ]

libs/langchain/langchain/agents/agent_toolkits/__init__.py

@@ -11,6 +11,7 @@ from langchain.agents.agent_toolkits.gmail.toolkit import GmailToolkit
 from langchain.agents.agent_toolkits.jira.toolkit import JiraToolkit
 from langchain.agents.agent_toolkits.json.base import create_json_agent
 from langchain.agents.agent_toolkits.json.toolkit import JsonToolkit
+from langchain.agents.agent_toolkits.multion.base import create_multion_agent
 from langchain.agents.agent_toolkits.nla.toolkit import NLAToolkit
 from langchain.agents.agent_toolkits.office365.toolkit import O365Toolkit
 from langchain.agents.agent_toolkits.openapi.base import create_openapi_agent
@@ -63,6 +64,7 @@ __all__ = [
     "create_pbi_agent",
     "create_pbi_chat_agent",
     "create_python_agent",
+    "create_multion_agent",
     "create_spark_dataframe_agent",
     "create_spark_sql_agent",
     "create_sql_agent",

libs/langchain/langchain/agents/xml/base.py

@@ -0,0 +1,118 @@
+from typing import Any, List, Tuple, Union
+
+from langchain.agents.agent import AgentOutputParser, BaseSingleActionAgent
+from langchain.agents.xml.prompt import agent_instructions
+from langchain.callbacks.base import Callbacks
+from langchain.chains.llm import LLMChain
+from langchain.prompts.chat import AIMessagePromptTemplate, ChatPromptTemplate
+from langchain.schema import AgentAction, AgentFinish
+from langchain.tools.base import BaseTool
+
+
+class XMLAgentOutputParser(AgentOutputParser):
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        if "</tool>" in text:
+            tool, tool_input = text.split("</tool>")
+            _tool = tool.split("<tool>")[1]
+            _tool_input = tool_input.split("<tool_input>")[1]
+            return AgentAction(tool=_tool, tool_input=_tool_input, log=text)
+        elif "<final_answer>" in text:
+            _, answer = text.split("<final_answer>")
+            return AgentFinish(return_values={"output": answer}, log=text)
+        else:
+            raise ValueError
+
+    def get_format_instructions(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def _type(self) -> str:
+        return "xml-agent"
+
+
+class XMLAgent(BaseSingleActionAgent):
+    """Agent that uses XML tags.
+
+    Args:
+        tools: list of tools the agent can choose from
+        llm_chain: The LLMChain to call to predict the next action
+
+    Examples:
+
+        .. code-block:: python
+
+            from langchain.agents import XMLAgent
+            from langchain
+
+            tools = ...
+            model =
+
+
+    """
+
+    tools: List[BaseTool]
+    """List of tools this agent has access to."""
+    llm_chain: LLMChain
+    """Chain to use to predict action."""
+
+    @property
+    def input_keys(self) -> List[str]:
+        return ["input"]
+
+    @staticmethod
+    def get_default_prompt() -> ChatPromptTemplate:
+        return ChatPromptTemplate.from_template(
+            agent_instructions
+        ) + AIMessagePromptTemplate.from_template("{intermediate_steps}")
+
+    @staticmethod
+    def get_default_output_parser() -> XMLAgentOutputParser:
+        return XMLAgentOutputParser()
+
+    def plan(
+        self,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> Union[AgentAction, AgentFinish]:
+        log = ""
+        for action, observation in intermediate_steps:
+            log += (
+                f"<tool>{action.tool}</tool><tool_input>{action.tool_input}"
+                f"</tool_input><observation>{observation}</observation>"
+            )
+        tools = ""
+        for tool in self.tools:
+            tools += f"{tool.name}: {tool.description}\n"
+        inputs = {
+            "intermediate_steps": log,
+            "tools": tools,
+            "question": kwargs["input"],
+            "stop": ["</tool_input>", "</final_answer>"],
+        }
+        response = self.llm_chain(inputs, callbacks=callbacks)
+        return response[self.llm_chain.output_key]
+
+    async def aplan(
+        self,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> Union[AgentAction, AgentFinish]:
+        log = ""
+        for action, observation in intermediate_steps:
+            log += (
+                f"<tool>{action.tool}</tool><tool_input>{action.tool_input}"
+                f"</tool_input><observation>{observation}</observation>"
+            )
+        tools = ""
+        for tool in self.tools:
+            tools += f"{tool.name}: {tool.description}\n"
+        inputs = {
+            "intermediate_steps": log,
+            "tools": tools,
+            "question": kwargs["input"],
+            "stop": ["</tool_input>", "</final_answer>"],
+        }
+        response = await self.llm_chain.acall(inputs, callbacks=callbacks)
+        return response[self.llm_chain.output_key]

libs/langchain/langchain/agents/xml/prompt.py

@@ -0,0 +1,21 @@
+# flake8: noqa
+agent_instructions = """You are a helpful assistant. Help the user answer any questions.
+
+You have access to the following tools:
+
+{tools}
+
+In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags. \
+You will then get back a response in the form <observation></observation>
+For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:
+
+<tool>search</tool><tool_input>weather in SF</tool_input>
+<observation>64 degrees</observation>
+
+When you are done, respond with a final answer between <final_answer></final_answer>. For example:
+
+<final_answer>The weather in SF is 64 degrees</final_answer>
+
+Begin!
+
+Question: {question}"""

libs/langchain/langchain/chains/__init__.py

@@ -34,6 +34,7 @@ from langchain.chains.graph_qa.cypher import GraphCypherQAChain
 from langchain.chains.graph_qa.hugegraph import HugeGraphQAChain
 from langchain.chains.graph_qa.kuzu import KuzuQAChain
 from langchain.chains.graph_qa.nebulagraph import NebulaGraphQAChain
+from langchain.chains.graph_qa.neptune_cypher import NeptuneOpenCypherQAChain
 from langchain.chains.graph_qa.sparql import GraphSparqlQAChain
 from langchain.chains.hyde.base import HypotheticalDocumentEmbedder
 from langchain.chains.llm import LLMChain
@@ -101,6 +102,7 @@ __all__ = [
     "MultiRouteChain",
     "NatBotChain",
     "NebulaGraphQAChain",
+    "NeptuneOpenCypherQAChain",
     "OpenAIModerationChain",
     "OpenAPIEndpointChain",
     "QAGenerationChain",

libs/langchain/langchain/document_loaders/async_html.py

@@ -26,23 +26,15 @@ default_header_template = {
 class AsyncHtmlLoader(BaseLoader):
     """Loads HTML asynchronously."""
 
-    web_paths: List[str]
-
-    requests_per_second: int = 2
-    """Max number of concurrent requests to make."""
-
-    requests_kwargs: Dict[str, Any] = {}
-    """kwargs for requests"""
-
-    raise_for_status: bool = False
-    """Raise an exception if http status code denotes an error."""
-
     def __init__(
         self,
         web_path: Union[str, List[str]],
         header_template: Optional[dict] = None,
         verify_ssl: Optional[bool] = True,
         proxies: Optional[dict] = None,
+        requests_per_second: int = 2,
+        requests_kwargs: Dict[str, Any] = {},
+        raise_for_status: bool = False,
     ):
         """Initialize with webpage path."""
 
@@ -74,6 +66,10 @@ class AsyncHtmlLoader(BaseLoader):
         if proxies:
             self.session.proxies.update(proxies)
 
+        self.requests_per_second = requests_per_second
+        self.requests_kwargs = requests_kwargs
+        self.raise_for_status = raise_for_status
+
     async def _fetch(
         self, url: str, retries: int = 3, cooldown: int = 2, backoff: float = 1.5
     ) -> str:

libs/langchain/langchain/document_loaders/git.py

@@ -49,7 +49,18 @@ class GitLoader(BaseLoader):
         if not os.path.exists(self.repo_path) and self.clone_url is None:
             raise ValueError(f"Path {self.repo_path} does not exist")
         elif self.clone_url:
-            repo = Repo.clone_from(self.clone_url, self.repo_path)
+            # If the repo_path already contains a git repository, verify that it's the
+            # same repository as the one we're trying to clone.
+            if os.path.isdir(os.path.join(self.repo_path, ".git")):
+                repo = Repo(self.repo_path)
+                # If the existing repository is not the same as the one we're trying to
+                # clone, raise an error.
+                if repo.remotes.origin.url != self.clone_url:
+                    raise ValueError(
+                        "A different repository is already cloned at this path."
+                    )
+            else:
+                repo = Repo.clone_from(self.clone_url, self.repo_path)
             repo.git.checkout(self.branch)
         else:
             repo = Repo(self.repo_path)

libs/langchain/langchain/prompts/chat.py

@@ -57,6 +57,14 @@ class BaseMessagePromptTemplate(Serializable, ABC):
         """
 
     def __add__(self, other: Any) -> ChatPromptTemplate:
+        """Combine two prompt templates.
+
+        Args:
+            other: Another prompt template.
+
+        Returns:
+            Combined prompt template.
+        """
         prompt = ChatPromptTemplate(messages=[self])
         return prompt + other
 
@@ -68,7 +76,7 @@ class MessagesPlaceholder(BaseMessagePromptTemplate):
     """Name of variable to use as messages."""
 
     def format_messages(self, **kwargs: Any) -> List[BaseMessage]:
-        """To a BaseMessage.
+        """Format messages from kwargs.
 
         Args:
             **kwargs: Keyword arguments to use for formatting.
@@ -156,10 +164,17 @@ class BaseStringMessagePromptTemplate(BaseMessagePromptTemplate, ABC):
 
     @abstractmethod
     def format(self, **kwargs: Any) -> BaseMessage:
-        """To a BaseMessage."""
+        """Format the prompt template.
+
+        Args:
+            **kwargs: Keyword arguments to use for formatting.
+
+        Returns:
+            Formatted message.
+        """
 
     def format_messages(self, **kwargs: Any) -> List[BaseMessage]:
-        """Format messages from kwargs. Should return a list of BaseMessages.
+        """Format messages from kwargs.
 
         Args:
             **kwargs: Keyword arguments to use for formatting.
@@ -187,6 +202,14 @@ class ChatMessagePromptTemplate(BaseStringMessagePromptTemplate):
     """Role of the message."""
 
     def format(self, **kwargs: Any) -> BaseMessage:
+        """Format the prompt template.
+
+        Args:
+            **kwargs: Keyword arguments to use for formatting.
+
+        Returns:
+            Formatted message.
+        """
         text = self.prompt.format(**kwargs)
         return ChatMessage(
             content=text, role=self.role, additional_kwargs=self.additional_kwargs
@@ -197,6 +220,14 @@ class HumanMessagePromptTemplate(BaseStringMessagePromptTemplate):
     """Human message prompt template. This is a message that is sent to the user."""
 
     def format(self, **kwargs: Any) -> BaseMessage:
+        """Format the prompt template.
+
+        Args:
+            **kwargs: Keyword arguments to use for formatting.
+
+        Returns:
+            Formatted message.
+        """
         text = self.prompt.format(**kwargs)
         return HumanMessage(content=text, additional_kwargs=self.additional_kwargs)
 
@@ -205,6 +236,14 @@ class AIMessagePromptTemplate(BaseStringMessagePromptTemplate):
     """AI message prompt template. This is a message that is not sent to the user."""
 
     def format(self, **kwargs: Any) -> BaseMessage:
+        """Format the prompt template.
+
+        Args:
+            **kwargs: Keyword arguments to use for formatting.
+
+        Returns:
+            Formatted message.
+        """
         text = self.prompt.format(**kwargs)
         return AIMessage(content=text, additional_kwargs=self.additional_kwargs)
 
@@ -215,6 +254,14 @@ class SystemMessagePromptTemplate(BaseStringMessagePromptTemplate):
     """
 
     def format(self, **kwargs: Any) -> BaseMessage:
+        """Format the prompt template.
+
+        Args:
+            **kwargs: Keyword arguments to use for formatting.
+
+        Returns:
+            Formatted message.
+        """
         text = self.prompt.format(**kwargs)
         return SystemMessage(content=text, additional_kwargs=self.additional_kwargs)
 
@@ -241,6 +288,15 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
     """Base class for chat prompt templates."""
 
     def format(self, **kwargs: Any) -> str:
+        """Format the chat template into a string.
+
+        Args:
+            **kwargs: keyword arguments to use for filling in template variables
+                      in all the template messages in this chat template.
+
+        Returns:
+            formatted string
+        """
         return self.format_prompt(**kwargs).to_string()
 
     def format_prompt(self, **kwargs: Any) -> PromptValue:
@@ -261,7 +317,7 @@ class BaseChatPromptTemplate(BasePromptTemplate, ABC):
 
 
 class ChatPromptTemplate(BaseChatPromptTemplate, ABC):
-    """A prompt template for a chat models.
+    """A prompt template for chat models.
 
     Use to create flexible templated prompts for chat models.
 
@@ -292,6 +348,14 @@ class ChatPromptTemplate(BaseChatPromptTemplate, ABC):
     """List of messages consisting of either message prompt templates or messages."""
 
     def __add__(self, other: Any) -> ChatPromptTemplate:
+        """Combine two prompt templates.
+
+        Args:
+            other: Another prompt template.
+
+        Returns:
+            Combined prompt template.
+        """
         # Allow for easy combining
         if isinstance(other, ChatPromptTemplate):
             return ChatPromptTemplate(messages=self.messages + other.messages)
@@ -393,6 +457,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate, ABC):
         messages: Sequence[
             Union[
                 BaseMessagePromptTemplate,
+                BaseChatPromptTemplate,
                 BaseMessage,
                 Tuple[str, str],
                 Tuple[Type, str],
@@ -404,7 +469,7 @@ class ChatPromptTemplate(BaseChatPromptTemplate, ABC):
 
         Examples:
 
-            Instantiation from a list of role strings and templates:
+            Instantiation from a list of message templates:
 
             .. code-block:: python
 
@@ -423,18 +488,6 @@ class ChatPromptTemplate(BaseChatPromptTemplate, ABC):
                     ("human", "Hello, how are you?"),
                 ])
 
-            Instantiation from a list message templates:
-
-
-            .. code-block:: python
-
-                template = ChatPromptTemplate.from_messages([
-                    ("human", "Hello, how are you?"),
-                    ("ai", "I'm doing well, thanks!"),
-                    ("human", "That's good to hear."),
-                ])
-
-
         Args:
             messages: sequence of message representations.
                   A message can be represented using the following formats:
@@ -451,7 +504,9 @@ class ChatPromptTemplate(BaseChatPromptTemplate, ABC):
         # Automatically infer input variables from messages
         input_vars = set()
         for _message in _messages:
-            if isinstance(_message, BaseMessagePromptTemplate):
+            if isinstance(
+                _message, (BaseChatPromptTemplate, BaseMessagePromptTemplate)
+            ):
                 input_vars.update(_message.input_variables)
 
         return cls(input_variables=sorted(input_vars), messages=_messages)
@@ -497,8 +552,42 @@ class ChatPromptTemplate(BaseChatPromptTemplate, ABC):
                 raise ValueError(f"Unexpected input: {message_template}")
         return result
 
-    def partial(self, **kwargs: Union[str, Callable[[], str]]) -> BasePromptTemplate:
-        raise NotImplementedError
+    def partial(self, **kwargs: Union[str, Callable[[], str]]) -> ChatPromptTemplate:
+        """Return a new ChatPromptTemplate with some of the input variables already
+        filled in.
+
+        Args:
+            **kwargs: keyword arguments to use for filling in template variables. Ought
+                        to be a subset of the input variables.
+
+        Returns:
+            A new ChatPromptTemplate.
+
+
+        Example:
+
+            .. code-block:: python
+
+                from langchain.prompts import ChatPromptTemplate
+
+                template = ChatPromptTemplate.from_messages(
+                    [
+                        ("system", "You are an AI assistant named {name}."),
+                        ("human", "Hi I'm {user}"),
+                        ("ai", "Hi there, {user}, I'm {name}."),
+                        ("human", "{input}"),
+                    ]
+                )
+                template2 = template.partial(user="Lucy", name="R2D2")
+
+                template2.format_messages(input="hello")
+        """
+        prompt_dict = self.__dict__.copy()
+        prompt_dict["input_variables"] = list(
+            set(self.input_variables).difference(kwargs)
+        )
+        prompt_dict["partial_variables"] = {**self.partial_variables, **kwargs}
+        return type(self)(**prompt_dict)
 
     @property
     def _prompt_type(self) -> str:
@@ -545,12 +634,13 @@ def _create_template_from_message_type(
 def _convert_to_message(
     message: Union[
         BaseMessagePromptTemplate,
+        BaseChatPromptTemplate,
         BaseMessage,
         Tuple[str, str],
         Tuple[Type, str],
         str,
     ]
-) -> Union[BaseMessage, BaseMessagePromptTemplate]:
+) -> Union[BaseMessage, BaseMessagePromptTemplate, BaseChatPromptTemplate]:
     """Instantiate a message from a variety of message formats.
 
     The message format can be one of the following:
@@ -567,8 +657,10 @@ def _convert_to_message(
     Returns:
         an instance of a message or a message template
     """
-    if isinstance(message, BaseMessagePromptTemplate):
-        _message: Union[BaseMessage, BaseMessagePromptTemplate] = message
+    if isinstance(message, (BaseMessagePromptTemplate, BaseChatPromptTemplate)):
+        _message: Union[
+            BaseMessage, BaseMessagePromptTemplate, BaseChatPromptTemplate
+        ] = message
     elif isinstance(message, BaseMessage):
         _message = message
     elif isinstance(message, str):

libs/langchain/langchain/prompts/few_shot.py

@@ -190,12 +190,9 @@ class FewShotChatMessagePromptTemplate(
 
         .. code-block:: python
 
-            from langchain.schema import SystemMessage
             from langchain.prompts import (
                 FewShotChatMessagePromptTemplate,
-                HumanMessagePromptTemplate,
-                SystemMessagePromptTemplate,
-                AIMessagePromptTemplate
+                ChatPromptTemplate
             )
 
             examples = [
@@ -203,24 +200,23 @@ class FewShotChatMessagePromptTemplate(
                 {"input": "2+3", "output": "5"},
             ]
 
+            example_prompt = ChatPromptTemplate.from_messages(
+                [('human', '{input}'), ('ai', '{output}')]
+            )
+
             few_shot_prompt = FewShotChatMessagePromptTemplate(
                 examples=examples,
                 # This is a prompt template used to format each individual example.
-                example_prompt=(
-                    HumanMessagePromptTemplate.from_template("{input}")
-                    + AIMessagePromptTemplate.from_template("{output}")
-                ),
+                example_prompt=example_prompt,
             )
 
-
-            final_prompt = (
-                SystemMessagePromptTemplate.from_template(
-                    "You are a helpful AI Assistant"
-                )
-                + few_shot_prompt
-                + HumanMessagePromptTemplate.from_template("{input}")
+            final_prompt = ChatPromptTemplate.from_messages(
+                [
+                    ('system', 'You are a helpful AI Assistant'),
+                    few_shot_prompt,
+                    ('human', '{input}'),
+                ]
             )
-
             final_prompt.format(input="What is 4+4?")
 
         Prompt template with dynamically selected examples:

libs/langchain/langchain/retrievers/web_research.py

@@ -34,18 +34,18 @@ class SearchQueries(BaseModel):
 
 DEFAULT_LLAMA_SEARCH_PROMPT = PromptTemplate(
     input_variables=["question"],
-    template="""<<SYS>> \n You are an assistant tasked with improving Google search 
-    results. \n <</SYS>> \n\n [INST] Generate THREE Google search queries that 
-    are similar to this question. The output should be a numbered list of questions 
-    and each should have a question mark at the end: \n\n {question} [/INST]""",
+    template="""<<SYS>> \n You are an assistant tasked with improving Google search \
+results. \n <</SYS>> \n\n [INST] Generate THREE Google search queries that \
+are similar to this question. The output should be a numbered list of questions \
+and each should have a question mark at the end: \n\n {question} [/INST]""",
 )
 
 DEFAULT_SEARCH_PROMPT = PromptTemplate(
     input_variables=["question"],
-    template="""You are an assistant tasked with improving Google search 
-    results. Generate THREE Google search queries that are similar to
-    this question. The output should be a numbered list of questions and each
-    should have a question mark at the end: {question}""",
+    template="""You are an assistant tasked with improving Google search \
+results. Generate THREE Google search queries that are similar to \
+this question. The output should be a numbered list of questions and each \
+should have a question mark at the end: {question}""",
 )
 
 

libs/langchain/langchain/schema/output_parser.py

@@ -35,9 +35,19 @@ class BaseGenerationOutputParser(
         self, input: str | BaseMessage, config: RunnableConfig | None = None
     ) -> T:
         if isinstance(input, BaseMessage):
-            return self.parse_result([ChatGeneration(message=input)])
+            return self._call_with_config(
+                lambda inner_input: self.parse_result(
+                    [ChatGeneration(message=inner_input)]
+                ),
+                input,
+                config,
+            )
         else:
-            return self.parse_result([Generation(text=input)])
+            return self._call_with_config(
+                lambda inner_input: self.parse_result([Generation(text=inner_input)]),
+                input,
+                config,
+            )
 
 
 class BaseOutputParser(BaseLLMOutputParser, Runnable[Union[str, BaseMessage], T]):
@@ -71,9 +81,19 @@ class BaseOutputParser(BaseLLMOutputParser, Runnable[Union[str, BaseMessage], T]
         self, input: str | BaseMessage, config: RunnableConfig | None = None
     ) -> T:
         if isinstance(input, BaseMessage):
-            return self.parse_result([ChatGeneration(message=input)])
+            return self._call_with_config(
+                lambda inner_input: self.parse_result(
+                    [ChatGeneration(message=inner_input)]
+                ),
+                input,
+                config,
+            )
         else:
-            return self.parse_result([Generation(text=input)])
+            return self._call_with_config(
+                lambda inner_input: self.parse_result([Generation(text=inner_input)]),
+                input,
+                config,
+            )
 
     def parse_result(self, result: List[Generation]) -> T:
         """Parse a list of candidate model Generations into a specific format.

libs/langchain/langchain/schema/runnable.py

@@ -108,6 +108,10 @@ class Runnable(Generic[Input, Output], ABC):
     ) -> List[Output]:
         configs = self._get_config_list(config, len(inputs))
 
+        # If there's only one input, don't bother with the executor
+        if len(inputs) == 1:
+            return [self.invoke(inputs[0], configs[0])]
+
         with ThreadPoolExecutor(max_workers=max_concurrency) as executor:
             return list(executor.map(self.invoke, inputs, configs))
 
@@ -714,6 +718,9 @@ class RunnableBinding(Serializable, Runnable[Input, Output]):
     def lc_serializable(self) -> bool:
         return True
 
+    def bind(self, **kwargs: Any) -> Runnable[Input, Output]:
+        return self.__class__(bound=self.bound, kwargs={**self.kwargs, **kwargs})
+
     def invoke(self, input: Input, config: Optional[RunnableConfig] = None) -> Output:
         return self.bound.invoke(input, config, **self.kwargs)
 
@@ -756,6 +763,140 @@ class RunnableBinding(Serializable, Runnable[Input, Output]):
             yield item
 
 
+class RouterInput(TypedDict):
+    key: str
+    input: Any
+
+
+class RouterRunnable(
+    Serializable, Generic[Input, Output], Runnable[RouterInput, Output]
+):
+    runnables: Mapping[str, Runnable[Input, Output]]
+
+    def __init__(self, runnables: Mapping[str, Runnable[Input, Output]]) -> None:
+        super().__init__(runnables=runnables)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @property
+    def lc_serializable(self) -> bool:
+        return True
+
+    def __or__(
+        self,
+        other: Union[
+            Runnable[Any, Other],
+            Callable[[Any], Other],
+            Mapping[str, Union[Runnable[Any, Other], Callable[[Any], Other]]],
+            Mapping[str, Any],
+        ],
+    ) -> RunnableSequence[RouterInput, Other]:
+        return RunnableSequence(first=self, last=_coerce_to_runnable(other))
+
+    def __ror__(
+        self,
+        other: Union[
+            Runnable[Other, Any],
+            Callable[[Any], Other],
+            Mapping[str, Union[Runnable[Other, Any], Callable[[Other], Any]]],
+            Mapping[str, Any],
+        ],
+    ) -> RunnableSequence[Other, Output]:
+        return RunnableSequence(first=_coerce_to_runnable(other), last=self)
+
+    def invoke(
+        self, input: RouterInput, config: Optional[RunnableConfig] = None
+    ) -> Output:
+        key = input["key"]
+        actual_input = input["input"]
+        if key not in self.runnables:
+            raise ValueError(f"No runnable associated with key '{key}'")
+
+        runnable = self.runnables[key]
+        return runnable.invoke(actual_input, config)
+
+    async def ainvoke(
+        self, input: RouterInput, config: Optional[RunnableConfig] = None
+    ) -> Output:
+        key = input["key"]
+        actual_input = input["input"]
+        if key not in self.runnables:
+            raise ValueError(f"No runnable associated with key '{key}'")
+
+        runnable = self.runnables[key]
+        return await runnable.ainvoke(actual_input, config)
+
+    def batch(
+        self,
+        inputs: List[RouterInput],
+        config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
+        *,
+        max_concurrency: Optional[int] = None,
+    ) -> List[Output]:
+        keys = [input["key"] for input in inputs]
+        actual_inputs = [input["input"] for input in inputs]
+        if any(key not in self.runnables for key in keys):
+            raise ValueError("One or more keys do not have a corresponding runnable")
+
+        runnables = [self.runnables[key] for key in keys]
+        configs = self._get_config_list(config, len(inputs))
+        with ThreadPoolExecutor(max_workers=max_concurrency) as executor:
+            return list(
+                executor.map(
+                    lambda runnable, input, config: runnable.invoke(input, config),
+                    runnables,
+                    actual_inputs,
+                    configs,
+                )
+            )
+
+    async def abatch(
+        self,
+        inputs: List[RouterInput],
+        config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None,
+        *,
+        max_concurrency: Optional[int] = None,
+    ) -> List[Output]:
+        keys = [input["key"] for input in inputs]
+        actual_inputs = [input["input"] for input in inputs]
+        if any(key not in self.runnables for key in keys):
+            raise ValueError("One or more keys do not have a corresponding runnable")
+
+        runnables = [self.runnables[key] for key in keys]
+        configs = self._get_config_list(config, len(inputs))
+        return await _gather_with_concurrency(
+            max_concurrency,
+            *(
+                runnable.ainvoke(input, config)
+                for runnable, input, config in zip(runnables, actual_inputs, configs)
+            ),
+        )
+
+    def stream(
+        self, input: RouterInput, config: Optional[RunnableConfig] = None
+    ) -> Iterator[Output]:
+        key = input["key"]
+        actual_input = input["input"]
+        if key not in self.runnables:
+            raise ValueError(f"No runnable associated with key '{key}'")
+
+        runnable = self.runnables[key]
+        yield from runnable.stream(actual_input, config)
+
+    async def astream(
+        self, input: RouterInput, config: Optional[RunnableConfig] = None
+    ) -> AsyncIterator[Output]:
+        key = input["key"]
+        actual_input = input["input"]
+        if key not in self.runnables:
+            raise ValueError(f"No runnable associated with key '{key}'")
+
+        runnable = self.runnables[key]
+        async for output in runnable.astream(actual_input, config):
+            yield output
+
+
 def _patch_config(
     config: RunnableConfig, callback_manager: BaseCallbackManager
 ) -> RunnableConfig:

libs/langchain/langchain/tools/amadeus/closest_airport.py

@@ -2,10 +2,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.chains import LLMChain
 from langchain.chat_models import ChatOpenAI
 from langchain.tools.amadeus.base import AmadeusBaseTool
@@ -58,10 +55,3 @@ class AmadeusClosestAirport(AmadeusBaseTool):
         output = llm_chain.run(location=location)
 
         return output
-
-    async def _arun(
-        self,
-        location: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError(f"The tool {self.name} does not support async yet.")

libs/langchain/langchain/tools/amadeus/flight_search.py

@@ -4,10 +4,7 @@ from typing import Dict, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.amadeus.base import AmadeusBaseTool
 
 logger = logging.getLogger(__name__)
@@ -153,14 +150,3 @@ class AmadeusFlightSearch(AmadeusBaseTool):
         endIndex = startIndex + RESULTS_PER_PAGE
 
         return output[startIndex:endIndex]
-
-    async def _arun(
-        self,
-        originLocationCode: str,
-        destinationLocationCode: str,
-        departureDateTimeEarliest: str,
-        departureDateTimeLatest: str,
-        page_number: int = 1,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> list:
-        raise NotImplementedError(f"The tool {self.name} does not support async yet.")

libs/langchain/langchain/tools/arxiv/tool.py

@@ -4,10 +4,7 @@ from typing import Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.arxiv import ArxivAPIWrapper
 
@@ -33,11 +30,3 @@ class ArxivQueryRun(BaseTool):
     ) -> str:
         """Use the Arxiv tool."""
         return self.api_wrapper.run(query)
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the Arxiv tool asynchronously."""
-        raise NotImplementedError("ArxivAPIWrapper does not support async")

libs/langchain/langchain/tools/azure_cognitive_services/form_recognizer.py

@@ -5,10 +5,7 @@ from typing import Any, Dict, List, Optional
 
 from pydantic import root_validator
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.azure_cognitive_services.utils import detect_file_src_type
 from langchain.tools.base import BaseTool
 from langchain.utils import get_from_dict_or_env
@@ -142,11 +139,3 @@ class AzureCogsFormRecognizerTool(BaseTool):
             return self._format_document_analysis_result(document_analysis_result)
         except Exception as e:
             raise RuntimeError(f"Error while running AzureCogsFormRecognizerTool: {e}")
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("AzureCogsFormRecognizerTool does not support async")

libs/langchain/langchain/tools/azure_cognitive_services/image_analysis.py

@@ -5,10 +5,7 @@ from typing import Any, Dict, Optional
 
 from pydantic import root_validator
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.azure_cognitive_services.utils import detect_file_src_type
 from langchain.tools.base import BaseTool
 from langchain.utils import get_from_dict_or_env
@@ -146,11 +143,3 @@ class AzureCogsImageAnalysisTool(BaseTool):
             return self._format_image_analysis_result(image_analysis_result)
         except Exception as e:
             raise RuntimeError(f"Error while running AzureCogsImageAnalysisTool: {e}")
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("AzureCogsImageAnalysisTool does not support async")

libs/langchain/langchain/tools/azure_cognitive_services/speech2text.py

@@ -6,10 +6,7 @@ from typing import Any, Dict, Optional
 
 from pydantic import root_validator
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.azure_cognitive_services.utils import (
     detect_file_src_type,
     download_audio_from_url,
@@ -121,11 +118,3 @@ class AzureCogsSpeech2TextTool(BaseTool):
             return text
         except Exception as e:
             raise RuntimeError(f"Error while running AzureCogsSpeech2TextTool: {e}")
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("AzureCogsSpeech2TextTool does not support async")

libs/langchain/langchain/tools/azure_cognitive_services/text2speech.py

@@ -6,10 +6,7 @@ from typing import Any, Dict, Optional
 
 from pydantic import root_validator
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utils import get_from_dict_or_env
 
@@ -104,11 +101,3 @@ class AzureCogsText2SpeechTool(BaseTool):
             return speech_file
         except Exception as e:
             raise RuntimeError(f"Error while running AzureCogsText2SpeechTool: {e}")
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("AzureCogsText2SpeechTool does not support async")

libs/langchain/langchain/tools/base.py

@@ -1,8 +1,10 @@
 """Base implementation for tools or skills."""
 from __future__ import annotations
 
+import asyncio
 import warnings
-from abc import ABC, abstractmethod
+from abc import abstractmethod
+from functools import partial
 from inspect import signature
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Tuple, Type, Union
 
@@ -24,6 +26,7 @@ from langchain.callbacks.manager import (
     CallbackManagerForToolRun,
     Callbacks,
 )
+from langchain.schema.runnable import Runnable, RunnableConfig
 
 
 class SchemaAnnotationError(TypeError):
@@ -129,7 +132,7 @@ class ToolException(Exception):
     pass
 
 
-class BaseTool(ABC, BaseModel, metaclass=ToolMetaclass):
+class BaseTool(BaseModel, Runnable[Union[str, Dict], Any], metaclass=ToolMetaclass):
     """Interface LangChain tools must implement."""
 
     name: str
@@ -191,6 +194,32 @@ class BaseTool(ABC, BaseModel, metaclass=ToolMetaclass):
             schema = create_schema_from_function(self.name, self._run)
             return schema.schema()["properties"]
 
+    # --- Runnable ---
+
+    def invoke(
+        self,
+        input: Union[str, Dict],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> Any:
+        config = config or {}
+        return self.run(input, **config, **kwargs)
+
+    async def ainvoke(
+        self,
+        input: Union[str, Dict],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if type(self)._arun == BaseTool._arun:
+            # If the tool does not implement async, fall back to default implementation
+            return super().ainvoke(input, config, **kwargs)
+
+        config = config or {}
+        return await self.arun(input, **config, **kwargs)
+
+    # --- Tool ---
+
     def _parse_input(
         self,
         tool_input: Union[str, Dict],
@@ -231,7 +260,6 @@ class BaseTool(ABC, BaseModel, metaclass=ToolMetaclass):
         to child implementations to enable tracing,
         """
 
-    @abstractmethod
     async def _arun(
         self,
         *args: Any,
@@ -242,6 +270,7 @@ class BaseTool(ABC, BaseModel, metaclass=ToolMetaclass):
         Add run_manager: Optional[AsyncCallbackManagerForToolRun] = None
         to child implementations to enable tracing,
         """
+        raise NotImplementedError()
 
     def _to_args_and_kwargs(self, tool_input: Union[str, Dict]) -> Tuple[Tuple, Dict]:
         # For backwards compatibility, if run_input is a string,
@@ -411,6 +440,24 @@ class Tool(BaseTool):
     coroutine: Optional[Callable[..., Awaitable[str]]] = None
     """The asynchronous version of the function."""
 
+    # --- Runnable ---
+
+    async def ainvoke(
+        self,
+        input: Union[str, Dict],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if not self.coroutine:
+            # If the tool does not implement async, fall back to default implementation
+            return await asyncio.get_running_loop().run_in_executor(
+                None, partial(self.invoke, input, config, **kwargs)
+            )
+
+        return super().ainvoke(input, config, **kwargs)
+
+    # --- Tool ---
+
     @property
     def args(self) -> dict:
         """The tool's input arguments."""
@@ -513,6 +560,24 @@ class StructuredTool(BaseTool):
     coroutine: Optional[Callable[..., Awaitable[Any]]] = None
     """The asynchronous version of the function."""
 
+    # --- Runnable ---
+
+    async def ainvoke(
+        self,
+        input: Union[str, Dict],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if not self.coroutine:
+            # If the tool does not implement async, fall back to default implementation
+            return await asyncio.get_running_loop().run_in_executor(
+                None, partial(self.invoke, input, config, **kwargs)
+            )
+
+        return super().ainvoke(input, config, **kwargs)
+
+    # --- Tool ---
+
     @property
     def args(self) -> dict:
         """The tool's input arguments."""

libs/langchain/langchain/tools/bing_search/tool.py

@@ -2,10 +2,7 @@
 
 from typing import Optional
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.bing_search import BingSearchAPIWrapper
 
@@ -29,14 +26,6 @@ class BingSearchRun(BaseTool):
         """Use the tool."""
         return self.api_wrapper.run(query)
 
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("BingSearchRun does not support async")
-
 
 class BingSearchResults(BaseTool):
     """Tool that queries the Bing Search API and gets back json."""
@@ -57,11 +46,3 @@ class BingSearchResults(BaseTool):
     ) -> str:
         """Use the tool."""
         return str(self.api_wrapper.results(query, self.num_results))
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("BingSearchResults does not support async")

libs/langchain/langchain/tools/brave_search/tool.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.brave_search import BraveSearchWrapper
 
@@ -45,11 +42,3 @@ class BraveSearch(BaseTool):
     ) -> str:
         """Use the tool."""
         return self.search_wrapper.run(query)
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("BraveSearch does not support async")

libs/langchain/langchain/tools/ddg_search/tool.py

@@ -5,10 +5,7 @@ from typing import Any, Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper
 
@@ -34,14 +31,6 @@ class DuckDuckGoSearchRun(BaseTool):
         """Use the tool."""
         return self.api_wrapper.run(query)
 
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("DuckDuckGoSearch does not support async")
-
 
 class DuckDuckGoSearchResults(BaseTool):
     """Tool that queries the DuckDuckGo search API and gets back json."""
@@ -68,14 +57,6 @@ class DuckDuckGoSearchResults(BaseTool):
         res_strs = [", ".join([f"{k}: {v}" for k, v in d.items()]) for d in res]
         return ", ".join([f"[{rs}]" for rs in res_strs])
 
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("DuckDuckGoSearchResults does not support async")
-
 
 def DuckDuckGoSearchTool(*args: Any, **kwargs: Any) -> DuckDuckGoSearchRun:
     """

libs/langchain/langchain/tools/file_management/copy.py

@@ -3,10 +3,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.tools.file_management.utils import (
     INVALID_PATH_TEMPLATE,
@@ -53,11 +50,4 @@ class CopyFileTool(BaseFileToolMixin, BaseTool):
         except Exception as e:
             return "Error: " + str(e)
 
-    async def _arun(
-        self,
-        source_path: str,
-        destination_path: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        # TODO: Add aiofiles method
-        raise NotImplementedError
+    # TODO: Add aiofiles method

libs/langchain/langchain/tools/file_management/delete.py

@@ -3,10 +3,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.tools.file_management.utils import (
     INVALID_PATH_TEMPLATE,
@@ -45,10 +42,4 @@ class DeleteFileTool(BaseFileToolMixin, BaseTool):
         except Exception as e:
             return "Error: " + str(e)
 
-    async def _arun(
-        self,
-        file_path: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        # TODO: Add aiofiles method
-        raise NotImplementedError
+    # TODO: Add aiofiles method

libs/langchain/langchain/tools/file_management/file_search.py

@@ -4,10 +4,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.tools.file_management.utils import (
     INVALID_PATH_TEMPLATE,
@@ -62,11 +59,4 @@ class FileSearchTool(BaseFileToolMixin, BaseTool):
         except Exception as e:
             return "Error: " + str(e)
 
-    async def _arun(
-        self,
-        dir_path: str,
-        pattern: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        # TODO: Add aiofiles method
-        raise NotImplementedError
+    # TODO: Add aiofiles method

libs/langchain/langchain/tools/file_management/list_dir.py

@@ -3,10 +3,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.tools.file_management.utils import (
     INVALID_PATH_TEMPLATE,
@@ -46,10 +43,4 @@ class ListDirectoryTool(BaseFileToolMixin, BaseTool):
         except Exception as e:
             return "Error: " + str(e)
 
-    async def _arun(
-        self,
-        dir_path: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        # TODO: Add aiofiles method
-        raise NotImplementedError
+    # TODO: Add aiofiles method

libs/langchain/langchain/tools/file_management/move.py

@@ -3,10 +3,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.tools.file_management.utils import (
     INVALID_PATH_TEMPLATE,
@@ -56,11 +53,4 @@ class MoveFileTool(BaseFileToolMixin, BaseTool):
         except Exception as e:
             return "Error: " + str(e)
 
-    async def _arun(
-        self,
-        source_path: str,
-        destination_path: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        # TODO: Add aiofiles method
-        raise NotImplementedError
+    # TODO: Add aiofiles method

libs/langchain/langchain/tools/file_management/read.py

@@ -2,10 +2,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.tools.file_management.utils import (
     INVALID_PATH_TEMPLATE,
@@ -45,10 +42,4 @@ class ReadFileTool(BaseFileToolMixin, BaseTool):
         except Exception as e:
             return "Error: " + str(e)
 
-    async def _arun(
-        self,
-        file_path: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        # TODO: Add aiofiles method
-        raise NotImplementedError
+    # TODO: Add aiofiles method

libs/langchain/langchain/tools/file_management/write.py

@@ -2,10 +2,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.tools.file_management.utils import (
     INVALID_PATH_TEMPLATE,
@@ -51,12 +48,4 @@ class WriteFileTool(BaseFileToolMixin, BaseTool):
         except Exception as e:
             return "Error: " + str(e)
 
-    async def _arun(
-        self,
-        file_path: str,
-        text: str,
-        append: bool = False,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        # TODO: Add aiofiles method
-        raise NotImplementedError
+    # TODO: Add aiofiles method

libs/langchain/langchain/tools/github/tool.py

@@ -11,10 +11,7 @@ from typing import Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.github import GitHubAPIWrapper
 
@@ -34,11 +31,3 @@ class GitHubAction(BaseTool):
     ) -> str:
         """Use the GitHub API to run an operation."""
         return self.api_wrapper.run(self.mode, instructions)
-
-    async def _arun(
-        self,
-        _: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the GitHub API to run an operation."""
-        raise NotImplementedError("GitHubAction does not support async")

libs/langchain/langchain/tools/gmail/create_draft.py

@@ -4,10 +4,7 @@ from typing import List, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.gmail.base import GmailBaseTool
 
 
@@ -88,14 +85,3 @@ class GmailCreateDraft(GmailBaseTool):
             return output
         except Exception as e:
             raise Exception(f"An error occurred: {e}")
-
-    async def _arun(
-        self,
-        message: str,
-        to: List[str],
-        subject: str,
-        cc: Optional[List[str]] = None,
-        bcc: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError(f"The tool {self.name} does not support async yet.")

libs/langchain/langchain/tools/gmail/get_message.py

@@ -4,10 +4,7 @@ from typing import Dict, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.gmail.base import GmailBaseTool
 from langchain.tools.gmail.utils import clean_email_body
 
@@ -62,11 +59,3 @@ class GmailGetMessage(GmailBaseTool):
             "subject": subject,
             "sender": sender,
         }
-
-    async def _arun(
-        self,
-        message_id: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> Dict:
-        """Run the tool."""
-        raise NotImplementedError

libs/langchain/langchain/tools/gmail/get_thread.py

@@ -2,10 +2,7 @@ from typing import Dict, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.gmail.base import GmailBaseTool
 
 
@@ -49,11 +46,3 @@ class GmailGetThread(GmailBaseTool):
                 {k: message[k] for k in keys_to_keep if k in message}
             )
         return thread_data
-
-    async def _arun(
-        self,
-        thread_id: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> Dict:
-        """Run the tool."""
-        raise NotImplementedError

libs/langchain/langchain/tools/gmail/search.py

@@ -5,10 +5,7 @@ from typing import Any, Dict, List, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.gmail.base import GmailBaseTool
 from langchain.tools.gmail.utils import clean_email_body
 
@@ -132,13 +129,3 @@ class GmailSearch(GmailBaseTool):
             return self._parse_messages(results)
         else:
             raise NotImplementedError(f"Resource of type {resource} not implemented.")
-
-    async def _arun(
-        self,
-        query: str,
-        resource: Resource = Resource.MESSAGES,
-        max_results: int = 10,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> List[Dict[str, Any]]:
-        """Run the tool."""
-        raise NotImplementedError

libs/langchain/langchain/tools/gmail/send_message.py

@@ -6,10 +6,7 @@ from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.gmail.base import GmailBaseTool
 
 
@@ -90,15 +87,3 @@ class GmailSendMessage(GmailBaseTool):
             return f'Message sent. Message Id: {sent_message["id"]}'
         except Exception as error:
             raise Exception(f"An error occurred: {error}")
-
-    async def _arun(
-        self,
-        message: str,
-        to: Union[str, List[str]],
-        subject: str,
-        cc: Optional[Union[str, List[str]]] = None,
-        bcc: Optional[Union[str, List[str]]] = None,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Run the tool asynchronously."""
-        raise NotImplementedError(f"The tool {self.name} does not support async yet.")

libs/langchain/langchain/tools/golden_query/tool.py

@@ -2,10 +2,7 @@
 
 from typing import Optional
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.golden_query import GoldenQueryAPIWrapper
 
@@ -34,11 +31,3 @@ class GoldenQueryRun(BaseTool):
     ) -> str:
         """Use the Golden tool."""
         return self.api_wrapper.run(query)
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the Golden tool asynchronously."""
-        raise NotImplementedError("Golden does not support async")

libs/langchain/langchain/tools/google_places/tool.py

@@ -4,10 +4,7 @@ from typing import Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.google_places_api import GooglePlacesAPIWrapper
 
@@ -38,11 +35,3 @@ class GooglePlacesTool(BaseTool):
     ) -> str:
         """Use the tool."""
         return self.api_wrapper.run(query)
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("GooglePlacesRun does not support async")

libs/langchain/langchain/tools/google_search/tool.py

@@ -2,10 +2,7 @@
 
 from typing import Optional
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.google_search import GoogleSearchAPIWrapper
 
@@ -29,14 +26,6 @@ class GoogleSearchRun(BaseTool):
         """Use the tool."""
         return self.api_wrapper.run(query)
 
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("GoogleSearchRun does not support async")
-
 
 class GoogleSearchResults(BaseTool):
     """Tool that queries the Google Search API and gets back json."""
@@ -57,11 +46,3 @@ class GoogleSearchResults(BaseTool):
     ) -> str:
         """Use the tool."""
         return str(self.api_wrapper.results(query, self.num_results))
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("GoogleSearchRun does not support async")

libs/langchain/langchain/tools/graphql/tool.py

@@ -1,10 +1,7 @@
 import json
 from typing import Optional
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.graphql import GraphQLAPIWrapper
 
@@ -36,11 +33,3 @@ class BaseGraphQLTool(BaseTool):
     ) -> str:
         result = self.graphql_wrapper.run(tool_input)
         return json.dumps(result, indent=2)
-
-    async def _arun(
-        self,
-        tool_input: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the Graphql tool asynchronously."""
-        raise NotImplementedError("GraphQLAPIWrapper does not support async")

libs/langchain/langchain/tools/human/tool.py

@@ -4,10 +4,7 @@ from typing import Callable, Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 
 
@@ -36,11 +33,3 @@ class HumanInputRun(BaseTool):
         """Use the Human input tool."""
         self.prompt_func(query)
         return self.input_func()
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the Human tool asynchronously."""
-        raise NotImplementedError("Human tool does not support async")

libs/langchain/langchain/tools/ifttt.py

@@ -36,10 +36,7 @@ from typing import Optional
 
 import requests
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 
 
@@ -62,10 +59,3 @@ class IFTTTWebhook(BaseTool):
         body = {"this": tool_input}
         response = requests.post(self.url, data=body)
         return response.text
-
-    async def _arun(
-        self,
-        tool_input: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError("Not implemented.")

libs/langchain/langchain/tools/jira/tool.py

@@ -32,10 +32,7 @@ from typing import Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.jira import JiraAPIWrapper
 
@@ -55,11 +52,3 @@ class JiraAction(BaseTool):
     ) -> str:
         """Use the Atlassian Jira API to run an operation."""
         return self.api_wrapper.run(self.mode, instructions)
-
-    async def _arun(
-        self,
-        _: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the Atlassian Jira API to run an operation."""
-        raise NotImplementedError("JiraAction does not support async")

libs/langchain/langchain/tools/multion/tool.py

@@ -3,10 +3,7 @@ from typing import Any, Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.multion import MultionClientAPIWrapper
 
@@ -38,13 +35,3 @@ class MultionClientTool(BaseTool):
     ) -> str:
         """Use the tool."""
         return self.api_wrapper.run(task, url, tabId)
-
-    async def _arun(
-        self,
-        task: str,
-        url: str,
-        tabId: Optional[Any] = None,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("Multion Client does not support async yet")

libs/langchain/langchain/tools/office365/create_draft_message.py

@@ -2,10 +2,7 @@ from typing import List, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.office365.base import O365BaseTool
 
 
@@ -69,14 +66,3 @@ class O365CreateDraftMessage(O365BaseTool):
 
         output = "Draft created: " + str(message)
         return output
-
-    async def _arun(
-        self,
-        message: str,
-        to: List[str],
-        subject: str,
-        cc: Optional[List[str]] = None,
-        bcc: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError(f"The tool {self.name} does not support async yet.")

libs/langchain/langchain/tools/office365/events_search.py

@@ -9,10 +9,7 @@ from typing import Any, Dict, List, Optional, Type
 
 from pydantic import BaseModel, Extra, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.office365.base import O365BaseTool
 from langchain.tools.office365.utils import clean_body
 
@@ -130,12 +127,3 @@ class O365SearchEvents(O365BaseTool):
             output_events.append(output_event)
 
         return output_events
-
-    async def _arun(
-        self,
-        query: str,
-        max_results: int = 10,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> List[Dict[str, Any]]:
-        """Run the tool."""
-        raise NotImplementedError

libs/langchain/langchain/tools/office365/messages_search.py

@@ -8,10 +8,7 @@ from typing import Any, Dict, List, Optional, Type
 
 from pydantic import BaseModel, Extra, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.office365.base import O365BaseTool
 from langchain.tools.office365.utils import clean_body
 
@@ -123,12 +120,3 @@ class O365SearchEmails(O365BaseTool):
             output_messages.append(output_message)
 
         return output_messages
-
-    async def _arun(
-        self,
-        query: str,
-        max_results: int = 10,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> List[Dict[str, Any]]:
-        """Run the tool."""
-        raise NotImplementedError

libs/langchain/langchain/tools/office365/send_event.py

@@ -9,10 +9,7 @@ from typing import List, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.office365.base import O365BaseTool
 
 
@@ -85,14 +82,3 @@ class O365SendEvent(O365BaseTool):
 
         output = "Event sent: " + str(event)
         return output
-
-    async def _arun(
-        self,
-        message: str,
-        to: List[str],
-        subject: str,
-        cc: Optional[List[str]] = None,
-        bcc: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError(f"The tool {self.name} does not support async yet.")

libs/langchain/langchain/tools/office365/send_message.py

@@ -2,10 +2,7 @@ from typing import List, Optional, Type
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.office365.base import O365BaseTool
 
 
@@ -69,14 +66,3 @@ class O365SendMessage(O365BaseTool):
 
         output = "Message sent: " + str(message)
         return output
-
-    async def _arun(
-        self,
-        message: str,
-        to: List[str],
-        subject: str,
-        cc: Optional[List[str]] = None,
-        bcc: Optional[List[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError(f"The tool {self.name} does not support async yet.")

libs/langchain/langchain/tools/openweathermap/tool.py

@@ -4,10 +4,7 @@ from typing import Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities import OpenWeatherMapAPIWrapper
 
@@ -31,11 +28,3 @@ class OpenWeatherMapQueryRun(BaseTool):
     ) -> str:
         """Use the OpenWeatherMap tool."""
         return self.api_wrapper.run(location)
-
-    async def _arun(
-        self,
-        location: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the OpenWeatherMap tool asynchronously."""
-        raise NotImplementedError("OpenWeatherMapQueryRun does not support async")

libs/langchain/langchain/tools/powerbi/tool.py

@@ -84,6 +84,7 @@ class QueryPowerBITool(BaseTool):
                 tables=self.powerbi.get_table_names(),
                 schemas=self.powerbi.get_schemas(),
                 examples=self.examples,
+                callbacks=run_manager.get_child() if run_manager else None,
             )
         except Exception as exc:  # pylint: disable=broad-except
             self.session_cache[tool_input] = f"Error on call to LLM: {exc}"
@@ -136,6 +137,7 @@ class QueryPowerBITool(BaseTool):
                 tables=self.powerbi.get_table_names(),
                 schemas=self.powerbi.get_schemas(),
                 examples=self.examples,
+                callbacks=run_manager.get_child() if run_manager else None,
             )
         except Exception as exc:  # pylint: disable=broad-except
             self.session_cache[tool_input] = f"Error on call to LLM: {exc}"

libs/langchain/langchain/tools/pubmed/tool.py

@@ -4,10 +4,7 @@ from typing import Optional
 
 from pydantic import Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.pupmed import PubMedAPIWrapper
 
@@ -33,11 +30,3 @@ class PubmedQueryRun(BaseTool):
     ) -> str:
         """Use the Arxiv tool."""
         return self.api_wrapper.run(query)
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the PubMed tool asynchronously."""
-        raise NotImplementedError("PubMedAPIWrapper does not support async")

libs/langchain/langchain/tools/python/tool.py

@@ -131,11 +131,3 @@ class PythonAstREPLTool(BaseTool):
                 return io_buffer.getvalue()
         except Exception as e:
             return "{}: {}".format(type(e).__name__, str(e))
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("PythonReplTool does not support async")

libs/langchain/langchain/tools/scenexplain/tool.py

@@ -3,10 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools.base import BaseTool
 from langchain.utilities.scenexplain import SceneXplainAPIWrapper
 
@@ -33,9 +30,3 @@ class SceneXplainTool(BaseTool):
     ) -> str:
         """Use the tool."""
         return self.api_wrapper.run(query)
-
-    async def _arun(
-        self, query: str, run_manager: Optional[AsyncCallbackManagerForToolRun] = None
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("SceneXplainTool does not support async")

libs/langchain/langchain/tools/spark_sql/tool.py

@@ -48,13 +48,6 @@ class QuerySparkSQLTool(BaseSparkSQLTool, BaseTool):
         """Execute the query, return the results or an error message."""
         return self.db.run_no_throw(query)
 
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError("QuerySqlDbTool does not support async")
-
 
 class InfoSparkSQLTool(BaseSparkSQLTool, BaseTool):
     """Tool for getting metadata about a Spark SQL."""
@@ -75,13 +68,6 @@ class InfoSparkSQLTool(BaseSparkSQLTool, BaseTool):
         """Get the schema for tables in a comma-separated list."""
         return self.db.get_table_info_no_throw(table_names.split(", "))
 
-    async def _arun(
-        self,
-        table_name: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError("SchemaSqlDbTool does not support async")
-
 
 class ListSparkSQLTool(BaseSparkSQLTool, BaseTool):
     """Tool for getting tables names."""
@@ -97,13 +83,6 @@ class ListSparkSQLTool(BaseSparkSQLTool, BaseTool):
         """Get the schema for a specific table."""
         return ", ".join(self.db.get_usable_table_names())
 
-    async def _arun(
-        self,
-        tool_input: str = "",
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError("ListTablesSqlDbTool does not support async")
-
 
 class QueryCheckerTool(BaseSparkSQLTool, BaseTool):
     """Use an LLM to check if a query is correct.
@@ -142,11 +121,15 @@ class QueryCheckerTool(BaseSparkSQLTool, BaseTool):
         run_manager: Optional[CallbackManagerForToolRun] = None,
     ) -> str:
         """Use the LLM to check the query."""
-        return self.llm_chain.predict(query=query)
+        return self.llm_chain.predict(
+            query=query, callbacks=run_manager.get_child() if run_manager else None
+        )
 
     async def _arun(
         self,
         query: str,
         run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
     ) -> str:
-        return await self.llm_chain.apredict(query=query)
+        return await self.llm_chain.apredict(
+            query=query, callbacks=run_manager.get_child() if run_manager else None
+        )

libs/langchain/langchain/tools/sql_database/tool.py

@@ -48,13 +48,6 @@ class QuerySQLDataBaseTool(BaseSQLDatabaseTool, BaseTool):
         """Execute the query, return the results or an error message."""
         return self.db.run_no_throw(query)
 
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError("QuerySqlDbTool does not support async")
-
 
 class InfoSQLDatabaseTool(BaseSQLDatabaseTool, BaseTool):
     """Tool for getting metadata about a SQL database."""
@@ -74,13 +67,6 @@ class InfoSQLDatabaseTool(BaseSQLDatabaseTool, BaseTool):
         """Get the schema for tables in a comma-separated list."""
         return self.db.get_table_info_no_throw(table_names.split(", "))
 
-    async def _arun(
-        self,
-        table_name: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError("SchemaSqlDbTool does not support async")
-
 
 class ListSQLDatabaseTool(BaseSQLDatabaseTool, BaseTool):
     """Tool for getting tables names."""
@@ -96,13 +82,6 @@ class ListSQLDatabaseTool(BaseSQLDatabaseTool, BaseTool):
         """Get the schema for a specific table."""
         return ", ".join(self.db.get_usable_table_names())
 
-    async def _arun(
-        self,
-        tool_input: str = "",
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        raise NotImplementedError("ListTablesSqlDbTool does not support async")
-
 
 class QuerySQLCheckerTool(BaseSQLDatabaseTool, BaseTool):
     """Use an LLM to check if a query is correct.
@@ -140,11 +119,19 @@ class QuerySQLCheckerTool(BaseSQLDatabaseTool, BaseTool):
         run_manager: Optional[CallbackManagerForToolRun] = None,
     ) -> str:
         """Use the LLM to check the query."""
-        return self.llm_chain.predict(query=query, dialect=self.db.dialect)
+        return self.llm_chain.predict(
+            query=query,
+            dialect=self.db.dialect,
+            callbacks=run_manager.get_child() if run_manager else None,
+        )
 
     async def _arun(
         self,
         query: str,
         run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
     ) -> str:
-        return await self.llm_chain.apredict(query=query, dialect=self.db.dialect)
+        return await self.llm_chain.apredict(
+            query=query,
+            dialect=self.db.dialect,
+            callbacks=run_manager.get_child() if run_manager else None,
+        )

libs/langchain/langchain/tools/steamship_image_generation/tool.py

@@ -18,10 +18,7 @@ from typing import TYPE_CHECKING, Dict, Optional
 
 from pydantic import root_validator
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.tools import BaseTool
 from langchain.tools.steamship_image_generation.utils import make_image_public
 from langchain.utils import get_from_dict_or_env
@@ -114,11 +111,3 @@ class SteamshipImageGenerationTool(BaseTool):
                 return blocks[0].id
 
         raise RuntimeError(f"[{self.name}] Tool unable to generate image!")
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("GenerateImageTool does not support async")

libs/langchain/langchain/tools/vectorstore/tool.py

@@ -5,10 +5,7 @@ from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, Field
 
-from langchain.callbacks.manager import (
-    AsyncCallbackManagerForToolRun,
-    CallbackManagerForToolRun,
-)
+from langchain.callbacks.manager import CallbackManagerForToolRun
 from langchain.chains import RetrievalQA, RetrievalQAWithSourcesChain
 from langchain.llms.openai import OpenAI
 from langchain.schema.language_model import BaseLanguageModel
@@ -55,15 +52,9 @@ class VectorStoreQATool(BaseVectorStoreTool, BaseTool):
         chain = RetrievalQA.from_chain_type(
             self.llm, retriever=self.vectorstore.as_retriever()
         )
-        return chain.run(query)
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("VectorStoreQATool does not support async")
+        return chain.run(
+            query, callbacks=run_manager.get_child() if run_manager else None
+        )
 
 
 class VectorStoreQAWithSourcesTool(BaseVectorStoreTool, BaseTool):
@@ -91,12 +82,10 @@ class VectorStoreQAWithSourcesTool(BaseVectorStoreTool, BaseTool):
         chain = RetrievalQAWithSourcesChain.from_chain_type(
             self.llm, retriever=self.vectorstore.as_retriever()
         )
-        return json.dumps(chain({chain.question_key: query}, return_only_outputs=True))
-
-    async def _arun(
-        self,
-        query: str,
-        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
-    ) -> str:
-        """Use the tool asynchronously."""
-        raise NotImplementedError("VectorStoreQAWithSourcesTool does not support async")
+        return json.dumps(
+            chain(
+                {chain.question_key: query},
+                return_only_outputs=True,
+                callbacks=run_manager.get_child() if run_manager else None,
+            )
+        )