bump to version 213 (#6688)

#  Add caching to BaseChatModel
Fixes #1644

(Sidenote: While testing, I noticed we have multiple implementations of
Fake LLMs, used for testing. I consolidated them.)

## Who can review?
Community members can review the PR once tests pass. Tag
maintainers/contributors who might be interested:
Models
- @hwchase17
- @agola11

Twitter: [@UmerHAdil](https://twitter.com/@UmerHAdil) | Discord:
RicChilligerDude#7589

---------

Co-authored-by: Harrison Chase <hw.chase.17@gmail.com>

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,56 +1,26 @@
-<!--
-Thank you for contributing to LangChain! Your PR will appear in our release under the title you set. Please make sure it highlights your valuable contribution.
+<!-- Thank you for contributing to LangChain!
 
-Replace this with a description of the change, the issue it fixes (if applicable), and relevant context. List any dependencies required for this change.
+Replace this comment with:
+  - Description: a description of the change, 
+  - Issue: the issue # it fixes (if applicable),
+  - Dependencies: any dependencies required for this change,
+  - Tag maintainer: for a quicker response, tag the relevant maintainer (see below),
+  - Twitter handle: we announce bigger features on Twitter. If your PR gets announced and you'd like a mention, we'll gladly shout you out!
 
-After you're done, someone will review your PR. They may suggest improvements. If no one reviews your PR within a few days, feel free to @-mention the same people again, as notifications can get lost.
+If you're adding a new integration, please include:
+  1. a test for the integration, preferably unit tests that do not rely on network access,
+  2. an example notebook showing its use.
 
-Finally, we'd love to show appreciation for your contribution - if you'd like us to shout you out on Twitter, please also include your handle!
--->
+Maintainer responsibilities:
+  - General / Misc / if you don't know who to tag: @dev2049
+  - DataLoaders / VectorStores / Retrievers: @rlancemartin, @eyurtsev
+  - Models / Prompts: @hwchase17, @dev2049
+  - Memory: @hwchase17
+  - Agents / Tools / Toolkits: @vowelparrot
+  - Tracing / Callbacks: @agola11
+  - Async: @agola11
 
-<!-- Remove if not applicable -->
-
-Fixes # (issue)
-
-#### Before submitting
-
-<!-- If you're adding a new integration, please include:
-
-1. a test for the integration - favor unit tests that does not rely on network access.
-2. an example notebook showing its use
-
-
-See contribution guidelines for more information on how to write tests, lint
-etc:
-
-https://github.com/hwchase17/langchain/blob/master/.github/CONTRIBUTING.md
--->
-
-#### Who can review?
-
-Tag maintainers/contributors who might be interested:
-
-<!-- For a quicker response, figure out the right person to tag with @
-
-  @hwchase17 - project lead
-
-  Tracing / Callbacks
-  - @agola11
-
-  Async
-  - @agola11
-
-  DataLoaders
-  - @eyurtsev
-
-  Models
-  - @hwchase17
-  - @agola11
-
-  Agents / Tools / Toolkits
-  - @hwchase17
-
-  VectorStores / Retrievers / Memory
-  - @dev2049
+If no one reviews your PR within a few days, feel free to @-mention the same people again.
 
+See contribution guidelines for more information on how to write/run tests, lint, etc: https://github.com/hwchase17/langchain/blob/master/.github/CONTRIBUTING.md
  -->

docs/docs_skeleton/docs/modules/model_io/models/chat/how_to/chat_model_caching.mdx

@@ -0,0 +1,9 @@
+# Caching
+LangChain provides an optional caching layer for Chat Models. This is useful for two reasons:
+
+It can save you money by reducing the number of API calls you make to the LLM provider, if you're often requesting the same completion multiple times.
+It can speed up your application by reducing the number of API calls you make to the LLM provider.
+
+import CachingChat from "@snippets/modules/model_io/models/chat/how_to/chat_model_caching.mdx"
+
+<CachingChat/>

docs/extras/ecosystem/integrations/amazon_api_gateway.mdx

@@ -0,0 +1,73 @@
+# Amazon API Gateway
+
+[Amazon API Gateway](https://aws.amazon.com/api-gateway/) is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale. APIs act as the "front door" for applications to access data, business logic, or functionality from your backend services. Using API Gateway, you can create RESTful APIs and WebSocket APIs that enable real-time two-way communication applications. API Gateway supports containerized and serverless workloads, as well as web applications.
+
+API Gateway handles all the tasks involved in accepting and processing up to hundreds of thousands of concurrent API calls, including traffic management, CORS support, authorization and access control, throttling, monitoring, and API version management. API Gateway has no minimum fees or startup costs. You pay for the API calls you receive and the amount of data transferred out and, with the API Gateway tiered pricing model, you can reduce your cost as your API usage scales.
+
+## LLM
+
+See a [usage example](/docs/modules/model_io/models/llms/integrations/amazon_api_gateway_example.html).
+
+```python
+from langchain.llms import AmazonAPIGateway
+
+api_url = "https://<api_gateway_id>.execute-api.<region>.amazonaws.com/LATEST/HF"
+llm = AmazonAPIGateway(api_url=api_url)
+
+# These are sample parameters for Falcon 40B Instruct Deployed from Amazon SageMaker JumpStart
+parameters = {
+    "max_new_tokens": 100,
+    "num_return_sequences": 1,
+    "top_k": 50,
+    "top_p": 0.95,
+    "do_sample": False,
+    "return_full_text": True,
+    "temperature": 0.2,
+}
+
+prompt = "what day comes after Friday?"
+llm.model_kwargs = parameters
+llm(prompt)
+>>> 'what day comes after Friday?\nSaturday'
+```
+
+## Agent
+
+```python
+from langchain.agents import load_tools
+from langchain.agents import initialize_agent
+from langchain.agents import AgentType
+from langchain.llms import AmazonAPIGateway
+
+api_url = "https://<api_gateway_id>.execute-api.<region>.amazonaws.com/LATEST/HF"
+llm = AmazonAPIGateway(api_url=api_url)
+
+parameters = {
+    "max_new_tokens": 50,
+    "num_return_sequences": 1,
+    "top_k": 250,
+    "top_p": 0.25,
+    "do_sample": False,
+    "temperature": 0.1,
+}
+
+llm.model_kwargs = parameters
+
+# Next, let's load some tools to use. Note that the `llm-math` tool uses an LLM, so we need to pass that in.
+tools = load_tools(["python_repl", "llm-math"], llm=llm)
+
+# Finally, let's initialize an agent with the tools, the language model, and the type of agent we want to use.
+agent = initialize_agent(
+    tools,
+    llm,
+    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+    verbose=True,
+)
+
+# Now let's test it out!
+agent.run("""
+Write a Python script that prints "Hello, world!"
+""")
+
+>>> 'Hello, world!'
+```

docs/extras/ecosystem/integrations/databricks/databricks.ipynb

@@ -1,273 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "707d13a7",
-   "metadata": {},
-   "source": [
-    "# Databricks\n",
-    "\n",
-    "This notebook covers how to connect to the [Databricks runtimes](https://docs.databricks.com/runtime/index.html) and [Databricks SQL](https://www.databricks.com/product/databricks-sql) using the SQLDatabase wrapper of LangChain.\n",
-    "It is broken into 3 parts: installation and setup, connecting to Databricks, and examples."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0076d072",
-   "metadata": {},
-   "source": [
-    "## Installation and Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "739b489b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install databricks-sql-connector"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "73113163",
-   "metadata": {},
-   "source": [
-    "## Connecting to Databricks\n",
-    "\n",
-    "You can connect to [Databricks runtimes](https://docs.databricks.com/runtime/index.html) and [Databricks SQL](https://www.databricks.com/product/databricks-sql) using the `SQLDatabase.from_databricks()` method.\n",
-    "\n",
-    "### Syntax\n",
-    "```python\n",
-    "SQLDatabase.from_databricks(\n",
-    "    catalog: str,\n",
-    "    schema: str,\n",
-    "    host: Optional[str] = None,\n",
-    "    api_token: Optional[str] = None,\n",
-    "    warehouse_id: Optional[str] = None,\n",
-    "    cluster_id: Optional[str] = None,\n",
-    "    engine_args: Optional[dict] = None,\n",
-    "    **kwargs: Any)\n",
-    "```\n",
-    "### Required Parameters\n",
-    "* `catalog`: The catalog name in the Databricks database.\n",
-    "* `schema`: The schema name in the catalog.\n",
-    "\n",
-    "### Optional Parameters\n",
-    "There following parameters are optional. When executing the method in a Databricks notebook, you don't need to provide them in most of the cases.\n",
-    "* `host`: The Databricks workspace hostname, excluding 'https://' part. Defaults to 'DATABRICKS_HOST' environment variable or current workspace if in a Databricks notebook.\n",
-    "* `api_token`: The Databricks personal access token for accessing the Databricks SQL warehouse or the cluster. Defaults to 'DATABRICKS_TOKEN' environment variable or a temporary one is generated if in a Databricks notebook.\n",
-    "* `warehouse_id`: The warehouse ID in the Databricks SQL.\n",
-    "* `cluster_id`: The cluster ID in the Databricks Runtime. If running in a Databricks notebook and both 'warehouse_id' and 'cluster_id' are None, it uses the ID of the cluster the notebook is attached to.\n",
-    "* `engine_args`: The arguments to be used when connecting Databricks.\n",
-    "* `**kwargs`: Additional keyword arguments for the `SQLDatabase.from_uri` method."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b11c7e48",
-   "metadata": {},
-   "source": [
-    "## Examples"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "8102bca0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Connecting to Databricks with SQLDatabase wrapper\n",
-    "from langchain import SQLDatabase\n",
-    "\n",
-    "db = SQLDatabase.from_databricks(catalog=\"samples\", schema=\"nyctaxi\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "9dd36f58",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Creating a OpenAI Chat LLM wrapper\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "\n",
-    "llm = ChatOpenAI(temperature=0, model_name=\"gpt-4\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5b5c5f1a",
-   "metadata": {},
-   "source": [
-    "### SQL Chain example\n",
-    "\n",
-    "This example demonstrates the use of the [SQL Chain](https://python.langchain.com/en/latest/modules/chains/examples/sqlite.html) for answering a question over a Databricks database."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "36f2270b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain import SQLDatabaseChain\n",
-    "\n",
-    "db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "4e2b5f25",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new SQLDatabaseChain chain...\u001b[0m\n",
-      "What is the average duration of taxi rides that start between midnight and 6am?\n",
-      "SQLQuery:\u001b[32;1m\u001b[1;3mSELECT AVG(UNIX_TIMESTAMP(tpep_dropoff_datetime) - UNIX_TIMESTAMP(tpep_pickup_datetime)) as avg_duration\n",
-      "FROM trips\n",
-      "WHERE HOUR(tpep_pickup_datetime) >= 0 AND HOUR(tpep_pickup_datetime) < 6\u001b[0m\n",
-      "SQLResult: \u001b[33;1m\u001b[1;3m[(987.8122786304605,)]\u001b[0m\n",
-      "Answer:\u001b[32;1m\u001b[1;3mThe average duration of taxi rides that start between midnight and 6am is 987.81 seconds.\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The average duration of taxi rides that start between midnight and 6am is 987.81 seconds.'"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "db_chain.run(\n",
-    "    \"What is the average duration of taxi rides that start between midnight and 6am?\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e496d5e5",
-   "metadata": {},
-   "source": [
-    "### SQL Database Agent example\n",
-    "\n",
-    "This example demonstrates the use of the [SQL Database Agent](/docs/modules/agents/toolkits/sql_database.html) for answering questions over a Databricks database."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "9918e86a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.agents import create_sql_agent\n",
-    "from langchain.agents.agent_toolkits import SQLDatabaseToolkit\n",
-    "\n",
-    "toolkit = SQLDatabaseToolkit(db=db, llm=llm)\n",
-    "agent = create_sql_agent(llm=llm, toolkit=toolkit, verbose=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "c484a76e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mAction: list_tables_sql_db\n",
-      "Action Input: \u001b[0m\n",
-      "Observation: \u001b[38;5;200m\u001b[1;3mtrips\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mI should check the schema of the trips table to see if it has the necessary columns for trip distance and duration.\n",
-      "Action: schema_sql_db\n",
-      "Action Input: trips\u001b[0m\n",
-      "Observation: \u001b[33;1m\u001b[1;3m\n",
-      "CREATE TABLE trips (\n",
-      "\ttpep_pickup_datetime TIMESTAMP, \n",
-      "\ttpep_dropoff_datetime TIMESTAMP, \n",
-      "\ttrip_distance FLOAT, \n",
-      "\tfare_amount FLOAT, \n",
-      "\tpickup_zip INT, \n",
-      "\tdropoff_zip INT\n",
-      ") USING DELTA\n",
-      "\n",
-      "/*\n",
-      "3 rows from trips table:\n",
-      "tpep_pickup_datetime\ttpep_dropoff_datetime\ttrip_distance\tfare_amount\tpickup_zip\tdropoff_zip\n",
-      "2016-02-14 16:52:13+00:00\t2016-02-14 17:16:04+00:00\t4.94\t19.0\t10282\t10171\n",
-      "2016-02-04 18:44:19+00:00\t2016-02-04 18:46:00+00:00\t0.28\t3.5\t10110\t10110\n",
-      "2016-02-17 17:13:57+00:00\t2016-02-17 17:17:55+00:00\t0.7\t5.0\t10103\t10023\n",
-      "*/\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mThe trips table has the necessary columns for trip distance and duration. I will write a query to find the longest trip distance and its duration.\n",
-      "Action: query_checker_sql_db\n",
-      "Action Input: SELECT trip_distance, tpep_dropoff_datetime - tpep_pickup_datetime as duration FROM trips ORDER BY trip_distance DESC LIMIT 1\u001b[0m\n",
-      "Observation: \u001b[31;1m\u001b[1;3mSELECT trip_distance, tpep_dropoff_datetime - tpep_pickup_datetime as duration FROM trips ORDER BY trip_distance DESC LIMIT 1\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mThe query is correct. I will now execute it to find the longest trip distance and its duration.\n",
-      "Action: query_sql_db\n",
-      "Action Input: SELECT trip_distance, tpep_dropoff_datetime - tpep_pickup_datetime as duration FROM trips ORDER BY trip_distance DESC LIMIT 1\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3m[(30.6, '0 00:43:31.000000000')]\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3mI now know the final answer.\n",
-      "Final Answer: The longest trip distance is 30.6 miles and it took 43 minutes and 31 seconds.\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'The longest trip distance is 30.6 miles and it took 43 minutes and 31 seconds.'"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent.run(\"What is the longest trip distance and how long did it take?\")"
-   ]
-  }
- ],
- "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/extras/ecosystem/integrations/motherduck.mdx

@@ -0,0 +1,50 @@
+# Motherduck
+
+>[Motherduck](https://motherduck.com/) is a managed DuckDB-in-the-cloud service.
+
+## Installation and Setup
+
+First, you need to install `duckdb` python package.
+
+```bash
+pip install duckdb
+```
+
+You will also need to sign up for an account at [Motherduck](https://motherduck.com/)
+
+After that, you should set up a connection string - we mostly integrate with Motherduck through SQLAlchemy.
+The connection string is likely in the form:
+
+```
+token="..."
+
+conn_str = f"duckdb:///md:{token}@my_db"
+```
+
+## SQLChain
+
+You can use the SQLChain to query data in your Motherduck instance in natural language.
+
+```
+from langchain import OpenAI, SQLDatabase, SQLDatabaseChain
+db = SQLDatabase.from_uri(conn_str)
+db_chain = SQLDatabaseChain.from_llm(OpenAI(temperature=0), db, verbose=True)
+```
+
+From here, see the [SQL Chain](/docs/modules/chains/popular/sqlite.html) documentation on how to use.
+
+
+## LLMCache
+
+You can also easily use Motherduck to cache LLM requests.
+Once again this is done through the SQLAlchemy wrapper.
+
+```
+import sqlalchemy
+eng = sqlalchemy.create_engine(conn_str)
+langchain.llm_cache = SQLAlchemyCache(engine=eng)
+```
+
+From here, see the [LLM Caching](/docs/modules/model_io/models/llms/how_to/llm_caching) documentation on how to use.
+
+

docs/extras/ecosystem/integrations/openllm.mdx

@@ -0,0 +1,70 @@
+# OpenLLM
+
+This page demonstrates how to use [OpenLLM](https://github.com/bentoml/OpenLLM)
+with LangChain.
+
+`OpenLLM` is an open platform for operating large language models (LLMs) in
+production. It enables developers to easily run inference with any open-source
+LLMs, deploy to the cloud or on-premises, and build powerful AI apps.
+
+## Installation and Setup
+
+Install the OpenLLM package via PyPI:
+
+```bash
+pip install openllm
+```
+
+## LLM
+
+OpenLLM supports a wide range of open-source LLMs as well as serving users' own
+fine-tuned LLMs. Use `openllm model` command to see all available models that
+are pre-optimized for OpenLLM.
+
+## Wrappers
+
+There is a OpenLLM Wrapper which supports loading LLM in-process or accessing a
+remote OpenLLM server:
+
+```python
+from langchain.llms import OpenLLM
+```
+
+### Wrapper for OpenLLM server
+
+This wrapper supports connecting to an OpenLLM server via HTTP or gRPC. The
+OpenLLM server can run either locally or on the cloud.
+
+To try it out locally, start an OpenLLM server:
+
+```bash
+openllm start flan-t5
+```
+
+Wrapper usage:
+
+```python
+from langchain.llms import OpenLLM
+
+llm = OpenLLM(server_url='http://localhost:3000')
+
+llm("What is the difference between a duck and a goose? And why there are so many Goose in Canada?")
+```
+
+### Wrapper for Local Inference
+
+You can also use the OpenLLM wrapper to load LLM in current Python process for
+running inference.
+
+```python
+from langchain.llms import OpenLLM
+
+llm = OpenLLM(model_name="dolly-v2", model_id='databricks/dolly-v2-7b')
+
+llm("What is the difference between a duck and a goose? And why there are so many Goose in Canada?")
+```
+
+### Usage
+
+For a more detailed walkthrough of the OpenLLM Wrapper, see the
+[example notebook](/docs/modules/model_io/models/llms/integrations/openllm.html)

docs/extras/guides/deployments/index.mdx

@@ -21,7 +21,8 @@ This guide aims to provide a comprehensive overview of the requirements for depl
 Understanding these components is crucial when assessing serving systems. LangChain integrates with several open-source projects designed to tackle these issues, providing a robust framework for productionizing your LLM applications. Some notable frameworks include:
 
 - [Ray Serve](/docs/ecosystem/integrations/ray_serve.html)
-- [BentoML](https://github.com/ssheng/BentoChain)
+- [BentoML](https://github.com/bentoml/BentoML)
+- [OpenLLM](/docs/ecosystem/integrations/openllm.html)
 - [Modal](/docs/ecosystem/integrations/modal.html)
 
 These links will provide further information on each ecosystem, assisting you in finding the best fit for your LLM deployment needs.
@@ -110,4 +111,4 @@ Rapid iteration also involves the ability to recreate your infrastructure quickl
 
 ## CI/CD
 
-In a fast-paced environment, implementing CI/CD pipelines can significantly speed up the iteration process. They help automate the testing and deployment of your LLM applications, reducing the risk of errors and enabling faster feedback and iteration.
+In a fast-paced environment, implementing CI/CD pipelines can significantly speed up the iteration process. They help automate the testing and deployment of your LLM applications, reducing the risk of errors and enabling faster feedback and iteration.

docs/extras/guides/deployments/template_repos.mdx

@@ -67,6 +67,11 @@ This repository allows users to serve local chains and agents as RESTful, gRPC,
 
 This repository provides an example of how to deploy a LangChain application with [BentoML](https://github.com/bentoml/BentoML). BentoML is a framework that enables the containerization of machine learning applications as standard OCI images. BentoML also allows for the automatic generation of OpenAPI and gRPC endpoints. With BentoML, you can integrate models from all popular ML frameworks and deploy them as microservices running on the most optimal hardware and scaling independently.
 
+## [OpenLLM](https://github.com/bentoml/OpenLLM)
+
+OpenLLM is a platform for operating large language models (LLMs) in production. With OpenLLM, you can run inference with any open-source LLM, deploy to the cloud or on-premises, and build powerful AI apps. It supports a wide range of open-source LLMs, offers flexible APIs, and first-class support for LangChain and BentoML.
+See OpenLLM's [integration doc](https://github.com/bentoml/OpenLLM#%EF%B8%8F-integrations) for usage with LangChain.
+
 ## [Databutton](https://databutton.com/home?new-data-app=true)
 
 These templates serve as examples of how to build, deploy, and share LangChain applications using Databutton. You can create user interfaces with Streamlit, automate tasks by scheduling Python code, and store files and data in the built-in store. Examples include a Chatbot interface with conversational memory, a Personal search engine, and a starter template for LangChain apps. Deploying and sharing is just one click away.

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

@@ -0,0 +1,232 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9502d5b0",
+   "metadata": {},
+   "source": [
+    "# OpenAI Multi Functions Agent\n",
+    "\n",
+    "This notebook showcases using an agent that uses the OpenAI functions ability to respond to the prompts of the user using a Large Language Model\n",
+    "\n",
+    "Install openai,google-search-results packages which are required as the langchain packages call them internally\n",
+    "\n",
+    ">pip install openai google-search-results\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c0a83623",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain import SerpAPIWrapper\n",
+    "from langchain.agents import initialize_agent, Tool\n",
+    "from langchain.agents import AgentType\n",
+    "from langchain.chat_models import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "86198d9c",
+   "metadata": {},
+   "source": [
+    "The agent is given ability to perform search functionalities with the respective tool\n",
+    "\n",
+    "SerpAPIWrapper:\n",
+    ">This initializes the SerpAPIWrapper for search functionality (search).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6fefaba2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialize the OpenAI language model\n",
+    "#Replace <your_api_key> in openai_api_key=\"<your_api_key>\" with your actual OpenAI key.\n",
+    "llm = ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo-0613\")\n",
+    "\n",
+    "# Initialize the SerpAPIWrapper for search functionality\n",
+    "#Replace <your_api_key> in openai_api_key=\"<your_api_key>\" with your actual SerpAPI key.\n",
+    "search = SerpAPIWrapper()\n",
+    "\n",
+    "# Define a list of tools offered by the agent\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name=\"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"Useful when you need to answer questions about current events. You should ask targeted questions.\"\n",
+    "    ),\n",
+    "]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9ff6cee9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mrkl = initialize_agent(tools, llm, agent=AgentType.OPENAI_MULTI_FUNCTIONS, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "cbe95c81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Do this so we can see exactly what's going on under the hood\n",
+    "import langchain\n",
+    "langchain.debug = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ba8e4cbe",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[32;1m\u001b[1;3m[chain/start]\u001b[0m \u001b[1m[1:chain:AgentExecutor] Entering Chain run with input:\n",
+      "\u001b[0m{\n",
+      "  \"input\": \"What is the weather in LA and SF?\"\n",
+      "}\n",
+      "\u001b[32;1m\u001b[1;3m[llm/start]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 2:llm:ChatOpenAI] Entering LLM run with input:\n",
+      "\u001b[0m{\n",
+      "  \"prompts\": [\n",
+      "    \"System: You are a helpful AI assistant.\\nHuman: What is the weather in LA and SF?\"\n",
+      "  ]\n",
+      "}\n",
+      "\u001b[36;1m\u001b[1;3m[llm/end]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 2:llm:ChatOpenAI] [2.91s] Exiting LLM run with output:\n",
+      "\u001b[0m{\n",
+      "  \"generations\": [\n",
+      "    [\n",
+      "      {\n",
+      "        \"text\": \"\",\n",
+      "        \"generation_info\": null,\n",
+      "        \"message\": {\n",
+      "          \"content\": \"\",\n",
+      "          \"additional_kwargs\": {\n",
+      "            \"function_call\": {\n",
+      "              \"name\": \"tool_selection\",\n",
+      "              \"arguments\": \"{\\n  \\\"actions\\\": [\\n    {\\n      \\\"action_name\\\": \\\"Search\\\",\\n      \\\"action\\\": {\\n        \\\"tool_input\\\": \\\"weather in Los Angeles\\\"\\n      }\\n    },\\n    {\\n      \\\"action_name\\\": \\\"Search\\\",\\n      \\\"action\\\": {\\n        \\\"tool_input\\\": \\\"weather in San Francisco\\\"\\n      }\\n    }\\n  ]\\n}\"\n",
+      "            }\n",
+      "          },\n",
+      "          \"example\": false\n",
+      "        }\n",
+      "      }\n",
+      "    ]\n",
+      "  ],\n",
+      "  \"llm_output\": {\n",
+      "    \"token_usage\": {\n",
+      "      \"prompt_tokens\": 81,\n",
+      "      \"completion_tokens\": 75,\n",
+      "      \"total_tokens\": 156\n",
+      "    },\n",
+      "    \"model_name\": \"gpt-3.5-turbo-0613\"\n",
+      "  },\n",
+      "  \"run\": null\n",
+      "}\n",
+      "\u001b[32;1m\u001b[1;3m[tool/start]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 3:tool:Search] Entering Tool run with input:\n",
+      "\u001b[0m\"{'tool_input': 'weather in Los Angeles'}\"\n",
+      "\u001b[36;1m\u001b[1;3m[tool/end]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 3:tool:Search] [608.693ms] Exiting Tool run with output:\n",
+      "\u001b[0m\"Mostly cloudy early, then sunshine for the afternoon. High 76F. Winds SW at 5 to 10 mph. Humidity59%.\"\n",
+      "\u001b[32;1m\u001b[1;3m[tool/start]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 4:tool:Search] Entering Tool run with input:\n",
+      "\u001b[0m\"{'tool_input': 'weather in San Francisco'}\"\n",
+      "\u001b[36;1m\u001b[1;3m[tool/end]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 4:tool:Search] [517.475ms] Exiting Tool run with output:\n",
+      "\u001b[0m\"Partly cloudy this evening, then becoming cloudy after midnight. Low 53F. Winds WSW at 10 to 20 mph. Humidity83%.\"\n",
+      "\u001b[32;1m\u001b[1;3m[llm/start]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 5:llm:ChatOpenAI] Entering LLM run with input:\n",
+      "\u001b[0m{\n",
+      "  \"prompts\": [\n",
+      "    \"System: You are a helpful AI assistant.\\nHuman: What is the weather in LA and SF?\\nAI: {'name': 'tool_selection', 'arguments': '{\\\\n  \\\"actions\\\": [\\\\n    {\\\\n      \\\"action_name\\\": \\\"Search\\\",\\\\n      \\\"action\\\": {\\\\n        \\\"tool_input\\\": \\\"weather in Los Angeles\\\"\\\\n      }\\\\n    },\\\\n    {\\\\n      \\\"action_name\\\": \\\"Search\\\",\\\\n      \\\"action\\\": {\\\\n        \\\"tool_input\\\": \\\"weather in San Francisco\\\"\\\\n      }\\\\n    }\\\\n  ]\\\\n}'}\\nFunction: Mostly cloudy early, then sunshine for the afternoon. High 76F. Winds SW at 5 to 10 mph. Humidity59%.\\nAI: {'name': 'tool_selection', 'arguments': '{\\\\n  \\\"actions\\\": [\\\\n    {\\\\n      \\\"action_name\\\": \\\"Search\\\",\\\\n      \\\"action\\\": {\\\\n        \\\"tool_input\\\": \\\"weather in Los Angeles\\\"\\\\n      }\\\\n    },\\\\n    {\\\\n      \\\"action_name\\\": \\\"Search\\\",\\\\n      \\\"action\\\": {\\\\n        \\\"tool_input\\\": \\\"weather in San Francisco\\\"\\\\n      }\\\\n    }\\\\n  ]\\\\n}'}\\nFunction: Partly cloudy this evening, then becoming cloudy after midnight. Low 53F. Winds WSW at 10 to 20 mph. Humidity83%.\"\n",
+      "  ]\n",
+      "}\n",
+      "\u001b[36;1m\u001b[1;3m[llm/end]\u001b[0m \u001b[1m[1:chain:AgentExecutor > 5:llm:ChatOpenAI] [2.33s] Exiting LLM run with output:\n",
+      "\u001b[0m{\n",
+      "  \"generations\": [\n",
+      "    [\n",
+      "      {\n",
+      "        \"text\": \"The weather in Los Angeles is mostly cloudy with a high of 76°F and a humidity of 59%. The weather in San Francisco is partly cloudy in the evening, becoming cloudy after midnight, with a low of 53°F and a humidity of 83%.\",\n",
+      "        \"generation_info\": null,\n",
+      "        \"message\": {\n",
+      "          \"content\": \"The weather in Los Angeles is mostly cloudy with a high of 76°F and a humidity of 59%. The weather in San Francisco is partly cloudy in the evening, becoming cloudy after midnight, with a low of 53°F and a humidity of 83%.\",\n",
+      "          \"additional_kwargs\": {},\n",
+      "          \"example\": false\n",
+      "        }\n",
+      "      }\n",
+      "    ]\n",
+      "  ],\n",
+      "  \"llm_output\": {\n",
+      "    \"token_usage\": {\n",
+      "      \"prompt_tokens\": 307,\n",
+      "      \"completion_tokens\": 54,\n",
+      "      \"total_tokens\": 361\n",
+      "    },\n",
+      "    \"model_name\": \"gpt-3.5-turbo-0613\"\n",
+      "  },\n",
+      "  \"run\": null\n",
+      "}\n",
+      "\u001b[36;1m\u001b[1;3m[chain/end]\u001b[0m \u001b[1m[1:chain:AgentExecutor] [6.37s] Exiting Chain run with output:\n",
+      "\u001b[0m{\n",
+      "  \"output\": \"The weather in Los Angeles is mostly cloudy with a high of 76°F and a humidity of 59%. The weather in San Francisco is partly cloudy in the evening, becoming cloudy after midnight, with a low of 53°F and a humidity of 83%.\"\n",
+      "}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The weather in Los Angeles is mostly cloudy with a high of 76°F and a humidity of 59%. The weather in San Francisco is partly cloudy in the evening, becoming cloudy after midnight, with a low of 53°F and a humidity of 83%.'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mrkl.run(\n",
+    "    \"What is the weather in LA and SF?\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f5f6743",
+   "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/agents/tools/integrations/twilio.ipynb

@@ -1,16 +1,20 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "dc23c48e",
    "metadata": {},
    "source": [
     "# Twilio\n",
     "\n",
-    "This notebook goes over how to use the [Twilio](https://www.twilio.com) API wrapper to send a text message."
+    "This notebook goes over how to use the [Twilio](https://www.twilio.com) API wrapper to send a message through SMS or [Twilio Messaging Channels](https://www.twilio.com/docs/messaging/channels).\n",
+    "\n",
+    "Twilio Messaging Channels facilitates integrations with 3rd party messaging apps and lets you send messages through WhatsApp Business Platform (GA), Facebook Messenger (Public Beta) and Google Business Messages (Private Beta)."
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "c1a33b13",
    "metadata": {},
@@ -31,6 +35,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "f7e883ae",
    "metadata": {},
@@ -41,11 +46,12 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "36c133be",
    "metadata": {},
    "source": [
-    "## Sending a message"
+    "## Sending an SMS"
    ]
   },
   {
@@ -81,6 +87,58 @@
    "source": [
     "twilio.run(\"hello world\", \"+16162904619\")"
    ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "de022dc9",
+   "metadata": {},
+   "source": [
+    "## Sending a WhatsApp Message"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a594d0bc",
+   "metadata": {},
+   "source": [
+    "You'll need to link your WhatsApp Business Account with Twilio. You'll also need to make sure that the number to send messages from is configured as a WhatsApp Enabled Sender on Twilio and registered with WhatsApp."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "94508aa0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.utilities.twilio import TwilioAPIWrapper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4b81750",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "twilio = TwilioAPIWrapper(\n",
+    "    #     account_sid=\"foo\",\n",
+    "    #     auth_token=\"bar\",\n",
+    "    #     from_number=\"whatsapp: baz,\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1181041b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "twilio.run(\"hello world\", \"whatsapp: +16162904619\")"
+   ]
   }
  ],
  "metadata": {

docs/extras/modules/chains/additional/openapi_openai.ipynb

@@ -0,0 +1,245 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e734b314",
+   "metadata": {},
+   "source": [
+    "# OpenAPI calls with OpenAI functions\n",
+    "\n",
+    "In this notebook we'll show how to create a chain that automatically makes calls to an API based only on an OpenAPI  spec. Under the hood, we're parsing the OpenAPI spec into a JSON schema that the OpenAI functions API can handle. This allows ChatGPT to automatically select and populate the relevant API call to make for any user input. Using the output of ChatGPT we then make the actual API call, and return the result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "555661b5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.openai_functions.openapi import get_openapi_chain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a95f510a",
+   "metadata": {},
+   "source": [
+    "## Query Klarna"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08e19b64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = get_openapi_chain(\"https://www.klarna.com/us/shopping/public/openai/v0/api-docs/\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "3959f866",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'products': [{'name': \"Tommy Hilfiger Men's Short Sleeve Button-Down Shirt\",\n",
+       "   'url': 'https://www.klarna.com/us/shopping/pl/cl10001/3204878580/Clothing/Tommy-Hilfiger-Men-s-Short-Sleeve-Button-Down-Shirt/?utm_source=openai&ref-site=openai_plugin',\n",
+       "   'price': '$26.78',\n",
+       "   'attributes': ['Material:Linen,Cotton',\n",
+       "    'Target Group:Man',\n",
+       "    'Color:Gray,Pink,White,Blue,Beige,Black,Turquoise',\n",
+       "    'Size:S,XL,M,XXL']},\n",
+       "  {'name': \"Van Heusen Men's Long Sleeve Button-Down Shirt\",\n",
+       "   'url': 'https://www.klarna.com/us/shopping/pl/cl10001/3201809514/Clothing/Van-Heusen-Men-s-Long-Sleeve-Button-Down-Shirt/?utm_source=openai&ref-site=openai_plugin',\n",
+       "   'price': '$18.89',\n",
+       "   'attributes': ['Material:Cotton',\n",
+       "    'Target Group:Man',\n",
+       "    'Color:Red,Gray,White,Blue',\n",
+       "    'Size:XL,XXL']},\n",
+       "  {'name': 'Brixton Bowery Flannel Shirt',\n",
+       "   'url': 'https://www.klarna.com/us/shopping/pl/cl10001/3202331096/Clothing/Brixton-Bowery-Flannel-Shirt/?utm_source=openai&ref-site=openai_plugin',\n",
+       "   'price': '$34.48',\n",
+       "   'attributes': ['Material:Cotton',\n",
+       "    'Target Group:Man',\n",
+       "    'Color:Gray,Blue,Black,Orange',\n",
+       "    'Size:XL,3XL,4XL,5XL,L,M,XXL']},\n",
+       "  {'name': 'Cubavera Four Pocket Guayabera Shirt',\n",
+       "   'url': 'https://www.klarna.com/us/shopping/pl/cl10001/3202055522/Clothing/Cubavera-Four-Pocket-Guayabera-Shirt/?utm_source=openai&ref-site=openai_plugin',\n",
+       "   'price': '$23.22',\n",
+       "   'attributes': ['Material:Polyester,Cotton',\n",
+       "    'Target Group:Man',\n",
+       "    'Color:Red,White,Blue,Black',\n",
+       "    'Size:S,XL,L,M,XXL']},\n",
+       "  {'name': 'Theory Sylvain Shirt - Eclipse',\n",
+       "   'url': 'https://www.klarna.com/us/shopping/pl/cl10001/3202028254/Clothing/Theory-Sylvain-Shirt-Eclipse/?utm_source=openai&ref-site=openai_plugin',\n",
+       "   'price': '$86.01',\n",
+       "   'attributes': ['Material:Polyester,Cotton',\n",
+       "    'Target Group:Man',\n",
+       "    'Color:Blue',\n",
+       "    'Size:S,XL,XS,L,M,XXL']}]}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(\"What are some options for a men's large blue button down shirt\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f648c77",
+   "metadata": {},
+   "source": [
+    "## Query a translation service\n",
+    "\n",
+    "Additionally, see the request payload by setting `verbose=True`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf6cd695",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = get_openapi_chain(\"https://api.speak.com/openapi.yaml\", verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "1ba51609",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mHuman: Use the provided API's to respond to this user query:\n",
+      "\n",
+      "How would you say no thanks in Russian\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Calling endpoint \u001b[32;1m\u001b[1;3mtranslate\u001b[0m with arguments:\n",
+      "\u001b[32;1m\u001b[1;3m{\n",
+      "  \"json\": {\n",
+      "    \"phrase_to_translate\": \"no thanks\",\n",
+      "    \"learning_language\": \"russian\",\n",
+      "    \"native_language\": \"english\",\n",
+      "    \"additional_context\": \"\",\n",
+      "    \"full_query\": \"How would you say no thanks in Russian\"\n",
+      "  }\n",
+      "}\u001b[0m\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'explanation': '<translation language=\"Russian\">\\nНет, спасибо. (Net, spasibo)\\n</translation>\\n\\n<alternatives>\\n1. \"Нет, я в порядке\" *(Neutral/Formal - Can be used in professional settings or formal situations.)*\\n2. \"Нет, спасибо, я откажусь\" *(Formal - Can be used in polite settings, such as a fancy dinner with colleagues or acquaintances.)*\\n3. \"Не надо\" *(Informal - Can be used in informal situations, such as declining an offer from a friend.)*\\n</alternatives>\\n\\n<example-convo language=\"Russian\">\\n<context>Max is being offered a cigarette at a party.</context>\\n* Sasha: \"Хочешь покурить?\"\\n* Max: \"Нет, спасибо. Я бросил.\"\\n* Sasha: \"Окей, понятно.\"\\n</example-convo>\\n\\n*[Report an issue or leave feedback](https://speak.com/chatgpt?rid=noczaa460do8yqs8xjun6zdm})*',\n",
+       " 'extra_response_instructions': 'Use all information in the API response and fully render all Markdown.\\nAlways end your response with a link to report an issue or leave feedback on the plugin.'}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(\"How would you say no thanks in Russian\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4923a291",
+   "metadata": {},
+   "source": [
+    "## Query XKCD"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a9198f62",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "chain = get_openapi_chain(\"https://gist.githubusercontent.com/roaldnefs/053e505b2b7a807290908fe9aa3e1f00/raw/0a212622ebfef501163f91e23803552411ed00e4/openapi.yaml\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3110c398",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'month': '6',\n",
+       " 'num': 2793,\n",
+       " 'link': '',\n",
+       " 'year': '2023',\n",
+       " 'news': '',\n",
+       " 'safe_title': 'Garden Path Sentence',\n",
+       " 'transcript': '',\n",
+       " 'alt': 'Arboretum Owner Denied Standing in Garden Path Suit on Grounds Grounds Appealing Appealing',\n",
+       " 'img': 'https://imgs.xkcd.com/comics/garden_path_sentence.png',\n",
+       " 'title': 'Garden Path Sentence',\n",
+       " 'day': '23'}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(\"What's today's comic?\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "venv"
+  },
+  "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.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/iugu.ipynb

@@ -54,7 +54,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Create a vectorstore retriver from the loader\n",
+    "# Create a vectorstore retriever from the loader\n",
     "# see https://python.langchain.com/en/latest/modules/data_connection/getting_started.html for more details\n",
     "\n",
     "index = VectorstoreIndexCreator().from_loaders([iugu_loader])\n",

docs/extras/modules/data_connection/document_loaders/integrations/merge_doc_loader.ipynb

@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "dd7c3503",
+   "metadata": {},
+   "source": [
+    "# MergeDocLoader\n",
+    "\n",
+    "Merge the documents returned from a set of specified data loaders."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e08dfff1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import WebBaseLoader\n",
+    "loader_web = WebBaseLoader(\"https://github.com/basecamp/handbook/blob/master/37signals-is-you.md\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "07b42b2e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import PyPDFLoader\n",
+    "loader_pdf = PyPDFLoader(\"../MachineLearning-Lecture01.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "912ede96",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders.merge import MergedDataLoader\n",
+    "loader_all=MergedDataLoader(loaders=[loader_web,loader_pdf])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "9d001311",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs_all=loader_all.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b9097486",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "23"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(docs_all)"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/modern_treasury.ipynb

@@ -1,6 +1,7 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -28,6 +29,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -79,7 +81,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Create a vectorstore retriver from the loader\n",
+    "# Create a vectorstore retriever from the loader\n",
     "# see https://python.langchain.com/en/latest/modules/data_connection/getting_started.html for more details\n",
     "\n",
     "index = VectorstoreIndexCreator().from_loaders([modern_treasury_loader])\n",

docs/extras/modules/data_connection/document_loaders/integrations/open_city_data.ipynb

@@ -0,0 +1,141 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9b721926",
+   "metadata": {},
+   "source": [
+    "# Open City Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "35c00849",
+   "metadata": {},
+   "source": [
+    "[Socrata](https://dev.socrata.com/foundry/data.sfgov.org/vw6y-z8j6) provides an API for city open data. \n",
+    "\n",
+    "For a dataset such as [SF crime](https://data.sfgov.org/Public-Safety/Police-Department-Incident-Reports-Historical-2003/tmnf-yvry), to to the `API` tab on top right. \n",
+    "\n",
+    "That provides you with the `dataset identifier`.\n",
+    "\n",
+    "Use the dataset identifier to grab specific tables for a given city_id (`data.sfgov.org`) - \n",
+    "\n",
+    "E.g., `vw6y-z8j6` for [SF 311 data](https://dev.socrata.com/foundry/data.sfgov.org/vw6y-z8j6).\n",
+    "\n",
+    "E.g., `tmnf-yvry` for [SF Police data](https://dev.socrata.com/foundry/data.sfgov.org/tmnf-yvry)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c93cc247",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install sodapy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b3464a02",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import OpenCityDataLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "478c5255",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = \"vw6y-z8j6\" # 311 data\n",
+    "dataset = \"tmnf-yvry\" # crime data\n",
+    "loader = OpenCityDataLoader(city_id=\"data.sfgov.org\",\n",
+    "                         dataset_id=dataset,\n",
+    "                         limit=2000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "fa914fc1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "WARNING:root:Requests made without an app_token will be subject to strict throttling limits.\n"
+     ]
+    }
+   ],
+   "source": [
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "73a6def2",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'pdid': '4133422003074',\n",
+       " 'incidntnum': '041334220',\n",
+       " 'incident_code': '03074',\n",
+       " 'category': 'ROBBERY',\n",
+       " 'descript': 'ROBBERY, BODILY FORCE',\n",
+       " 'dayofweek': 'Monday',\n",
+       " 'date': '2004-11-22T00:00:00.000',\n",
+       " 'time': '17:50',\n",
+       " 'pddistrict': 'INGLESIDE',\n",
+       " 'resolution': 'NONE',\n",
+       " 'address': 'GENEVA AV / SANTOS ST',\n",
+       " 'x': '-122.420084075249',\n",
+       " 'y': '37.7083109744362',\n",
+       " 'location': {'type': 'Point',\n",
+       "  'coordinates': [-122.420084075249, 37.7083109744362]},\n",
+       " ':@computed_region_26cr_cadq': '9',\n",
+       " ':@computed_region_rxqg_mtj9': '8',\n",
+       " ':@computed_region_bh8s_q3mv': '309'}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eval(docs[0].page_content)"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/pandas_dataframe.ipynb

@@ -42,7 +42,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "id": "ac273ca1",
    "metadata": {},
    "outputs": [
@@ -116,7 +116,7 @@
        "4     Braves                  83.31       94"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -127,7 +127,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "66e47a13",
    "metadata": {},
    "outputs": [],
@@ -137,7 +137,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 5,
    "id": "2334caca",
    "metadata": {},
    "outputs": [],
@@ -147,7 +147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 6,
    "id": "d616c2b0",
    "metadata": {},
    "outputs": [
@@ -186,7 +186,7 @@
        " Document(page_content='Astros', metadata={' \"Payroll (millions)\"': 60.65, ' \"Wins\"': 55})]"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -197,11 +197,52 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "beb55c2f",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "page_content='Nationals' metadata={' \"Payroll (millions)\"': 81.34, ' \"Wins\"': 98}\n",
+      "page_content='Reds' metadata={' \"Payroll (millions)\"': 82.2, ' \"Wins\"': 97}\n",
+      "page_content='Yankees' metadata={' \"Payroll (millions)\"': 197.96, ' \"Wins\"': 95}\n",
+      "page_content='Giants' metadata={' \"Payroll (millions)\"': 117.62, ' \"Wins\"': 94}\n",
+      "page_content='Braves' metadata={' \"Payroll (millions)\"': 83.31, ' \"Wins\"': 94}\n",
+      "page_content='Athletics' metadata={' \"Payroll (millions)\"': 55.37, ' \"Wins\"': 94}\n",
+      "page_content='Rangers' metadata={' \"Payroll (millions)\"': 120.51, ' \"Wins\"': 93}\n",
+      "page_content='Orioles' metadata={' \"Payroll (millions)\"': 81.43, ' \"Wins\"': 93}\n",
+      "page_content='Rays' metadata={' \"Payroll (millions)\"': 64.17, ' \"Wins\"': 90}\n",
+      "page_content='Angels' metadata={' \"Payroll (millions)\"': 154.49, ' \"Wins\"': 89}\n",
+      "page_content='Tigers' metadata={' \"Payroll (millions)\"': 132.3, ' \"Wins\"': 88}\n",
+      "page_content='Cardinals' metadata={' \"Payroll (millions)\"': 110.3, ' \"Wins\"': 88}\n",
+      "page_content='Dodgers' metadata={' \"Payroll (millions)\"': 95.14, ' \"Wins\"': 86}\n",
+      "page_content='White Sox' metadata={' \"Payroll (millions)\"': 96.92, ' \"Wins\"': 85}\n",
+      "page_content='Brewers' metadata={' \"Payroll (millions)\"': 97.65, ' \"Wins\"': 83}\n",
+      "page_content='Phillies' metadata={' \"Payroll (millions)\"': 174.54, ' \"Wins\"': 81}\n",
+      "page_content='Diamondbacks' metadata={' \"Payroll (millions)\"': 74.28, ' \"Wins\"': 81}\n",
+      "page_content='Pirates' metadata={' \"Payroll (millions)\"': 63.43, ' \"Wins\"': 79}\n",
+      "page_content='Padres' metadata={' \"Payroll (millions)\"': 55.24, ' \"Wins\"': 76}\n",
+      "page_content='Mariners' metadata={' \"Payroll (millions)\"': 81.97, ' \"Wins\"': 75}\n",
+      "page_content='Mets' metadata={' \"Payroll (millions)\"': 93.35, ' \"Wins\"': 74}\n",
+      "page_content='Blue Jays' metadata={' \"Payroll (millions)\"': 75.48, ' \"Wins\"': 73}\n",
+      "page_content='Royals' metadata={' \"Payroll (millions)\"': 60.91, ' \"Wins\"': 72}\n",
+      "page_content='Marlins' metadata={' \"Payroll (millions)\"': 118.07, ' \"Wins\"': 69}\n",
+      "page_content='Red Sox' metadata={' \"Payroll (millions)\"': 173.18, ' \"Wins\"': 69}\n",
+      "page_content='Indians' metadata={' \"Payroll (millions)\"': 78.43, ' \"Wins\"': 68}\n",
+      "page_content='Twins' metadata={' \"Payroll (millions)\"': 94.08, ' \"Wins\"': 66}\n",
+      "page_content='Rockies' metadata={' \"Payroll (millions)\"': 78.06, ' \"Wins\"': 64}\n",
+      "page_content='Cubs' metadata={' \"Payroll (millions)\"': 88.19, ' \"Wins\"': 61}\n",
+      "page_content='Astros' metadata={' \"Payroll (millions)\"': 60.65, ' \"Wins\"': 55}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Use lazy load for larger table, which won't read the full table into memory \n",
+    "for i in loader.lazy_load():\n",
+    "    print(i)"
+   ]
   }
  ],
  "metadata": {
@@ -220,7 +261,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,

docs/extras/modules/data_connection/document_loaders/integrations/recursive_url_loader.ipynb

@@ -0,0 +1,232 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5a7cc773",
+   "metadata": {},
+   "source": [
+    "# Recursive URL Loader\n",
+    "\n",
+    "We may want to process load all URLs under a root directory.\n",
+    "\n",
+    "For example, let's look at the [LangChain JS documentation](https://js.langchain.com/docs/).\n",
+    "\n",
+    "This has many interesting child pages that we may want to read in bulk.\n",
+    "\n",
+    "Of course, the `WebBaseLoader` can load a list of pages. \n",
+    "\n",
+    "But, the challenge is traversing the tree of child pages and actually assembling that list!\n",
+    " \n",
+    "We do this using the `RecusiveUrlLoader`.\n",
+    "\n",
+    "This also gives us the flexibility to exclude some children (e.g., the `api` directory with > 800 child pages)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "2e3532b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders.recursive_url_loader import RecusiveUrlLoader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6384c057",
+   "metadata": {},
+   "source": [
+    "Let's try a simple example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d69e5620",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "url = 'https://js.langchain.com/docs/modules/memory/examples/'\n",
+    "loader=RecusiveUrlLoader(url=url)\n",
+    "docs=loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "084fb2ce",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "12"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "89355b7c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\n\\n\\n\\nDynamoDB-Backed Chat Memory | \\uf8ffü¶úÔ∏è\\uf8ffüîó Lan'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[0].page_content[:50]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "13bd7e16",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'source': 'https://js.langchain.com/docs/modules/memory/examples/dynamodb',\n",
+       " 'title': 'DynamoDB-Backed Chat Memory | \\uf8ffü¶úÔ∏è\\uf8ffüîó Langchain',\n",
+       " 'description': 'For longer-term persistence across chat sessions, you can swap out the default in-memory chatHistory that backs chat memory classes like BufferMemory for a DynamoDB instance.',\n",
+       " 'language': 'en'}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[0].metadata"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40fc13ef",
+   "metadata": {},
+   "source": [
+    "Now, let's try a more extensive example, the `docs` root dir.\n",
+    "\n",
+    "We will skip everything under `api`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "30ff61d3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "url = 'https://js.langchain.com/docs/'\n",
+    "exclude_dirs=['https://js.langchain.com/docs/api/']\n",
+    "loader=RecusiveUrlLoader(url=url,exclude_dirs=exclude_dirs)\n",
+    "docs=loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "457e30f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "176"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "bca80b4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\n\\n\\n\\nHacker News | \\uf8ffü¶úÔ∏è\\uf8ffüîó Langchain\\n\\n\\n\\n\\n\\nSkip'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[0].page_content[:50]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "df97cf22",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'source': 'https://js.langchain.com/docs/modules/indexes/document_loaders/examples/web_loaders/hn',\n",
+       " 'title': 'Hacker News | \\uf8ffü¶úÔ∏è\\uf8ffüîó Langchain',\n",
+       " 'description': 'This example goes over how to load data from the hacker news website, using Cheerio. One document will be created for each page.',\n",
+       " 'language': 'en'}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[0].metadata"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/document_loaders/integrations/spreedly.ipynb

@@ -1,6 +1,7 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -26,6 +27,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -69,7 +71,7 @@
     }
    ],
    "source": [
-    "# Create a vectorstore retriver from the loader\n",
+    "# Create a vectorstore retriever from the loader\n",
     "# see https://python.langchain.com/en/latest/modules/data_connection/getting_started.html for more details\n",
     "\n",
     "index = VectorstoreIndexCreator().from_loaders([spreedly_loader])\n",

docs/extras/modules/data_connection/document_loaders/integrations/stripe.ipynb

@@ -1,6 +1,7 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -25,6 +26,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -62,7 +64,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Create a vectorstore retriver from the loader\n",
+    "# Create a vectorstore retriever from the loader\n",
     "# see https://python.langchain.com/en/latest/modules/data_connection/getting_started.html for more details\n",
     "\n",
     "index = VectorstoreIndexCreator().from_loaders([stripe_loader])\n",

docs/extras/modules/data_connection/document_transformers/text_splitters/markdown_header_metadata.ipynb

@@ -50,8 +50,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "19c044f0",
+   "execution_count": 2,
+   "id": "ceb3c1fb",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -65,13 +65,16 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'content': 'Hi this is Jim  \\nHi this is Joe', 'metadata': {'Header 1': 'Foo', 'Header 2': 'Bar'}}\n",
-      "{'content': 'Hi this is Lance', 'metadata': {'Header 1': 'Foo', 'Header 2': 'Bar', 'Header 3': 'Boo'}}\n",
-      "{'content': 'Hi this is Molly', 'metadata': {'Header 1': 'Foo', 'Header 2': 'Baz'}}\n"
-     ]
+     "data": {
+      "text/plain": [
+       "[Document(page_content='Hi this is Jim  \\nHi this is Joe', metadata={'Header 1': 'Foo', 'Header 2': 'Bar'}),\n",
+       " Document(page_content='Hi this is Lance', metadata={'Header 1': 'Foo', 'Header 2': 'Bar', 'Header 3': 'Boo'}),\n",
+       " Document(page_content='Hi this is Molly', metadata={'Header 1': 'Foo', 'Header 2': 'Baz'})]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -85,8 +88,28 @@
     "\n",
     "markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)\n",
     "md_header_splits = markdown_splitter.split_text(markdown_document)\n",
-    "for split in md_header_splits:\n",
-    "    print(split)"
+    "md_header_splits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "aac1738c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "langchain.schema.Document"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(md_header_splits[0])"
    ]
   },
   {
@@ -99,10 +122,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "id": "480e0e3a",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='Markdown[9] is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as a markup language that is appealing to human readers in its source code form.[9]', metadata={'Header 1': 'Intro', 'Header 2': 'History'}),\n",
+       " Document(page_content='Markdown is widely used in blogging, instant messaging, online forums, collaborative software, documentation pages, and readme files.', metadata={'Header 1': 'Intro', 'Header 2': 'History'}),\n",
+       " Document(page_content='As Markdown popularity grew rapidly, many Markdown implementations appeared, driven mostly by the need for  \\nadditional features such as tables, footnotes, definition lists,[note 1] and Markdown inside HTML blocks.  \\n#### Standardization', metadata={'Header 1': 'Intro', 'Header 2': 'Rise and divergence'}),\n",
+       " Document(page_content='#### Standardization  \\nFrom 2012, a group of people, including Jeff Atwood and John MacFarlane, launched what Atwood characterised as a standardisation effort.', metadata={'Header 1': 'Intro', 'Header 2': 'Rise and divergence'}),\n",
+       " Document(page_content='Implementations of Markdown are available for over a dozen programming languages.', metadata={'Header 1': 'Intro', 'Header 2': 'Implementations'})]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "markdown_document = \"# Intro \\n\\n    ## History \\n\\n Markdown[9] is a lightweight markup language for creating formatted text using a plain-text editor. John Gruber created Markdown in 2004 as a markup language that is appealing to human readers in its source code form.[9] \\n\\n Markdown is widely used in blogging, instant messaging, online forums, collaborative software, documentation pages, and readme files. \\n\\n ## Rise and divergence \\n\\n As Markdown popularity grew rapidly, many Markdown implementations appeared, driven mostly by the need for \\n\\n additional features such as tables, footnotes, definition lists,[note 1] and Markdown inside HTML blocks. \\n\\n #### Standardization \\n\\n From 2012, a group of people, including Jeff Atwood and John MacFarlane, launched what Atwood characterised as a standardisation effort. \\n\\n ## Implementations \\n\\n Implementations of Markdown are available for over a dozen programming languages.\"\n",
     "\n",
@@ -117,60 +155,13 @@
     "\n",
     "# Char-level splits\n",
     "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
-    "chunk_size = 10\n",
-    "chunk_overlap = 0\n",
+    "chunk_size = 250\n",
+    "chunk_overlap = 30\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)\n",
     "\n",
-    "# Split within each header group\n",
-    "all_splits=[]\n",
-    "all_metadatas=[]    \n",
-    "for header_group in md_header_splits:\n",
-    "    _splits = text_splitter.split_text(header_group['content'])\n",
-    "    _metadatas = [header_group['metadata'] for _ in _splits]\n",
-    "    all_splits += _splits\n",
-    "    all_metadatas += _metadatas"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "3f5d775e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Markdown[9'"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all_splits[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "33ab0d5c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'Header 1': 'Intro', 'Header 2': 'History'}"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all_metadatas[0]"
+    "# Split\n",
+    "splits = text_splitter.split_documents(md_header_splits)\n",
+    "splits"
    ]
   }
  ],

docs/extras/modules/data_connection/retrievers/how_to/self_query/myscale_self_query.ipynb

@@ -148,7 +148,7 @@
     "    # This will teach the LLM to use it as a column when constructing filter.\n",
     "    AttributeInfo(\n",
     "        name=\"length(genre)\",\n",
-    "        description=\"The lenth of genres of the movie\", \n",
+    "        description=\"The length of genres of the movie\", \n",
     "        type=\"integer\", \n",
     "    ),\n",
     "    # Now you can define a column as timestamp. By simply set the type to timestamp.\n",

docs/extras/modules/data_connection/retrievers/integrations/amazon_kendra_retriever.ipynb

@@ -26,7 +26,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#!pip install boto3"
+    "%pip install boto3"
    ]
   },
   {
@@ -36,7 +36,7 @@
    "outputs": [],
    "source": [
     "import boto3\n",
-    "from langchain.retrievers import AwsKendraIndexRetriever"
+    "from langchain.retrievers import AmazonKendraRetriever"
    ]
   },
   {
@@ -53,11 +53,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "kclient = boto3.client(\"kendra\", region_name=\"us-east-1\")\n",
-    "\n",
-    "retriever = AwsKendraIndexRetriever(\n",
-    "    kclient=kclient,\n",
-    "    kendraindex=\"kendraindex\",\n",
+    "retriever = AmazonKendraRetriever(\n",
+    "    index_id=\"c0806df7-e76b-4bce-9b5c-d5582f6b1a03\"\n",
     ")"
    ]
   },
@@ -66,7 +63,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now you can use retrieved documents from AWS Kendra Index"
+    "Now you can use retrieved documents from Kendra index"
    ]
   },
   {

docs/extras/modules/data_connection/vectorstores/integrations/chroma.ipynb

@@ -1,107 +1,80 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "683953b3",
    "metadata": {},
    "source": [
     "# Chroma\n",
     "\n",
-    ">[Chroma](https://docs.trychroma.com/getting-started) is a database for building AI applications with embeddings.\n",
+    ">[Chroma](https://docs.trychroma.com/getting-started) is a AI-native open-source vector database focused on developer productivity and happiness. Chroma is licensed under Apache 2.0.\n",
     "\n",
-    "This notebook shows how to use functionality related to the `Chroma` vector database."
+    "<a href=\"https://discord.gg/MMeYNTmh3x\" target=\"_blank\">\n",
+    "  <img src=\"https://img.shields.io/discord/1073293645303795742\" alt=\"Discord\" />\n",
+    "</a>&nbsp;&nbsp;\n",
+    "<a href=\"https://github.com/chroma-core/chroma/blob/master/LICENSE\" target=\"_blank\">\n",
+    "  <img src=\"https://img.shields.io/static/v1?label=license&message=Apache 2.0&color=white\" alt=\"License\" />\n",
+    "</a>&nbsp;&nbsp;\n",
+    "<img src=\"https://github.com/chroma-core/chroma/actions/workflows/chroma-integration-test.yml/badge.svg?branch=main\" alt=\"Integration Tests\" />\n",
+    "\n",
+    "- [Website](https://www.trychroma.com/)\n",
+    "- [Documentation](https://docs.trychroma.com/)\n",
+    "- [Twitter](https://twitter.com/trychroma)\n",
+    "- [Discord](https://discord.gg/MMeYNTmh3x)\n",
+    "\n",
+    "Chroma is fully-typed, fully-tested and fully-documented.\n",
+    "\n",
+    "Install Chroma with:\n",
+    "\n",
+    "```sh\n",
+    "pip install chromadb\n",
+    "```\n",
+    "\n",
+    "Chroma runs in various modes. See below for examples of each integrated with LangChain.\n",
+    "- `in-memory` - in a python script or jupyter notebook\n",
+    "- `in-memory with persistance` - in a script or notebook and save/load to disk\n",
+    "- `in a docker container` - as a server running your local machine or in the cloud\n",
+    "\n",
+    "Like any other database, you can: \n",
+    "- `.add` \n",
+    "- `.get` \n",
+    "- `.update`\n",
+    "- `.upsert`\n",
+    "- `.delete`\n",
+    "- `.peek`\n",
+    "- and `.query` runs the similarity search.\n",
+    "\n",
+    "View full docs at [docs](https://docs.trychroma.com/reference/Collection). To access these methods directly, you can do `._collection_.method()`\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "0825fa4a-d950-4e78-8bba-20cfcc347765",
-   "metadata": {
-    "tags": []
-   },
+   "id": "12e83df7",
+   "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install chromadb"
+    "# first install dependencies\n",
+    "!pip install langchain\n",
+    "!pip install langchainplus_sdk\n",
+    "!pip install chromadb\n"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "42080f37-8fd1-4cec-acd9-15d2b03b2f4d",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " ········\n"
-     ]
-    }
-   ],
+   "cell_type": "markdown",
+   "id": "2b5ffbf8",
+   "metadata": {},
    "source": [
-    "# get a token: https://platform.openai.com/account/api-keys\n",
+    "## Basic Example\n",
     "\n",
-    "from getpass import getpass\n",
-    "\n",
-    "OPENAI_API_KEY = getpass()"
+    "In this basic example, we take the most recent State of the Union Address, split it into chunks, embed it using an open-source embedding model, load it into Chroma, and then query it."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "c7a94d6c-b4d4-4498-9bdd-eb50c92b85c5",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "aac9563e",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.vectorstores import Chroma\n",
-    "from langchain.document_loaders import TextLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "a3c3999a",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "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": "code",
-   "execution_count": 9,
-   "id": "5eabdb75",
-   "metadata": {
-    "tags": []
-   },
+   "execution_count": 14,
+   "id": "ae9fcf3e",
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
@@ -109,21 +82,7 @@
      "text": [
       "Using embedded DuckDB without persistence: data will be transient\n"
      ]
-    }
-   ],
-   "source": [
-    "db = Chroma.from_documents(docs, embeddings)\n",
-    "\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = db.similarity_search(query)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "4b172de8",
-   "metadata": {},
-   "outputs": [
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -139,20 +98,312 @@
     }
    ],
    "source": [
+    "# import\n",
+    "from langchain.embeddings.sentence_transformer import SentenceTransformerEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain.document_loaders import TextLoader\n",
+    "\n",
+    "# load the document and split it into chunks\n",
+    "loader = TextLoader(\"../../../state_of_the_union.txt\")\n",
+    "documents = loader.load()\n",
+    "\n",
+    "# split it into chunks\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "# create the open-source embedding function\n",
+    "embedding_function = SentenceTransformerEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
+    "\n",
+    "# load it into Chroma\n",
+    "db = Chroma.from_documents(docs, embedding_function)\n",
+    "\n",
+    "# query it\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = db.similarity_search(query)\n",
+    "\n",
+    "# print results\n",
     "print(docs[0].page_content)"
    ]
   },
   {
-   "attachments": {},
+   "cell_type": "markdown",
+   "id": "5c9a11cc",
+   "metadata": {},
+   "source": [
+    "## Basic Example (including saving to disk)\n",
+    "\n",
+    "Extending the previous example, if you want to save to disk, simply initialize the Chroma client and pass the directory where you want the data to be saved to. \n",
+    "\n",
+    "`Caution`: Chroma makes a best-effort to automatically save data to disk, however multiple in-memory clients can stomp each other's work. As a best practice, only have one client per path running at any given time.\n",
+    "\n",
+    "`Protip`: Sometimes you can call `db.persist()` to force a save. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "49f9bd49",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using embedded DuckDB with persistence: data will be stored in: ./chroma_db\n",
+      "Using embedded DuckDB with persistence: data will be stored in: ./chroma_db\n",
+      "No embedding_function provided, using default embedding function: SentenceTransformerEmbeddingFunction\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# save to disk\n",
+    "db2 = Chroma.from_documents(docs, embedding_function, persist_directory=\"./chroma_db\")\n",
+    "db2.persist()\n",
+    "docs = db.similarity_search(query)\n",
+    "\n",
+    "# load from disk\n",
+    "db3 = Chroma(persist_directory=\"./chroma_db\")\n",
+    "docs = db.similarity_search(query)\n",
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e9cf6d70",
+   "metadata": {},
+   "source": [
+    "## Basic Example (using the Docker Container)\n",
+    "\n",
+    "You can also run the Chroma Server in a Docker container separately, create a Client to connect to it, and then pass that to LangChain. \n",
+    "\n",
+    "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",
+    "git clone git@github.com:chroma-core/chroma.git\n",
+    "docker-compose up -d --build\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "74aee70e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "No embedding_function provided, using default embedding function: SentenceTransformerEmbeddingFunction\n",
+      "No embedding_function provided, using default embedding function: SentenceTransformerEmbeddingFunction\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# create the chroma client\n",
+    "import chromadb\n",
+    "import uuid\n",
+    "from chromadb.config import Settings\n",
+    "client = chromadb.Client(Settings(chroma_api_impl=\"rest\",\n",
+    "                                        chroma_server_host=\"localhost\",\n",
+    "                                        chroma_server_http_port=\"8000\"\n",
+    "                                    ))\n",
+    "client.reset() # resets the database\n",
+    "collection = client.create_collection(\"my_collection\")\n",
+    "for doc in docs:\n",
+    "    collection.add(ids=[str(uuid.uuid1())], metadatas=doc.metadata, documents=doc.page_content)\n",
+    "\n",
+    "# tell LangChain to use our client and collection name\n",
+    "db4 = Chroma(client=client, collection_name=\"my_collection\")\n",
+    "docs = db.similarity_search(query)\n",
+    "print(docs[0].page_content)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ed3ec50",
+   "metadata": {},
+   "source": [
+    "## Update and Delete\n",
+    "\n",
+    "While building toward a real application, you want to go beyond adding data, and also update and delete data. \n",
+    "\n",
+    "Chroma has users provide `ids` to simplify the bookkeeping here. `ids` can be the name of the file, or a combined has like `filename_paragraphNumber`, etc.\n",
+    "\n",
+    "Chroma supports all these operations - though some of them are still being integrated all the way through the LangChain interface. Additional workflow improvements will be added soon.\n",
+    "\n",
+    "Here is a basic example showing how to do various operations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "81a02810",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using embedded DuckDB without persistence: data will be transient\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'source': '../../../state_of_the_union.txt', 'new_value': 'hello world'}\n",
+      "{'ids': ['1'], 'embeddings': None, 'documents': ['Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \\n\\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.'], 'metadatas': [{'source': '../../../state_of_the_union.txt', 'new_value': 'hello world'}]}\n",
+      "count before 4\n",
+      "count after 3\n"
+     ]
+    }
+   ],
+   "source": [
+    "# create simple ids\n",
+    "ids = [str(i) for i in range(1, len(docs)+1)]\n",
+    "\n",
+    "# add data\n",
+    "example_db = Chroma.from_documents(docs, embedding_function, ids=ids)\n",
+    "docs = example_db.similarity_search(query)\n",
+    "print(docs[0].metadata)\n",
+    "\n",
+    "# update the metadata for a document\n",
+    "docs[0].metadata = {'source': '../../../state_of_the_union.txt', 'new_value': 'hello world'}\n",
+    "example_db.update_document(ids[0], docs[0])\n",
+    "print(example_db._collection.get(ids=[ids[0]]))\n",
+    "\n",
+    "# delete the last document\n",
+    "print(\"count before\", example_db._collection.count())\n",
+    "example_db._collection.delete(ids=[ids[-1]])\n",
+    "print(\"count after\", example_db._collection.count())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac6bc71a",
+   "metadata": {},
+   "source": [
+    "## Use OpenAI Embeddings\n",
+    "\n",
+    "Many people like to use OpenAIEmbeddings, here is how to set that up."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "42080f37-8fd1-4cec-acd9-15d2b03b2f4d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# get a token: https://platform.openai.com/account/api-keys\n",
+    "\n",
+    "from getpass import getpass\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "\n",
+    "OPENAI_API_KEY = getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "c7a94d6c-b4d4-4498-9bdd-eb50c92b85c5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "5eabdb75",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using embedded DuckDB without persistence: data will be transient\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "embeddings = OpenAIEmbeddings()\n",
+    "db5 = Chroma.from_documents(docs, embeddings)\n",
+    "\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = db.similarity_search(query)\n",
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d9c28ad",
+   "metadata": {},
+   "source": [
+    "***\n",
+    "\n",
+    "## Other Information"
+   ]
+  },
+  {
    "cell_type": "markdown",
    "id": "18152965",
    "metadata": {},
    "source": [
-    "## Similarity search with score"
+    "### Similarity search with score"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "346347d7",
    "metadata": {},
@@ -197,127 +448,15 @@
    ]
   },
   {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "8061454b",
-   "metadata": {},
-   "source": [
-    "## Persistance\n",
-    "\n",
-    "The below steps cover how to persist a ChromaDB instance"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "2b76db26",
-   "metadata": {},
-   "source": [
-    "### Initialize PeristedChromaDB\n",
-    "Create embeddings for each chunk and insert into the Chroma vector database. The persist_directory argument tells ChromaDB where to store the database when it's persisted.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "cdb86e0d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running Chroma using direct local API.\n",
-      "No existing DB found in db, skipping load\n",
-      "No existing DB found in db, skipping load\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Embed and store the texts\n",
-    "# Supplying a persist_directory will store the embeddings on disk\n",
-    "persist_directory = \"db\"\n",
-    "\n",
-    "embedding = OpenAIEmbeddings()\n",
-    "vectordb = Chroma.from_documents(\n",
-    "    documents=docs, embedding=embedding, persist_directory=persist_directory\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "f568a322",
-   "metadata": {},
-   "source": [
-    "### Persist the Database\n",
-    "We should call persist() to ensure the embeddings are written to disk."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "74b08cb4",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Persisting DB to disk, putting it in the save folder db\n",
-      "PersistentDuckDB del, about to run persist\n",
-      "Persisting DB to disk, putting it in the save folder db\n"
-     ]
-    }
-   ],
-   "source": [
-    "vectordb.persist()\n",
-    "vectordb = None"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "cc9ed900",
-   "metadata": {},
-   "source": [
-    "### Load the Database from disk, and create the chain\n",
-    "Be sure to pass the same persist_directory and embedding_function as you did when you instantiated the database. Initialize the chain we will use for question answering."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "31fecfe9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running Chroma using direct local API.\n",
-      "loaded in 4 embeddings\n",
-      "loaded in 1 collections\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Now we can load the persisted database from disk, and use it as normal.\n",
-    "vectordb = Chroma(persist_directory=persist_directory, embedding_function=embedding)"
-   ]
-  },
-  {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "794a7552",
    "metadata": {},
    "source": [
-    "## Retriever options\n",
+    "### Retriever options\n",
     "\n",
     "This section goes over different options for how to use Chroma as a retriever.\n",
     "\n",
-    "### MMR\n",
+    "#### MMR\n",
     "\n",
     "In addition to using similarity search in the retriever object, you can also use `mmr`."
    ]
@@ -352,82 +491,6 @@
    "source": [
     "retriever.get_relevant_documents(query)[0]"
    ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "2a877f08",
-   "metadata": {},
-   "source": [
-    "## Updating a Document\n",
-    "The `update_document` function allows you to modify the content of a document in the Chroma instance after it has been added. Let's see an example of how to use this function."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "a559c3f1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Import Document class\n",
-    "from langchain.docstore.document import Document\n",
-    "\n",
-    "# Initial document content and id\n",
-    "initial_content = \"This is an initial document content\"\n",
-    "document_id = \"doc1\"\n",
-    "\n",
-    "# Create an instance of Document with initial content and metadata\n",
-    "original_doc = Document(page_content=initial_content, metadata={\"page\": \"0\"})\n",
-    "\n",
-    "# Initialize a Chroma instance with the original document\n",
-    "new_db = Chroma.from_documents(\n",
-    "    collection_name=\"test_collection\",\n",
-    "    documents=[original_doc],\n",
-    "    embedding=OpenAIEmbeddings(),  # using the same embeddings as before\n",
-    "    ids=[document_id],\n",
-    ")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "60a7c273",
-   "metadata": {},
-   "source": [
-    "At this point, we have a new Chroma instance with a single document \"This is an initial document content\" with id \"doc1\". Now, let's update the content of the document."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "55e48056",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "This is the updated document content {'page': '1'}\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Updated document content\n",
-    "updated_content = \"This is the updated document content\"\n",
-    "\n",
-    "# Create a new Document instance with the updated content\n",
-    "updated_doc = Document(page_content=updated_content, metadata={\"page\": \"1\"})\n",
-    "\n",
-    "# Update the document in the Chroma instance by passing the document id and the updated document\n",
-    "new_db.update_document(document_id=document_id, document=updated_doc)\n",
-    "\n",
-    "# Now, let's retrieve the updated document using similarity search\n",
-    "output = new_db.similarity_search(updated_content, k=1)\n",
-    "\n",
-    "# Print the content of the retrieved document\n",
-    "print(output[0].page_content, output[0].metadata)"
-   ]
   }
  ],
  "metadata": {
@@ -446,7 +509,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.11.3"
   }
  },
  "nbformat": 4,

docs/extras/modules/data_connection/vectorstores/integrations/clarifai.ipynb

@@ -0,0 +1,286 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "683953b3",
+   "metadata": {},
+   "source": [
+    "# Clarifai\n",
+    "\n",
+    ">[Clarifai](https://www.clarifai.com/) is a AI Platform that provides the full AI lifecycle ranging from data exploration, data labeling, model building and inference. A Clarifai application can be used as a vector database after uploading inputs. \n",
+    "\n",
+    "This notebook shows how to use functionality related to the `Clarifai` vector database.\n",
+    "\n",
+    "To use Clarifai, you must have an account and a Personal Access Token key. \n",
+    "Here are the [installation instructions](https://clarifai.com/settings/security )."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "1eecfb1c",
+   "metadata": {},
+   "source": [
+    "# Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4c41cad-08ef-4f72-a545-2151e4598efe",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Install required dependencies\n",
+    "!pip install clarifai"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "93039ada",
+   "metadata": {},
+   "source": [
+    "# Imports\n",
+    "Here we will be setting the personal access token. You can find your PAT under settings/security on the platform."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c1e38361-c1fe-4ac6-86e9-c90ebaf7ae87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Please login and get your API key from  https://clarifai.com/settings/security \n",
+    "from getpass import getpass\n",
+    "\n",
+    "CLARIFAI_PAT_KEY = getpass()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "320af802-9271-46ee-948f-d2453933d44b",
+   "metadata": {},
+   "source": [
+    "We want to use `OpenAIEmbeddings` so we have to get the OpenAI API Key."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "aac9563e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Import the required modules\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.document_loaders import TextLoader\n",
+    "from langchain.vectorstores import Clarifai"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "edcf5159",
+   "metadata": {},
+   "source": [
+    "# Setup\n",
+    "Setup the user id and app id where the text data will be uploaded. \n",
+    "\n",
+    "You will have to first create an account on [Clarifai](https://clarifai.com/login) and then create an application."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4d853395",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "USER_ID = 'USERNAME_ID'\n",
+    "APP_ID = 'APPLICATION_ID'\n",
+    "NUMBER_OF_DOCS = 4"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "5631bdd5",
+   "metadata": {},
+   "source": [
+    "## From Texts\n",
+    "Create a Clarifai vectorstore from a list of texts. This section will upload each text with its respective metadata to a Clarifai Application. The Clarifai Application can then be used for semantic search to find relevant texts."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1d828f77",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = [\"I really enjoy spending time with you\", \"I hate spending time with my dog\", \"I want to go for a run\", \\\n",
+    "    \"I went to the movies yesterday\", \"I love playing soccer with my friends\"]\n",
+    "\n",
+    "metadatas = [{\"id\": i, \"text\": text} for i, text in enumerate(texts)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "738bff27",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clarifai_vector_db = Clarifai.from_texts(user_id=USER_ID, app_id=APP_ID, texts=texts, pat=CLARIFAI_PAT_KEY, number_of_docs=NUMBER_OF_DOCS, metadatas = metadatas)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e755cdce",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='I really enjoy spending time with you', metadata={'text': 'I really enjoy spending time with you', 'id': 0.0}),\n",
+       " Document(page_content='I went to the movies yesterday', metadata={'text': 'I went to the movies yesterday', 'id': 3.0}),\n",
+       " Document(page_content='zab', metadata={'page': '2'}),\n",
+       " Document(page_content='zab', metadata={'page': '2'})]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs = clarifai_vector_db.similarity_search(\"I would love to see you\")\n",
+    "docs"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c39504e4",
+   "metadata": {},
+   "source": [
+    "## From Documents\n",
+    "Create a Clarifai vectorstore from a list of Documents. This section will upload each document with its respective metadata to a Clarifai Application. The Clarifai Application can then be used for semantic search to find relevant documents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a3c3999a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "69ae7e35",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \\n\\nLast year COVID-19 kept us apart. This year we are finally together again. \\n\\nTonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \\n\\nWith a duty to one another to the American people to the Constitution. \\n\\nAnd with an unwavering resolve that freedom will always triumph over tyranny. \\n\\nSix days ago, Russia’s Vladimir Putin sought to shake the foundations of the free world thinking he could make it bend to his menacing ways. But he badly miscalculated. \\n\\nHe thought he could roll into Ukraine and the world would roll over. Instead he met a wall of strength he never imagined. \\n\\nHe met the Ukrainian people. \\n\\nFrom President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " Document(page_content='Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. \\n\\nIn this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight. \\n\\nLet each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. \\n\\nPlease rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. \\n\\nThroughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos.   \\n\\nThey keep moving.   \\n\\nAnd the costs and the threats to America and the world keep rising.   \\n\\nThat’s why the NATO Alliance was created to secure peace and stability in Europe after World War 2. \\n\\nThe United States is a member along with 29 other nations. \\n\\nIt matters. American diplomacy matters. American resolve matters.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " Document(page_content='Putin’s latest attack on Ukraine was premeditated and unprovoked. \\n\\nHe rejected repeated efforts at diplomacy. \\n\\nHe thought the West and NATO wouldn’t respond. And he thought he could divide us at home. Putin was wrong. We were ready.  Here is what we did.   \\n\\nWe prepared extensively and carefully. \\n\\nWe spent months building a coalition of other freedom-loving nations from Europe and the Americas to Asia and Africa to confront Putin. \\n\\nI spent countless hours unifying our European allies. We shared with the world in advance what we knew Putin was planning and precisely how he would try to falsely justify his aggression.  \\n\\nWe countered Russia’s lies with truth.   \\n\\nAnd now that he has acted the free world is holding him accountable. \\n\\nAlong with twenty-seven members of the European Union including France, Germany, Italy, as well as countries like the United Kingdom, Canada, Japan, Korea, Australia, New Zealand, and many others, even Switzerland.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " Document(page_content='We are inflicting pain on Russia and supporting the people of Ukraine. Putin is now isolated from the world more than ever. \\n\\nTogether with our allies –we are right now enforcing powerful economic sanctions. \\n\\nWe are cutting off Russia’s largest banks from the international financial system.  \\n\\nPreventing Russia’s central bank from defending the Russian Ruble making Putin’s $630 Billion “war fund” worthless.   \\n\\nWe are choking off Russia’s access to technology that will sap its economic strength and weaken its military for years to come.  \\n\\nTonight I say to the Russian oligarchs and corrupt leaders who have bilked billions of dollars off this violent regime no more. \\n\\nThe U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs.  \\n\\nWe are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains.', metadata={'source': '../../../state_of_the_union.txt'})]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[:4]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "40bf1305",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "USER_ID = 'USERNAME_ID'\n",
+    "APP_ID = 'APPLICATION_ID'\n",
+    "NUMBER_OF_DOCS = 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6e104aee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clarifai_vector_db = Clarifai.from_documents(user_id=USER_ID, app_id=APP_ID, documents=docs, pat=CLARIFAI_PAT_KEY, number_of_docs=NUMBER_OF_DOCS)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9c608226",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='And I will keep doing everything in my power to crack down on gun trafficking and ghost guns you can buy online and make at home—they have no serial numbers and can’t be traced. \\n\\nAnd I ask Congress to pass proven measures to reduce gun violence. Pass universal background checks. Why should anyone on a terrorist list be able to purchase a weapon? \\n\\nBan assault weapons and high-capacity magazines. \\n\\nRepeal the liability shield that makes gun manufacturers the only industry in America that can’t be sued. \\n\\nThese laws don’t infringe on the Second Amendment. They save lives. \\n\\nThe most fundamental right in America is the right to vote – and to have it counted. And it’s under assault. \\n\\nIn state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections. \\n\\nWe cannot let this happen.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " Document(page_content='We can’t change how divided we’ve been. But we can change how we move forward—on COVID-19 and other issues we must face together. \\n\\nI recently visited the New York City Police Department days after the funerals of Officer Wilbert Mora and his partner, Officer Jason Rivera. \\n\\nThey were responding to a 9-1-1 call when a man shot and killed them with a stolen gun. \\n\\nOfficer Mora was 27 years old. \\n\\nOfficer Rivera was 22. \\n\\nBoth Dominican Americans who’d grown up on the same streets they later chose to patrol as police officers. \\n\\nI spoke with their families and told them that we are forever in debt for their sacrifice, and we will carry on their mission to restore the trust and safety every community deserves. \\n\\nI’ve worked on these issues a long time. \\n\\nI know what works: Investing in crime preventionand community police officers who’ll walk the beat, who’ll know the neighborhood, and who can restore trust and safety.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " Document(page_content='A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. \\n\\nAnd if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. \\n\\nWe can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling.  \\n\\nWe’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers.  \\n\\nWe’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. \\n\\nWe’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " Document(page_content='So let’s not abandon our streets. Or choose between safety and equal justice. \\n\\nLet’s come together to protect our communities, restore trust, and hold law enforcement accountable. \\n\\nThat’s why the Justice Department required body cameras, banned chokeholds, and restricted no-knock warrants for its officers. \\n\\nThat’s why the American Rescue Plan provided $350 Billion that cities, states, and counties can use to hire more police and invest in proven strategies like community violence interruption—trusted messengers breaking the cycle of violence and trauma and giving young people hope.  \\n\\nWe should all agree: The answer is not to Defund the police. The answer is to FUND the police with the resources and training they need to protect our communities. \\n\\nI ask Democrats and Republicans alike: Pass my budget and keep our neighborhoods safe.', metadata={'source': '../../../state_of_the_union.txt'})]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs = clarifai_vector_db.similarity_search(\"Texts related to criminals and violence\")\n",
+    "docs"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/data_connection/vectorstores/integrations/mongodb_atlas_vector_search.ipynb

@@ -0,0 +1,222 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "683953b3",
+   "metadata": {},
+   "source": [
+    "# MongoDB Atlas Vector Search\n",
+    "\n",
+    ">[MongoDB Atlas](https://www.mongodb.com/docs/atlas/) is a fully-managed cloud database available in AWS , Azure, and GCP.  It now has support for native Vector Search on your MongoDB document data.\n",
+    "\n",
+    "This notebook shows how to use `MongoDB Atlas Vector Search` to store your embeddings in MongoDB documents, create a vector search index, and perform KNN search with an approximate nearest neighbor algorithm.\n",
+    "\n",
+    "It uses the [knnBeta Operator](https://www.mongodb.com/docs/atlas/atlas-search/knn-beta) available in MongoDB Atlas Search. This feature is in Public Preview and available for evaluation purposes, to validate functionality, and to gather feedback from public preview users. It is not recommended for production deployments as we may introduce breaking changes.\n",
+    "\n",
+    "To use MongoDB Atlas, you must first deploy a cluster. We have a Forever-Free tier of clusters available. \n",
+    "To get started head over to Atlas here: [quick start](https://www.mongodb.com/docs/atlas/getting-started/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4c41cad-08ef-4f72-a545-2151e4598efe",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "!pip install pymongo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1e38361-c1fe-4ac6-86e9-c90ebaf7ae87",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import getpass\n",
+    "\n",
+    "MONGODB_ATLAS_CLUSTER_URI = getpass.getpass(\"MongoDB Atlas Cluster URI:\")\n",
+    "MONGODB_ATLAS_CLUSTER_URI = os.environ[\"MONGODB_ATLAS_CLUSTER_URI\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "457ace44-1d95-4001-9dd5-78811ab208ad",
+   "metadata": {},
+   "source": [
+    "We want to use `OpenAIEmbeddings` so we need to set up our OpenAI API Key. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d8f240d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")\n",
+    "OPENAI_API_KEY = os.environ[\"OPENAI_API_KEY\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f3ecc42",
+   "metadata": {},
+   "source": [
+    "Now, let's create a vector search index on your cluster. In the below example, `embedding` is the name of the field that contains the embedding vector. Please refer to the [documentation](https://www.mongodb.com/docs/atlas/atlas-search/define-field-mappings-for-vector-search) to get more details on how to define an Atlas Vector Search index.\n",
+    "You can name the index `langchain_demo` and create the index on the namespace `lanchain_db.langchain_col`. Finally, write the following definition in the JSON editor on MongoDB Atlas:\n",
+    "\n",
+    "```json\n",
+    "{\n",
+    "  \"mappings\": {\n",
+    "    \"dynamic\": true,\n",
+    "    \"fields\": {\n",
+    "      \"embedding\": {\n",
+    "        \"dimensions\": 1536,\n",
+    "        \"similarity\": \"cosine\",\n",
+    "        \"type\": \"knnVector\"\n",
+    "      }\n",
+    "    }\n",
+    "  }\n",
+    "}\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "aac9563e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import MongoDBAtlasVectorSearch\n",
+    "from langchain.document_loaders import TextLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "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": "code",
+   "execution_count": null,
+   "id": "6e104aee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pymongo import MongoClient\n",
+    "\n",
+    "# initialize MongoDB python client\n",
+    "client = MongoClient(MONGODB_ATLAS_CLUSTER_URI)\n",
+    "\n",
+    "db_name = \"lanchain_db\"\n",
+    "collection_name = \"langchain_col\"\n",
+    "collection = client[db_name][collection_name]\n",
+    "index_name = \"langchain_demo\"\n",
+    "\n",
+    "# insert the documents in MongoDB Atlas with their embedding\n",
+    "docsearch = MongoDBAtlasVectorSearch.from_documents(\n",
+    "    docs, embeddings, collection=collection, index_name=index_name\n",
+    ")\n",
+    "\n",
+    "# perform a similarity search between the embedding of the query and the embeddings of the documents\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = docsearch.similarity_search(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9c608226",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "851a2ec9-9390-49a4-8412-3e132c9f789d",
+   "metadata": {},
+   "source": [
+    "You can reuse the vector search index you created, make sure the `OPENAI_API_KEY` environment variable is set up, then execute another query."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6336fe79-3e73-48be-b20a-0ff1bb6a4399",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pymongo import MongoClient\n",
+    "from langchain.vectorstores import MongoDBAtlasVectorSearch\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "import os\n",
+    "\n",
+    "MONGODB_ATLAS_URI = os.environ[\"MONGODB_ATLAS_URI\"]\n",
+    "\n",
+    "# initialize MongoDB python client\n",
+    "client = MongoClient(MONGODB_ATLAS_URI)\n",
+    "\n",
+    "db_name = \"langchain_db\"\n",
+    "collection_name = \"langchain_col\"\n",
+    "collection = client[db_name][collection_name]\n",
+    "index_name = \"langchain_index\"\n",
+    "\n",
+    "# initialize vector store\n",
+    "vectorStore = MongoDBAtlasVectorSearch(\n",
+    "    collection, OpenAIEmbeddings(), index_name=index_name\n",
+    ")\n",
+    "\n",
+    "# perform a similarity search between the embedding of the query and the embeddings of the documents\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = vectorStore.similarity_search(query)\n",
+    "\n",
+    "print(docs[0].page_content)"
+   ]
+  }
+ ],
+ "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/data_connection/vectorstores/integrations/redis.ipynb

@@ -70,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -84,9 +84,16 @@
     "embeddings = OpenAIEmbeddings()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you're not interested in the keys of your entries you can also create your redis instance from the documents."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -96,44 +103,41 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 6,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'link'"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "source": [
+    "If you're interested in the keys of your entries you have to split your docs in texts and metadatas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "texts = [d.page_content for d in docs]\n",
+    "metadatas = [d.metadata for d in docs]\n",
+    "\n",
+    "rds, keys = Redis.from_texts_return_keys(texts,\n",
+    "                                    embeddings,\n",
+    "                                    redis_url=\"redis://localhost:6379\",\n",
+    "                                    index_name=\"link\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": [
     "rds.index_name"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
-      "\n",
-      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
-      "\n",
-      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
-      "\n",
-      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
     "results = rds.similarity_search(query)\n",
@@ -142,34 +146,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['doc:link:d7d02e3faf1b40bbbe29a683ff75b280']\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(rds.add_texts([\"Ankush went to Princeton\"]))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ankush went to Princeton\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "query = \"Princeton\"\n",
     "results = rds.similarity_search(query)\n",
@@ -178,23 +166,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
-      "\n",
-      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
-      "\n",
-      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
-      "\n",
-      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Load from existing index\n",
     "rds = Redis.from_existing_index(\n",
@@ -219,7 +193,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -228,7 +202,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -244,7 +218,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -260,6 +234,31 @@
     "# Here we can see it doesn't return any results because there are no relevant documents\n",
     "retriever.get_relevant_documents(\"where did ankush go to college?\")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Delete keys"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To delete your entries you have to address them by their keys."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "Redis.delete(keys, redis_url=\"redis://localhost:6379\")"
+   ]
   }
  ],
  "metadata": {

docs/extras/modules/data_connection/vectorstores/integrations/starrocks.ipynb

@@ -0,0 +1,313 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "59723cea",
+   "metadata": {},
+   "source": [
+    "# StarRocks\n",
+    "\n",
+    "[StarRocks | A High-Performance Analytical Database](https://www.starrocks.io/)\n",
+    "\n",
+    "StarRocks is a next-gen sub-second MPP database for full analytics scenarios, including multi-dimensional analytics, real-time analytics and ad-hoc query.\n",
+    "\n",
+    "Usually StarRocks is categorized into OLAP, and it has showed excellent performance in [ClickBench — a Benchmark For Analytical DBMS](https://benchmark.clickhouse.com/). Since it has a super-fast vectorized execution engine, it could also be used as a fast vectordb.\n",
+    "\n",
+    "Here we'll show how to use the StarRocks Vector Store."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1685854f",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Import all used modules"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c891bba",
+   "metadata": {},
+   "source": [
+    "Set `update_vectordb = False` at the beginning. If there is no docs updated, then we don't need to rebuild the embeddings of docs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3c85fb93",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/dirlt/utils/py3env/lib/python3.9/site-packages/requests/__init__.py:102: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (5.1.0)/charset_normalizer (2.0.9) doesn't match a supported version!\n",
+      "  warnings.warn(\"urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported \"\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.vectorstores import StarRocks\n",
+    "from langchain.vectorstores.starrocks import StarRocksSettings\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter\n",
+    "from langchain import OpenAI,VectorDBQA\n",
+    "from langchain.document_loaders import DirectoryLoader\n",
+    "from langchain.chains import RetrievalQA\n",
+    "from langchain.document_loaders import TextLoader, UnstructuredMarkdownLoader\n",
+    "\n",
+    "update_vectordb = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee821c00",
+   "metadata": {},
+   "source": [
+    "## Load docs and split them into tokens"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "34ba0cfd",
+   "metadata": {},
+   "source": [
+    "Load all markdown files under the `docs` directory\n",
+    "\n",
+    "for starrocks documents, you can clone repo from https://github.com/StarRocks/starrocks, and there is `docs` directory in it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "85912696",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = DirectoryLoader('./docs', glob='**/*.md', loader_cls=UnstructuredMarkdownLoader)\n",
+    "documents = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b415fe2a",
+   "metadata": {},
+   "source": [
+    "Split docs into tokens, and set `update_vectordb = True` because there are new docs/tokens."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "07e8acff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load text splitter and split docs into snippets of text\n",
+    "text_splitter = TokenTextSplitter(chunk_size=400, chunk_overlap=50)\n",
+    "split_docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "# tell vectordb to update text embeddings\n",
+    "update_vectordb = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1f365370",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Document(page_content='Compile StarRocks with Docker\\n\\nThis topic describes how to compile StarRocks using Docker.\\n\\nOverview\\n\\nStarRocks provides development environment images for both Ubuntu 22.04 and CentOS 7.9. With the image, you can launch a Docker container and compile StarRocks in the container.\\n\\nStarRocks version and DEV ENV image\\n\\nDifferent branches of StarRocks correspond to different development environment images provided on StarRocks Docker Hub.\\n\\nFor Ubuntu 22.04:\\n\\n| Branch name | Image name              |\\n  | --------------- | ----------------------------------- |\\n  | main            | starrocks/dev-env-ubuntu:latest     |\\n  | branch-3.0      | starrocks/dev-env-ubuntu:3.0-latest |\\n  | branch-2.5      | starrocks/dev-env-ubuntu:2.5-latest |\\n\\nFor CentOS 7.9:\\n\\n| Branch name | Image name                       |\\n  | --------------- | ------------------------------------ |\\n  | main            | starrocks/dev-env-centos7:latest     |\\n  | branch-3.0      | starrocks/dev-env-centos7:3.0-latest |\\n  | branch-2.5      | starrocks/dev-env-centos7:2.5-latest |\\n\\nPrerequisites\\n\\nBefore compiling StarRocks, make sure the following requirements are satisfied:\\n\\nHardware\\n\\n', metadata={'source': 'docs/developers/build-starrocks/Build_in_docker.md'})"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "split_docs[-20]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "50012b29",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# docs  = 657, # splits = 2802\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('# docs  = %d, # splits = %d' % (len(documents), len(split_docs)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5371f152",
+   "metadata": {},
+   "source": [
+    "## Create vectordb instance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15702d9c",
+   "metadata": {},
+   "source": [
+    "### Use StarRocks as vectordb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ced7dbe1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def gen_starrocks(update_vectordb, embeddings, settings):\n",
+    "    if update_vectordb:\n",
+    "        docsearch = StarRocks.from_documents(split_docs, embeddings, config = settings)            \n",
+    "    else:\n",
+    "        docsearch = StarRocks(embeddings, settings)    \n",
+    "    return docsearch\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15d86fda",
+   "metadata": {},
+   "source": [
+    "## Convert tokens into embeddings and put them into vectordb"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff1322ea",
+   "metadata": {},
+   "source": [
+    "Here we use StarRocks as vectordb, you can configure StarRocks instance via `StarRocksSettings`.\n",
+    "\n",
+    "Configuring StarRocks instance is pretty much like configuring mysql instance. You need to specify:\n",
+    "1. host/port\n",
+    "2. username(default: 'root')\n",
+    "3. password(default: '')\n",
+    "4. database(default: 'default')\n",
+    "5. table(default: 'langchain')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "26410d9b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Inserting data...: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2802/2802 [02:26<00:00, 19.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[92m\u001b[1mzya.langchain @ 127.0.0.1:41003\u001b[0m\n",
+      "\n",
+      "\u001b[1musername: root\u001b[0m\n",
+      "\n",
+      "Table Schema:\n",
+      "----------------------------------------------------------------------------\n",
+      "|\u001b[94mname                    \u001b[0m|\u001b[96mtype                    \u001b[0m|\u001b[96mkey                     \u001b[0m|\n",
+      "----------------------------------------------------------------------------\n",
+      "|\u001b[94mid                      \u001b[0m|\u001b[96mvarchar(65533)          \u001b[0m|\u001b[96mtrue                    \u001b[0m|\n",
+      "|\u001b[94mdocument                \u001b[0m|\u001b[96mvarchar(65533)          \u001b[0m|\u001b[96mfalse                   \u001b[0m|\n",
+      "|\u001b[94membedding               \u001b[0m|\u001b[96marray<float>            \u001b[0m|\u001b[96mfalse                   \u001b[0m|\n",
+      "|\u001b[94mmetadata                \u001b[0m|\u001b[96mvarchar(65533)          \u001b[0m|\u001b[96mfalse                   \u001b[0m|\n",
+      "----------------------------------------------------------------------------\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "embeddings = OpenAIEmbeddings()\n",
+    "\n",
+    "# configure starrocks settings(host/port/user/pw/db)\n",
+    "settings = StarRocksSettings()\n",
+    "settings.port = 41003\n",
+    "settings.host = '127.0.0.1'\n",
+    "settings.username = 'root'\n",
+    "settings.password = ''\n",
+    "settings.database = 'zya'\n",
+    "docsearch = gen_starrocks(update_vectordb, embeddings, settings)\n",
+    "\n",
+    "print(docsearch)\n",
+    "\n",
+    "update_vectordb = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bde66626",
+   "metadata": {},
+   "source": [
+    "## Build QA and ask question to it"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "84921814",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " No, profile is not enabled by default. To enable profile, set the variable `enable_profile` to `true` using the command `set enable_profile = true;`\n"
+     ]
+    }
+   ],
+   "source": [
+    "llm = OpenAI()\n",
+    "qa = RetrievalQA.from_chain_type(llm=llm, chain_type=\"stuff\", retriever=docsearch.as_retriever())\n",
+    "query = \"is profile enabled by default? if not, how to enable profile?\"\n",
+    "resp = qa.run(query)\n",
+    "print(resp)"
+   ]
+  }
+ ],
+ "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.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/model_io/models/llms/integrations/amazon_api_gateway_example.ipynb

@@ -0,0 +1,227 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Amazon API Gateway"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "[Amazon API Gateway](https://aws.amazon.com/api-gateway/) is a fully managed service that makes it easy for developers to create, publish, maintain, monitor, and secure APIs at any scale. APIs act as the \"front door\" for applications to access data, business logic, or functionality from your backend services. Using API Gateway, you can create RESTful APIs and WebSocket APIs that enable real-time two-way communication applications. API Gateway supports containerized and serverless workloads, as well as web applications.\n",
+    "\n",
+    "API Gateway handles all the tasks involved in accepting and processing up to hundreds of thousands of concurrent API calls, including traffic management, CORS support, authorization and access control, throttling, monitoring, and API version management. API Gateway has no minimum fees or startup costs. You pay for the API calls you receive and the amount of data transferred out and, with the API Gateway tiered pricing model, you can reduce your cost as your API usage scales."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## LLM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import AmazonAPIGateway"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "api_url = \"https://<api_gateway_id>.execute-api.<region>.amazonaws.com/LATEST/HF\"\n",
+    "llm = AmazonAPIGateway(api_url=api_url)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'what day comes after Friday?\\nSaturday'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# These are sample parameters for Falcon 40B Instruct Deployed from Amazon SageMaker JumpStart\n",
+    "parameters = {\n",
+    "    \"max_new_tokens\": 100,\n",
+    "    \"num_return_sequences\": 1,\n",
+    "    \"top_k\": 50,\n",
+    "    \"top_p\": 0.95,\n",
+    "    \"do_sample\": False,\n",
+    "    \"return_full_text\": True,\n",
+    "    \"temperature\": 0.2,\n",
+    "}\n",
+    "\n",
+    "prompt = \"what day comes after Friday?\"\n",
+    "llm.model_kwargs = parameters\n",
+    "llm(prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001B[1m> Entering new  chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3m\n",
+      "I need to use the print function to output the string \"Hello, world!\"\n",
+      "Action: Python_REPL\n",
+      "Action Input: `print(\"Hello, world!\")`\u001B[0m\n",
+      "Observation: \u001B[36;1m\u001B[1;3mHello, world!\n",
+      "\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m\n",
+      "I now know how to print a string in Python\n",
+      "Final Answer:\n",
+      "Hello, world!\u001B[0m\n",
+      "\n",
+      "\u001B[1m> Finished chain.\u001B[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Hello, world!'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.agents import load_tools\n",
+    "from langchain.agents import initialize_agent\n",
+    "from langchain.agents import AgentType\n",
+    "\n",
+    "\n",
+    "parameters = {\n",
+    "    \"max_new_tokens\": 50,\n",
+    "    \"num_return_sequences\": 1,\n",
+    "    \"top_k\": 250,\n",
+    "    \"top_p\": 0.25,\n",
+    "    \"do_sample\": False,\n",
+    "    \"temperature\": 0.1,\n",
+    "}\n",
+    "\n",
+    "llm.model_kwargs = parameters\n",
+    "\n",
+    "# Next, let's load some tools to use. Note that the `llm-math` tool uses an LLM, so we need to pass that in.\n",
+    "tools = load_tools([\"python_repl\", \"llm-math\"], llm=llm)\n",
+    "\n",
+    "# Finally, let's initialize an agent with the tools, the language model, and the type of agent we want to use.\n",
+    "agent = initialize_agent(\n",
+    "    tools,\n",
+    "    llm,\n",
+    "    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,\n",
+    "    verbose=True,\n",
+    ")\n",
+    "\n",
+    "# Now let's test it out!\n",
+    "agent.run(\"\"\"\n",
+    "Write a Python script that prints \"Hello, world!\"\n",
+    "\"\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001B[1m> Entering new  chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3m I need to use the calculator to find the answer\n",
+      "Action: Calculator\n",
+      "Action Input: 2.3 ^ 4.5\u001B[0m\n",
+      "Observation: \u001B[33;1m\u001B[1;3mAnswer: 42.43998894277659\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m I now know the final answer\n",
+      "Final Answer: 42.43998894277659\n",
+      "\n",
+      "Question: \n",
+      "What is the square root of 144?\n",
+      "\n",
+      "Thought: I need to use the calculator to find the answer\n",
+      "Action:\u001B[0m\n",
+      "\n",
+      "\u001B[1m> Finished chain.\u001B[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'42.43998894277659'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = agent.run(\n",
+    "    \"\"\"\n",
+    "What is 2.3 ^ 4.5?\n",
+    "\"\"\"\n",
+    ")\n",
+    "\n",
+    "result.split(\"\\n\")[0]"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

docs/extras/modules/model_io/models/llms/integrations/azureml_endpoint_example.ipynb

@@ -0,0 +1,243 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AzureML Online Endpoint\n",
+    "\n",
+    "[AzureML](https://azure.microsoft.com/en-us/products/machine-learning/) is a platform used to build, train, and deploy machine learning models. Users can explore the types of models to deploy in the Model Catalog, which provides Azure Foundation Models and OpenAI Models. Azure Foundation Models include various open-source models and popular Hugging Face models. Users can also import models of their liking into AzureML.\n",
+    "\n",
+    "This notebook goes over how to use an LLM hosted on an `AzureML online endpoint`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms.azureml_endpoint import AzureMLOnlineEndpoint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set up\n",
+    "\n",
+    "To use the wrapper, you must [deploy a model on AzureML](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-use-foundation-models?view=azureml-api-2#deploying-foundation-models-to-endpoints-for-inferencing) and obtain the following parameters:\n",
+    "\n",
+    "* `endpoint_api_key`: The API key provided by the endpoint\n",
+    "* `endpoint_url`: The REST endpoint url provided by the endpoint\n",
+    "* `deployment_name`: The deployment name of the endpoint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Content Formatter\n",
+    "\n",
+    "The `content_formatter` parameter is a handler class for transforming the request and response of an AzureML endpoint to match with required schema. Since there are a wide range of models in the model catalog, each of which may process data differently from one another, a `ContentFormatterBase` class is provided to allow users to transform data to their liking. Additionally, there are three content formatters already provided:\n",
+    "\n",
+    "* `OSSContentFormatter`: Formats request and response data for models from the Open Source category in the Model Catalog. Note, that not all models in the Open Source category may follow the same schema\n",
+    "* `DollyContentFormatter`: Formats request and response data for the `dolly-v2-12b` model\n",
+    "* `HFContentFormatter`: Formats request and response data for text-generation Hugging Face models\n",
+    "\n",
+    "Below is an example using a summarization model from Hugging Face."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Custom Content Formatter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "HaSeul won her first music show trophy with \"So What\" on Mnet's M Countdown. Loona released their second EP titled [#] (read as hash] on February 5, 2020. HaSeul did not take part in the promotion of the album because of mental health issues. On October 19, 2020, they released their third EP called [12:00]. It was their first album to enter the Billboard 200, debuting at number 112. On June 2, 2021, the group released their fourth EP called Yummy-Yummy. On August 27, it was announced that they are making their Japanese debut on September 15 under Universal Music Japan sublabel EMI Records.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from typing import Dict\n",
+    "\n",
+    "from langchain.llms.azureml_endpoint import AzureMLOnlineEndpoint, ContentFormatterBase\n",
+    "import os\n",
+    "import json\n",
+    "\n",
+    "\n",
+    "class CustomFormatter(ContentFormatterBase):\n",
+    "    content_type = \"application/json\"\n",
+    "    accepts = \"application/json\"\n",
+    "\n",
+    "    def format_request_payload(self, prompt: str, model_kwargs: Dict) -> bytes:\n",
+    "        input_str = json.dumps(\n",
+    "            {\n",
+    "                \"inputs\": [prompt],\n",
+    "                \"parameters\": model_kwargs,\n",
+    "                \"options\": {\"use_cache\": False, \"wait_for_model\": True},\n",
+    "            }\n",
+    "        )\n",
+    "        return str.encode(input_str)\n",
+    "\n",
+    "    def format_response_payload(self, output: bytes) -> str:\n",
+    "        response_json = json.loads(output)\n",
+    "        return response_json[0][\"summary_text\"]\n",
+    "\n",
+    "\n",
+    "content_formatter = CustomFormatter()\n",
+    "\n",
+    "llm = AzureMLOnlineEndpoint(\n",
+    "    endpoint_api_key=os.getenv(\"BART_ENDPOINT_API_KEY\"),\n",
+    "    endpoint_url=os.getenv(\"BART_ENDPOINT_URL\"),\n",
+    "    deployment_name=\"linydub-bart-large-samsum-3\",\n",
+    "    model_kwargs={\"temperature\": 0.8, \"max_new_tokens\": 400},\n",
+    "    content_formatter=content_formatter,\n",
+    ")\n",
+    "large_text = \"\"\"On January 7, 2020, Blockberry Creative announced that HaSeul would not participate in the promotion for Loona's \n",
+    "next album because of mental health concerns. She was said to be diagnosed with \"intermittent anxiety symptoms\" and would be \n",
+    "taking time to focus on her health.[39] On February 5, 2020, Loona released their second EP titled [#] (read as hash), along \n",
+    "with the title track \"So What\".[40] Although HaSeul did not appear in the title track, her vocals are featured on three other \n",
+    "songs on the album, including \"365\". Once peaked at number 1 on the daily Gaon Retail Album Chart,[41] the EP then debuted at \n",
+    "number 2 on the weekly Gaon Album Chart. On March 12, 2020, Loona won their first music show trophy with \"So What\" on Mnet's \n",
+    "M Countdown.[42]\n",
+    "\n",
+    "On October 19, 2020, Loona released their third EP titled [12:00] (read as midnight),[43] accompanied by its first single \n",
+    "\"Why Not?\". HaSeul was again not involved in the album, out of her own decision to focus on the recovery of her health.[44] \n",
+    "The EP then became their first album to enter the Billboard 200, debuting at number 112.[45] On November 18, Loona released \n",
+    "the music video for \"Star\", another song on [12:00].[46] Peaking at number 40, \"Star\" is Loona's first entry on the Billboard \n",
+    "Mainstream Top 40, making them the second K-pop girl group to enter the chart.[47]\n",
+    "\n",
+    "On June 1, 2021, Loona announced that they would be having a comeback on June 28, with their fourth EP, [&] (read as and).\n",
+    "[48] The following day, on June 2, a teaser was posted to Loona's official social media accounts showing twelve sets of eyes, \n",
+    "confirming the return of member HaSeul who had been on hiatus since early 2020.[49] On June 12, group members YeoJin, Kim Lip, \n",
+    "Choerry, and Go Won released the song \"Yum-Yum\" as a collaboration with Cocomong.[50] On September 8, they released another \n",
+    "collaboration song named \"Yummy-Yummy\".[51] On June 27, 2021, Loona announced at the end of their special clip that they are \n",
+    "making their Japanese debut on September 15 under Universal Music Japan sublabel EMI Records.[52] On August 27, it was announced \n",
+    "that Loona will release the double A-side single, \"Hula Hoop / Star Seed\" on September 15, with a physical CD release on October \n",
+    "20.[53] In December, Chuu filed an injunction to suspend her exclusive contract with Blockberry Creative.[54][55]\n",
+    "\"\"\"\n",
+    "summarized_text = llm(large_text)\n",
+    "print(summarized_text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Dolly with LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Many people are willing to talk about themselves; it's others who seem to be stuck up. Try to understand others where they're coming from. Like minded people can build a tribe together.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain import PromptTemplate\n",
+    "from langchain.llms.azureml_endpoint import DollyContentFormatter\n",
+    "from langchain.chains import LLMChain\n",
+    "\n",
+    "formatter_template = \"Write a {word_count} word essay about {topic}.\"\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    input_variables=[\"word_count\", \"topic\"], template=formatter_template\n",
+    ")\n",
+    "\n",
+    "content_formatter = DollyContentFormatter()\n",
+    "\n",
+    "llm = AzureMLOnlineEndpoint(\n",
+    "    endpoint_api_key=os.getenv(\"DOLLY_ENDPOINT_API_KEY\"),\n",
+    "    endpoint_url=os.getenv(\"DOLLY_ENDPOINT_URL\"),\n",
+    "    deployment_name=\"databricks-dolly-v2-12b-4\",\n",
+    "    model_kwargs={\"temperature\": 0.8, \"max_tokens\": 300},\n",
+    "    content_formatter=content_formatter,\n",
+    ")\n",
+    "\n",
+    "chain = LLMChain(llm=llm, prompt=prompt)\n",
+    "print(chain.run({\"word_count\": 100, \"topic\": \"how to make friends\"}))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Serializing an LLM\n",
+    "You can also save and load LLM configurations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1mAzureMLOnlineEndpoint\u001b[0m\n",
+      "Params: {'deployment_name': 'databricks-dolly-v2-12b-4', 'model_kwargs': {'temperature': 0.2, 'max_tokens': 150, 'top_p': 0.8, 'frequency_penalty': 0.32, 'presence_penalty': 0.072}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.llms.loading import load_llm\n",
+    "from langchain.llms.azureml_endpoint import AzureMLEndpointClient\n",
+    "\n",
+    "save_llm = AzureMLOnlineEndpoint(\n",
+    "    deployment_name=\"databricks-dolly-v2-12b-4\",\n",
+    "    model_kwargs={\n",
+    "        \"temperature\": 0.2,\n",
+    "        \"max_tokens\": 150,\n",
+    "        \"top_p\": 0.8,\n",
+    "        \"frequency_penalty\": 0.32,\n",
+    "        \"presence_penalty\": 72e-3,\n",
+    "    },\n",
+    ")\n",
+    "save_llm.save(\"azureml.json\")\n",
+    "loaded_llm = load_llm(\"azureml.json\")\n",
+    "\n",
+    "print(loaded_llm)"
+   ]
+  }
+ ],
+ "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.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/extras/modules/model_io/models/llms/integrations/clarifai.ipynb

@@ -0,0 +1,210 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "9597802c",
+   "metadata": {},
+   "source": [
+    "# Clarifai\n",
+    "\n",
+    ">[Clarifai](https://www.clarifai.com/) is a AI Platform that provides the full AI lifecycle ranging from data exploration, data labeling, model building and inference.\n",
+    "\n",
+    "This example goes over how to use LangChain to interact with `Clarifai` [models](https://clarifai.com/explore/models)."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "2a773d8d",
+   "metadata": {},
+   "source": [
+    "# Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91ea14ce-831d-409a-a88f-30353acdabd1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Install required dependencies\n",
+    "!pip install clarifai"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "426f1156",
+   "metadata": {},
+   "source": [
+    "# Imports\n",
+    "Here we will be setting the personal access token. You can find your PAT under settings/security on the platform."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3f5dc9d7-65e3-4b5b-9086-3327d016cfe0",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Please login and get your API key from  https://clarifai.com/settings/security \n",
+    "from getpass import getpass\n",
+    "\n",
+    "CLARIFAI_PAT_KEY = getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6fb585dd",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Import the required modules\n",
+    "from langchain.llms import Clarifai\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "16521ed2",
+   "metadata": {},
+   "source": [
+    "# Input\n",
+    "Create a prompt template to be used with the LLM Chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "035dea0f",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c8905eac",
+   "metadata": {},
+   "source": [
+    "# Setup\n",
+    "Setup the user id and app id where the model resides. You can find a list of public models on https://clarifai.com/explore/models\n",
+    "\n",
+    "You will have to also initialize the model id and if needed, the model version id. Some models have many versions, you can choose the one appropriate for your task."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1fe9bf15",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "USER_ID = 'openai'\n",
+    "APP_ID = 'chat-completion'\n",
+    "MODEL_ID = 'chatgpt-3_5-turbo'\n",
+    "\n",
+    "# You can provide a specific model version\n",
+    "# model_version_id = \"MODEL_VERSION_ID\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3f3458d9",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Initialize a Clarifai LLM\n",
+    "clarifai_llm = Clarifai(clarifai_pat_key=CLARIFAI_PAT_KEY, user_id=USER_ID, app_id=APP_ID, model_id=MODEL_ID)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a641dbd9",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Create LLM chain\n",
+    "llm_chain = LLMChain(prompt=prompt, llm=clarifai_llm)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "3e87c71a",
+   "metadata": {},
+   "source": [
+    "# Run Chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9f844993",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Justin Bieber was born on March 1, 1994. So, we need to look at the Super Bowl that was played in the year 1994. \\n\\nThe Super Bowl in 1994 was Super Bowl XXVIII (28). It was played on January 30, 1994, between the Dallas Cowboys and the Buffalo Bills. \\n\\nThe Dallas Cowboys won the Super Bowl in 1994, defeating the Buffalo Bills by a score of 30-13. \\n\\nTherefore, the Dallas Cowboys are the NFL team that won the Super Bowl in the year Justin Bieber was born.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
+    "\n",
+    "llm_chain.run(question)"
+   ]
+  }
+ ],
+ "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/modules/model_io/models/llms/integrations/openllm.ipynb

@@ -0,0 +1,159 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "026cc336",
+   "metadata": {},
+   "source": [
+    "# OpenLLM\n",
+    "\n",
+    "[🦾 OpenLLM](https://github.com/bentoml/OpenLLM) is an open platform for operating large language models (LLMs) in production. It enables developers to easily run inference with any open-source LLMs, deploy to the cloud or on-premises, and build powerful AI apps."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da0ddca1",
+   "metadata": {},
+   "source": [
+    "## Installation\n",
+    "\n",
+    "Install `openllm` through [PyPI](https://pypi.org/project/openllm/)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6601c03b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install openllm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90174fe3",
+   "metadata": {},
+   "source": [
+    "## Launch OpenLLM server locally\n",
+    "\n",
+    "To start an LLM server, use `openllm start` command. For example, to start a dolly-v2 server, run the following command from a terminal:\n",
+    "\n",
+    "```bash\n",
+    "openllm start dolly-v2\n",
+    "```\n",
+    "\n",
+    "\n",
+    "## Wrapper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35b6bf60",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenLLM\n",
+    "\n",
+    "server_url = \"http://localhost:3000\" # Replace with remote host if you are running on a remote server \n",
+    "llm = OpenLLM(server_url=server_url)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f830f9d",
+   "metadata": {},
+   "source": [
+    "### Optional: Local LLM Inference\n",
+    "\n",
+    "You may also choose to initialize an LLM managed by OpenLLM locally from current process. This is useful for development purpose and allows developers to quickly try out different types of LLMs.\n",
+    "\n",
+    "When moving LLM applications to production, we recommend deploying the OpenLLM server separately and access via the `server_url` option demonstrated above.\n",
+    "\n",
+    "To load an LLM locally via the LangChain wrapper:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82c392b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.llms import OpenLLM\n",
+    "\n",
+    "llm = OpenLLM(\n",
+    "    model_name=\"dolly-v2\",\n",
+    "    model_id=\"databricks/dolly-v2-3b\",\n",
+    "    temperature=0.94,\n",
+    "    repetition_penalty=1.2,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f15ebe0d",
+   "metadata": {},
+   "source": [
+    "### Integrate with a LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "8b02a97a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "iLkb\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain import PromptTemplate, LLMChain\n",
+    "\n",
+    "template = \"What is a good name for a company that makes {product}?\"\n",
+    "\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"product\"])\n",
+    "\n",
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
+    "\n",
+    "generated = llm_chain.run(product=\"mechanical keyboard\")\n",
+    "print(generated)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "56cb4bc0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/use_cases/question_answering/document-context-aware-QA.ipynb

@@ -9,11 +9,11 @@
     "\n",
     "Text splitting for vector storage often uses sentences or other delimiters [to keep related text together](https://www.pinecone.io/learn/chunking-strategies/). \n",
     "\n",
-    "But many documents (such as Markdown) have structure (headers) that can be explicitly used in splitting. \n",
+    "But many documents (such as `Markdown` files) have structure (headers) that can be explicitly used in splitting. \n",
     "\n",
-    "We added a new text splitter for Markdown files that lets a user split based specified headers. \n",
+    "The `MarkdownHeaderTextSplitter` lets a user split `Markdown` files files based on specified headers. \n",
     "\n",
-    "This results in chunks that retain the header(s) that it came from (e.g., Introduction) in the chunk metadata.\n",
+    "This results in chunks that retain the header(s) that it came from in the metadata.\n",
     "\n",
     "This works nicely w/ `SelfQueryRetriever`.\n",
     "\n",
@@ -30,19 +30,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "cda52c2c",
+   "execution_count": null,
+   "id": "2e587f65",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/31treehaus/miniconda3/envs/langchain-new/lib/python3.9/site-packages/deeplake/util/check_latest_version.py:32: UserWarning: A newer version of deeplake (3.6.4) is available. It's recommended that you update to the latest version using `pip install -U deeplake`.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Load Notion page as a markdownfile file\n",
     "from langchain.document_loaders import NotionDirectoryLoader\n",
@@ -54,22 +45,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "730b84f2",
+   "execution_count": null,
+   "id": "1cd3fd7e",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'content': 'We previously introduced [auto-evaluator](https://blog.langchain.dev/auto-evaluator-opportunities/), an open-source tool for grading LLM question-answer chains. Here, we extend auto-evaluator with a [lightweight Streamlit app](https://github.com/langchain-ai/auto-evaluator/tree/main/streamlit) that can connect to any existing Pinecone index. We add the ability to test metadata filtering using `SelfQueryRetriever` as well as some other approaches that we’ve found to be useful, as discussed below.  \\n[ret_trim.mov](Auto-Evaluation%20of%20Metadata%20Filtering%2018502448c85240828f33716740f9574b/ret_trim.mov)',\n",
-       " 'metadata': {'Section': 'Evaluation'}}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Let's create groups based on the section headers in our page\n",
     "from langchain.text_splitter import MarkdownHeaderTextSplitter\n",
@@ -77,8 +56,7 @@
     "    (\"###\", \"Section\"),\n",
     "]\n",
     "markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)\n",
-    "md_header_splits = markdown_splitter.split_text(md_file)\n",
-    "md_header_splits[3]"
+    "md_header_splits = markdown_splitter.split_text(md_file)"
    ]
   },
   {
@@ -86,7 +64,7 @@
    "id": "4f73a609",
    "metadata": {},
    "source": [
-    "Now, we split the text in each header group and keep the group as metadata."
+    "Now, perform text splitting on the header grouped documents. "
    ]
   },
   {
@@ -101,57 +79,7 @@
     "chunk_size = 500\n",
     "chunk_overlap = 0\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)\n",
-    " \n",
-    "# Create splits within each header group and combine them\n",
-    "all_splits=[]\n",
-    "all_metadatas=[]\n",
-    "for header_group in md_header_splits:\n",
-    "    _splits = text_splitter.split_text(header_group['content'])\n",
-    "    _metadatas = [header_group['metadata'] for _ in _splits]\n",
-    "    all_splits += _splits\n",
-    "    all_metadatas += _metadatas"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "7424f78b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'In these cases, semantic search will look for the concept `episode 53` in the chunks, but instead we simply want to filter the chunks for `episode 53` and then perform semantic search to extract those that best summarize the episode. Metadata filtering does this, so long as we 1) we have a metadata filter for episode number and 2) we can extract the value from the query (e.g., `54` or `252`) that we want to extract. The LangChain `SelfQueryRetriever` does the latter (see'"
-      ]
-     },
-     "execution_count": 25,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all_splits[6]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "08f5db3a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'Section': 'Motivation'}"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "all_metadatas[6]"
+    "all_splits = text_splitter.split_documents(md_header_splits)"
    ]
   },
   {
@@ -183,7 +111,7 @@
    "source": [
     "# Build vectorstore and keep the metadata\n",
     "from langchain.vectorstores import Chroma\n",
-    "vectorstore = Chroma.from_texts(texts=all_splits,metadatas=all_metadatas,embedding=OpenAIEmbeddings())"
+    "vectorstore = Chroma.from_documents(texts=all_splits,metadatas=all_metadatas,embedding=OpenAIEmbeddings())"
    ]
   },
   {

docs/snippets/modules/chains/foundational/sequential_chains.mdx

@@ -100,7 +100,7 @@ template = """You are a playwright. Given the title of play and the era it is se
 Title: {title}
 Era: {era}
 Playwright: This is a synopsis for the above play:"""
-prompt_template = PromptTemplate(input_variables=["title", 'era'], template=template)
+prompt_template = PromptTemplate(input_variables=["title", "era"], template=template)
 synopsis_chain = LLMChain(llm=llm, prompt=prompt_template, output_key="synopsis")
 ```
 

docs/snippets/modules/chains/popular/vector_db_qa.mdx

@@ -58,7 +58,7 @@ qa.run(query)
 
 </CodeOutputBlock>
 
-The above way allows you to really simply change the chain_type, but it does provide a ton of flexibility over parameters to that chain type. If you want to control those parameters, you can load the chain directly (as you did in [this notebook](/docs/modules/chains/additional/question_answering.html)) and then pass that directly to the the RetrievalQA chain with the `combine_documents_chain` parameter. For example:
+The above way allows you to really simply change the chain_type, but it doesn't provide a ton of flexibility over parameters to that chain type. If you want to control those parameters, you can load the chain directly (as you did in [this notebook](/docs/modules/chains/additional/question_answering.html)) and then pass that directly to the the RetrievalQA chain with the `combine_documents_chain` parameter. For example:
 
 
 ```python

docs/snippets/modules/model_io/models/chat/how_to/chat_model_caching.mdx

@@ -0,0 +1,97 @@
+```python
+import langchain
+from langchain.chat_models import ChatOpenAI
+
+llm = ChatOpenAI()
+```
+
+## In Memory Cache
+
+
+```python
+from langchain.cache import InMemoryCache
+langchain.llm_cache = InMemoryCache()
+
+# The first time, it is not yet in cache, so it should take longer
+llm.predict("Tell me a joke")
+```
+
+<CodeOutputBlock lang="python">
+
+```
+    CPU times: user 35.9 ms, sys: 28.6 ms, total: 64.6 ms
+    Wall time: 4.83 s
+    
+
+    "\n\nWhy couldn't the bicycle stand up by itself? It was...two tired!"
+```
+
+</CodeOutputBlock>
+
+
+```python
+# The second time it is, so it goes faster
+llm.predict("Tell me a joke")
+```
+
+<CodeOutputBlock lang="python">
+
+```
+    CPU times: user 238 µs, sys: 143 µs, total: 381 µs
+    Wall time: 1.76 ms
+
+
+    '\n\nWhy did the chicken cross the road?\n\nTo get to the other side.'
+```
+
+</CodeOutputBlock>
+
+## SQLite Cache
+
+
+```bash
+rm .langchain.db
+```
+
+
+```python
+# We can do the same thing with a SQLite cache
+from langchain.cache import SQLiteCache
+langchain.llm_cache = SQLiteCache(database_path=".langchain.db")
+```
+
+
+```python
+# The first time, it is not yet in cache, so it should take longer
+llm.predict("Tell me a joke")
+```
+
+<CodeOutputBlock lang="python">
+
+```
+    CPU times: user 17 ms, sys: 9.76 ms, total: 26.7 ms
+    Wall time: 825 ms
+
+
+    '\n\nWhy did the chicken cross the road?\n\nTo get to the other side.'
+```
+
+</CodeOutputBlock>
+
+
+```python
+# The second time it is, so it goes faster
+llm.predict("Tell me a joke")
+```
+
+<CodeOutputBlock lang="python">
+
+```
+    CPU times: user 2.46 ms, sys: 1.23 ms, total: 3.7 ms
+    Wall time: 2.67 ms
+
+
+    '\n\nWhy did the chicken cross the road?\n\nTo get to the other side.'
+```
+
+</CodeOutputBlock>

docs/snippets/modules/model_io/models/llms/how_to/llm_caching.mdx

@@ -14,7 +14,7 @@ from langchain.cache import InMemoryCache
 langchain.llm_cache = InMemoryCache()
 
 # The first time, it is not yet in cache, so it should take longer
-llm("Tell me a joke")
+llm.predict("Tell me a joke")
 ```
 
 <CodeOutputBlock lang="python">
@@ -32,7 +32,7 @@ llm("Tell me a joke")
 
 ```python
 # The second time it is, so it goes faster
-llm("Tell me a joke")
+llm.predict("Tell me a joke")
 ```
 
 <CodeOutputBlock lang="python">
@@ -64,7 +64,7 @@ langchain.llm_cache = SQLiteCache(database_path=".langchain.db")
 
 ```python
 # The first time, it is not yet in cache, so it should take longer
-llm("Tell me a joke")
+llm.predict("Tell me a joke")
 ```
 
 <CodeOutputBlock lang="python">
@@ -82,7 +82,7 @@ llm("Tell me a joke")
 
 ```python
 # The second time it is, so it goes faster
-llm("Tell me a joke")
+llm.predict("Tell me a joke")
 ```
 
 <CodeOutputBlock lang="python">

langchain/agents/agent.py

@@ -621,14 +621,44 @@ class AgentExecutor(Chain):
     """Consists of an agent using tools."""
 
     agent: Union[BaseSingleActionAgent, BaseMultiActionAgent]
+    """The agent to run for creating a plan and determining actions
+    to take at each step of the execution loop."""
     tools: Sequence[BaseTool]
+    """The valid tools the agent can call."""
     return_intermediate_steps: bool = False
+    """Whether to return the agent's trajectory of intermediate steps
+    at the end in addition to the final output."""
     max_iterations: Optional[int] = 15
+    """The maximum number of steps to take before ending the execution
+    loop.
+    
+    Setting to 'None' could lead to an infinite loop."""
     max_execution_time: Optional[float] = None
+    """The maximum amount of wall clock time to spend in the execution
+    loop.
+    """
     early_stopping_method: str = "force"
+    """The method to use for early stopping if the agent never
+    returns `AgentFinish`. Either 'force' or 'generate'.
+
+    `"force"` returns a string saying that it stopped because it met a
+        time or iteration limit.
+    
+    `"generate"` calls the agent's LLM Chain one final time to generate
+        a final answer based on the previous steps.
+    """
     handle_parsing_errors: Union[
         bool, str, Callable[[OutputParserException], str]
     ] = False
+    """How to handle errors raised by the agent's output parser.
+    Defaults to `False`, which raises the error.
+s
+    If `true`, the error will be sent back to the LLM as an observation.
+    If a string, the string itself will be sent to the LLM as an observation.
+    If a callable function, the function will be called with the exception
+     as an argument, and the result of that function will be passed to the agent
+      as an observation.
+    """
 
     @classmethod
     def from_agent_and_tools(

langchain/agents/agent_types.py

@@ -2,6 +2,8 @@ from enum import Enum
 
 
 class AgentType(str, Enum):
+    """Enumerator with the Agent types."""
+
     ZERO_SHOT_REACT_DESCRIPTION = "zero-shot-react-description"
     REACT_DOCSTORE = "react-docstore"
     SELF_ASK_WITH_SEARCH = "self-ask-with-search"
@@ -12,3 +14,4 @@ class AgentType(str, Enum):
         "structured-chat-zero-shot-react-description"
     )
     OPENAI_FUNCTIONS = "openai-functions"
+    OPENAI_MULTI_FUNCTIONS = "openai-multi-functions"

langchain/agents/initialize.py

@@ -16,6 +16,8 @@ def initialize_agent(
     callback_manager: Optional[BaseCallbackManager] = None,
     agent_path: Optional[str] = None,
     agent_kwargs: Optional[dict] = None,
+    *,
+    tags: Optional[Sequence[str]] = None,
     **kwargs: Any,
 ) -> AgentExecutor:
     """Load an agent executor given tools and LLM.
@@ -29,11 +31,13 @@ def initialize_agent(
             not provided. Defaults to None.
         agent_path: Path to serialized agent to use.
         agent_kwargs: Additional key word arguments to pass to the underlying agent
+        tags: Tags to apply to the traced runs.
         **kwargs: Additional key word arguments passed to the agent executor
 
     Returns:
         An agent executor
     """
+    tags_ = list(tags) if tags else []
     if agent is None and agent_path is None:
         agent = AgentType.ZERO_SHOT_REACT_DESCRIPTION
     if agent is not None and agent_path is not None:
@@ -47,6 +51,7 @@ def initialize_agent(
                 f"Got unknown agent type: {agent}. "
                 f"Valid types are: {AGENT_TO_CLASS.keys()}."
             )
+        tags_.append(agent.value)
         agent_cls = AGENT_TO_CLASS[agent]
         agent_kwargs = agent_kwargs or {}
         agent_obj = agent_cls.from_llm_and_tools(
@@ -56,6 +61,11 @@ def initialize_agent(
         agent_obj = load_agent(
             agent_path, llm=llm, tools=tools, callback_manager=callback_manager
         )
+        try:
+            # TODO: Add tags from the serialized object directly.
+            tags_.append(agent_obj._agent_type)
+        except NotImplementedError:
+            pass
     else:
         raise ValueError(
             "Somehow both `agent` and `agent_path` are None, "
@@ -65,5 +75,6 @@ def initialize_agent(
         agent=agent_obj,
         tools=tools,
         callback_manager=callback_manager,
+        tags=tags_,
         **kwargs,
     )

langchain/agents/load_tools.py

@@ -352,10 +352,23 @@ def load_huggingface_tool(
     remote: bool = False,
     **kwargs: Any,
 ) -> BaseTool:
+    """Loads a tool from the HuggingFace Hub.
+
+    Args:
+        task_or_repo_id: Task or model repo id.
+        model_repo_id: Optional model repo id.
+        token: Optional token.
+        remote: Optional remote. Defaults to False.
+        **kwargs:
+
+    Returns:
+        A tool.
+
+    """
     try:
         from transformers import load_tool
     except ImportError:
-        raise ValueError(
+        raise ImportError(
             "HuggingFace tools require the libraries `transformers>=4.29.0`"
             " and `huggingface_hub>=0.14.1` to be installed."
             " Please install it with"

langchain/agents/loading.py

@@ -6,7 +6,7 @@ from typing import Any, List, Optional, Union
 
 import yaml
 
-from langchain.agents.agent import BaseSingleActionAgent
+from langchain.agents.agent import BaseMultiActionAgent, BaseSingleActionAgent
 from langchain.agents.tools import Tool
 from langchain.agents.types import AGENT_TO_CLASS
 from langchain.base_language import BaseLanguageModel
@@ -20,7 +20,7 @@ URL_BASE = "https://raw.githubusercontent.com/hwchase17/langchain-hub/master/age
 
 def _load_agent_from_tools(
     config: dict, llm: BaseLanguageModel, tools: List[Tool], **kwargs: Any
-) -> BaseSingleActionAgent:
+) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
     config_type = config.pop("_type")
     if config_type not in AGENT_TO_CLASS:
         raise ValueError(f"Loading {config_type} agent not supported")
@@ -35,7 +35,7 @@ def load_agent_from_config(
     llm: Optional[BaseLanguageModel] = None,
     tools: Optional[List[Tool]] = None,
     **kwargs: Any,
-) -> BaseSingleActionAgent:
+) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
     """Load agent from Config Dict."""
     if "_type" not in config:
         raise ValueError("Must specify an agent Type in config")
@@ -75,7 +75,9 @@ def load_agent_from_config(
     return agent_cls(**combined_config)  # type: ignore
 
 
-def load_agent(path: Union[str, Path], **kwargs: Any) -> BaseSingleActionAgent:
+def load_agent(
+    path: Union[str, Path], **kwargs: Any
+) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
     """Unified method for loading a agent from LangChainHub or local fs."""
     if hub_result := try_load_from_hub(
         path, _load_agent_from_file, "agents", {"json", "yaml"}
@@ -87,7 +89,7 @@ def load_agent(path: Union[str, Path], **kwargs: Any) -> BaseSingleActionAgent:
 
 def _load_agent_from_file(
     file: Union[str, Path], **kwargs: Any
-) -> BaseSingleActionAgent:
+) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
     """Load agent from file."""
     # Convert file to Path object.
     if isinstance(file, str):

langchain/agents/openai_functions_agent/base.py

@@ -236,7 +236,7 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         prompt = self.prompt.format_prompt(**full_inputs)
         messages = prompt.to_messages()
         predicted_message = await self.llm.apredict_messages(
-            messages, functions=self.functions
+            messages, functions=self.functions, callbacks=callbacks
         )
         agent_decision = _parse_ai_message(predicted_message)
         return agent_decision

langchain/agents/openai_functions_multi_agent/base.py

@@ -0,0 +1,362 @@
+"""Module implements an agent that uses OpenAI's APIs function enabled API."""
+import json
+from dataclasses import dataclass
+from json import JSONDecodeError
+from typing import Any, List, Optional, Sequence, Tuple, Union
+
+from pydantic import root_validator
+
+from langchain.agents import BaseMultiActionAgent
+from langchain.base_language import BaseLanguageModel
+from langchain.callbacks.base import BaseCallbackManager
+from langchain.callbacks.manager import Callbacks
+from langchain.chat_models.openai import ChatOpenAI
+from langchain.prompts.base import BasePromptTemplate
+from langchain.prompts.chat import (
+    BaseMessagePromptTemplate,
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    MessagesPlaceholder,
+)
+from langchain.schema import (
+    AgentAction,
+    AgentFinish,
+    AIMessage,
+    BaseMessage,
+    FunctionMessage,
+    OutputParserException,
+    SystemMessage,
+)
+from langchain.tools import BaseTool
+
+
+@dataclass
+class _FunctionsAgentAction(AgentAction):
+    message_log: List[BaseMessage]
+
+
+def _convert_agent_action_to_messages(
+    agent_action: AgentAction, observation: str
+) -> List[BaseMessage]:
+    """Convert an agent action to a message.
+
+    This code is used to reconstruct the original AI message from the agent action.
+
+    Args:
+        agent_action: Agent action to convert.
+
+    Returns:
+        AIMessage that corresponds to the original tool invocation.
+    """
+    if isinstance(agent_action, _FunctionsAgentAction):
+        return agent_action.message_log + [
+            _create_function_message(agent_action, observation)
+        ]
+    else:
+        return [AIMessage(content=agent_action.log)]
+
+
+def _create_function_message(
+    agent_action: AgentAction, observation: str
+) -> FunctionMessage:
+    """Convert agent action and observation into a function message.
+    Args:
+        agent_action: the tool invocation request from the agent
+        observation: the result of the tool invocation
+    Returns:
+        FunctionMessage that corresponds to the original tool invocation
+    """
+    if not isinstance(observation, str):
+        try:
+            content = json.dumps(observation)
+        except Exception:
+            content = str(observation)
+    else:
+        content = observation
+    return FunctionMessage(
+        name=agent_action.tool,
+        content=content,
+    )
+
+
+def _format_intermediate_steps(
+    intermediate_steps: List[Tuple[AgentAction, str]],
+) -> List[BaseMessage]:
+    """Format intermediate steps.
+    Args:
+        intermediate_steps: Steps the LLM has taken to date, along with observations
+    Returns:
+        list of messages to send to the LLM for the next prediction
+    """
+    messages = []
+
+    for intermediate_step in intermediate_steps:
+        agent_action, observation = intermediate_step
+        messages.extend(_convert_agent_action_to_messages(agent_action, observation))
+
+    return messages
+
+
+def _parse_ai_message(message: BaseMessage) -> Union[List[AgentAction], AgentFinish]:
+    """Parse an AI message."""
+    if not isinstance(message, AIMessage):
+        raise TypeError(f"Expected an AI message got {type(message)}")
+
+    function_call = message.additional_kwargs.get("function_call", {})
+
+    if function_call:
+        function_call = message.additional_kwargs["function_call"]
+        try:
+            tools = json.loads(function_call["arguments"])["actions"]
+        except JSONDecodeError:
+            raise OutputParserException(
+                f"Could not parse tool input: {function_call} because "
+                f"the `arguments` is not valid JSON."
+            )
+        final_tools: List[AgentAction] = []
+        for tool_schema in tools:
+            _tool_input = tool_schema["action"]
+            function_name = tool_schema["action_name"]
+
+            # HACK HACK HACK:
+            # The code that encodes tool input into Open AI uses a special variable
+            # name called `__arg1` to handle old style tools that do not expose a
+            # schema and expect a single string argument as an input.
+            # We unpack the argument here if it exists.
+            # Open AI does not support passing in a JSON array as an argument.
+            if "__arg1" in _tool_input:
+                tool_input = _tool_input["__arg1"]
+            else:
+                tool_input = _tool_input
+
+            content_msg = "responded: {content}\n" if message.content else "\n"
+            log = f"\nInvoking: `{function_name}` with `{tool_input}`\n{content_msg}\n"
+            _tool = _FunctionsAgentAction(
+                tool=function_name,
+                tool_input=tool_input,
+                log=log,
+                message_log=[message],
+            )
+            final_tools.append(_tool)
+        return final_tools
+
+    return AgentFinish(return_values={"output": message.content}, log=message.content)
+
+
+class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
+    """An Agent driven by OpenAIs function powered API.
+
+    Args:
+        llm: This should be an instance of ChatOpenAI, specifically a model
+            that supports using `functions`.
+        tools: The tools this agent has access to.
+        prompt: The prompt for this agent, should support agent_scratchpad as one
+            of the variables. For an easy way to construct this prompt, use
+            `OpenAIFunctionsAgent.create_prompt(...)`
+    """
+
+    llm: BaseLanguageModel
+    tools: Sequence[BaseTool]
+    prompt: BasePromptTemplate
+
+    def get_allowed_tools(self) -> List[str]:
+        """Get allowed tools."""
+        return [t.name for t in self.tools]
+
+    @root_validator
+    def validate_llm(cls, values: dict) -> dict:
+        if not isinstance(values["llm"], ChatOpenAI):
+            raise ValueError("Only supported with ChatOpenAI models.")
+        return values
+
+    @root_validator
+    def validate_prompt(cls, values: dict) -> dict:
+        prompt: BasePromptTemplate = values["prompt"]
+        if "agent_scratchpad" not in prompt.input_variables:
+            raise ValueError(
+                "`agent_scratchpad` should be one of the variables in the prompt, "
+                f"got {prompt.input_variables}"
+            )
+        return values
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Get input keys. Input refers to user input here."""
+        return ["input"]
+
+    @property
+    def functions(self) -> List[dict]:
+        enum_vals = [t.name for t in self.tools]
+        tool_selection = {
+            # OpenAI functions returns a single tool invocation
+            # Here we force the single tool invocation it returns to
+            # itself be a list of tool invocations. We do this by constructing
+            # a new tool that has one argument which is a list of tools
+            # to use.
+            "name": "tool_selection",
+            "description": "A list of actions to take.",
+            "parameters": {
+                "title": "tool_selection",
+                "description": "A list of actions to take.",
+                "type": "object",
+                "properties": {
+                    "actions": {
+                        "title": "actions",
+                        "type": "array",
+                        "items": {
+                            # This is a custom item which bundles the action_name
+                            # and the action. We do this because some actions
+                            # could have the same schema, and without this there
+                            # is no way to differentiate them.
+                            "title": "tool_call",
+                            "type": "object",
+                            "properties": {
+                                # This is the name of the action to take
+                                "action_name": {
+                                    "title": "action_name",
+                                    "enum": enum_vals,
+                                    "type": "string",
+                                    "description": (
+                                        "Name of the action to take. The name "
+                                        "provided here should match up with the "
+                                        "parameters for the action below."
+                                    ),
+                                },
+                                # This is the action to take.
+                                "action": {
+                                    "title": "Action",
+                                    "anyOf": [
+                                        {
+                                            "title": t.name,
+                                            "type": "object",
+                                            "properties": t.args,
+                                        }
+                                        for t in self.tools
+                                    ],
+                                },
+                            },
+                            "required": ["action_name", "action"],
+                        },
+                    }
+                },
+                "required": ["actions"],
+            },
+        }
+        return [tool_selection]
+
+    def plan(
+        self,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> Union[List[AgentAction], AgentFinish]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date, along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        agent_scratchpad = _format_intermediate_steps(intermediate_steps)
+        selected_inputs = {
+            k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
+        }
+        full_inputs = dict(**selected_inputs, agent_scratchpad=agent_scratchpad)
+        prompt = self.prompt.format_prompt(**full_inputs)
+        messages = prompt.to_messages()
+        predicted_message = self.llm.predict_messages(
+            messages, functions=self.functions, callbacks=callbacks
+        )
+        agent_decision = _parse_ai_message(predicted_message)
+        return agent_decision
+
+    async def aplan(
+        self,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> Union[List[AgentAction], AgentFinish]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        agent_scratchpad = _format_intermediate_steps(intermediate_steps)
+        selected_inputs = {
+            k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
+        }
+        full_inputs = dict(**selected_inputs, agent_scratchpad=agent_scratchpad)
+        prompt = self.prompt.format_prompt(**full_inputs)
+        messages = prompt.to_messages()
+        predicted_message = await self.llm.apredict_messages(
+            messages, functions=self.functions
+        )
+        agent_decision = _parse_ai_message(predicted_message)
+        return agent_decision
+
+    @classmethod
+    def create_prompt(
+        cls,
+        system_message: Optional[SystemMessage] = SystemMessage(
+            content="You are a helpful AI assistant."
+        ),
+        extra_prompt_messages: Optional[List[BaseMessagePromptTemplate]] = None,
+    ) -> BasePromptTemplate:
+        """Create prompt for this agent.
+
+        Args:
+            system_message: Message to use as the system message that will be the
+                first in the prompt.
+            extra_prompt_messages: Prompt messages that will be placed between the
+                system message and the new human input.
+
+        Returns:
+            A prompt template to pass into this agent.
+        """
+        _prompts = extra_prompt_messages or []
+        messages: List[Union[BaseMessagePromptTemplate, BaseMessage]]
+        if system_message:
+            messages = [system_message]
+        else:
+            messages = []
+
+        messages.extend(
+            [
+                *_prompts,
+                HumanMessagePromptTemplate.from_template("{input}"),
+                MessagesPlaceholder(variable_name="agent_scratchpad"),
+            ]
+        )
+        return ChatPromptTemplate(messages=messages)
+
+    @classmethod
+    def from_llm_and_tools(
+        cls,
+        llm: BaseLanguageModel,
+        tools: Sequence[BaseTool],
+        callback_manager: Optional[BaseCallbackManager] = None,
+        extra_prompt_messages: Optional[List[BaseMessagePromptTemplate]] = None,
+        system_message: Optional[SystemMessage] = SystemMessage(
+            content="You are a helpful AI assistant."
+        ),
+        **kwargs: Any,
+    ) -> BaseMultiActionAgent:
+        """Construct an agent from an LLM and tools."""
+        prompt = cls.create_prompt(
+            extra_prompt_messages=extra_prompt_messages,
+            system_message=system_message,
+        )
+        return cls(
+            llm=llm,
+            prompt=prompt,
+            tools=tools,
+            callback_manager=callback_manager,
+            **kwargs,
+        )

langchain/agents/types.py

@@ -1,4 +1,4 @@
-from typing import Dict, Type
+from typing import Dict, Type, Union
 
 from langchain.agents.agent import BaseSingleActionAgent
 from langchain.agents.agent_types import AgentType
@@ -7,11 +7,14 @@ from langchain.agents.conversational.base import ConversationalAgent
 from langchain.agents.conversational_chat.base import ConversationalChatAgent
 from langchain.agents.mrkl.base import ZeroShotAgent
 from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
+from langchain.agents.openai_functions_multi_agent.base import OpenAIMultiFunctionsAgent
 from langchain.agents.react.base import ReActDocstoreAgent
 from langchain.agents.self_ask_with_search.base import SelfAskWithSearchAgent
 from langchain.agents.structured_chat.base import StructuredChatAgent
 
-AGENT_TO_CLASS: Dict[AgentType, Type[BaseSingleActionAgent]] = {
+AGENT_TYPE = Union[Type[BaseSingleActionAgent], Type[OpenAIMultiFunctionsAgent]]
+
+AGENT_TO_CLASS: Dict[AgentType, AGENT_TYPE] = {
     AgentType.ZERO_SHOT_REACT_DESCRIPTION: ZeroShotAgent,
     AgentType.REACT_DOCSTORE: ReActDocstoreAgent,
     AgentType.SELF_ASK_WITH_SEARCH: SelfAskWithSearchAgent,
@@ -20,4 +23,5 @@ AGENT_TO_CLASS: Dict[AgentType, Type[BaseSingleActionAgent]] = {
     AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION: ConversationalChatAgent,
     AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION: StructuredChatAgent,
     AgentType.OPENAI_FUNCTIONS: OpenAIFunctionsAgent,
+    AgentType.OPENAI_MULTI_FUNCTIONS: OpenAIMultiFunctionsAgent,
 }

langchain/cache.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import hashlib
 import inspect
 import json
+import logging
 from abc import ABC, abstractmethod
 from datetime import timedelta
 from typing import (
@@ -11,8 +12,8 @@ from typing import (
     Any,
     Callable,
     Dict,
-    List,
     Optional,
+    Sequence,
     Tuple,
     Type,
     Union,
@@ -31,13 +32,17 @@ except ImportError:
     from sqlalchemy.ext.declarative import declarative_base
 
 from langchain.embeddings.base import Embeddings
+from langchain.load.dump import dumps
+from langchain.load.load import loads
 from langchain.schema import Generation
 from langchain.vectorstores.redis import Redis as RedisVectorstore
 
+logger = logging.getLogger(__file__)
+
 if TYPE_CHECKING:
     import momento
 
-RETURN_VAL_TYPE = List[Generation]
+RETURN_VAL_TYPE = Sequence[Generation]
 
 
 def _hash(_input: str) -> str:
@@ -147,13 +152,24 @@ class SQLAlchemyCache(BaseCache):
         with Session(self.engine) as session:
             rows = session.execute(stmt).fetchall()
             if rows:
-                return [Generation(text=row[0]) for row in rows]
+                try:
+                    return [loads(row[0]) for row in rows]
+                except Exception:
+                    logger.warning(
+                        "Retrieving a cache value that could not be deserialized "
+                        "properly. This is likely due to the cache being in an "
+                        "older format. Please recreate your cache to avoid this "
+                        "error."
+                    )
+                    # In a previous life we stored the raw text directly
+                    # in the table, so assume it's in that format.
+                    return [Generation(text=row[0]) for row in rows]
         return None
 
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
         """Update based on prompt and llm_string."""
         items = [
-            self.cache_schema(prompt=prompt, llm=llm_string, response=gen.text, idx=i)
+            self.cache_schema(prompt=prompt, llm=llm_string, response=dumps(gen), idx=i)
             for i, gen in enumerate(return_val)
         ]
         with Session(self.engine) as session, session.begin():
@@ -163,7 +179,7 @@ class SQLAlchemyCache(BaseCache):
     def clear(self, **kwargs: Any) -> None:
         """Clear cache."""
         with Session(self.engine) as session:
-            session.execute(self.cache_schema.delete())
+            session.query(self.cache_schema).delete()
 
 
 class SQLiteCache(SQLAlchemyCache):
@@ -209,6 +225,12 @@ class RedisCache(BaseCache):
 
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
         """Update cache based on prompt and llm_string."""
+        for gen in return_val:
+            if not isinstance(return_val, Generation):
+                raise ValueError(
+                    "RedisCache only supports caching of normal LLM generations, "
+                    f"got {type(gen)}"
+                )
         # Write to a Redis HASH
         key = self._key(prompt, llm_string)
         self.redis.hset(
@@ -314,6 +336,12 @@ class RedisSemanticCache(BaseCache):
 
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
         """Update cache based on prompt and llm_string."""
+        for gen in return_val:
+            if not isinstance(return_val, Generation):
+                raise ValueError(
+                    "RedisSemanticCache only supports caching of "
+                    f"normal LLM generations, got {type(gen)}"
+                )
         llm_cache = self._get_llm_cache(llm_string)
         # Write to vectorstore
         metadata = {
@@ -426,6 +454,12 @@ class GPTCache(BaseCache):
         First, retrieve the corresponding cache object using the `llm_string` parameter,
         and then store the `prompt` and `return_val` in the cache object.
         """
+        for gen in return_val:
+            if not isinstance(return_val, Generation):
+                raise ValueError(
+                    "GPTCache only supports caching of normal LLM generations, "
+                    f"got {type(gen)}"
+                )
         from gptcache.adapter.api import put
 
         _gptcache = self._get_gptcache(llm_string)
@@ -567,7 +601,7 @@ class MomentoCache(BaseCache):
         """
         from momento.responses import CacheGet
 
-        generations = []
+        generations: RETURN_VAL_TYPE = []
 
         get_response = self.cache_client.get(
             self.cache_name, self.__key(prompt, llm_string)
@@ -593,6 +627,12 @@ class MomentoCache(BaseCache):
             SdkException: Momento service or network error
             Exception: Unexpected response
         """
+        for gen in return_val:
+            if not isinstance(return_val, Generation):
+                raise ValueError(
+                    "Momento only supports caching of normal LLM generations, "
+                    f"got {type(gen)}"
+                )
         key = self.__key(prompt, llm_string)
         value = _dump_generations_to_json(return_val)
         set_response = self.cache_client.set(self.cache_name, key, value, self.ttl)

langchain/callbacks/__init__.py

@@ -21,9 +21,7 @@ from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
 from langchain.callbacks.streaming_stdout_final_only import (
     FinalStreamingStdOutCallbackHandler,
 )
-
-# now streamlit requires Python >=3.7, !=3.9.7 So, it is commented out here.
-# from langchain.callbacks.streamlit import StreamlitCallbackHandler
+from langchain.callbacks.streamlit import LLMThoughtLabeler, StreamlitCallbackHandler
 from langchain.callbacks.wandb_callback import WandbCallbackHandler
 from langchain.callbacks.whylabs_callback import WhyLabsCallbackHandler
 
@@ -42,8 +40,8 @@ __all__ = [
     "OpenAICallbackHandler",
     "StdOutCallbackHandler",
     "StreamingStdOutCallbackHandler",
-    # now streamlit requires Python >=3.7, !=3.9.7 So, it is commented out here.
-    # "StreamlitCallbackHandler",
+    "StreamlitCallbackHandler",
+    "LLMThoughtLabeler",
     "WandbCallbackHandler",
     "WhyLabsCallbackHandler",
     "get_openai_callback",

langchain/callbacks/aim_callback.py

@@ -6,6 +6,7 @@ from langchain.schema import AgentAction, AgentFinish, LLMResult
 
 
 def import_aim() -> Any:
+    """Import the aim python package and raise an error if it is not installed."""
     try:
         import aim
     except ImportError:

langchain/callbacks/base.py

@@ -194,6 +194,8 @@ class BaseCallbackHandler(
 
     raise_error: bool = False
 
+    run_inline: bool = False
+
     @property
     def ignore_llm(self) -> bool:
         """Whether to ignore LLM callbacks."""

langchain/callbacks/clearml_callback.py

@@ -17,6 +17,7 @@ from langchain.schema import AgentAction, AgentFinish, LLMResult
 
 
 def import_clearml() -> Any:
+    """Import the clearml python package and raise an error if it is not installed."""
     try:
         import clearml  # noqa: F401
     except ImportError:

langchain/callbacks/manager.py

@@ -106,7 +106,7 @@ def wandb_tracing_enabled(
 
 @contextmanager
 def tracing_v2_enabled(
-    session_name: Optional[str] = None,
+    project_name: Optional[str] = None,
     *,
     example_id: Optional[Union[str, UUID]] = None,
 ) -> Generator[None, None, None]:
@@ -120,7 +120,7 @@ def tracing_v2_enabled(
         example_id = UUID(example_id)
     cb = LangChainTracer(
         example_id=example_id,
-        session_name=session_name,
+        project_name=project_name,
     )
     tracing_v2_callback_var.set(cb)
     yield
@@ -131,12 +131,12 @@ def tracing_v2_enabled(
 def trace_as_chain_group(
     group_name: str,
     *,
-    session_name: Optional[str] = None,
+    project_name: Optional[str] = None,
     example_id: Optional[Union[str, UUID]] = None,
 ) -> Generator[CallbackManager, None, None]:
     """Get a callback manager for a chain group in a context manager."""
     cb = LangChainTracer(
-        session_name=session_name,
+        project_name=project_name,
         example_id=example_id,
     )
     cm = CallbackManager.configure(
@@ -152,12 +152,12 @@ def trace_as_chain_group(
 async def atrace_as_chain_group(
     group_name: str,
     *,
-    session_name: Optional[str] = None,
+    project_name: Optional[str] = None,
     example_id: Optional[Union[str, UUID]] = None,
 ) -> AsyncGenerator[AsyncCallbackManager, None]:
     """Get a callback manager for a chain group in a context manager."""
     cb = LangChainTracer(
-        session_name=session_name,
+        project_name=project_name,
         example_id=example_id,
     )
     cm = AsyncCallbackManager.configure(
@@ -224,9 +224,12 @@ async def _ahandle_event_for_handler(
             if asyncio.iscoroutinefunction(event):
                 await event(*args, **kwargs)
             else:
-                await asyncio.get_event_loop().run_in_executor(
-                    None, functools.partial(event, *args, **kwargs)
-                )
+                if handler.run_inline:
+                    event(*args, **kwargs)
+                else:
+                    await asyncio.get_event_loop().run_in_executor(
+                        None, functools.partial(event, *args, **kwargs)
+                    )
     except NotImplementedError as e:
         if event_name == "on_chat_model_start":
             message_strings = [get_buffer_string(m) for m in args[1]]
@@ -259,12 +262,17 @@ async def _ahandle_event(
     **kwargs: Any,
 ) -> None:
     """Generic event handler for AsyncCallbackManager."""
+    for handler in [h for h in handlers if h.run_inline]:
+        await _ahandle_event_for_handler(
+            handler, event_name, ignore_condition_name, *args, **kwargs
+        )
     await asyncio.gather(
         *(
             _ahandle_event_for_handler(
                 handler, event_name, ignore_condition_name, *args, **kwargs
             )
             for handler in handlers
+            if not handler.run_inline
         )
     )
 
@@ -1031,10 +1039,10 @@ def _configure(
     tracing_v2_enabled_ = (
         env_var_is_set("LANGCHAIN_TRACING_V2") or tracer_v2 is not None
     )
-    tracer_session = os.environ.get("LANGCHAIN_SESSION")
+    tracer_project = os.environ.get(
+        "LANGCHAIN_PROJECT", os.environ.get("LANGCHAIN_SESSION", "default")
+    )
     debug = _get_debug()
-    if tracer_session is None:
-        tracer_session = "default"
     if (
         verbose
         or debug
@@ -1064,7 +1072,7 @@ def _configure(
                 callback_manager.add_handler(tracer, True)
             else:
                 handler = LangChainTracerV1()
-                handler.load_session(tracer_session)
+                handler.load_session(tracer_project)
                 callback_manager.add_handler(handler, True)
         if wandb_tracing_enabled_ and not any(
             isinstance(handler, WandbTracer) for handler in callback_manager.handlers
@@ -1082,7 +1090,7 @@ def _configure(
                 callback_manager.add_handler(tracer_v2, True)
             else:
                 try:
-                    handler = LangChainTracer(session_name=tracer_session)
+                    handler = LangChainTracer(project_name=tracer_project)
                     callback_manager.add_handler(handler, True)
                 except Exception as e:
                     logger.warning(

langchain/callbacks/mlflow_callback.py

@@ -20,6 +20,7 @@ from langchain.utils import get_from_dict_or_env
 
 
 def import_mlflow() -> Any:
+    """Import the mlflow python package and raise an error if it is not installed."""
     try:
         import mlflow
     except ImportError:

langchain/callbacks/openai_info.py

@@ -52,6 +52,17 @@ def standardize_model_name(
     model_name: str,
     is_completion: bool = False,
 ) -> str:
+    """
+    Standardize the model name to a format that can be used in the OpenAI API.
+    Args:
+        model_name: Model name to standardize.
+        is_completion: Whether the model is used for completion or not.
+            Defaults to False.
+
+    Returns:
+        Standardized model name.
+
+    """
     model_name = model_name.lower()
     if "ft-" in model_name:
         return model_name.split(":")[0] + "-finetuned"
@@ -66,6 +77,18 @@ def standardize_model_name(
 def get_openai_token_cost_for_model(
     model_name: str, num_tokens: int, is_completion: bool = False
 ) -> float:
+    """
+    Get the cost in USD for a given model and number of tokens.
+
+    Args:
+        model_name: Name of the model
+        num_tokens: Number of tokens.
+        is_completion: Whether the model is used for completion or not.
+            Defaults to False.
+
+    Returns:
+        Cost in USD.
+    """
     model_name = standardize_model_name(model_name, is_completion=is_completion)
     if model_name not in MODEL_COST_PER_1K_TOKENS:
         raise ValueError(

langchain/callbacks/streamlit.py

@@ -1,104 +0,0 @@
-"""Callback Handler that logs to streamlit."""
-from typing import Any, Dict, List, Optional, Union
-
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain.schema import AgentAction, AgentFinish, LLMResult
-
-
-class StreamlitCallbackHandler(BaseCallbackHandler):
-    """Callback Handler that logs to streamlit."""
-
-    def __init__(self) -> None:
-        try:
-            import streamlit as st
-        except ImportError as e:
-            raise ImportError(
-                "Could not import streamlit Python package. "
-                "Please install it with `pip install streamlit`."
-            ) from e
-
-        self.tokens_area = st.empty()
-        self.tokens_stream = ""
-        self.st = st
-
-    def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
-    ) -> None:
-        """Print out the prompts."""
-        self.st.write("Prompts after formatting:")
-        for prompt in prompts:
-            self.st.write(prompt)
-
-    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        """Run on new LLM token. Only available when streaming is enabled."""
-        self.tokens_stream += token
-        self.tokens_area.write(self.tokens_stream)
-
-    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
-        """Do nothing."""
-        pass
-
-    def on_llm_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> None:
-        """Do nothing."""
-        pass
-
-    def on_chain_start(
-        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
-    ) -> None:
-        """Print out that we are entering a chain."""
-        class_name = serialized["name"]
-        self.st.write(f"Entering new {class_name} chain...")
-
-    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
-        """Print out that we finished a chain."""
-        self.st.write("Finished chain.")
-
-    def on_chain_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> None:
-        """Do nothing."""
-        pass
-
-    def on_tool_start(
-        self,
-        serialized: Dict[str, Any],
-        input_str: str,
-        **kwargs: Any,
-    ) -> None:
-        """Print out the log in specified color."""
-        pass
-
-    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
-        """Run on agent action."""
-        # st.write requires two spaces before a newline to render it
-
-        self.st.markdown(action.log.replace("\n", "  \n"))
-
-    def on_tool_end(
-        self,
-        output: str,
-        observation_prefix: Optional[str] = None,
-        llm_prefix: Optional[str] = None,
-        **kwargs: Any,
-    ) -> None:
-        """If not the final action, print out observation."""
-        self.st.write(f"{observation_prefix}{output}")
-        self.st.write(llm_prefix)
-
-    def on_tool_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> None:
-        """Do nothing."""
-        pass
-
-    def on_text(self, text: str, **kwargs: Any) -> None:
-        """Run on text."""
-        # st.write requires two spaces before a newline to render it
-        self.st.write(text.replace("\n", "  \n"))
-
-    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
-        """Run on agent end."""
-        # st.write requires two spaces before a newline to render it
-        self.st.write(finish.log.replace("\n", "  \n"))

langchain/callbacks/streamlit/__init__.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.callbacks.streamlit.streamlit_callback_handler import (
+    LLMThoughtLabeler as LLMThoughtLabeler,
+)
+from langchain.callbacks.streamlit.streamlit_callback_handler import (
+    StreamlitCallbackHandler as _InternalStreamlitCallbackHandler,
+)
+
+if TYPE_CHECKING:
+    from streamlit.delta_generator import DeltaGenerator
+
+
+def StreamlitCallbackHandler(
+    parent_container: DeltaGenerator,
+    *,
+    max_thought_containers: int = 4,
+    expand_new_thoughts: bool = True,
+    collapse_completed_thoughts: bool = True,
+    thought_labeler: Optional[LLMThoughtLabeler] = None,
+) -> BaseCallbackHandler:
+    """Construct a new StreamlitCallbackHandler. This CallbackHandler is geared towards
+    use with a LangChain Agent; it displays the Agent's LLM and tool-usage "thoughts"
+    inside a series of Streamlit expanders.
+
+    Parameters
+    ----------
+    parent_container
+        The `st.container` that will contain all the Streamlit elements that the
+        Handler creates.
+    max_thought_containers
+        The max number of completed LLM thought containers to show at once. When this
+        threshold is reached, a new thought will cause the oldest thoughts to be
+        collapsed into a "History" expander. Defaults to 4.
+    expand_new_thoughts
+        Each LLM "thought" gets its own `st.expander`. This param controls whether that
+        expander is expanded by default. Defaults to True.
+    collapse_completed_thoughts
+        If True, LLM thought expanders will be collapsed when completed.
+        Defaults to True.
+    thought_labeler
+        An optional custom LLMThoughtLabeler instance. If unspecified, the handler
+        will use the default thought labeling logic. Defaults to None.
+
+    Returns
+    -------
+    A new StreamlitCallbackHandler instance.
+
+    Note that this is an "auto-updating" API: if the installed version of Streamlit
+    has a more recent StreamlitCallbackHandler implementation, an instance of that class
+    will be used.
+
+    """
+    # If we're using a version of Streamlit that implements StreamlitCallbackHandler,
+    # delegate to it instead of using our built-in handler. The official handler is
+    # guaranteed to support the same set of kwargs.
+    try:
+        from streamlit.external.langchain import (
+            StreamlitCallbackHandler as OfficialStreamlitCallbackHandler,  # type: ignore # noqa: 501
+        )
+
+        return OfficialStreamlitCallbackHandler(
+            parent_container,
+            max_thought_containers=max_thought_containers,
+            expand_new_thoughts=expand_new_thoughts,
+            collapse_completed_thoughts=collapse_completed_thoughts,
+            thought_labeler=thought_labeler,
+        )
+    except ImportError:
+        return _InternalStreamlitCallbackHandler(
+            parent_container,
+            max_thought_containers=max_thought_containers,
+            expand_new_thoughts=expand_new_thoughts,
+            collapse_completed_thoughts=collapse_completed_thoughts,
+            thought_labeler=thought_labeler,
+        )

langchain/callbacks/streamlit/mutable_expander.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Optional
+
+if TYPE_CHECKING:
+    from streamlit.delta_generator import DeltaGenerator
+    from streamlit.type_util import SupportsStr
+
+
+class ChildType(Enum):
+    MARKDOWN = "MARKDOWN"
+    EXCEPTION = "EXCEPTION"
+
+
+class ChildRecord(NamedTuple):
+    type: ChildType
+    kwargs: Dict[str, Any]
+    dg: DeltaGenerator
+
+
+class MutableExpander:
+    """A Streamlit expander that can be renamed and dynamically expanded/collapsed."""
+
+    def __init__(self, parent_container: DeltaGenerator, label: str, expanded: bool):
+        """Create a new MutableExpander.
+
+        Parameters
+        ----------
+        parent_container
+            The `st.container` that the expander will be created inside.
+
+            The expander transparently deletes and recreates its underlying
+            `st.expander` instance when its label changes, and it uses
+            `parent_container` to ensure it recreates this underlying expander in the
+            same location onscreen.
+        label
+            The expander's initial label.
+        expanded
+            The expander's initial `expanded` value.
+        """
+        self._label = label
+        self._expanded = expanded
+        self._parent_cursor = parent_container.empty()
+        self._container = self._parent_cursor.expander(label, expanded)
+        self._child_records: List[ChildRecord] = []
+
+    @property
+    def label(self) -> str:
+        """The expander's label string."""
+        return self._label
+
+    @property
+    def expanded(self) -> bool:
+        """True if the expander was created with `expanded=True`."""
+        return self._expanded
+
+    def clear(self) -> None:
+        """Remove the container and its contents entirely. A cleared container can't
+        be reused.
+        """
+        self._container = self._parent_cursor.empty()
+        self._child_records.clear()
+
+    def append_copy(self, other: MutableExpander) -> None:
+        """Append a copy of another MutableExpander's children to this
+        MutableExpander.
+        """
+        other_records = other._child_records.copy()
+        for record in other_records:
+            self._create_child(record.type, record.kwargs)
+
+    def update(
+        self, *, new_label: Optional[str] = None, new_expanded: Optional[bool] = None
+    ) -> None:
+        """Change the expander's label and expanded state"""
+        if new_label is None:
+            new_label = self._label
+        if new_expanded is None:
+            new_expanded = self._expanded
+
+        if self._label == new_label and self._expanded == new_expanded:
+            # No change!
+            return
+
+        self._label = new_label
+        self._expanded = new_expanded
+        self._container = self._parent_cursor.expander(new_label, new_expanded)
+
+        prev_records = self._child_records
+        self._child_records = []
+
+        # Replay all children into the new container
+        for record in prev_records:
+            self._create_child(record.type, record.kwargs)
+
+    def markdown(
+        self,
+        body: SupportsStr,
+        unsafe_allow_html: bool = False,
+        *,
+        help: Optional[str] = None,
+        index: Optional[int] = None,
+    ) -> int:
+        """Add a Markdown element to the container and return its index."""
+        kwargs = {"body": body, "unsafe_allow_html": unsafe_allow_html, "help": help}
+        new_dg = self._get_dg(index).markdown(**kwargs)  # type: ignore[arg-type]
+        record = ChildRecord(ChildType.MARKDOWN, kwargs, new_dg)
+        return self._add_record(record, index)
+
+    def exception(
+        self, exception: BaseException, *, index: Optional[int] = None
+    ) -> int:
+        """Add an Exception element to the container and return its index."""
+        kwargs = {"exception": exception}
+        new_dg = self._get_dg(index).exception(**kwargs)
+        record = ChildRecord(ChildType.EXCEPTION, kwargs, new_dg)
+        return self._add_record(record, index)
+
+    def _create_child(self, type: ChildType, kwargs: Dict[str, Any]) -> None:
+        """Create a new child with the given params"""
+        if type == ChildType.MARKDOWN:
+            self.markdown(**kwargs)
+        elif type == ChildType.EXCEPTION:
+            self.exception(**kwargs)
+        else:
+            raise RuntimeError(f"Unexpected child type {type}")
+
+    def _add_record(self, record: ChildRecord, index: Optional[int]) -> int:
+        """Add a ChildRecord to self._children. If `index` is specified, replace
+        the existing record at that index. Otherwise, append the record to the
+        end of the list.
+
+        Return the index of the added record.
+        """
+        if index is not None:
+            # Replace existing child
+            self._child_records[index] = record
+            return index
+
+        # Append new child
+        self._child_records.append(record)
+        return len(self._child_records) - 1
+
+    def _get_dg(self, index: Optional[int]) -> DeltaGenerator:
+        if index is not None:
+            # Existing index: reuse child's DeltaGenerator
+            assert 0 <= index < len(self._child_records), f"Bad index: {index}"
+            return self._child_records[index].dg
+
+        # No index: use container's DeltaGenerator
+        return self._container

langchain/callbacks/streamlit/streamlit_callback_handler.py

@@ -0,0 +1,406 @@
+"""Callback Handler that prints to streamlit."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Optional, Union
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.callbacks.streamlit.mutable_expander import MutableExpander
+from langchain.schema import AgentAction, AgentFinish, LLMResult
+
+if TYPE_CHECKING:
+    from streamlit.delta_generator import DeltaGenerator
+
+
+def _convert_newlines(text: str) -> str:
+    """Convert newline characters to markdown newline sequences
+    (space, space, newline).
+    """
+    return text.replace("\n", "  \n")
+
+
+CHECKMARK_EMOJI = "✅"
+THINKING_EMOJI = ":thinking_face:"
+HISTORY_EMOJI = ":books:"
+EXCEPTION_EMOJI = "⚠️"
+
+
+class LLMThoughtState(Enum):
+    # The LLM is thinking about what to do next. We don't know which tool we'll run.
+    THINKING = "THINKING"
+    # The LLM has decided to run a tool. We don't have results from the tool yet.
+    RUNNING_TOOL = "RUNNING_TOOL"
+    # We have results from the tool.
+    COMPLETE = "COMPLETE"
+
+
+class ToolRecord(NamedTuple):
+    name: str
+    input_str: str
+
+
+class LLMThoughtLabeler:
+    """
+    Generates markdown labels for LLMThought containers. Pass a custom
+    subclass of this to StreamlitCallbackHandler to override its default
+    labeling logic.
+    """
+
+    def get_initial_label(self) -> str:
+        """Return the markdown label for a new LLMThought that doesn't have
+        an associated tool yet.
+        """
+        return f"{THINKING_EMOJI} **Thinking...**"
+
+    def get_tool_label(self, tool: ToolRecord, is_complete: bool) -> str:
+        """Return the label for an LLMThought that has an associated
+        tool.
+
+        Parameters
+        ----------
+        tool
+            The tool's ToolRecord
+
+        is_complete
+            True if the thought is complete; False if the thought
+            is still receiving input.
+
+        Returns
+        -------
+        The markdown label for the thought's container.
+
+        """
+        input = tool.input_str
+        name = tool.name
+        emoji = CHECKMARK_EMOJI if is_complete else THINKING_EMOJI
+        if name == "_Exception":
+            emoji = EXCEPTION_EMOJI
+            name = "Parsing error"
+        idx = min([60, len(input)])
+        input = input[0:idx]
+        if len(tool.input_str) > idx:
+            input = input + "..."
+        input = input.replace("\n", " ")
+        label = f"{emoji} **{name}:** {input}"
+        return label
+
+    def get_history_label(self) -> str:
+        """Return a markdown label for the special 'history' container
+        that contains overflow thoughts.
+        """
+        return f"{HISTORY_EMOJI} **History**"
+
+    def get_final_agent_thought_label(self) -> str:
+        """Return the markdown label for the agent's final thought -
+        the "Now I have the answer" thought, that doesn't involve
+        a tool.
+        """
+        return f"{CHECKMARK_EMOJI} **Complete!**"
+
+
+class LLMThought:
+    def __init__(
+        self,
+        parent_container: DeltaGenerator,
+        labeler: LLMThoughtLabeler,
+        expanded: bool,
+        collapse_on_complete: bool,
+    ):
+        self._container = MutableExpander(
+            parent_container=parent_container,
+            label=labeler.get_initial_label(),
+            expanded=expanded,
+        )
+        self._state = LLMThoughtState.THINKING
+        self._llm_token_stream = ""
+        self._llm_token_writer_idx: Optional[int] = None
+        self._last_tool: Optional[ToolRecord] = None
+        self._collapse_on_complete = collapse_on_complete
+        self._labeler = labeler
+
+    @property
+    def container(self) -> MutableExpander:
+        """The container we're writing into."""
+        return self._container
+
+    @property
+    def last_tool(self) -> Optional[ToolRecord]:
+        """The last tool executed by this thought"""
+        return self._last_tool
+
+    def _reset_llm_token_stream(self) -> None:
+        self._llm_token_stream = ""
+        self._llm_token_writer_idx = None
+
+    def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str]) -> None:
+        self._reset_llm_token_stream()
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        # This is only called when the LLM is initialized with `streaming=True`
+        self._llm_token_stream += _convert_newlines(token)
+        self._llm_token_writer_idx = self._container.markdown(
+            self._llm_token_stream, index=self._llm_token_writer_idx
+        )
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        # `response` is the concatenation of all the tokens received by the LLM.
+        # If we're receiving streaming tokens from `on_llm_new_token`, this response
+        # data is redundant
+        self._reset_llm_token_stream()
+
+    def on_llm_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        self._container.markdown("**LLM encountered an error...**")
+        self._container.exception(error)
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        # Called with the name of the tool we're about to run (in `serialized[name]`),
+        # and its input. We change our container's label to be the tool name.
+        self._state = LLMThoughtState.RUNNING_TOOL
+        tool_name = serialized["name"]
+        self._last_tool = ToolRecord(name=tool_name, input_str=input_str)
+        self._container.update(
+            new_label=self._labeler.get_tool_label(self._last_tool, is_complete=False)
+        )
+
+    def on_tool_end(
+        self,
+        output: str,
+        color: Optional[str] = None,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._container.markdown(f"**{output}**")
+
+    def on_tool_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        self._container.markdown("**Tool encountered an error...**")
+        self._container.exception(error)
+
+    def on_agent_action(
+        self, action: AgentAction, color: Optional[str] = None, **kwargs: Any
+    ) -> Any:
+        # Called when we're about to kick off a new tool. The `action` data
+        # tells us the tool we're about to use, and the input we'll give it.
+        # We don't output anything here, because we'll receive this same data
+        # when `on_tool_start` is called immediately after.
+        pass
+
+    def complete(self, final_label: Optional[str] = None) -> None:
+        """Finish the thought."""
+        if final_label is None and self._state == LLMThoughtState.RUNNING_TOOL:
+            assert (
+                self._last_tool is not None
+            ), "_last_tool should never be null when _state == RUNNING_TOOL"
+            final_label = self._labeler.get_tool_label(
+                self._last_tool, is_complete=True
+            )
+        self._state = LLMThoughtState.COMPLETE
+        if self._collapse_on_complete:
+            self._container.update(new_label=final_label, new_expanded=False)
+        else:
+            self._container.update(new_label=final_label)
+
+    def clear(self) -> None:
+        """Remove the thought from the screen. A cleared thought can't be reused."""
+        self._container.clear()
+
+
+class StreamlitCallbackHandler(BaseCallbackHandler):
+    def __init__(
+        self,
+        parent_container: DeltaGenerator,
+        *,
+        max_thought_containers: int = 4,
+        expand_new_thoughts: bool = True,
+        collapse_completed_thoughts: bool = True,
+        thought_labeler: Optional[LLMThoughtLabeler] = None,
+    ):
+        """Create a StreamlitCallbackHandler instance.
+
+        Parameters
+        ----------
+        parent_container
+            The `st.container` that will contain all the Streamlit elements that the
+            Handler creates.
+        max_thought_containers
+            The max number of completed LLM thought containers to show at once. When
+            this threshold is reached, a new thought will cause the oldest thoughts to
+            be collapsed into a "History" expander. Defaults to 4.
+        expand_new_thoughts
+            Each LLM "thought" gets its own `st.expander`. This param controls whether
+            that expander is expanded by default. Defaults to True.
+        collapse_completed_thoughts
+            If True, LLM thought expanders will be collapsed when completed.
+            Defaults to True.
+        thought_labeler
+            An optional custom LLMThoughtLabeler instance. If unspecified, the handler
+            will use the default thought labeling logic. Defaults to None.
+        """
+        self._parent_container = parent_container
+        self._history_parent = parent_container.container()
+        self._history_container: Optional[MutableExpander] = None
+        self._current_thought: Optional[LLMThought] = None
+        self._completed_thoughts: List[LLMThought] = []
+        self._max_thought_containers = max(max_thought_containers, 1)
+        self._expand_new_thoughts = expand_new_thoughts
+        self._collapse_completed_thoughts = collapse_completed_thoughts
+        self._thought_labeler = thought_labeler or LLMThoughtLabeler()
+
+    def _require_current_thought(self) -> LLMThought:
+        """Return our current LLMThought. Raise an error if we have no current
+        thought.
+        """
+        if self._current_thought is None:
+            raise RuntimeError("Current LLMThought is unexpectedly None!")
+        return self._current_thought
+
+    def _get_last_completed_thought(self) -> Optional[LLMThought]:
+        """Return our most recent completed LLMThought, or None if we don't have one."""
+        if len(self._completed_thoughts) > 0:
+            return self._completed_thoughts[len(self._completed_thoughts) - 1]
+        return None
+
+    @property
+    def _num_thought_containers(self) -> int:
+        """The number of 'thought containers' we're currently showing: the
+        number of completed thought containers, the history container (if it exists),
+        and the current thought container (if it exists).
+        """
+        count = len(self._completed_thoughts)
+        if self._history_container is not None:
+            count += 1
+        if self._current_thought is not None:
+            count += 1
+        return count
+
+    def _complete_current_thought(self, final_label: Optional[str] = None) -> None:
+        """Complete the current thought, optionally assigning it a new label.
+        Add it to our _completed_thoughts list.
+        """
+        thought = self._require_current_thought()
+        thought.complete(final_label)
+        self._completed_thoughts.append(thought)
+        self._current_thought = None
+
+    def _prune_old_thought_containers(self) -> None:
+        """If we have too many thoughts onscreen, move older thoughts to the
+        'history container.'
+        """
+        while (
+            self._num_thought_containers > self._max_thought_containers
+            and len(self._completed_thoughts) > 0
+        ):
+            # Create our history container if it doesn't exist, and if
+            # max_thought_containers is > 1. (if max_thought_containers is 1, we don't
+            # have room to show history.)
+            if self._history_container is None and self._max_thought_containers > 1:
+                self._history_container = MutableExpander(
+                    self._history_parent,
+                    label=self._thought_labeler.get_history_label(),
+                    expanded=False,
+                )
+
+            oldest_thought = self._completed_thoughts.pop(0)
+            if self._history_container is not None:
+                self._history_container.markdown(oldest_thought.container.label)
+                self._history_container.append_copy(oldest_thought.container)
+            oldest_thought.clear()
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        if self._current_thought is None:
+            self._current_thought = LLMThought(
+                parent_container=self._parent_container,
+                expanded=self._expand_new_thoughts,
+                collapse_on_complete=self._collapse_completed_thoughts,
+                labeler=self._thought_labeler,
+            )
+
+        self._current_thought.on_llm_start(serialized, prompts)
+
+        # We don't prune_old_thought_containers here, because our container won't
+        # be visible until it has a child.
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        self._require_current_thought().on_llm_new_token(token, **kwargs)
+        self._prune_old_thought_containers()
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        self._require_current_thought().on_llm_end(response, **kwargs)
+        self._prune_old_thought_containers()
+
+    def on_llm_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        self._require_current_thought().on_llm_error(error, **kwargs)
+        self._prune_old_thought_containers()
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        self._require_current_thought().on_tool_start(serialized, input_str, **kwargs)
+        self._prune_old_thought_containers()
+
+    def on_tool_end(
+        self,
+        output: str,
+        color: Optional[str] = None,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._require_current_thought().on_tool_end(
+            output, color, observation_prefix, llm_prefix, **kwargs
+        )
+        self._complete_current_thought()
+
+    def on_tool_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        self._require_current_thought().on_tool_error(error, **kwargs)
+        self._prune_old_thought_containers()
+
+    def on_text(
+        self,
+        text: str,
+        color: Optional[str] = None,
+        end: str = "",
+        **kwargs: Any,
+    ) -> None:
+        pass
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        pass
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        pass
+
+    def on_chain_error(
+        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
+    ) -> None:
+        pass
+
+    def on_agent_action(
+        self, action: AgentAction, color: Optional[str] = None, **kwargs: Any
+    ) -> Any:
+        self._require_current_thought().on_agent_action(action, color, **kwargs)
+        self._prune_old_thought_containers()
+
+    def on_agent_finish(
+        self, finish: AgentFinish, color: Optional[str] = None, **kwargs: Any
+    ) -> None:
+        if self._current_thought is not None:
+            self._current_thought.complete(
+                self._thought_labeler.get_final_agent_thought_label()
+            )
+            self._current_thought = None

langchain/callbacks/tracers/langchain.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 
 import logging
 import os
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import Future, ThreadPoolExecutor, wait
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Set, Union
 from uuid import UUID
 
 from langchainplus_sdk import LangChainPlusClient
@@ -21,6 +21,7 @@ from langchain.schema import BaseMessage, messages_to_dict
 
 logger = logging.getLogger(__name__)
 _LOGGED = set()
+_TRACERS: List[LangChainTracer] = []
 
 
 def log_error_once(method: str, exception: Exception) -> None:
@@ -32,13 +33,19 @@ def log_error_once(method: str, exception: Exception) -> None:
     logger.error(exception)
 
 
+def wait_for_all_tracers() -> None:
+    global _TRACERS
+    for tracer in _TRACERS:
+        tracer.wait_for_futures()
+
+
 class LangChainTracer(BaseTracer):
     """An implementation of the SharedTracer that POSTS to the langchain endpoint."""
 
     def __init__(
         self,
         example_id: Optional[Union[UUID, str]] = None,
-        session_name: Optional[str] = None,
+        project_name: Optional[str] = None,
         client: Optional[LangChainPlusClient] = None,
         **kwargs: Any,
     ) -> None:
@@ -48,10 +55,15 @@ class LangChainTracer(BaseTracer):
         self.example_id = (
             UUID(example_id) if isinstance(example_id, str) else example_id
         )
-        self.session_name = session_name or os.getenv("LANGCHAIN_SESSION", "default")
+        self.project_name = project_name or os.getenv(
+            "LANGCHAIN_PROJECT", os.getenv("LANGCHAIN_SESSION", "default")
+        )
         # set max_workers to 1 to process tasks in order
         self.executor = ThreadPoolExecutor(max_workers=1)
         self.client = client or LangChainPlusClient()
+        self._futures: Set[Future] = set()
+        global _TRACERS
+        _TRACERS.append(self)
 
     def on_chat_model_start(
         self,
@@ -93,7 +105,7 @@ class LangChainTracer(BaseTracer):
         extra["runtime"] = get_runtime_environment()
         run_dict["extra"] = extra
         try:
-            run = self.client.create_run(**run_dict, session_name=self.session_name)
+            self.client.create_run(**run_dict, project_name=self.project_name)
         except Exception as e:
             # Errors are swallowed by the thread executor so we need to log them here
             log_error_once("post", e)
@@ -110,40 +122,67 @@ class LangChainTracer(BaseTracer):
 
     def _on_llm_start(self, run: Run) -> None:
         """Persist an LLM run."""
-        self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        )
 
     def _on_chat_model_start(self, run: Run) -> None:
         """Persist an LLM run."""
-        self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        )
 
     def _on_llm_end(self, run: Run) -> None:
         """Process the LLM Run."""
-        self.executor.submit(self._update_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._update_run_single, run.copy(deep=True))
+        )
 
     def _on_llm_error(self, run: Run) -> None:
         """Process the LLM Run upon error."""
-        self.executor.submit(self._update_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._update_run_single, run.copy(deep=True))
+        )
 
     def _on_chain_start(self, run: Run) -> None:
         """Process the Chain Run upon start."""
-        self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        )
 
     def _on_chain_end(self, run: Run) -> None:
         """Process the Chain Run."""
-        self.executor.submit(self._update_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._update_run_single, run.copy(deep=True))
+        )
 
     def _on_chain_error(self, run: Run) -> None:
         """Process the Chain Run upon error."""
-        self.executor.submit(self._update_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._update_run_single, run.copy(deep=True))
+        )
 
     def _on_tool_start(self, run: Run) -> None:
         """Process the Tool Run upon start."""
-        self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._persist_run_single, run.copy(deep=True))
+        )
 
     def _on_tool_end(self, run: Run) -> None:
         """Process the Tool Run."""
-        self.executor.submit(self._update_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._update_run_single, run.copy(deep=True))
+        )
 
     def _on_tool_error(self, run: Run) -> None:
         """Process the Tool Run upon error."""
-        self.executor.submit(self._update_run_single, run.copy(deep=True))
+        self._futures.add(
+            self.executor.submit(self._update_run_single, run.copy(deep=True))
+        )
+
+    def wait_for_futures(self) -> None:
+        """Wait for the given futures to complete."""
+        futures = list(self._futures)
+        wait(futures)
+        for future in futures:
+            self._futures.remove(future)

langchain/callbacks/tracers/stdout.py

@@ -7,6 +7,16 @@ from langchain.input import get_bolded_text, get_colored_text
 
 
 def try_json_stringify(obj: Any, fallback: str) -> str:
+    """
+    Try to stringify an object to JSON.
+    Args:
+        obj: Object to stringify.
+        fallback: Fallback string to return if the object cannot be stringified.
+
+    Returns:
+        A JSON string if the object can be stringified, otherwise the fallback string.
+
+    """
     try:
         return json.dumps(obj, indent=2, ensure_ascii=False)
     except Exception:
@@ -14,6 +24,16 @@ def try_json_stringify(obj: Any, fallback: str) -> str:
 
 
 def elapsed(run: Any) -> str:
+    """Get the elapsed time of a run.
+
+    Args:
+        run: any object with a start_time and end_time attribute.
+
+    Returns:
+        A string with the elapsed time in seconds or
+            milliseconds if time is less than a second.
+
+    """
     elapsed_time = run.end_time - run.start_time
     milliseconds = elapsed_time.total_seconds() * 1000
     if milliseconds < 1000:
@@ -22,6 +42,8 @@ def elapsed(run: Any) -> str:
 
 
 class ConsoleCallbackHandler(BaseTracer):
+    """Tracer that prints to the console."""
+
     name = "console_callback_handler"
 
     def _persist_run(self, run: Run) -> None:

langchain/callbacks/tracers/wandb.py

@@ -137,6 +137,8 @@ def _replace_type_with_kind(data: Any) -> Any:
 
 
 class WandbRunArgs(TypedDict):
+    """Arguments for the WandbTracer."""
+
     job_type: Optional[str]
     dir: Optional[StrPath]
     config: Union[Dict, str, None]

langchain/callbacks/utils.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, Iterable, Tuple, Union
 
 
 def import_spacy() -> Any:
+    """Import the spacy python package and raise an error if it is not installed."""
     try:
         import spacy
     except ImportError:
@@ -15,6 +16,7 @@ def import_spacy() -> Any:
 
 
 def import_pandas() -> Any:
+    """Import the pandas python package and raise an error if it is not installed."""
     try:
         import pandas
     except ImportError:
@@ -26,6 +28,7 @@ def import_pandas() -> Any:
 
 
 def import_textstat() -> Any:
+    """Import the textstat python package and raise an error if it is not installed."""
     try:
         import textstat
     except ImportError:

langchain/callbacks/wandb_callback.py

@@ -17,6 +17,7 @@ from langchain.schema import AgentAction, AgentFinish, LLMResult
 
 
 def import_wandb() -> Any:
+    """Import the wandb python package and raise an error if it is not installed."""
     try:
         import wandb  # noqa: F401
     except ImportError:

langchain/callbacks/whylabs_callback.py

@@ -18,6 +18,16 @@ def import_langkit(
     toxicity: bool = False,
     themes: bool = False,
 ) -> Any:
+    """Import the langkit python package and raise an error if it is not installed.
+
+    Args:
+        sentiment: Whether to import the langkit.sentiment module. Defaults to False.
+        toxicity: Whether to import the langkit.toxicity module. Defaults to False.
+        themes: Whether to import the langkit.themes module. Defaults to False.
+
+    Returns:
+        The imported langkit module.
+    """
     try:
         import langkit  # noqa: F401
         import langkit.regexes  # noqa: F401

langchain/chains/graph_qa/cypher.py

@@ -18,6 +18,14 @@ INTERMEDIATE_STEPS_KEY = "intermediate_steps"
 
 
 def extract_cypher(text: str) -> str:
+    """
+    Extract Cypher code from a text.
+    Args:
+        text: Text to extract Cypher code from.
+
+    Returns:
+        Cypher code extracted from the text.
+    """
     # The pattern to find Cypher code enclosed in triple backticks
     pattern = r"```(.*?)```"
 

langchain/chains/natbot/crawler.py

@@ -34,6 +34,8 @@ black_listed_elements: Set[str] = {
 
 
 class ElementInViewPort(TypedDict):
+    """A typed dictionary containing information about elements in the viewport."""
+
     node_index: str
     backend_node_id: int
     node_name: Optional[str]
@@ -51,7 +53,7 @@ class Crawler:
         try:
             from playwright.sync_api import sync_playwright
         except ImportError:
-            raise ValueError(
+            raise ImportError(
                 "Could not import playwright python package. "
                 "Please install it with `pip install playwright`."
             )

langchain/chains/openai_functions/citation_fuzzy_match.py

@@ -64,6 +64,14 @@ class QuestionAnswer(BaseModel):
 
 
 def create_citation_fuzzy_match_chain(llm: BaseLanguageModel) -> LLMChain:
+    """Create a citation fuzzy match chain.
+
+    Args:
+        llm: Language model to use for the chain.
+
+    Returns:
+        Chain (LLMChain) that can be used to answer questions with citations.
+    """
     output_parser = PydanticOutputFunctionsParser(pydantic_schema=QuestionAnswer)
     schema = QuestionAnswer.schema()
     function = {

langchain/chains/openai_functions/extraction.py

@@ -40,6 +40,15 @@ Passage:
 
 
 def create_extraction_chain(schema: dict, llm: BaseLanguageModel) -> Chain:
+    """Creates a chain that extracts information from a passage.
+
+    Args:
+        schema: The schema of the entities to extract.
+        llm: The language model to use.
+
+    Returns:
+        Chain that can be used to extract information from a passage.
+    """
     function = _get_extraction_function(schema)
     prompt = ChatPromptTemplate.from_template(_EXTRACTION_TEMPLATE)
     output_parser = JsonKeyOutputFunctionsParser(key_name="info")
@@ -56,6 +65,16 @@ def create_extraction_chain(schema: dict, llm: BaseLanguageModel) -> Chain:
 def create_extraction_chain_pydantic(
     pydantic_schema: Any, llm: BaseLanguageModel
 ) -> Chain:
+    """Creates a chain that extracts information from a passage using pydantic schema.
+
+    Args:
+        pydantic_schema: The pydantic schema of the entities to extract.
+        llm: The language model to use.
+
+    Returns:
+        Chain that can be used to extract information from a passage.
+    """
+
     class PydanticSchema(BaseModel):
         info: List[pydantic_schema]  # type: ignore
 

langchain/chains/openai_functions/openapi.py

@@ -0,0 +1,270 @@
+import json
+import re
+from collections import defaultdict
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+import requests
+from openapi_schema_pydantic import Parameter
+from requests import Response
+
+from langchain import BasePromptTemplate, LLMChain
+from langchain.base_language import BaseLanguageModel
+from langchain.callbacks.manager import CallbackManagerForChainRun
+from langchain.chains.base import Chain
+from langchain.chains.sequential import SequentialChain
+from langchain.chat_models import ChatOpenAI
+from langchain.input import get_colored_text
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from langchain.prompts import ChatPromptTemplate
+from langchain.tools import APIOperation
+from langchain.utilities.openapi import OpenAPISpec
+
+
+def _get_description(o: Any, prefer_short: bool) -> Optional[str]:
+    summary = getattr(o, "summary", None)
+    description = getattr(o, "description", None)
+    if prefer_short:
+        return summary or description
+    return description or summary
+
+
+def _format_url(url: str, path_params: dict) -> str:
+    expected_path_param = re.findall(r"{(.*?)}", url)
+    new_params = {}
+    for param in expected_path_param:
+        clean_param = param.lstrip(".;").rstrip("*")
+        val = path_params[clean_param]
+        if isinstance(val, list):
+            if param[0] == ".":
+                sep = "." if param[-1] == "*" else ","
+                new_val = "." + sep.join(val)
+            elif param[0] == ";":
+                sep = f"{clean_param}=" if param[-1] == "*" else ","
+                new_val = f"{clean_param}=" + sep.join(val)
+            else:
+                new_val = ",".join(val)
+        elif isinstance(val, dict):
+            kv_sep = "=" if param[-1] == "*" else ","
+            kv_strs = [kv_sep.join((k, v)) for k, v in val.items()]
+            if param[0] == ".":
+                sep = "."
+                new_val = "."
+            elif param[0] == ";":
+                sep = ";"
+                new_val = ";"
+            else:
+                sep = ","
+                new_val = ""
+            new_val += sep.join(kv_strs)
+        else:
+            if param[0] == ".":
+                new_val = f".{val}"
+            elif param[0] == ";":
+                new_val = f";{clean_param}={val}"
+            else:
+                new_val = val
+        new_params[param] = new_val
+    return url.format(**new_params)
+
+
+def _openapi_params_to_json_schema(params: List[Parameter], spec: OpenAPISpec) -> dict:
+    properties = {}
+    required = []
+    for p in params:
+        if p.param_schema:
+            schema = spec.get_schema(p.param_schema)
+        else:
+            media_type_schema = list(p.content.values())[0].media_type_schema  # type: ignore  # noqa: E501
+            schema = spec.get_schema(media_type_schema)
+        if p.description and not schema.description:
+            schema.description = p.description
+        properties[p.name] = json.loads(schema.json(exclude_none=True))
+        if p.required:
+            required.append(p.name)
+    return {"type": "object", "properties": properties, "required": required}
+
+
+def openapi_spec_to_openai_fn(
+    spec: OpenAPISpec,
+) -> Tuple[List[Dict[str, Any]], Callable]:
+    """Convert a valid OpenAPI spec to the JSON Schema format expected for OpenAI
+        functions.
+
+    Args:
+        spec: OpenAPI spec to convert.
+
+    Returns:
+        Tuple of the OpenAI functions JSON schema and a default function for executing
+            a request based on the OpenAI function schema.
+    """
+    if not spec.paths:
+        return [], lambda: None
+    functions = []
+    _name_to_call_map = {}
+    for path in spec.paths:
+        path_params = {
+            (p.name, p.param_in): p for p in spec.get_parameters_for_path(path)
+        }
+        for method in spec.get_methods_for_path(path):
+            request_args = {}
+            op = spec.get_operation(path, method)
+            op_params = path_params.copy()
+            for param in spec.get_parameters_for_operation(op):
+                op_params[(param.name, param.param_in)] = param
+            params_by_type = defaultdict(list)
+            for name_loc, p in op_params.items():
+                params_by_type[name_loc[1]].append(p)
+            param_loc_to_arg_name = {
+                "query": "params",
+                "header": "headers",
+                "cookie": "cookies",
+                "path": "path_params",
+            }
+            for param_loc, arg_name in param_loc_to_arg_name.items():
+                if params_by_type[param_loc]:
+                    request_args[arg_name] = _openapi_params_to_json_schema(
+                        params_by_type[param_loc], spec
+                    )
+            request_body = spec.get_request_body_for_operation(op)
+            # TODO: Support more MIME types.
+            if request_body and request_body.content:
+                media_types = {}
+                for media_type, media_type_object in request_body.content.items():
+                    if media_type_object.media_type_schema:
+                        schema = spec.get_schema(media_type_object.media_type_schema)
+                        media_types[media_type] = json.loads(
+                            schema.json(exclude_none=True)
+                        )
+                if len(media_types) == 1:
+                    media_type, schema_dict = list(media_types.items())[0]
+                    key = "json" if media_type == "application/json" else "data"
+                    request_args[key] = schema_dict
+                elif len(media_types) > 1:
+                    request_args["data"] = {"anyOf": list(media_types.values())}
+
+            api_op = APIOperation.from_openapi_spec(spec, path, method)
+            fn = {
+                "name": api_op.operation_id,
+                "description": api_op.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": request_args,
+                },
+            }
+            functions.append(fn)
+            _name_to_call_map[fn["name"]] = {
+                "method": method,
+                "url": api_op.base_url + api_op.path,
+            }
+
+    def default_call_api(name: str, fn_args: dict, **kwargs: Any) -> Any:
+        method = _name_to_call_map[name]["method"]
+        url = _name_to_call_map[name]["url"]
+        path_params = fn_args.pop("path_params", {})
+        _format_url(url, path_params)
+        if "data" in fn_args and isinstance(fn_args["data"], dict):
+            fn_args["data"] = json.dumps(fn_args["data"])
+        _kwargs = {**fn_args, **kwargs}
+        return requests.request(method, url, **_kwargs)
+
+    return functions, default_call_api
+
+
+class SimpleRequestChain(Chain):
+    request_method: Callable
+    output_key: str = "response"
+    input_key: str = "function"
+
+    @property
+    def input_keys(self) -> List[str]:
+        return [self.input_key]
+
+    @property
+    def output_keys(self) -> List[str]:
+        return [self.output_key]
+
+    def _call(
+        self,
+        inputs: Dict[str, Any],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Dict[str, Any]:
+        """Run the logic of this chain and return the output."""
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+        name = inputs["function"].pop("name")
+        args = inputs["function"].pop("arguments")
+        _pretty_name = get_colored_text(name, "green")
+        _pretty_args = get_colored_text(json.dumps(args, indent=2), "green")
+        _text = f"Calling endpoint {_pretty_name} with arguments:\n" + _pretty_args
+        _run_manager.on_text(_text)
+        api_response: Response = self.request_method(name, args)
+        if api_response.status_code != 200:
+            response = (
+                f"{api_response.status_code}: {api_response.reason}"
+                + f"\nFor {name} "
+                + f"Called with args: {args['params']}"
+            )
+        else:
+            try:
+                response = api_response.json()
+            except Exception:  # noqa: E722
+                response = api_response.text
+        return {self.output_key: response}
+
+
+def get_openapi_chain(
+    spec: Union[OpenAPISpec, str],
+    llm: Optional[BaseLanguageModel] = None,
+    prompt: Optional[BasePromptTemplate] = None,
+    request_chain: Optional[Chain] = None,
+    llm_kwargs: Optional[Dict] = None,
+    verbose: bool = False,
+    **kwargs: Any,
+) -> SequentialChain:
+    """Create a chain for querying an API from a OpenAPI spec.
+
+    Args:
+        spec: OpenAPISpec or url/file/text string corresponding to one.
+        llm: language model, should be an OpenAI function-calling model, e.g.
+            `ChatOpenAI(model="gpt-3.5-turbo-0613")`.
+        prompt: Main prompt template to use.
+        request_chain: Chain for taking the functions output and executing the request.
+    """
+    if isinstance(spec, str):
+        for conversion in (
+            OpenAPISpec.from_url,
+            OpenAPISpec.from_file,
+            OpenAPISpec.from_text,
+        ):
+            try:
+                spec = conversion(spec)  # type: ignore[arg-type]
+                break
+            except Exception:  # noqa: E722
+                pass
+        if isinstance(spec, str):
+            raise ValueError(f"Unable to parse spec from source {spec}")
+    openai_fns, call_api_fn = openapi_spec_to_openai_fn(spec)
+    llm = llm or ChatOpenAI(
+        model="gpt-3.5-turbo-0613",
+    )
+    prompt = prompt or ChatPromptTemplate.from_template(
+        "Use the provided API's to respond to this user query:\n\n{query}"
+    )
+    llm_chain = LLMChain(
+        llm=llm,
+        prompt=prompt,
+        llm_kwargs={"functions": openai_fns},
+        output_parser=JsonOutputFunctionsParser(args_only=False),
+        output_key="function",
+        verbose=verbose,
+        **(llm_kwargs or {}),
+    )
+    request_chain = request_chain or SimpleRequestChain(
+        request_method=call_api_fn, verbose=verbose
+    )
+    return SequentialChain(
+        chains=[llm_chain, request_chain],
+        input_variables=llm_chain.input_keys,
+        output_variables=["response"],
+        verbose=verbose,
+        **kwargs,
+    )

langchain/chains/openai_functions/qa_with_structure.py

@@ -29,6 +29,18 @@ def create_qa_with_structure_chain(
     output_parser: str = "base",
     prompt: Optional[Union[PromptTemplate, ChatPromptTemplate]] = None,
 ) -> LLMChain:
+    """Create a question answering chain that returns an answer with sources.
+
+    Args:
+        llm: Language model to use for the chain.
+        schema: Pydantic schema to use for the output.
+        output_parser: Output parser to use. Should be one of `pydantic` or `base`.
+            Default to `base`.
+        prompt: Optional prompt to use for the chain.
+
+    Returns:
+
+    """
     if output_parser == "pydantic":
         if not (isinstance(schema, type) and issubclass(schema, BaseModel)):
             raise ValueError(
@@ -79,4 +91,13 @@ def create_qa_with_structure_chain(
 
 
 def create_qa_with_sources_chain(llm: BaseLanguageModel, **kwargs: Any) -> LLMChain:
+    """Create a question answering chain that returns an answer with sources.
+
+    Args:
+        llm: Language model to use for the chain.
+        **kwargs: Keyword arguments to pass to `create_qa_with_structure_chain`.
+
+    Returns:
+        Chain (LLMChain) that can be used to answer questions with citations.
+    """
     return create_qa_with_structure_chain(llm, AnswerWithSources, **kwargs)

langchain/chains/openai_functions/tagging.py

@@ -27,6 +27,15 @@ Passage:
 
 
 def create_tagging_chain(schema: dict, llm: BaseLanguageModel) -> Chain:
+    """Creates a chain that extracts information from a passage.
+
+    Args:
+        schema: The schema of the entities to extract.
+        llm: The language model to use.
+
+    Returns:
+        Chain (LLMChain) that can be used to extract information from a passage.
+    """
     function = _get_tagging_function(schema)
     prompt = ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)
     output_parser = JsonOutputFunctionsParser()
@@ -43,6 +52,15 @@ def create_tagging_chain(schema: dict, llm: BaseLanguageModel) -> Chain:
 def create_tagging_chain_pydantic(
     pydantic_schema: Any, llm: BaseLanguageModel
 ) -> Chain:
+    """Creates a chain that extracts information from a passage.
+
+    Args:
+        pydantic_schema: The pydantic schema of the entities to extract.
+        llm: The language model to use.
+
+    Returns:
+        Chain (LLMChain) that can be used to extract information from a passage.
+    """
     openai_schema = pydantic_schema.schema()
     function = _get_tagging_function(openai_schema)
     prompt = ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)

langchain/chains/openai_functions/utils.py

@@ -29,4 +29,12 @@ def _convert_schema(schema: dict) -> dict:
 
 
 def get_llm_kwargs(function: dict) -> dict:
+    """Returns the kwargs for the LLMChain constructor.
+
+    Args:
+        function: The function to use.
+
+    Returns:
+        The kwargs for the LLMChain constructor.
+    """
     return {"functions": [function], "function_call": {"name": function["name"]}}

langchain/chains/prompt_selector.py

@@ -31,8 +31,24 @@ class ConditionalPromptSelector(BasePromptSelector):
 
 
 def is_llm(llm: BaseLanguageModel) -> bool:
+    """Check if the language model is a LLM.
+
+    Args:
+        llm: Language model to check.
+
+    Returns:
+        True if the language model is a BaseLLM model, False otherwise.
+    """
     return isinstance(llm, BaseLLM)
 
 
 def is_chat_model(llm: BaseLanguageModel) -> bool:
+    """Check if the language model is a chat model.
+
+    Args:
+        llm: Language model to check.
+
+    Returns:
+        True if the language model is a BaseChatModel model, False otherwise.
+    """
     return isinstance(llm, BaseChatModel)

langchain/chains/query_constructor/base.py

@@ -123,6 +123,22 @@ def load_query_constructor_chain(
     enable_limit: bool = False,
     **kwargs: Any,
 ) -> LLMChain:
+    """
+    Load a query constructor chain.
+    Args:
+        llm: BaseLanguageModel to use for the chain.
+        document_contents: The contents of the document to be queried.
+        attribute_info: A list of AttributeInfo objects describing
+            the attributes of the document.
+        examples: Optional list of examples to use for the chain.
+        allowed_comparators: An optional list of allowed comparators.
+        allowed_operators: An optional list of allowed operators.
+        enable_limit: Whether to enable the limit operator. Defaults to False.
+        **kwargs:
+
+    Returns:
+        A LLMChain that can be used to construct queries.
+    """
     prompt = _get_prompt(
         document_contents,
         attribute_info,

langchain/chains/query_constructor/ir.py

@@ -60,12 +60,16 @@ class Expr(BaseModel):
 
 
 class Operator(str, Enum):
+    """Enumerator of the operations."""
+
     AND = "and"
     OR = "or"
     NOT = "not"
 
 
 class Comparator(str, Enum):
+    """Enumerator of the comparison operators."""
+
     EQ = "eq"
     GT = "gt"
     GTE = "gte"

langchain/chains/query_constructor/parser.py

@@ -57,6 +57,9 @@ GRAMMAR = """
 
 @v_args(inline=True)
 class QueryTransformer(Transformer):
+    """Transforms a query string into an IR representation
+    (intermediate representation)."""
+
     def __init__(
         self,
         *args: Any,
@@ -136,6 +139,16 @@ def get_parser(
     allowed_comparators: Optional[Sequence[Comparator]] = None,
     allowed_operators: Optional[Sequence[Operator]] = None,
 ) -> Lark:
+    """
+    Returns a parser for the query language.
+
+    Args:
+        allowed_comparators: Optional[Sequence[Comparator]]
+        allowed_operators: Optional[Sequence[Operator]]
+
+    Returns:
+        Lark parser for the query language.
+    """
     transformer = QueryTransformer(
         allowed_comparators=allowed_comparators, allowed_operators=allowed_operators
     )

langchain/chat_models/__init__.py

@@ -1,5 +1,6 @@
 from langchain.chat_models.anthropic import ChatAnthropic
 from langchain.chat_models.azure_openai import AzureChatOpenAI
+from langchain.chat_models.fake import FakeListChatModel
 from langchain.chat_models.google_palm import ChatGooglePalm
 from langchain.chat_models.openai import ChatOpenAI
 from langchain.chat_models.promptlayer_openai import PromptLayerChatOpenAI
@@ -8,6 +9,7 @@ from langchain.chat_models.vertexai import ChatVertexAI
 __all__ = [
     "ChatOpenAI",
     "AzureChatOpenAI",
+    "FakeListChatModel",
     "PromptLayerChatOpenAI",
     "ChatAnthropic",
     "ChatGooglePalm",

langchain/chat_models/base.py

@@ -17,7 +17,7 @@ from langchain.callbacks.manager import (
     CallbackManagerForLLMRun,
     Callbacks,
 )
-from langchain.load.dump import dumpd
+from langchain.load.dump import dumpd, dumps
 from langchain.schema import (
     AIMessage,
     BaseMessage,
@@ -35,6 +35,7 @@ def _get_verbosity() -> bool:
 
 
 class BaseChatModel(BaseLanguageModel, ABC):
+    cache: Optional[bool] = None
     verbose: bool = Field(default_factory=_get_verbosity)
     """Whether to print out response text."""
     callbacks: Callbacks = Field(default=None, exclude=True)
@@ -61,6 +62,25 @@ class BaseChatModel(BaseLanguageModel, ABC):
     def _combine_llm_outputs(self, llm_outputs: List[Optional[dict]]) -> dict:
         return {}
 
+    def _get_invocation_params(
+        self,
+        stop: Optional[List[str]] = None,
+    ) -> dict:
+        params = self.dict()
+        params["stop"] = stop
+        return params
+
+    def _get_llm_string(self, stop: Optional[List[str]] = None, **kwargs: Any) -> str:
+        if self.lc_serializable:
+            params = {**kwargs, **{"stop": stop}}
+            param_string = str(sorted([(k, v) for k, v in params.items()]))
+            llm_string = dumps(self)
+            return llm_string + "---" + param_string
+        else:
+            params = self._get_invocation_params(stop=stop)
+            params = {**params, **kwargs}
+            return str(sorted([(k, v) for k, v in params.items()]))
+
     def generate(
         self,
         messages: List[List[BaseMessage]],
@@ -71,9 +91,7 @@ class BaseChatModel(BaseLanguageModel, ABC):
         **kwargs: Any,
     ) -> LLMResult:
         """Top Level call"""
-
-        params = self.dict()
-        params["stop"] = stop
+        params = self._get_invocation_params(stop=stop)
         options = {"stop": stop}
 
         callback_manager = CallbackManager.configure(
@@ -87,14 +105,11 @@ class BaseChatModel(BaseLanguageModel, ABC):
             dumpd(self), messages, invocation_params=params, options=options
         )
 
-        new_arg_supported = inspect.signature(self._generate).parameters.get(
-            "run_manager"
-        )
         try:
             results = [
-                self._generate(m, stop=stop, run_manager=run_manager, **kwargs)
-                if new_arg_supported
-                else self._generate(m, stop=stop)
+                self._generate_with_cache(
+                    m, stop=stop, run_manager=run_manager, **kwargs
+                )
                 for m in messages
             ]
         except (KeyboardInterrupt, Exception) as e:
@@ -118,8 +133,7 @@ class BaseChatModel(BaseLanguageModel, ABC):
         **kwargs: Any,
     ) -> LLMResult:
         """Top Level call"""
-        params = self.dict()
-        params["stop"] = stop
+        params = self._get_invocation_params(stop=stop)
         options = {"stop": stop}
 
         callback_manager = AsyncCallbackManager.configure(
@@ -133,15 +147,12 @@ class BaseChatModel(BaseLanguageModel, ABC):
             dumpd(self), messages, invocation_params=params, options=options
         )
 
-        new_arg_supported = inspect.signature(self._agenerate).parameters.get(
-            "run_manager"
-        )
         try:
             results = await asyncio.gather(
                 *[
-                    self._agenerate(m, stop=stop, run_manager=run_manager, **kwargs)
-                    if new_arg_supported
-                    else self._agenerate(m, stop=stop)
+                    self._agenerate_with_cache(
+                        m, stop=stop, run_manager=run_manager, **kwargs
+                    )
                     for m in messages
                 ]
             )
@@ -178,6 +189,84 @@ class BaseChatModel(BaseLanguageModel, ABC):
             prompt_messages, stop=stop, callbacks=callbacks, **kwargs
         )
 
+    def _generate_with_cache(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        new_arg_supported = inspect.signature(self._generate).parameters.get(
+            "run_manager"
+        )
+        disregard_cache = self.cache is not None and not self.cache
+        if langchain.llm_cache is None or disregard_cache:
+            # This happens when langchain.cache is None, but self.cache is True
+            if self.cache is not None and self.cache:
+                raise ValueError(
+                    "Asked to cache, but no cache found at `langchain.cache`."
+                )
+            if new_arg_supported:
+                return self._generate(
+                    messages, stop=stop, run_manager=run_manager, **kwargs
+                )
+            else:
+                return self._generate(messages, stop=stop, **kwargs)
+        else:
+            llm_string = self._get_llm_string(stop=stop, **kwargs)
+            prompt = dumps(messages)
+            cache_val = langchain.llm_cache.lookup(prompt, llm_string)
+            if isinstance(cache_val, list):
+                return ChatResult(generations=cache_val)
+            else:
+                if new_arg_supported:
+                    result = self._generate(
+                        messages, stop=stop, run_manager=run_manager, **kwargs
+                    )
+                else:
+                    result = self._generate(messages, stop=stop, **kwargs)
+                langchain.llm_cache.update(prompt, llm_string, result.generations)
+                return result
+
+    async def _agenerate_with_cache(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        new_arg_supported = inspect.signature(self._agenerate).parameters.get(
+            "run_manager"
+        )
+        disregard_cache = self.cache is not None and not self.cache
+        if langchain.llm_cache is None or disregard_cache:
+            # This happens when langchain.cache is None, but self.cache is True
+            if self.cache is not None and self.cache:
+                raise ValueError(
+                    "Asked to cache, but no cache found at `langchain.cache`."
+                )
+            if new_arg_supported:
+                return await self._agenerate(
+                    messages, stop=stop, run_manager=run_manager, **kwargs
+                )
+            else:
+                return await self._agenerate(messages, stop=stop, **kwargs)
+        else:
+            llm_string = self._get_llm_string(stop=stop, **kwargs)
+            prompt = dumps(messages)
+            cache_val = langchain.llm_cache.lookup(prompt, llm_string)
+            if isinstance(cache_val, list):
+                return ChatResult(generations=cache_val)
+            else:
+                if new_arg_supported:
+                    result = await self._agenerate(
+                        messages, stop=stop, run_manager=run_manager, **kwargs
+                    )
+                else:
+                    result = await self._agenerate(messages, stop=stop, **kwargs)
+                langchain.llm_cache.update(prompt, llm_string, result.generations)
+                return result
+
     @abstractmethod
     def _generate(
         self,

langchain/chat_models/fake.py

@@ -0,0 +1,33 @@
+"""Fake ChatModel for testing purposes."""
+from typing import Any, List, Mapping, Optional
+
+from langchain.callbacks.manager import CallbackManagerForLLMRun
+from langchain.chat_models.base import SimpleChatModel
+from langchain.schema import BaseMessage
+
+
+class FakeListChatModel(SimpleChatModel):
+    """Fake ChatModel for testing purposes."""
+
+    responses: List
+    i: int = 0
+
+    @property
+    def _llm_type(self) -> str:
+        return "fake-list-chat-model"
+
+    def _call(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        """First try to lookup in queries, else return 'foo' or 'bar'."""
+        response = self.responses[self.i]
+        self.i += 1
+        return response
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        return {"responses": self.responses}

langchain/chat_models/google_palm.py

@@ -36,6 +36,8 @@ logger = logging.getLogger(__name__)
 
 
 class ChatGooglePalmError(Exception):
+    """Error raised when there is an issue with the Google PaLM API."""
+
     pass
 
 

langchain/chat_models/vertexai.py

@@ -129,8 +129,9 @@ class ChatVertexAI(_VertexAICommon, BaseChatModel):
         context = history.system_message.content if history.system_message else None
         params = {**self._default_params, **kwargs}
         if not self.is_codey_model:
-            params["context"] = context
-        chat = self.client.start_chat(**params)
+            chat = self.client.start_chat(context=context, **params)
+        else:
+            chat = self.client.start_chat(**params)
         for pair in history.history:
             chat._history.append((pair.question.content, pair.answer.content))
         response = chat.send_message(question.content, **params)

langchain/client/runner_utils.py

@@ -224,23 +224,31 @@ async def _gather_with_concurrency(
                 tracer_queue.put_nowait(tracer)
             return result
 
-    return await asyncio.gather(
+    results = await asyncio.gather(
         *(run_coroutine_with_semaphore(function) for function in async_funcs)
     )
+    while tracer_queue:
+        try:
+            tracer = tracer_queue.get_nowait()
+        except asyncio.QueueEmpty:
+            break
+        if tracer:
+            tracer.wait_for_futures()
+    return results
 
 
-async def _tracer_initializer(session_name: Optional[str]) -> Optional[LangChainTracer]:
+async def _tracer_initializer(project_name: Optional[str]) -> Optional[LangChainTracer]:
     """
     Initialize a tracer to share across tasks.
 
     Args:
-        session_name: The session name for the tracer.
+        project_name: The project name for the tracer.
 
     Returns:
-        A LangChainTracer instance with an active session.
+        A LangChainTracer instance with an active project.
     """
-    if session_name:
-        tracer = LangChainTracer(session_name=session_name)
+    if project_name:
+        tracer = LangChainTracer(project_name=project_name)
         return tracer
     else:
         return None
@@ -252,12 +260,12 @@ async def arun_on_examples(
     *,
     concurrency_level: int = 5,
     num_repetitions: int = 1,
-    session_name: Optional[str] = None,
+    project_name: Optional[str] = None,
     verbose: bool = False,
     tags: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     """
-    Run the chain on examples and store traces to the specified session name.
+    Run the chain on examples and store traces to the specified project name.
 
     Args:
         examples: Examples to run the model or chain over
@@ -268,7 +276,7 @@ async def arun_on_examples(
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
             intervals.
-        session_name: Session name to use when tracing runs.
+        project_name: Project name to use when tracing runs.
         verbose: Whether to print progress.
         tags: Tags to add to the traces.
 
@@ -299,7 +307,7 @@ async def arun_on_examples(
 
     await _gather_with_concurrency(
         concurrency_level,
-        functools.partial(_tracer_initializer, session_name),
+        functools.partial(_tracer_initializer, project_name),
         *(functools.partial(process_example, e) for e in examples),
     )
     return results
@@ -378,11 +386,11 @@ def run_on_examples(
     llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     *,
     num_repetitions: int = 1,
-    session_name: Optional[str] = None,
+    project_name: Optional[str] = None,
     verbose: bool = False,
     tags: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
-    """Run the chain on examples and store traces to the specified session name.
+    """Run the chain on examples and store traces to the specified project name.
 
     Args:
         examples: Examples to run model or chain over.
@@ -393,14 +401,14 @@ def run_on_examples(
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
             intervals.
-        session_name: Session name to use when tracing runs.
+        project_name: Project name to use when tracing runs.
         verbose: Whether to print progress.
         tags: Tags to add to the run traces.
     Returns:
         A dictionary mapping example ids to the model outputs.
     """
     results: Dict[str, Any] = {}
-    tracer = LangChainTracer(session_name=session_name) if session_name else None
+    tracer = LangChainTracer(project_name=project_name) if project_name else None
     for i, example in enumerate(examples):
         result = run_llm_or_chain(
             example,
@@ -411,17 +419,19 @@ def run_on_examples(
         )
         if verbose:
             print(f"{i+1} processed", flush=True, end="\r")
-    results[str(example.id)] = result
+        results[str(example.id)] = result
+    if tracer:
+        tracer.wait_for_futures()
     return results
 
 
-def _get_session_name(
-    session_name: Optional[str],
+def _get_project_name(
+    project_name: Optional[str],
     llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     dataset_name: str,
 ) -> str:
-    if session_name is not None:
-        return session_name
+    if project_name is not None:
+        return project_name
     current_time = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
     if isinstance(llm_or_chain_factory, BaseLanguageModel):
         model_name = llm_or_chain_factory.__class__.__name__
@@ -436,13 +446,13 @@ async def arun_on_dataset(
     *,
     concurrency_level: int = 5,
     num_repetitions: int = 1,
-    session_name: Optional[str] = None,
+    project_name: Optional[str] = None,
     verbose: bool = False,
     client: Optional[LangChainPlusClient] = None,
     tags: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     """
-    Run the chain on a dataset and store traces to the specified session name.
+    Run the chain on a dataset and store traces to the specified project name.
 
     Args:
         client: Client to use to read the dataset.
@@ -454,7 +464,7 @@ async def arun_on_dataset(
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
             intervals.
-        session_name: Name of the session to store the traces in.
+        project_name: Name of the project to store the traces in.
             Defaults to {dataset_name}-{chain class name}-{datetime}.
         verbose: Whether to print progress.
         client: Client to use to read the dataset. If not provided, a new
@@ -462,11 +472,10 @@ async def arun_on_dataset(
         tags: Tags to add to each run in the sesssion.
 
     Returns:
-        A dictionary containing the run's session name and the resulting model outputs.
+        A dictionary containing the run's project name and the resulting model outputs.
     """
     client_ = client or LangChainPlusClient()
-    session_name = _get_session_name(session_name, llm_or_chain_factory, dataset_name)
-    client_.create_session(session_name, mode="eval")
+    project_name = _get_project_name(project_name, llm_or_chain_factory, dataset_name)
     dataset = client_.read_dataset(dataset_name=dataset_name)
     examples = client_.list_examples(dataset_id=str(dataset.id))
 
@@ -475,12 +484,12 @@ async def arun_on_dataset(
         llm_or_chain_factory,
         concurrency_level=concurrency_level,
         num_repetitions=num_repetitions,
-        session_name=session_name,
+        project_name=project_name,
         verbose=verbose,
         tags=tags,
     )
     return {
-        "session_name": session_name,
+        "project_name": project_name,
         "results": results,
     }
 
@@ -490,12 +499,12 @@ def run_on_dataset(
     llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
     *,
     num_repetitions: int = 1,
-    session_name: Optional[str] = None,
+    project_name: Optional[str] = None,
     verbose: bool = False,
     client: Optional[LangChainPlusClient] = None,
     tags: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
-    """Run the chain on a dataset and store traces to the specified session name.
+    """Run the chain on a dataset and store traces to the specified project name.
 
     Args:
         dataset_name: Name of the dataset to run the chain on.
@@ -506,7 +515,7 @@ def run_on_dataset(
         num_repetitions: Number of times to run the model on each example.
             This is useful when testing success rates or generating confidence
             intervals.
-        session_name: Name of the session to store the traces in.
+        project_name: Name of the project to store the traces in.
             Defaults to {dataset_name}-{chain class name}-{datetime}.
         verbose: Whether to print progress.
         client: Client to use to access the dataset. If None, a new client
@@ -514,22 +523,21 @@ def run_on_dataset(
         tags: Tags to add to each run in the sesssion.
 
     Returns:
-        A dictionary containing the run's session name and the resulting model outputs.
+        A dictionary containing the run's project name and the resulting model outputs.
     """
     client_ = client or LangChainPlusClient()
-    session_name = _get_session_name(session_name, llm_or_chain_factory, dataset_name)
-    client_.create_session(session_name, mode="eval")
+    project_name = _get_project_name(project_name, llm_or_chain_factory, dataset_name)
     dataset = client_.read_dataset(dataset_name=dataset_name)
     examples = client_.list_examples(dataset_id=str(dataset.id))
     results = run_on_examples(
         examples,
         llm_or_chain_factory,
         num_repetitions=num_repetitions,
-        session_name=session_name,
+        project_name=project_name,
         verbose=verbose,
         tags=tags,
     )
     return {
-        "session_name": session_name,
+        "project_name": project_name,
         "results": results,
     }

langchain/document_loaders/__init__.py

@@ -67,6 +67,7 @@ from langchain.document_loaders.markdown import UnstructuredMarkdownLoader
 from langchain.document_loaders.mastodon import MastodonTootsLoader
 from langchain.document_loaders.max_compute import MaxComputeLoader
 from langchain.document_loaders.mediawikidump import MWDumpLoader
+from langchain.document_loaders.merge import MergedDataLoader
 from langchain.document_loaders.modern_treasury import ModernTreasuryLoader
 from langchain.document_loaders.notebook import NotebookLoader
 from langchain.document_loaders.notion import NotionDirectoryLoader
@@ -75,6 +76,7 @@ from langchain.document_loaders.obsidian import ObsidianLoader
 from langchain.document_loaders.odt import UnstructuredODTLoader
 from langchain.document_loaders.onedrive import OneDriveLoader
 from langchain.document_loaders.onedrive_file import OneDriveFileLoader
+from langchain.document_loaders.open_city_data import OpenCityDataLoader
 from langchain.document_loaders.pdf import (
     MathpixPDFLoader,
     OnlinePDFLoader,
@@ -92,6 +94,7 @@ from langchain.document_loaders.psychic import PsychicLoader
 from langchain.document_loaders.pyspark_dataframe import PySparkDataFrameLoader
 from langchain.document_loaders.python import PythonLoader
 from langchain.document_loaders.readthedocs import ReadTheDocsLoader
+from langchain.document_loaders.recursive_url_loader import RecusiveUrlLoader
 from langchain.document_loaders.reddit import RedditPostsLoader
 from langchain.document_loaders.roam import RoamLoader
 from langchain.document_loaders.rtf import UnstructuredRTFLoader
@@ -200,6 +203,7 @@ __all__ = [
     "MastodonTootsLoader",
     "MathpixPDFLoader",
     "MaxComputeLoader",
+    "MergedDataLoader",
     "ModernTreasuryLoader",
     "NotebookLoader",
     "NotionDBLoader",
@@ -209,6 +213,7 @@ __all__ = [
     "OneDriveLoader",
     "OnlinePDFLoader",
     "OutlookMessageLoader",
+    "OpenCityDataLoader",
     "PDFMinerLoader",
     "PDFMinerPDFasHTMLLoader",
     "PDFPlumberLoader",
@@ -222,6 +227,7 @@ __all__ = [
     "PySparkDataFrameLoader",
     "PythonLoader",
     "ReadTheDocsLoader",
+    "RecusiveUrlLoader",
     "RedditPostsLoader",
     "RoamLoader",
     "S3DirectoryLoader",

langchain/document_loaders/airtable.py

@@ -5,7 +5,7 @@ from langchain.document_loaders.base import BaseLoader
 
 
 class AirtableLoader(BaseLoader):
-    """Loader that loads local airbyte json files."""
+    """Loader for Airtable tables."""
 
     def __init__(self, api_token: str, table_id: str, base_id: str):
         """Initialize with API token and the IDs for table and base"""
@@ -14,7 +14,7 @@ class AirtableLoader(BaseLoader):
         self.base_id = base_id
 
     def lazy_load(self) -> Iterator[Document]:
-        """Load Table."""
+        """Lazy load records from table."""
 
         from pyairtable import Table
 

langchain/document_loaders/blockchain.py

@@ -11,6 +11,8 @@ from langchain.document_loaders.base import BaseLoader
 
 
 class BlockchainType(Enum):
+    """Enumerator of the supported blockchains."""
+
     ETH_MAINNET = "eth-mainnet"
     ETH_GOERLI = "eth-goerli"
     POLYGON_MAINNET = "polygon-mainnet"

langchain/document_loaders/chatgpt.py

@@ -8,6 +8,15 @@ from langchain.document_loaders.base import BaseLoader
 
 
 def concatenate_rows(message: dict, title: str) -> str:
+    """
+    Combine message information in a readable format ready to be used.
+    Args:
+        message: Message to be concatenated
+        title: Title of the conversation
+
+    Returns:
+        Concatenated message
+    """
     if not message:
         return ""
 

langchain/document_loaders/confluence.py

@@ -18,6 +18,8 @@ logger = logging.getLogger(__name__)
 
 
 class ContentFormat(str, Enum):
+    """Enumerator of the content formats of Confluence page."""
+
     STORAGE = "body.storage"
     VIEW = "body.view"
 

langchain/document_loaders/dataframe.py

@@ -1,5 +1,5 @@
 """Load from Dataframe object"""
-from typing import Any, List
+from typing import Any, Iterator, List
 
 from langchain.docstore.document import Document
 from langchain.document_loaders.base import BaseLoader
@@ -19,16 +19,15 @@ class DataFrameLoader(BaseLoader):
         self.data_frame = data_frame
         self.page_content_column = page_content_column
 
-    def load(self) -> List[Document]:
-        """Load from the dataframe."""
-        result = []
-        # For very large dataframes, this needs to yield instead of building a list
-        # but that would require chaging return type to a generator for BaseLoader
-        # and all its subclasses, which is a bigger refactor. Marking as future TODO.
-        # This change will allow us to extend this to Spark and Dask dataframes.
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load records from dataframe."""
+
         for _, row in self.data_frame.iterrows():
             text = row[self.page_content_column]
             metadata = row.to_dict()
             metadata.pop(self.page_content_column)
-            result.append(Document(page_content=text, metadata=metadata))
-        return result
+            yield Document(page_content=text, metadata=metadata)
+
+    def load(self) -> List[Document]:
+        """Load full dataframe."""
+        return list(self.lazy_load())

langchain/document_loaders/docugami.py

@@ -243,7 +243,7 @@ class DocugamiLoader(BaseLoader, BaseModel):
             artifact_url = artifact.get("url")
             artifact_doc = artifact.get("document")
 
-            if artifact_name == f"{project_id}.xml" and artifact_url and artifact_doc:
+            if artifact_name == "report-values.xml" and artifact_url and artifact_doc:
                 doc_id = artifact_doc["id"]
                 metadata: Dict = {}
 
@@ -266,11 +266,11 @@ class DocugamiLoader(BaseLoader, BaseModel):
                     artifact_tree = etree.parse(io.BytesIO(response.content))
                     artifact_root = artifact_tree.getroot()
                     ns = artifact_root.nsmap
-                    entries = artifact_root.xpath("//wp:Entry", namespaces=ns)
+                    entries = artifact_root.xpath("//pr:Entry", namespaces=ns)
                     for entry in entries:
-                        heading = entry.xpath("./wp:Heading", namespaces=ns)[0].text
+                        heading = entry.xpath("./pr:Heading", namespaces=ns)[0].text
                         value = " ".join(
-                            entry.xpath("./wp:Value", namespaces=ns)[0].itertext()
+                            entry.xpath("./pr:Value", namespaces=ns)[0].itertext()
                         ).strip()
                         metadata[heading] = value
                     per_file_metadata[doc_id] = metadata

langchain/document_loaders/embaas.py

@@ -45,6 +45,8 @@ class EmbaasDocumentExtractionParameters(TypedDict):
 
 
 class EmbaasDocumentExtractionPayload(EmbaasDocumentExtractionParameters):
+    """Payload for the Embaas document extraction API."""
+
     bytes: str
     """The base64 encoded bytes of the document to extract text from."""
 

langchain/document_loaders/fauna.py

@@ -5,7 +5,8 @@ from langchain.document_loaders.base import BaseLoader
 
 
 class FaunaLoader(BaseLoader):
-    """
+    """FaunaDB Loader.
+
     Attributes:
         query (str): The FQL query string to execute.
         page_content_field (str): The field that contains the content of each page.

langchain/document_loaders/iugu.py

@@ -17,6 +17,8 @@ IUGU_ENDPOINTS = {
 
 
 class IuguLoader(BaseLoader):
+    """Loader that fetches data from IUGU."""
+
     def __init__(self, resource: str, api_token: Optional[str] = None) -> None:
         self.resource = resource
         api_token = api_token or get_from_env("api_token", "IUGU_API_TOKEN")

langchain/document_loaders/merge.py

@@ -0,0 +1,27 @@
+from typing import Iterator, List
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseLoader
+
+
+class MergedDataLoader(BaseLoader):
+    """Merge documents from a list of loaders"""
+
+    def __init__(self, loaders: List):
+        """Initialize with a list of loaders"""
+        self.loaders = loaders
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load docs from each individual loader."""
+        for loader in self.loaders:
+            # Check if lazy_load is implemented
+            try:
+                data = loader.lazy_load()
+            except NotImplementedError:
+                data = loader.load()
+            for document in data:
+                yield document
+
+    def load(self) -> List[Document]:
+        """Load docs."""
+        return list(self.lazy_load())

langchain/document_loaders/modern_treasury.py

@@ -27,6 +27,8 @@ incoming_payment_details",
 
 
 class ModernTreasuryLoader(BaseLoader):
+    """Loader that fetches data from Modern Treasury."""
+
     def __init__(
         self,
         resource: str,

langchain/document_loaders/open_city_data.py

@@ -0,0 +1,37 @@
+from typing import Iterator, List
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseLoader
+
+
+class OpenCityDataLoader(BaseLoader):
+    """Loader that loads Open city data."""
+
+    def __init__(self, city_id: str, dataset_id: str, limit: int):
+        """Initialize with dataset_id"""
+        """ Example: https://dev.socrata.com/foundry/data.sfgov.org/vw6y-z8j6 """
+        """ e.g., city_id = data.sfgov.org """
+        """ e.g., dataset_id = vw6y-z8j6 """
+        self.city_id = city_id
+        self.dataset_id = dataset_id
+        self.limit = limit
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load records."""
+
+        from sodapy import Socrata
+
+        client = Socrata(self.city_id, None)
+        results = client.get(self.dataset_id, limit=self.limit)
+        for record in results:
+            yield Document(
+                page_content=str(record),
+                metadata={
+                    "source": self.city_id + "_" + self.dataset_id,
+                },
+            )
+
+    def load(self) -> List[Document]:
+        """Load records."""
+
+        return list(self.lazy_load())

langchain/document_loaders/parsers/txt.py

@@ -7,6 +7,8 @@ from langchain.schema import Document
 
 
 class TextParser(BaseBlobParser):
+    """Parser for text blobs."""
+
     def lazy_parse(self, blob: Blob) -> Iterator[Document]:
         """Lazily parse the blob."""
         yield Document(page_content=blob.as_string(), metadata={"source": blob.source})

langchain/document_loaders/recursive_url_loader.py

@@ -0,0 +1,86 @@
+from typing import Iterator, List, Optional, Set
+from urllib.parse import urlparse
+
+import requests
+from bs4 import BeautifulSoup
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseLoader
+
+
+class RecusiveUrlLoader(BaseLoader):
+    """Loader that loads all child links from a given url."""
+
+    def __init__(self, url: str, exclude_dirs: Optional[str] = None) -> None:
+        """Initialize with URL to crawl and any sub-directories to exclude."""
+        self.url = url
+        self.exclude_dirs = exclude_dirs
+
+    def get_child_links_recursive(
+        self, url: str, visited: Optional[Set[str]] = None
+    ) -> Set[str]:
+        """Recursively get all child links starting with the path of the input URL."""
+
+        # Construct the base and parent URLs
+        parsed_url = urlparse(url)
+        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+        parent_url = "/".join(parsed_url.path.split("/")[:-1])
+        current_path = parsed_url.path
+
+        # Add a trailing slash if not present
+        if not base_url.endswith("/"):
+            base_url += "/"
+        if not parent_url.endswith("/"):
+            parent_url += "/"
+
+        # Exclude the root and parent from list
+        visited = set() if visited is None else visited
+
+        # Exclude the links that start with any of the excluded directories
+        if self.exclude_dirs and any(
+            url.startswith(exclude_dir) for exclude_dir in self.exclude_dirs
+        ):
+            return visited
+
+        # Get all links that are relative to the root of the website
+        response = requests.get(url)
+        soup = BeautifulSoup(response.text, "html.parser")
+        all_links = [link.get("href") for link in soup.find_all("a")]
+
+        # Extract only the links that are children of the current URL
+        child_links = list(
+            {
+                link
+                for link in all_links
+                if link and link.startswith(current_path) and link != current_path
+            }
+        )
+
+        # Get absolute path for all root relative links listed
+        absolute_paths = [
+            f"{urlparse(base_url).scheme}://{urlparse(base_url).netloc}{link}"
+            for link in child_links
+        ]
+
+        # Store the visited links and recursively visit the children
+        for link in absolute_paths:
+            # Check all unvisited links
+            if link not in visited:
+                visited.add(link)
+                # If the link is a directory (w/ children) then visit it
+                if link.endswith("/"):
+                    visited.update(self.get_child_links_recursive(link, visited))
+
+        return visited
+
+    def lazy_load(self) -> Iterator[Document]:
+        from langchain.document_loaders import WebBaseLoader
+
+        """Lazy load web pages."""
+        child_links = self.get_child_links_recursive(self.url)
+        loader = WebBaseLoader(list(child_links))
+        return loader.lazy_load()
+
+    def load(self) -> List[Document]:
+        """Load web pages."""
+        return list(self.lazy_load())

langchain/document_loaders/spreedly.py

@@ -20,6 +20,8 @@ SPREEDLY_ENDPOINTS = {
 
 
 class SpreedlyLoader(BaseLoader):
+    """Loader that fetches data from Spreedly API."""
+
     def __init__(self, access_token: str, resource: str) -> None:
         self.access_token = access_token
         self.resource = resource

langchain/document_loaders/stripe.py

@@ -18,6 +18,8 @@ STRIPE_ENDPOINTS = {
 
 
 class StripeLoader(BaseLoader):
+    """Loader that fetches data from Stripe."""
+
     def __init__(self, resource: str, access_token: Optional[str] = None) -> None:
         self.resource = resource
         access_token = access_token or get_from_env(

langchain/document_loaders/web_base.py

@@ -2,7 +2,7 @@
 import asyncio
 import logging
 import warnings
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, Iterator, List, Optional, Union
 
 import aiohttp
 import requests
@@ -197,16 +197,17 @@ class WebBaseLoader(BaseLoader):
 
         return self._scrape(self.web_path, parser)
 
-    def load(self) -> List[Document]:
-        """Load text from the url(s) in web_path."""
-        docs = []
+    def lazy_load(self) -> Iterator[Document]:
+        """Lazy load text from the url(s) in web_path."""
         for path in self.web_paths:
             soup = self._scrape(path)
             text = soup.get_text()
             metadata = _build_metadata(soup, path)
-            docs.append(Document(page_content=text, metadata=metadata))
+            yield Document(page_content=text, metadata=metadata)
 
-        return docs
+    def load(self) -> List[Document]:
+        """Load text from the url(s) in web_path."""
+        return list(self.lazy_load())
 
     def aload(self) -> List[Document]:
         """Load text from the urls in web_path async into Documents."""