fmt

.github/CONTRIBUTING.md

@@ -72,10 +72,9 @@ tell Poetry to use the virtualenv python environment (`poetry config virtualenvs
 
 ### Core vs. Experimental
 
-This repository contains three separate projects:
+This repository contains two separate projects:
 - `langchain`: core langchain code, abstractions, and use cases.
-- `langchain_core`: contain interfaces for key abstractions as well as logic for combining them in chains (LCEL).
-- `langchain_experimental`: see the [Experimental README](https://github.com/langchain-ai/langchain/tree/master/libs/experimental/README.md) for more information.
+- `langchain.experimental`: see the [Experimental README](https://github.com/langchain-ai/langchain/tree/master/libs/experimental/README.md) for more information.
 
 Each of these has its own development environment. Docs are run from the top-level makefile, but development
 is split across separate test & release flows.
@@ -129,24 +128,6 @@ make docker_tests
 
 There are also [integration tests and code-coverage](https://github.com/langchain-ai/langchain/tree/master/libs/langchain/tests/README.md) available.
 
-### Only develop langchain_core or langchain_experimental
-
-If you are only developing `langchain_core` or `langchain_experimental`, you can simply install the dependencies for the respective projects and run tests:
-
-```bash
-cd libs/core
-poetry install --with test
-make test
-```
-
-Or:
-
-```bash
-cd libs/experimental
-poetry install --with test
-make test
-```
-
 ### Formatting and Linting
 
 Run these locally before submitting a PR; the CI system will check also.

README.md

@@ -104,7 +104,3 @@ Please see [here](https://python.langchain.com) for full documentation, which in
 As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
 
 For detailed information on how to contribute, see [here](.github/CONTRIBUTING.md).
-
-## 🌟 Contributors
-
-[![langchain contributors](https://contrib.rocks/image?repo=langchain-ai/langchain&max=2000)](https://github.com/langchain-ai/langchain/graphs/contributors)

docs/.local_build.sh

@@ -9,16 +9,12 @@ SCRIPT_DIR="$(cd "$(dirname "$0")"; pwd)"
 cd "${SCRIPT_DIR}"
 
 mkdir -p ../_dist
-rsync -ruv . ../_dist
+cp -r . ../_dist
 cd ../_dist
 poetry run python scripts/model_feat_table.py
-poetry run nbdoc_build --srcdir docs --pause 0
-mkdir docs/templates
-cp ../templates/docs/INDEX.md docs/templates/index.md
+poetry run nbdoc_build --srcdir docs
 cp ../cookbook/README.md src/pages/cookbook.mdx
 cp ../.github/CONTRIBUTING.md docs/contributing.md
-mkdir -p docs/templates
-cp ../templates/docs/INDEX.md docs/templates/index.md
 wget https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md -O docs/langserve.md
 poetry run python scripts/generate_api_reference_links.py
 yarn install

docs/docs/expression_language/cookbook/index.mdx

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 3
+sidebar_position: 2
 ---
 
 # Cookbook

docs/docs/expression_language/cookbook/multiple_chains.ipynb

@@ -146,7 +146,7 @@
    "source": [
     "### Branching and Merging\n",
     "\n",
-    "You may want the output of one component to be processed by 2 or more other components. [RunnableParallels](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableParallel.html#langchain_core.runnables.base.RunnableParallel) let you split or fork the chain so multiple components can process the input in parallel. Later, other components can join or merge the results to synthesize a final response. This type of chain creates a computation graph that looks like the following:\n",
+    "You may want the output of one component to be processed by 2 or more other components. [RunnableMaps](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.base.RunnableMap.html) let you split or fork the chain so multiple components can process the input in parallel. Later, other components can join or merge the results to synthesize a final response. This type of chain creates a computation graph that looks like the following:\n",
     "\n",
     "```text\n",
     "     Input\n",

docs/docs/expression_language/cookbook/prompt_llm_parser.ipynb

@@ -317,7 +317,7 @@
    "source": [
     "## Simplifying input\n",
     "\n",
-    "To make invocation even simpler, we can add a `RunnableParallel` to take care of creating the prompt input dict for us:"
+    "To make invocation even simpler, we can add a `RunnableMap` to take care of creating the prompt input dict for us:"
    ]
   },
   {
@@ -327,9 +327,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnableParallel, RunnablePassthrough\n",
+    "from langchain.schema.runnable import RunnableMap, RunnablePassthrough\n",
     "\n",
-    "map_ = RunnableParallel(foo=RunnablePassthrough())\n",
+    "map_ = RunnableMap(foo=RunnablePassthrough())\n",
     "chain = (\n",
     "    map_\n",
     "    | prompt\n",

docs/docs/expression_language/cookbook/retrieval.ipynb

@@ -171,7 +171,7 @@
    "outputs": [],
    "source": [
     "from langchain.schema import format_document\n",
-    "from langchain.schema.runnable import RunnableParallel"
+    "from langchain.schema.runnable import RunnableMap"
    ]
   },
   {
@@ -256,7 +256,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "_inputs = RunnableParallel(\n",
+    "_inputs = RunnableMap(\n",
     "    standalone_question=RunnablePassthrough.assign(\n",
     "        chat_history=lambda x: _format_chat_history(x[\"chat_history\"])\n",
     "    )\n",

docs/docs/expression_language/how_to/fallbacks.ipynb

@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "d3e893bf",
    "metadata": {},
    "outputs": [],
@@ -44,24 +44,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "dfdd8bf5",
    "metadata": {},
    "outputs": [],
    "source": [
     "from unittest.mock import patch\n",
     "\n",
-    "import httpx\n",
-    "from openai import RateLimitError\n",
-    "\n",
-    "request = httpx.Request(\"GET\", \"/\")\n",
-    "response = httpx.Response(200, request=request)\n",
-    "error = RateLimitError(\"rate limit\", response=response, body=\"\")"
+    "from openai.error import RateLimitError"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "id": "e6fdffc1",
    "metadata": {},
    "outputs": [],
@@ -74,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 27,
    "id": "584461ab",
    "metadata": {},
    "outputs": [
@@ -88,7 +83,7 @@
    ],
    "source": [
     "# Let's use just the OpenAI LLm first, to show that we run into an error\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(openai_llm.invoke(\"Why did the chicken cross the road?\"))\n",
     "    except:\n",
@@ -111,7 +106,7 @@
    ],
    "source": [
     "# Now let's try with fallbacks to Anthropic\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(llm.invoke(\"Why did the chicken cross the road?\"))\n",
     "    except:\n",
@@ -153,7 +148,7 @@
     "    ]\n",
     ")\n",
     "chain = prompt | llm\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
     "    except:\n",
@@ -291,7 +286,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/functions.ipynb

@@ -82,7 +82,7 @@
    "source": [
     "## Accepting a Runnable Config\n",
     "\n",
-    "Runnable lambdas can optionally accept a [RunnableConfig](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.config.RunnableConfig.html#langchain_core.runnables.config.RunnableConfig), which they can use to pass callbacks, tags, and other configuration information to nested runs."
+    "Runnable lambdas can optionally accept a [RunnableConfig](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.config.RunnableConfig.html?highlight=runnableconfig#langchain.schema.runnable.config.RunnableConfig), which they can use to pass callbacks, tags, and other configuration information to nested runs."
    ]
   },
   {

docs/docs/expression_language/how_to/index.mdx

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 2
+sidebar_position: 1
 ---
 
 # How to

docs/docs/expression_language/how_to/map.ipynb

@@ -104,7 +104,7 @@
    "source": [
     "Here the input to prompt is expected to be a map with keys \"context\" and \"question\". The user input is just the question. So we need to get the context using our retriever and passthrough the user input under the \"question\" key.\n",
     "\n",
-    "Note that when composing a RunnableParallel with another Runnable we don't even need to wrap our dictionary in the RunnableParallel class — the type conversion is handled for us."
+    "Note that when composing a RunnableMap with another Runnable we don't even need to wrap our dictionary in the RunnableMap class — the type conversion is handled for us."
    ]
   },
   {
@@ -114,7 +114,7 @@
    "source": [
     "## Parallelism\n",
     "\n",
-    "RunnableParallel are also useful for running independent processes in parallel, since each Runnable in the map is executed in parallel. For example, we can see our earlier `joke_chain`, `poem_chain` and `map_chain` all have about the same runtime, even though `map_chain` executes both of the other two."
+    "RunnableMaps are also useful for running independent processes in parallel, since each Runnable in the map is executed in parallel. For example, we can see our earlier `joke_chain`, `poem_chain` and `map_chain` all have about the same runtime, even though `map_chain` executes both of the other two."
    ]
   },
   {

docs/docs/expression_language/how_to/message_history.ipynb

@@ -290,9 +290,9 @@
    ],
    "source": [
     "from langchain.schema.messages import HumanMessage\n",
-    "from langchain.schema.runnable import RunnableParallel\n",
+    "from langchain.schema.runnable import RunnableMap\n",
     "\n",
-    "chain = RunnableParallel({\"output_message\": ChatAnthropic(model=\"claude-2\")})\n",
+    "chain = RunnableMap({\"output_message\": ChatAnthropic(model=\"claude-2\")})\n",
     "chain_with_history = RunnableWithMessageHistory(\n",
     "    chain,\n",
     "    lambda session_id: RedisChatMessageHistory(session_id, url=REDIS_URL),\n",

docs/docs/expression_language/index.mdx

@@ -20,7 +20,7 @@ Whenever your LCEL chains have steps that can be executed in parallel (eg if you
 Configure retries and fallbacks for any part of your LCEL chain. This is a great way to make your chains more reliable at scale. We’re currently working on adding streaming support for retries/fallbacks, so you can get the added reliability without any latency cost.
 
 **Access intermediate results**
-For more complex chains it’s often very useful to access the results of intermediate steps even before the final output is produced. This can be used to let end-users know something is happening, or even just to debug your chain. You can stream intermediate results, and it’s available on every [LangServe](/docs/langserve) server.
+For more complex chains it’s often very useful to access the results of intermediate steps even before the final output is produced. This can be used let end-users know something is happening, or even just to debug your chain. You can stream intermediate results, and it’s available on every [LangServe](/docs/langserve) server.
 
 **Input and output schemas**
 Input and output schemas give every LCEL chain Pydantic and JSONSchema schemas inferred from the structure of your chain. This can be used for validation of inputs and outputs, and is an integral part of LangServe.
@@ -30,4 +30,4 @@ As your chains get more and more complex, it becomes increasingly important to u
 With LCEL, **all** steps are automatically logged to [LangSmith](/docs/langsmith/) for maximum observability and debuggability.
 
 **Seamless LangServe deployment integration**
-Any chain created with LCEL can be easily deployed using [LangServe](/docs/langserve).
+Any chain created with LCEL can be easily deployed using [LangServe](/docs/langserve).

docs/docs/expression_language/interface.ipynb

@@ -16,7 +16,7 @@
    "id": "9a9acd2e",
    "metadata": {},
    "source": [
-    "To make it as easy as possible to create custom chains, we've implemented a [\"Runnable\"](https://api.python.langchain.com/en/stable/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable) protocol. The `Runnable` protocol is implemented for most components. \n",
+    "To make it as easy as possible to create custom chains, we've implemented a [\"Runnable\"](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.base.Runnable.html#langchain.schema.runnable.base.Runnable) protocol. The `Runnable` protocol is implemented for most components. \n",
     "This is a standard interface, which makes it easy to define custom chains as well as invoke them in a standard way. \n",
     "The standard interface includes:\n",
     "\n",

docs/docs/get_started/introduction.mdx

@@ -79,7 +79,7 @@ Walkthroughs and techniques for common end-to-end use cases, like:
 ### [Integrations](/docs/integrations/providers/)
 LangChain is part of a rich ecosystem of tools that integrate with our framework and build on top of it. Check out our growing list of [integrations](/docs/integrations/providers/).
 
-### [Guides](/docs/guides/guides/debugging)
+### [Guides](/docs/guides/adapters/openai)
 Best practices for developing with LangChain.
 
 ### [API reference](https://api.python.langchain.com)

docs/docs/get_started/quickstart.mdx

@@ -344,7 +344,7 @@ category_chain = chat_prompt | ChatOpenAI() | CommaSeparatedListOutputParser()
 app = FastAPI(
   title="LangChain Server",
   version="1.0",
-  description="A simple API server using LangChain's Runnable interfaces",
+  description="A simple api server using Langchain's Runnable interfaces",
 )
 
 # 3. Adding chain route

docs/docs/guides/fallbacks.ipynb

@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 18,
    "id": "d3e893bf",
    "metadata": {},
    "outputs": [],
@@ -46,24 +46,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 21,
    "id": "dfdd8bf5",
    "metadata": {},
    "outputs": [],
    "source": [
     "from unittest.mock import patch\n",
     "\n",
-    "import httpx\n",
-    "from openai import RateLimitError\n",
-    "\n",
-    "request = httpx.Request(\"GET\", \"/\")\n",
-    "response = httpx.Response(200, request=request)\n",
-    "error = RateLimitError(\"rate limit\", response=response, body=\"\")"
+    "from openai.error import RateLimitError"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 24,
    "id": "e6fdffc1",
    "metadata": {},
    "outputs": [],
@@ -76,7 +71,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 27,
    "id": "584461ab",
    "metadata": {},
    "outputs": [
@@ -90,7 +85,7 @@
    ],
    "source": [
     "# Let's use just the OpenAI LLm first, to show that we run into an error\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(openai_llm.invoke(\"Why did the chicken cross the road?\"))\n",
     "    except:\n",
@@ -113,7 +108,7 @@
    ],
    "source": [
     "# Now let's try with fallbacks to Anthropic\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(llm.invoke(\"Why did the chicken cross the road?\"))\n",
     "    except:\n",
@@ -155,7 +150,7 @@
     "    ]\n",
     ")\n",
     "chain = prompt | llm\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
     "    except:\n",
@@ -436,7 +431,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/guides/privacy/presidio_data_anonymization/qa_privacy_protection.ipynb

@@ -60,7 +60,7 @@
     "\n",
     " Firstly, the wallet contains my credit card with number 4111 1111 1111 1111, which is registered under my name and linked to my bank account, PL61109010140000071219812874.\n",
     "\n",
-    " Additionally, the wallet had a driver's license - DL No: 999000680 issued to my name. It also houses my Social Security Number, 602-76-4532.\n",
+    " Additionally, the wallet had a driver's license - DL No: 999000680 issued to my name. It also houses my Social Security Number, 602-76-4532. \n",
     "\n",
     " What's more, I had my polish identity card there, with the number ABC123456.\n",
     "\n",
@@ -68,7 +68,7 @@
     "\n",
     " In case any information arises regarding my wallet, please reach out to me on my phone number, 999-888-7777, or through my personal email, johndoe@example.com.\n",
     "\n",
-    " Please consider this information to be highly confidential and respect my privacy.\n",
+    " Please consider this information to be highly confidential and respect my privacy. \n",
     "\n",
     " The bank has been informed about the stolen credit card and necessary actions have been taken from their end. They will be reachable at their official email, support@bankname.com.\n",
     " My representative there is Victoria Cherry (her business phone: 987-654-3210).\n",
@@ -667,11 +667,7 @@
     "from langchain.chat_models.openai import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
     "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import (\n",
-    "    RunnableLambda,\n",
-    "    RunnableParallel,\n",
-    "    RunnablePassthrough,\n",
-    ")\n",
+    "from langchain.schema.runnable import RunnableLambda, RunnableMap, RunnablePassthrough\n",
     "\n",
     "# 6. Create anonymizer chain\n",
     "template = \"\"\"Answer the question based only on the following context:\n",
@@ -684,7 +680,7 @@
     "model = ChatOpenAI(temperature=0.3)\n",
     "\n",
     "\n",
-    "_inputs = RunnableParallel(\n",
+    "_inputs = RunnableMap(\n",
     "    question=RunnablePassthrough(),\n",
     "    # It is important to remember about question anonymization\n",
     "    anonymized_question=RunnableLambda(anonymizer.anonymize),\n",
@@ -886,7 +882,7 @@
     "\n",
     "\n",
     "chain_with_deanonymization = (\n",
-    "    RunnableParallel({\"question\": RunnablePassthrough()})\n",
+    "    RunnableMap({\"question\": RunnablePassthrough()})\n",
     "    | {\n",
     "        \"context\": itemgetter(\"question\")\n",
     "        | retriever\n",

docs/docs/guides/safety/amazon_comprehend_chain.ipynb

@@ -7,9 +7,7 @@
    "source": [
     "# Amazon Comprehend Moderation Chain\n",
     "\n",
-    ">[Amazon Comprehend](https://aws.amazon.com/comprehend/) is a natural-language processing (NLP) service that uses machine learning to uncover valuable insights and connections in text.\n",
-    "\n",
-    "This notebook shows how to use `Amazon Comprehend` to detect and handle `Personally Identifiable Information` (`PII`) and toxicity.\n",
+    "This notebook shows how to use [Amazon Comprehend](https://aws.amazon.com/comprehend/) to detect and handle `Personally Identifiable Information` (`PII`) and toxicity.\n",
     "\n",
     "## Setting up"
    ]
@@ -1419,7 +1417,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/adapters/openai-old.ipynb

@@ -1,285 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "700a516b",
-   "metadata": {},
-   "source": [
-    "# OpenAI Adapter(Old)\n",
-    "\n",
-    "**Please ensure OpenAI library is less than 1.0.0; otherwise, refer to the newer doc [OpenAI Adapter](./openai.ipynb).**\n",
-    "\n",
-    "A lot of people get started with OpenAI but want to explore other models. LangChain's integrations with many model providers make this easy to do so. While LangChain has it's own message and model APIs, we've also made it as easy as possible to explore other models by exposing an adapter to adapt LangChain models to the OpenAI api.\n",
-    "\n",
-    "At the moment this only deals with output and does not return other information (token counts, stop reasons, etc)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "6017f26a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import openai\n",
-    "from langchain.adapters import openai as lc_openai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b522ceda",
-   "metadata": {},
-   "source": [
-    "## ChatCompletion.create"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "1d22eb61",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{\"role\": \"user\", \"content\": \"hi\"}]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d550d3ad",
-   "metadata": {},
-   "source": [
-    "Original OpenAI call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "012d81ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "result = openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
-    ")\n",
-    "result[\"choices\"][0][\"message\"].to_dict_recursive()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "db5b5500",
-   "metadata": {},
-   "source": [
-    "LangChain OpenAI wrapper call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "c67a5ac8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lc_result = lc_openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
-    ")\n",
-    "lc_result[\"choices\"][0][\"message\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "034ba845",
-   "metadata": {},
-   "source": [
-    "Swapping out model providers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "f7c94827",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': ' Hello!'}"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lc_result = lc_openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"claude-2\", temperature=0, provider=\"ChatAnthropic\"\n",
-    ")\n",
-    "lc_result[\"choices\"][0][\"message\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cb3f181d",
-   "metadata": {},
-   "source": [
-    "## ChatCompletion.stream"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f7b8cd18",
-   "metadata": {},
-   "source": [
-    "Original OpenAI call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "fd8cb1ea",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'role': 'assistant', 'content': ''}\n",
-      "{'content': 'Hello'}\n",
-      "{'content': '!'}\n",
-      "{'content': ' How'}\n",
-      "{'content': ' can'}\n",
-      "{'content': ' I'}\n",
-      "{'content': ' assist'}\n",
-      "{'content': ' you'}\n",
-      "{'content': ' today'}\n",
-      "{'content': '?'}\n",
-      "{}\n"
-     ]
-    }
-   ],
-   "source": [
-    "for c in openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
-    "):\n",
-    "    print(c[\"choices\"][0][\"delta\"].to_dict_recursive())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0b2a076b",
-   "metadata": {},
-   "source": [
-    "LangChain OpenAI wrapper call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "id": "9521218c",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'role': 'assistant', 'content': ''}\n",
-      "{'content': 'Hello'}\n",
-      "{'content': '!'}\n",
-      "{'content': ' How'}\n",
-      "{'content': ' can'}\n",
-      "{'content': ' I'}\n",
-      "{'content': ' assist'}\n",
-      "{'content': ' you'}\n",
-      "{'content': ' today'}\n",
-      "{'content': '?'}\n",
-      "{}\n"
-     ]
-    }
-   ],
-   "source": [
-    "for c in lc_openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
-    "):\n",
-    "    print(c[\"choices\"][0][\"delta\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0fc39750",
-   "metadata": {},
-   "source": [
-    "Swapping out model providers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "68f0214e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'role': 'assistant', 'content': ' Hello'}\n",
-      "{'content': '!'}\n",
-      "{}\n"
-     ]
-    }
-   ],
-   "source": [
-    "for c in lc_openai.ChatCompletion.create(\n",
-    "    messages=messages,\n",
-    "    model=\"claude-2\",\n",
-    "    temperature=0,\n",
-    "    stream=True,\n",
-    "    provider=\"ChatAnthropic\",\n",
-    "):\n",
-    "    print(c[\"choices\"][0][\"delta\"])"
-   ]
-  }
- ],
- "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.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/adapters/openai.ipynb

@@ -7,8 +7,6 @@
    "source": [
     "# OpenAI Adapter\n",
     "\n",
-    "**Please ensure OpenAI library is version 1.0.0 or higher; otherwise, refer to the older doc [OpenAI Adapter(Old)](./openai-old.ipynb).**\n",
-    "\n",
     "A lot of people get started with OpenAI but want to explore other models. LangChain's integrations with many model providers make this easy to do so. While LangChain has it's own message and model APIs, we've also made it as easy as possible to explore other models by exposing an adapter to adapt LangChain models to the OpenAI api.\n",
     "\n",
     "At the moment this only deals with output and does not return other information (token counts, stop reasons, etc)."
@@ -30,12 +28,12 @@
    "id": "b522ceda",
    "metadata": {},
    "source": [
-    "## chat.completions.create"
+    "## ChatCompletion.create"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 29,
    "id": "1d22eb61",
    "metadata": {},
    "outputs": [],
@@ -53,29 +51,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 15,
    "id": "012d81ae",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'content': 'Hello! How can I assist you today?',\n",
-       " 'role': 'assistant',\n",
-       " 'function_call': None,\n",
-       " 'tool_calls': None}"
+       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "result = openai.chat.completions.create(\n",
+    "result = openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
     ")\n",
-    "result.choices[0].message.model_dump()"
+    "result[\"choices\"][0][\"message\"].to_dict_recursive()"
    ]
   },
   {
@@ -88,48 +83,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 17,
    "id": "c67a5ac8",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I help you today?'}"
+       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "lc_result = lc_openai.chat.completions.create(\n",
+    "lc_result = lc_openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
     ")\n",
-    "\n",
-    "lc_result.choices[0].message  # Attribute access"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "37a6e461-8608-47f6-ac45-12ad753c062a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I help you today?'}"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lc_result[\"choices\"][0][\"message\"]  # Also compatible with index access"
+    "lc_result[\"choices\"][0][\"message\"]"
    ]
   },
   {
@@ -142,26 +115,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 19,
    "id": "f7c94827",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
+       "{'role': 'assistant', 'content': ' Hello!'}"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "lc_result = lc_openai.chat.completions.create(\n",
+    "lc_result = lc_openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"claude-2\", temperature=0, provider=\"ChatAnthropic\"\n",
     ")\n",
-    "lc_result.choices[0].message"
+    "lc_result[\"choices\"][0][\"message\"]"
    ]
   },
   {
@@ -169,7 +142,7 @@
    "id": "cb3f181d",
    "metadata": {},
    "source": [
-    "## chat.completions.stream"
+    "## ChatCompletion.stream"
    ]
   },
   {
@@ -182,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 24,
    "id": "fd8cb1ea",
    "metadata": {},
    "outputs": [
@@ -190,25 +163,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'content': '', 'function_call': None, 'role': 'assistant', 'tool_calls': None}\n",
-      "{'content': 'Hello', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': '!', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' How', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' can', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' I', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' assist', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' you', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' today', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': '?', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': None, 'function_call': None, 'role': None, 'tool_calls': None}\n"
+      "{'role': 'assistant', 'content': ''}\n",
+      "{'content': 'Hello'}\n",
+      "{'content': '!'}\n",
+      "{'content': ' How'}\n",
+      "{'content': ' can'}\n",
+      "{'content': ' I'}\n",
+      "{'content': ' assist'}\n",
+      "{'content': ' you'}\n",
+      "{'content': ' today'}\n",
+      "{'content': '?'}\n",
+      "{}\n"
      ]
     }
    ],
    "source": [
-    "for c in openai.chat.completions.create(\n",
+    "for c in openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
     "):\n",
-    "    print(c.choices[0].delta.model_dump())"
+    "    print(c[\"choices\"][0][\"delta\"].to_dict_recursive())"
    ]
   },
   {
@@ -221,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 30,
    "id": "9521218c",
    "metadata": {},
    "outputs": [
@@ -244,10 +217,10 @@
     }
    ],
    "source": [
-    "for c in lc_openai.chat.completions.create(\n",
+    "for c in lc_openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
     "):\n",
-    "    print(c.choices[0].delta)"
+    "    print(c[\"choices\"][0][\"delta\"])"
    ]
   },
   {
@@ -260,7 +233,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 31,
    "id": "68f0214e",
    "metadata": {},
    "outputs": [
@@ -268,22 +241,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'role': 'assistant', 'content': ''}\n",
-      "{'content': 'Hello'}\n",
+      "{'role': 'assistant', 'content': ' Hello'}\n",
       "{'content': '!'}\n",
-      "{'content': ' How'}\n",
-      "{'content': ' can'}\n",
-      "{'content': ' I'}\n",
-      "{'content': ' assist'}\n",
-      "{'content': ' you'}\n",
-      "{'content': ' today'}\n",
-      "{'content': '?'}\n",
       "{}\n"
      ]
     }
    ],
    "source": [
-    "for c in lc_openai.chat.completions.create(\n",
+    "for c in lc_openai.ChatCompletion.create(\n",
     "    messages=messages,\n",
     "    model=\"claude-2\",\n",
     "    temperature=0,\n",
@@ -310,7 +275,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/bedrock.ipynb

@@ -7,15 +7,7 @@
    "source": [
     "# Bedrock Chat\n",
     "\n",
-    ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of \n",
-    "> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, \n",
-    "> `Meta`, `Stability AI`, and `Amazon` via a single API, along with a broad set of capabilities you need to \n",
-    "> build generative AI applications with security, privacy, and responsible AI. Using `Amazon Bedrock`, \n",
-    "> you can easily experiment with and evaluate top FMs for your use case, privately customize them with \n",
-    "> your data using techniques such as fine-tuning and `Retrieval Augmented Generation` (`RAG`), and build \n",
-    "> agents that execute tasks using your enterprise systems and data sources. Since `Amazon Bedrock` is \n",
-    "> serverless, you don't have to manage any infrastructure, and you can securely integrate and deploy \n",
-    "> generative AI capabilities into your applications using the AWS services you are already familiar with.\n"
+    "[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that makes FMs from leading AI startups and Amazon available via an API, so you can choose from a wide range of FMs to find the model that is best suited for your use case"
    ]
   },
   {
@@ -139,7 +131,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/ernie.ipynb

@@ -7,19 +7,7 @@
     "# ERNIE-Bot Chat\n",
     "\n",
     "[ERNIE-Bot](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/jlil56u11) is a large language model developed by Baidu, covering a huge amount of Chinese data.\n",
-    "This notebook covers how to get started with ErnieBot chat models.\n",
-    "\n",
-    "**Note:** We recommend users using this class to switch to [Baidu Qianfan](./baidu_qianfan_endpoint). they are 3 why we recommend users to use `QianfanChatEndpoint`:\n",
-    "1. `QianfanChatEndpoint` support more LLM in the Qianfan platform.\n",
-    "2. `QianfanChatEndpoint` support streaming mode.\n",
-    "3. `QianfanChatEndpoint` support function calling usgage.\n",
-    "\n",
-    "Some tips for migration:\n",
-    "- change `ernie_client_id` to `qianfan_ak`, also change `ernie_client_secret` to `qianfan_sk`.\n",
-    "- install `qianfan` package. \n",
-    "    ```\n",
-    "    pip install qianfan\n",
-    "    ```"
+    "This notebook covers how to get started with ErnieBot chat models."
    ]
   },
   {

docs/docs/integrations/chat/ollama.ipynb

@@ -119,159 +119,6 @@
     "chat_model(messages)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Extraction\n",
-    " \n",
-    "Update your version of Ollama and supply the [`format`](https://github.com/jmorganca/ollama/blob/main/docs/api.md#json-mode) flag.\n",
-    "\n",
-    "We can enforce the model to produce JSON.\n",
-    "\n",
-    "**Note:** You can also try out the experimental [OllamaFunctions](https://python.langchain.com/docs/integrations/chat/ollama_functions) wrapper for convenience."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.callbacks.manager import CallbackManager\n",
-    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
-    "from langchain.chat_models import ChatOllama\n",
-    "\n",
-    "chat_model = ChatOllama(\n",
-    "    model=\"llama2\",\n",
-    "    format=\"json\",\n",
-    "    callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Sure! Here's a JSON response with the colors of the sky at different times of the day:\n",
-      " Begriffe und Abkürzungen:\n",
-      "\n",
-      "* `time`: The time of day (in 24-hour format)\n",
-      "* `sky_color`: The color of the sky at that time (as a hex code)\n",
-      "\n",
-      "Here are the colors of the sky at different times of the day:\n",
-      "```json\n",
-      "[\n",
-      "  {\n",
-      "    \"time\": \"6am\",\n",
-      "    \"sky_color\": \"#0080c0\"\n",
-      "  },\n",
-      "  {\n",
-      "    \"time\": \"9am\",\n",
-      "    \"sky_color\": \"#3498db\"\n",
-      "  },\n",
-      "  {\n",
-      "    \"time\": \"12pm\",\n",
-      "    \"sky_color\": \"#ef7c00\"\n",
-      "  },\n",
-      "  {\n",
-      "    \"time\": \"3pm\",\n",
-      "    \"sky_color\": \"#9564b6\"\n",
-      "  },\n",
-      "  {\n",
-      "    \"time\": \"6pm\",\n",
-      "    \"sky_color\": \"#e78ac3\"\n",
-      "  },\n",
-      "  {\n",
-      "    \"time\": \"9pm\",\n",
-      "    \"sky_color\": \"#5f006a\"\n",
-      "  }\n",
-      "]\n",
-      "```\n",
-      "In this response, the `time` property is a string in 24-hour format, representing the time of day. The `sky_color` property is a hex code representing the color of the sky at that time. For example, at 6am, the sky is blue (#0080c0), while at 9pm, it's dark blue (#5f006a)."
-     ]
-    }
-   ],
-   "source": [
-    "from langchain.schema import HumanMessage\n",
-    "\n",
-    "messages = [\n",
-    "    HumanMessage(\n",
-    "        content=\"What color is the sky at different times of the day? Respond using JSON\"\n",
-    "    )\n",
-    "]\n",
-    "\n",
-    "chat_model_response = chat_model(messages)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " Sure! Based on the JSON schema you provided, here's the information we can gather about a person named John who is 35 years old and loves pizza:\n",
-      "\n",
-      "**Name:** John\n",
-      "\n",
-      "**Age:** 35 (integer)\n",
-      "\n",
-      "**Favorite food:** Pizza (string)\n",
-      "\n",
-      "So, the JSON object for John would look like this:\n",
-      "```json\n",
-      "{\n",
-      "  \"name\": \"John\",\n",
-      "  \"age\": 35,\n",
-      "  \"fav_food\": \"pizza\"\n",
-      "}\n",
-      "```\n",
-      "Note that we cannot provide additional information about John beyond what is specified in the schema. For example, we do not have any information about his gender, occupation, or address, as those fields are not included in the schema."
-     ]
-    }
-   ],
-   "source": [
-    "import json\n",
-    "\n",
-    "from langchain.schema import HumanMessage\n",
-    "\n",
-    "json_schema = {\n",
-    "    \"title\": \"Person\",\n",
-    "    \"description\": \"Identifying information about a person.\",\n",
-    "    \"type\": \"object\",\n",
-    "    \"properties\": {\n",
-    "        \"name\": {\"title\": \"Name\", \"description\": \"The person's name\", \"type\": \"string\"},\n",
-    "        \"age\": {\"title\": \"Age\", \"description\": \"The person's age\", \"type\": \"integer\"},\n",
-    "        \"fav_food\": {\n",
-    "            \"title\": \"Fav Food\",\n",
-    "            \"description\": \"The person's favorite food\",\n",
-    "            \"type\": \"string\",\n",
-    "        },\n",
-    "    },\n",
-    "    \"required\": [\"name\", \"age\"],\n",
-    "}\n",
-    "\n",
-    "messages = [\n",
-    "    HumanMessage(\n",
-    "        content=\"Please tell me about a person using the following JSON schema:\"\n",
-    "    ),\n",
-    "    HumanMessage(content=json.dumps(json_schema, indent=2)),\n",
-    "    HumanMessage(\n",
-    "        content=\"Now, considering the schema, tell me about a person named John who is 35 years old and loves pizza.\"\n",
-    "    ),\n",
-    "]\n",
-    "\n",
-    "chat_model_response = chat_model(messages)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -528,5 +375,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 2
 }

docs/docs/integrations/chat/ollama_functions.ipynb

@@ -1,171 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Ollama Functions\n",
-    "\n",
-    "This notebook shows how to use an experimental wrapper around Ollama that gives it the same API as OpenAI Functions.\n",
-    "\n",
-    "Note that more powerful and capable models will perform better with complex schema and/or multiple functions. The examples below use Mistral.\n",
-    "For a complete list of supported models and model variants, see the [Ollama model library](https://ollama.ai/library).\n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "Follow [these instructions](https://github.com/jmorganca/ollama) to set up and run a local Ollama instance.\n",
-    "\n",
-    "## Usage\n",
-    "\n",
-    "You can initialize OllamaFunctions in a similar way to how you'd initialize a standard ChatOllama instance:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_experimental.llms.ollama_functions import OllamaFunctions\n",
-    "\n",
-    "model = OllamaFunctions(model=\"mistral\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can then bind functions defined with JSON Schema parameters and a `function_call` parameter to force the model to call the given function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = model.bind(\n",
-    "    functions=[\n",
-    "        {\n",
-    "            \"name\": \"get_current_weather\",\n",
-    "            \"description\": \"Get the current weather in a given location\",\n",
-    "            \"parameters\": {\n",
-    "                \"type\": \"object\",\n",
-    "                \"properties\": {\n",
-    "                    \"location\": {\n",
-    "                        \"type\": \"string\",\n",
-    "                        \"description\": \"The city and state, \" \"e.g. San Francisco, CA\",\n",
-    "                    },\n",
-    "                    \"unit\": {\n",
-    "                        \"type\": \"string\",\n",
-    "                        \"enum\": [\"celsius\", \"fahrenheit\"],\n",
-    "                    },\n",
-    "                },\n",
-    "                \"required\": [\"location\"],\n",
-    "            },\n",
-    "        }\n",
-    "    ],\n",
-    "    function_call={\"name\": \"get_current_weather\"},\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Calling a function with this model then results in JSON output matching the provided schema:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='', additional_kwargs={'function_call': {'name': 'get_current_weather', 'arguments': '{\"location\": \"Boston, MA\", \"unit\": \"celsius\"}'}})"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.schema import HumanMessage\n",
-    "\n",
-    "model.invoke(\"what is the weather in Boston?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using for extraction\n",
-    "\n",
-    "One useful thing you can do with function calling here is extracting properties from a given input in a structured format:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'name': 'Alex', 'height': 5, 'hair_color': 'blonde'},\n",
-       " {'name': 'Claudia', 'height': 6, 'hair_color': 'brunette'}]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.chains import create_extraction_chain\n",
-    "\n",
-    "# Schema\n",
-    "schema = {\n",
-    "    \"properties\": {\n",
-    "        \"name\": {\"type\": \"string\"},\n",
-    "        \"height\": {\"type\": \"integer\"},\n",
-    "        \"hair_color\": {\"type\": \"string\"},\n",
-    "    },\n",
-    "    \"required\": [\"name\", \"height\"],\n",
-    "}\n",
-    "\n",
-    "# Input\n",
-    "input = \"\"\"Alex is 5 feet tall. Claudia is 1 feet taller than Alex and jumps higher than him. Claudia is a brunette and Alex is blonde.\"\"\"\n",
-    "\n",
-    "# Run chain\n",
-    "llm = OllamaFunctions(model=\"mistral\", temperature=0)\n",
-    "chain = create_extraction_chain(schema, llm)\n",
-    "chain.run(input)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/chat/volcengine_maas.ipynb

@@ -1,177 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "404758628c7b20f6",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "# Volc Engine Maas\n",
-    "\n",
-    "This notebook provides you with a guide on how to get started with volc engine maas chat models."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2cd2ebd9d023c4d3",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# Install the package\n",
-    "!pip install volcengine"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "51e7f967cb78f5b7",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:43:37.131292Z",
-     "start_time": "2023-11-27T10:43:37.127250Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.chat_models import VolcEngineMaasChat\n",
-    "from langchain.schema import HumanMessage"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "139667d44689f9e0",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:43:49.911867Z",
-     "start_time": "2023-11-27T10:43:49.908329Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "chat = VolcEngineMaasChat(volc_engine_maas_ak=\"your ak\", volc_engine_maas_sk=\"your sk\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e84ebc4feedcc739",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "or you can set access_key and secret_key in your environment variables\n",
-    "```bash\n",
-    "export VOLC_ACCESSKEY=YOUR_AK\n",
-    "export VOLC_SECRETKEY=YOUR_SK\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "35da18414ad17aa0",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:43:53.101852Z",
-     "start_time": "2023-11-27T10:43:51.741041Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "AIMessage(content='好的，这是一个笑话：\\n\\n为什么鸟儿不会玩电脑游戏？\\n\\n因为它们没有翅膀！')"
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chat([HumanMessage(content=\"给我讲个笑话\")])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a55e5a9ed80ec49e",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "# volc engine maas chat with stream"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "b4e4049980ac68ef",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:43:55.120405Z",
-     "start_time": "2023-11-27T10:43:55.114707Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "chat = VolcEngineMaasChat(\n",
-    "    volc_engine_maas_ak=\"your ak\",\n",
-    "    volc_engine_maas_sk=\"your sk\",\n",
-    "    streaming=True,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "id": "fe709a4ffb5c811d",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:43:58.775294Z",
-     "start_time": "2023-11-27T10:43:56.799401Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "AIMessage(content='好的，这是一个笑话：\\n\\n三岁的女儿说她会造句了，妈妈让她用“年轻”造句，女儿说：“妈妈减肥，一年轻了好几斤”。')"
-     },
-     "execution_count": 28,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chat([HumanMessage(content=\"给我讲个笑话\")])"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 2
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/chat_loaders/discord.ipynb

@@ -30,7 +30,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Writing discord_chats.txt\n"
+      "Overwriting discord_chats.txt\n"
      ]
     }
    ],
@@ -240,14 +240,14 @@
     {
      "data": {
       "text/plain": [
-       "[{'messages': [AIMessage(content='Love music! Do you like jazz?', additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': '08/15/2023 11:10 AM\\n'}]}),\n",
-       "   HumanMessage(content='Yes! Jazz is fantastic. Ever heard this one?\\nWebsite\\nListen to classic jazz track...', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': '08/15/2023 9:27 PM\\n'}]}),\n",
-       "   AIMessage(content='Indeed! Great choice. 🎷', additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': 'Yesterday at 5:03 AM\\n'}]}),\n",
-       "   HumanMessage(content='Thanks! How about some virtual sightseeing?\\nWebsite\\nVirtual tour of famous landmarks...', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': 'Yesterday at 5:23 AM\\n'}]}),\n",
-       "   AIMessage(content=\"Sounds fun! Let's explore.\", additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': 'Today at 2:38 PM\\n'}]}),\n",
-       "   HumanMessage(content='Enjoy the tour! See you around.', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': 'Today at 2:56 PM\\n'}]}),\n",
-       "   AIMessage(content='Thank you! Goodbye! 👋', additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': 'Today at 3:00 PM\\n'}]}),\n",
-       "   HumanMessage(content='Farewell! Happy exploring.', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': 'Today at 3:02 PM\\n'}]})]}]"
+       "[{'messages': [AIMessage(content='Love music! Do you like jazz?', additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': '08/15/2023 11:10 AM\\n'}]}, example=False),\n",
+       "   HumanMessage(content='Yes! Jazz is fantastic. Ever heard this one?\\nWebsite\\nListen to classic jazz track...', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': '08/15/2023 9:27 PM\\n'}]}, example=False),\n",
+       "   AIMessage(content='Indeed! Great choice. 🎷', additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': 'Yesterday at 5:03 AM\\n'}]}, example=False),\n",
+       "   HumanMessage(content='Thanks! How about some virtual sightseeing?\\nWebsite\\nVirtual tour of famous landmarks...', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': 'Yesterday at 5:23 AM\\n'}]}, example=False),\n",
+       "   AIMessage(content=\"Sounds fun! Let's explore.\", additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': 'Today at 2:38 PM\\n'}]}, example=False),\n",
+       "   HumanMessage(content='Enjoy the tour! See you around.', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': 'Today at 2:56 PM\\n'}]}, example=False),\n",
+       "   AIMessage(content='Thank you! Goodbye! 👋', additional_kwargs={'sender': 'talkingtower', 'events': [{'message_time': 'Today at 3:00 PM\\n'}]}, example=False),\n",
+       "   HumanMessage(content='Farewell! Happy exploring.', additional_kwargs={'sender': 'reporterbob', 'events': [{'message_time': 'Today at 3:02 PM\\n'}]}, example=False)]}]"
       ]
      },
      "execution_count": 5,
@@ -279,7 +279,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Thank you! Have a great day!"
+      "Thank you! Have a wonderful day! 🌟"
      ]
     }
    ],
@@ -317,7 +317,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.2"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat_loaders/facebook.ipynb

@@ -32,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "647f2158-a42e-4634-b283-b8492caf542a",
    "metadata": {},
    "outputs": [
@@ -91,7 +91,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "a0869bc6",
    "metadata": {},
    "outputs": [],
@@ -114,7 +114,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "id": "f61ee277",
    "metadata": {},
    "outputs": [],
@@ -126,19 +126,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "id": "ec466ad7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[HumanMessage(content=\"Hi Hermione! How's your summer going so far?\", additional_kwargs={'sender': 'Harry Potter'}),\n",
-       " HumanMessage(content=\"Harry! Lovely to hear from you. My summer is going well, though I do miss everyone. I'm spending most of my time going through my books and researching fascinating new topics. How about you?\", additional_kwargs={'sender': 'Hermione Granger'}),\n",
-       " HumanMessage(content=\"I miss you all too. The Dursleys are being their usual unpleasant selves but I'm getting by. At least I can practice some spells in my room without them knowing. Let me know if you find anything good in your researching!\", additional_kwargs={'sender': 'Harry Potter'})]"
+       "[HumanMessage(content=\"Hi Hermione! How's your summer going so far?\", additional_kwargs={'sender': 'Harry Potter'}, example=False),\n",
+       " HumanMessage(content=\"Harry! Lovely to hear from you. My summer is going well, though I do miss everyone. I'm spending most of my time going through my books and researching fascinating new topics. How about you?\", additional_kwargs={'sender': 'Hermione Granger'}, example=False),\n",
+       " HumanMessage(content=\"I miss you all too. The Dursleys are being their usual unpleasant selves but I'm getting by. At least I can practice some spells in my room without them knowing. Let me know if you find anything good in your researching!\", additional_kwargs={'sender': 'Harry Potter'}, example=False)]"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -150,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 10,
    "id": "8a3ee473",
    "metadata": {},
    "outputs": [],
@@ -162,7 +162,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 12,
    "id": "9f41e122",
    "metadata": {},
    "outputs": [
@@ -172,7 +172,7 @@
        "9"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -196,7 +196,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 14,
    "id": "5a78030d-b757-4bbe-8a6c-841056f46df7",
    "metadata": {},
    "outputs": [],
@@ -209,7 +209,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 17,
    "id": "ff35b028-78bf-4c5b-9ec6-939fe67de7f7",
    "metadata": {},
    "outputs": [],
@@ -220,19 +220,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 19,
    "id": "4b11906e-a496-4d01-9f0d-1938c14147bf",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[AIMessage(content=\"Professor Snape, I was hoping I could speak with you for a moment about something that's been concerning me lately.\", additional_kwargs={'sender': 'Harry Potter'}),\n",
-       " HumanMessage(content=\"What is it, Potter? I'm quite busy at the moment.\", additional_kwargs={'sender': 'Severus Snape'}),\n",
-       " AIMessage(content=\"I apologize for the interruption, sir. I'll be brief. I've noticed some strange activity around the school grounds at night. I saw a cloaked figure lurking near the Forbidden Forest last night. I'm worried someone may be plotting something sinister.\", additional_kwargs={'sender': 'Harry Potter'})]"
+       "[AIMessage(content=\"Professor Snape, I was hoping I could speak with you for a moment about something that's been concerning me lately.\", additional_kwargs={'sender': 'Harry Potter'}, example=False),\n",
+       " HumanMessage(content=\"What is it, Potter? I'm quite busy at the moment.\", additional_kwargs={'sender': 'Severus Snape'}, example=False),\n",
+       " AIMessage(content=\"I apologize for the interruption, sir. I'll be brief. I've noticed some strange activity around the school grounds at night. I saw a cloaked figure lurking near the Forbidden Forest last night. I'm worried someone may be plotting something sinister.\", additional_kwargs={'sender': 'Harry Potter'}, example=False)]"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -253,7 +253,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 20,
    "id": "21372331",
    "metadata": {},
    "outputs": [],
@@ -263,7 +263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 38,
    "id": "92c5ae7a",
    "metadata": {},
    "outputs": [
@@ -282,7 +282,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 33,
    "id": "dfcbd181",
    "metadata": {
     "scrolled": true
@@ -299,7 +299,7 @@
        "  'content': \"I apologize for the interruption, sir. I'll be brief. I've noticed some strange activity around the school grounds at night. I saw a cloaked figure lurking near the Forbidden Forest last night. I'm worried someone may be plotting something sinister.\"}]"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 33,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -321,7 +321,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 42,
    "id": "13cd290a-b1e9-4686-bb5e-d99de8b8612b",
    "metadata": {},
    "outputs": [
@@ -331,7 +331,7 @@
        "100"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 42,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -364,7 +364,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 43,
    "id": "95ce3f63-3c80-44b2-9060-534ad74e16fa",
    "metadata": {},
    "outputs": [],
@@ -374,7 +374,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 58,
    "id": "ab9e28eb",
    "metadata": {},
    "outputs": [
@@ -382,7 +382,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "File file-ULumAXLEFw3vB6bb9uy6DNVC ready after 0.00 seconds.\n"
+      "File file-zCyNBeg4snpbBL7VkvsuhCz8 ready afer 30.55 seconds.\n"
      ]
     }
    ],
@@ -399,16 +399,16 @@
     "    my_file.write((json.dumps({\"messages\": m}) + \"\\n\").encode(\"utf-8\"))\n",
     "\n",
     "my_file.seek(0)\n",
-    "training_file = openai.files.create(file=my_file, purpose=\"fine-tune\")\n",
+    "training_file = openai.File.create(file=my_file, purpose=\"fine-tune\")\n",
     "\n",
     "# OpenAI audits each training file for compliance reasons.\n",
     "# This make take a few minutes\n",
-    "status = openai.files.retrieve(training_file.id).status\n",
+    "status = openai.File.retrieve(training_file.id).status\n",
     "start_time = time.time()\n",
     "while status != \"processed\":\n",
     "    print(f\"Status=[{status}]... {time.time() - start_time:.2f}s\", end=\"\\r\", flush=True)\n",
     "    time.sleep(5)\n",
-    "    status = openai.files.retrieve(training_file.id).status\n",
+    "    status = openai.File.retrieve(training_file.id).status\n",
     "print(f\"File {training_file.id} ready after {time.time() - start_time:.2f} seconds.\")"
    ]
   },
@@ -422,12 +422,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 59,
    "id": "3f451425",
    "metadata": {},
    "outputs": [],
    "source": [
-    "job = openai.fine_tuning.jobs.create(\n",
+    "job = openai.FineTuningJob.create(\n",
     "    training_file=training_file.id,\n",
     "    model=\"gpt-3.5-turbo\",\n",
     ")"
@@ -443,7 +443,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 60,
    "id": "bac1637a-c087-4523-ade1-c47f9bf4c6f4",
    "metadata": {},
    "outputs": [
@@ -451,23 +451,23 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Status=[running]... 874.29s. 56.93s\r"
+      "Status=[running]... 908.87s\r"
      ]
     }
    ],
    "source": [
-    "status = openai.fine_tuning.jobs.retrieve(job.id).status\n",
+    "status = openai.FineTuningJob.retrieve(job.id).status\n",
     "start_time = time.time()\n",
     "while status != \"succeeded\":\n",
     "    print(f\"Status=[{status}]... {time.time() - start_time:.2f}s\", end=\"\\r\", flush=True)\n",
     "    time.sleep(5)\n",
-    "    job = openai.fine_tuning.jobs.retrieve(job.id)\n",
+    "    job = openai.FineTuningJob.retrieve(job.id)\n",
     "    status = job.status"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 66,
    "id": "535895e1-bc69-40e5-82ed-e24ed2baeeee",
    "metadata": {},
    "outputs": [
@@ -475,7 +475,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "ft:gpt-3.5-turbo-0613:personal::8QnAzWMr\n"
+      "ft:gpt-3.5-turbo-0613:personal::7rDwkaOq\n"
      ]
     }
    ],
@@ -495,7 +495,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 67,
    "id": "3925d60d",
    "metadata": {},
    "outputs": [],
@@ -510,7 +510,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 69,
    "id": "7190cf2e-ab34-4ceb-bdad-45f24f069c29",
    "metadata": {},
    "outputs": [],
@@ -529,7 +529,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 72,
    "id": "f02057e9-f914-40b1-9c9d-9432ff594b98",
    "metadata": {},
    "outputs": [
@@ -537,7 +537,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "I'm taking Charms, Defense Against the Dark Arts, Herbology, Potions, Transfiguration, and Ancient Runes. How about you?"
+      "The usual - Potions, Transfiguration, Defense Against the Dark Arts. What about you?"
      ]
     }
    ],
@@ -545,6 +545,14 @@
     "for tok in chain.stream({\"input\": \"What classes are you taking?\"}):\n",
     "    print(tok, end=\"\", flush=True)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "35331503-3cc6-4d64-955e-64afe6b5fef3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -563,7 +571,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat_loaders/imessage.ipynb

@@ -243,16 +243,16 @@
     "    my_file.write((json.dumps({\"messages\": m}) + \"\\n\").encode(\"utf-8\"))\n",
     "\n",
     "my_file.seek(0)\n",
-    "training_file = openai.files.create(file=my_file, purpose=\"fine-tune\")\n",
+    "training_file = openai.File.create(file=my_file, purpose=\"fine-tune\")\n",
     "\n",
     "# OpenAI audits each training file for compliance reasons.\n",
     "# This make take a few minutes\n",
-    "status = openai.files.retrieve(training_file.id).status\n",
+    "status = openai.File.retrieve(training_file.id).status\n",
     "start_time = time.time()\n",
     "while status != \"processed\":\n",
     "    print(f\"Status=[{status}]... {time.time() - start_time:.2f}s\", end=\"\\r\", flush=True)\n",
     "    time.sleep(5)\n",
-    "    status = openai.files.retrieve(training_file.id).status\n",
+    "    status = openai.File.retrieve(training_file.id).status\n",
     "print(f\"File {training_file.id} ready after {time.time() - start_time:.2f} seconds.\")"
    ]
   },
@@ -271,7 +271,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "job = openai.fine_tuning.jobs.create(\n",
+    "job = openai.FineTuningJob.create(\n",
     "    training_file=training_file.id,\n",
     "    model=\"gpt-3.5-turbo\",\n",
     ")"
@@ -300,12 +300,12 @@
     }
    ],
    "source": [
-    "status = openai.fine_tuning.jobs.retrieve(job.id).status\n",
+    "status = openai.FineTuningJob.retrieve(job.id).status\n",
     "start_time = time.time()\n",
     "while status != \"succeeded\":\n",
     "    print(f\"Status=[{status}]... {time.time() - start_time:.2f}s\", end=\"\\r\", flush=True)\n",
     "    time.sleep(5)\n",
-    "    job = openai.fine_tuning.jobs.retrieve(job.id)\n",
+    "    job = openai.FineTuningJob.retrieve(job.id)\n",
     "    status = job.status"
    ]
   },
@@ -416,7 +416,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.2"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat_loaders/langsmith_dataset.ipynb

@@ -123,7 +123,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 10,
    "id": "817bc077-c18a-473b-94a4-a7d810d583a8",
    "metadata": {},
    "outputs": [],
@@ -145,7 +145,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 11,
    "id": "9e5ac127-b094-4584-9159-5a6d3d7315c7",
    "metadata": {},
    "outputs": [],
@@ -166,7 +166,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "11d19e28-be49-4801-8065-1a58d13cd192",
    "metadata": {},
    "outputs": [
@@ -174,7 +174,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Status=[running]... 429.55s. 46.34s\r"
+      "Status=[running]... 302.42s. 143.85s\r"
      ]
     }
    ],
@@ -190,20 +190,20 @@
     "    my_file.write((json.dumps({\"messages\": dialog}) + \"\\n\").encode(\"utf-8\"))\n",
     "\n",
     "my_file.seek(0)\n",
-    "training_file = openai.files.create(file=my_file, purpose=\"fine-tune\")\n",
+    "training_file = openai.File.create(file=my_file, purpose=\"fine-tune\")\n",
     "\n",
-    "job = openai.fine_tuning.jobs.create(\n",
+    "job = openai.FineTuningJob.create(\n",
     "    training_file=training_file.id,\n",
     "    model=\"gpt-3.5-turbo\",\n",
     ")\n",
     "\n",
     "# Wait for the fine-tuning to complete (this may take some time)\n",
-    "status = openai.fine_tuning.jobs.retrieve(job.id).status\n",
+    "status = openai.FineTuningJob.retrieve(job.id).status\n",
     "start_time = time.time()\n",
     "while status != \"succeeded\":\n",
     "    print(f\"Status=[{status}]... {time.time() - start_time:.2f}s\", end=\"\\r\", flush=True)\n",
     "    time.sleep(5)\n",
-    "    status = openai.fine_tuning.jobs.retrieve(job.id).status\n",
+    "    status = openai.FineTuningJob.retrieve(job.id).status\n",
     "\n",
     "# Now your model is fine-tuned!"
    ]
@@ -220,18 +220,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "3f472ca4-fa9b-485d-bd37-8ce3c59c44db",
    "metadata": {},
    "outputs": [],
    "source": [
     "# Get the fine-tuned model ID\n",
-    "job = openai.fine_tuning.jobs.retrieve(job.id)\n",
+    "job = openai.FineTuningJob.retrieve(job.id)\n",
     "model_id = job.fine_tuned_model\n",
     "\n",
     "# Use the fine-tuned model in LangChain\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "\n",
     "model = ChatOpenAI(\n",
     "    model=model_id,\n",
     "    temperature=1,\n",
@@ -240,21 +238,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "7d3b5845-6385-42d1-9f7d-5ea798dc2cd9",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='[{\"s\": \"There were three ravens\", \"object\": \"tree\", \"relation\": \"sat on\"}, {\"s\": \"three ravens\", \"object\": \"a tree\", \"relation\": \"sat on\"}]')"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "model.invoke(\"There were three ravens sat on a tree.\")"
    ]
@@ -284,7 +271,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat_loaders/langsmith_llm_runs.ipynb

@@ -35,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "473adce5-c863-49e6-85c3-049e0ec2222e",
    "metadata": {},
    "outputs": [],
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "9a36d27f-2f3b-4148-b94a-9436fe8b00e0",
    "metadata": {},
    "outputs": [],
@@ -105,7 +105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "89bcc676-27e8-40dc-a4d6-92cf28e0db58",
    "metadata": {},
    "outputs": [
@@ -144,7 +144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "cd44ff01-22cf-431a-8bf4-29a758d1fcff",
    "metadata": {},
    "outputs": [],
@@ -169,10 +169,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "62da7d8f-5cfc-45a6-946e-2bcda2b0ba1f",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Retrying langchain.chat_models.openai.ChatOpenAI.completion_with_retry.<locals>._completion_with_retry in 4.0 seconds as it raised ServiceUnavailableError: The server is overloaded or not ready yet..\n"
+     ]
+    }
+   ],
    "source": [
     "math_questions = [\n",
     "    \"What's 45/9?\",\n",
@@ -211,7 +219,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "d6037992-050d-4ada-a061-860c124f0bf1",
    "metadata": {},
    "outputs": [],
@@ -223,7 +231,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "id": "0444919a-6f5a-4726-9916-4603b1420d0e",
    "metadata": {},
    "outputs": [],
@@ -258,7 +266,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "id": "817bc077-c18a-473b-94a4-a7d810d583a8",
    "metadata": {},
    "outputs": [],
@@ -280,7 +288,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "9e5ac127-b094-4584-9159-5a6d3d7315c7",
    "metadata": {},
    "outputs": [],
@@ -301,7 +309,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "11d19e28-be49-4801-8065-1a58d13cd192",
    "metadata": {},
    "outputs": [
@@ -309,7 +317,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Status=[running]... 349.84s. 17.72s\r"
+      "Status=[running]... 346.26s. 31.70s\r"
      ]
     }
    ],
@@ -325,20 +333,20 @@
     "    my_file.write((json.dumps({\"messages\": dialog}) + \"\\n\").encode(\"utf-8\"))\n",
     "\n",
     "my_file.seek(0)\n",
-    "training_file = openai.files.create(file=my_file, purpose=\"fine-tune\")\n",
+    "training_file = openai.File.create(file=my_file, purpose=\"fine-tune\")\n",
     "\n",
-    "job = openai.fine_tuning.jobs.create(\n",
+    "job = openai.FineTuningJob.create(\n",
     "    training_file=training_file.id,\n",
     "    model=\"gpt-3.5-turbo\",\n",
     ")\n",
     "\n",
     "# Wait for the fine-tuning to complete (this may take some time)\n",
-    "status = openai.fine_tuning.jobs.retrieve(job.id).status\n",
+    "status = openai.FineTuningJob.retrieve(job.id).status\n",
     "start_time = time.time()\n",
     "while status != \"succeeded\":\n",
     "    print(f\"Status=[{status}]... {time.time() - start_time:.2f}s\", end=\"\\r\", flush=True)\n",
     "    time.sleep(5)\n",
-    "    status = openai.fine_tuning.jobs.retrieve(job.id).status\n",
+    "    status = openai.FineTuningJob.retrieve(job.id).status\n",
     "\n",
     "# Now your model is fine-tuned!"
    ]
@@ -355,18 +363,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "7f45b281-1dfa-43cb-bd28-99fa7e9f45d1",
    "metadata": {},
    "outputs": [],
    "source": [
     "# Get the fine-tuned model ID\n",
-    "job = openai.fine_tuning.jobs.retrieve(job.id)\n",
+    "job = openai.FineTuningJob.retrieve(job.id)\n",
     "model_id = job.fine_tuned_model\n",
     "\n",
     "# Use the fine-tuned model in LangChain\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "\n",
     "model = ChatOpenAI(\n",
     "    model=model_id,\n",
     "    temperature=1,\n",
@@ -375,17 +381,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 18,
    "id": "7d3b5845-6385-42d1-9f7d-5ea798dc2cd9",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='Let me calculate that for you.')"
+       "AIMessage(content='{\\n  \"num1\": 56,\\n  \"num2\": 7,\\n  \"operation\": \"/\"\\n}')"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -419,7 +425,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/document_loaders/amazon_textract.ipynb

@@ -1,884 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "1f3cebbe-079a-4bfe-b1a1-07bdac882ce2",
-   "metadata": {},
-   "source": [
-    "# Amazon Textract \n",
-    "\n",
-    ">[Amazon Textract](https://docs.aws.amazon.com/managedservices/latest/userguide/textract.html) is a machine learning (ML) service that automatically extracts text, handwriting, and data from scanned documents.\n",
-    ">\n",
-    ">It goes beyond simple optical character recognition (OCR) to identify, understand, and extract data from forms and tables. Today, many companies manually extract data from scanned documents such as PDFs, images, tables, and forms, or through simple OCR software that requires manual configuration (which often must be updated when the form changes). To overcome these manual and expensive processes, `Textract` uses ML to read and process any type of document, accurately extracting text, handwriting, tables, and other data with no manual effort. \n",
-    "\n",
-    "This sample demonstrates the use of `Amazon Textract` in combination with LangChain as a DocumentLoader.\n",
-    "\n",
-    "`Textract` supports`PDF`, `TIF`F, `PNG` and `JPEG` format.\n",
-    "\n",
-    "`Textract` supports these [document sizes, languages and characters](https://docs.aws.amazon.com/textract/latest/dg/limits-document.html)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "a1aa66d4-85f2-42ad-a8d3-de7cea8d6c35",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install boto3 openai tiktoken python-dotenv"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "e4305a0d-37da-41f9-a52c-7d166d7dbabf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install \"amazon-textract-caller>=0.2.0\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "400b25c6-befa-4730-a201-39ff112c8858",
-   "metadata": {},
-   "source": [
-    "## Sample 1\n",
-    "\n",
-    "The first example uses a local file, which internally will be send to Amazon Textract sync API [DetectDocumentText](https://docs.aws.amazon.com/textract/latest/dg/API_DetectDocumentText.html). \n",
-    "\n",
-    "Local files or URL endpoints like HTTP:// are limited to one page documents for Textract.\n",
-    "Multi-page documents have to reside on S3. This sample file is a jpeg."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1becee92-e82f-42d4-9b4e-b23d77cbe88d",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.document_loaders import AmazonTextractPDFLoader\n",
-    "\n",
-    "loader = AmazonTextractPDFLoader(\"example_data/alejandro_rosalez_sample-small.jpeg\")\n",
-    "documents = loader.load()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d566dc56-c9a9-44ec-84fb-a81928f90d40",
-   "metadata": {},
-   "source": [
-    "Output from the file"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "1272ce8c-d298-4059-ac0a-780bf5f82302",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='Patient Information First Name: ALEJANDRO Last Name: ROSALEZ Date of Birth: 10/10/1982 Sex: M Marital Status: MARRIED Email Address: Address: 123 ANY STREET City: ANYTOWN State: CA Zip Code: 12345 Phone: 646-555-0111 Emergency Contact 1: First Name: CARLOS Last Name: SALAZAR Phone: 212-555-0150 Relationship to Patient: BROTHER Emergency Contact 2: First Name: JANE Last Name: DOE Phone: 650-555-0123 Relationship FRIEND to Patient: Did you feel fever or feverish lately? Yes No Are you having shortness of breath? Yes No Do you have a cough? Yes No Did you experience loss of taste or smell? Yes No Where you in contact with any confirmed COVID-19 positive patients? Yes No Did you travel in the past 14 days to any regions affected by COVID-19? Yes No Patient Information First Name: ALEJANDRO Last Name: ROSALEZ Date of Birth: 10/10/1982 Sex: M Marital Status: MARRIED Email Address: Address: 123 ANY STREET City: ANYTOWN State: CA Zip Code: 12345 Phone: 646-555-0111 Emergency Contact 1: First Name: CARLOS Last Name: SALAZAR Phone: 212-555-0150 Relationship to Patient: BROTHER Emergency Contact 2: First Name: JANE Last Name: DOE Phone: 650-555-0123 Relationship FRIEND to Patient: Did you feel fever or feverish lately? Yes No Are you having shortness of breath? Yes No Do you have a cough? Yes No Did you experience loss of taste or smell? Yes No Where you in contact with any confirmed COVID-19 positive patients? Yes No Did you travel in the past 14 days to any regions affected by COVID-19? Yes No ', metadata={'source': 'example_data/alejandro_rosalez_sample-small.jpeg', 'page': 1})]"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "documents"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4cf7f19c-3635-453a-9c76-4baf98b8d7f4",
-   "metadata": {},
-   "source": [
-    "## Sample 2\n",
-    "The next sample loads a file from an HTTPS endpoint. \n",
-    "It has to be single page, as Amazon Textract requires all multi-page documents to be stored on S3."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "10374bfb-b325-451f-8bd0-c686710ab68c",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.document_loaders import AmazonTextractPDFLoader\n",
-    "\n",
-    "loader = AmazonTextractPDFLoader(\n",
-    "    \"https://amazon-textract-public-content.s3.us-east-2.amazonaws.com/langchain/alejandro_rosalez_sample_1.jpg\"\n",
-    ")\n",
-    "documents = loader.load()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "16a2b6a3-7514-4c2c-a427-6847169af473",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='Patient Information First Name: ALEJANDRO Last Name: ROSALEZ Date of Birth: 10/10/1982 Sex: M Marital Status: MARRIED Email Address: Address: 123 ANY STREET City: ANYTOWN State: CA Zip Code: 12345 Phone: 646-555-0111 Emergency Contact 1: First Name: CARLOS Last Name: SALAZAR Phone: 212-555-0150 Relationship to Patient: BROTHER Emergency Contact 2: First Name: JANE Last Name: DOE Phone: 650-555-0123 Relationship FRIEND to Patient: Did you feel fever or feverish lately? Yes No Are you having shortness of breath? Yes No Do you have a cough? Yes No Did you experience loss of taste or smell? Yes No Where you in contact with any confirmed COVID-19 positive patients? Yes No Did you travel in the past 14 days to any regions affected by COVID-19? Yes No Patient Information First Name: ALEJANDRO Last Name: ROSALEZ Date of Birth: 10/10/1982 Sex: M Marital Status: MARRIED Email Address: Address: 123 ANY STREET City: ANYTOWN State: CA Zip Code: 12345 Phone: 646-555-0111 Emergency Contact 1: First Name: CARLOS Last Name: SALAZAR Phone: 212-555-0150 Relationship to Patient: BROTHER Emergency Contact 2: First Name: JANE Last Name: DOE Phone: 650-555-0123 Relationship FRIEND to Patient: Did you feel fever or feverish lately? Yes No Are you having shortness of breath? Yes No Do you have a cough? Yes No Did you experience loss of taste or smell? Yes No Where you in contact with any confirmed COVID-19 positive patients? Yes No Did you travel in the past 14 days to any regions affected by COVID-19? Yes No ', metadata={'source': 'example_data/alejandro_rosalez_sample-small.jpeg', 'page': 1})]"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "documents"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3a9cd8ec-e663-4dc7-9db1-d2f575253141",
-   "metadata": {},
-   "source": [
-    "## Sample 3\n",
-    "\n",
-    "Processing a multi-page document requires the document to be on S3. The sample document resides in a bucket in us-east-2 and Textract needs to be called in that same region to be successful, so we set the region_name on the client and pass that in to the loader to ensure Textract is called from us-east-2. You could also to have your notebook running in us-east-2, setting the AWS_DEFAULT_REGION set to us-east-2 or when running in a different environment, pass in a boto3 Textract client with that region name like in the cell below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "8185e3e6-9599-4a47-8969-d6dcef3e6404",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "import boto3\n",
-    "\n",
-    "textract_client = boto3.client(\"textract\", region_name=\"us-east-2\")\n",
-    "\n",
-    "file_path = \"s3://amazon-textract-public-content/langchain/layout-parser-paper.pdf\"\n",
-    "loader = AmazonTextractPDFLoader(file_path, client=textract_client)\n",
-    "documents = loader.load()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b8901eec-070d-4fd6-9d65-52211d332441",
-   "metadata": {},
-   "source": [
-    "Now getting the number of pages to validate the response (printing out the full response would be quite long...). We expect 16 pages."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "b23c01c8-cf69-4fe2-8141-4621edb7d79c",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "16"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "len(documents)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b3e41b4d-b159-4274-89be-80d8159134ef",
-   "metadata": {},
-   "source": [
-    "## Using the AmazonTextractPDFLoader in an LangChain chain (e. g. OpenAI)\n",
-    "\n",
-    "The AmazonTextractPDFLoader can be used in a chain the same way the other loaders are used.\n",
-    "Textract itself does have a [Query feature](https://docs.aws.amazon.com/textract/latest/dg/API_Query.html), which offers similar functionality to the QA chain in this sample, which is worth checking out as well."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "53c47b24-cc06-4256-9e5b-a82fc80bc55d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# You can store your OPENAI_API_KEY in a .env file as well\n",
-    "# import os\n",
-    "# from dotenv import load_dotenv\n",
-    "\n",
-    "# load_dotenv()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "a9ae004c-246c-4c7f-8458-191cd7424a9b",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Or set the OpenAI key in the environment directly\n",
-    "import os\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"your-OpenAI-API-key\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "d52b089c-10ca-45fb-8669-8a1c5fee10d5",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "' The authors are Zejiang Shen, Ruochen Zhang, Melissa Dell, Benjamin Charles Germain Lee, Jacob Carlson, Weining Li, Gardner, M., Grus, J., Neumann, M., Tafjord, O., Dasigi, P., Liu, N., Peters, M., Schmitz, M., Zettlemoyer, L., Lukasz Garncarek, Powalski, R., Stanislawek, T., Topolski, B., Halama, P., Gralinski, F., Graves, A., Fernández, S., Gomez, F., Schmidhuber, J., Harley, A.W., Ufkes, A., Derpanis, K.G., He, K., Gkioxari, G., Dollár, P., Girshick, R., He, K., Zhang, X., Ren, S., Sun, J., Kay, A., Lamiroy, B., Lopresti, D., Mears, J., Jakeway, E., Ferriter, M., Adams, C., Yarasavage, N., Thomas, D., Zwaard, K., Li, M., Cui, L., Huang,'"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.chains.question_answering import load_qa_chain\n",
-    "from langchain.llms import OpenAI\n",
-    "\n",
-    "chain = load_qa_chain(llm=OpenAI(), chain_type=\"map_reduce\")\n",
-    "query = [\"Who are the autors?\"]\n",
-    "\n",
-    "chain.run(input_documents=documents, question=query)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1a09d18b-ab7b-468e-ae66-f92abf666b9b",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "availableInstances": [
-   {
-    "_defaultOrder": 0,
-    "_isFastLaunch": true,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 4,
-    "name": "ml.t3.medium",
-    "vcpuNum": 2
-   },
-   {
-    "_defaultOrder": 1,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 8,
-    "name": "ml.t3.large",
-    "vcpuNum": 2
-   },
-   {
-    "_defaultOrder": 2,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 16,
-    "name": "ml.t3.xlarge",
-    "vcpuNum": 4
-   },
-   {
-    "_defaultOrder": 3,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 32,
-    "name": "ml.t3.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 4,
-    "_isFastLaunch": true,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 8,
-    "name": "ml.m5.large",
-    "vcpuNum": 2
-   },
-   {
-    "_defaultOrder": 5,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 16,
-    "name": "ml.m5.xlarge",
-    "vcpuNum": 4
-   },
-   {
-    "_defaultOrder": 6,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 32,
-    "name": "ml.m5.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 7,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 64,
-    "name": "ml.m5.4xlarge",
-    "vcpuNum": 16
-   },
-   {
-    "_defaultOrder": 8,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 128,
-    "name": "ml.m5.8xlarge",
-    "vcpuNum": 32
-   },
-   {
-    "_defaultOrder": 9,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 192,
-    "name": "ml.m5.12xlarge",
-    "vcpuNum": 48
-   },
-   {
-    "_defaultOrder": 10,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 256,
-    "name": "ml.m5.16xlarge",
-    "vcpuNum": 64
-   },
-   {
-    "_defaultOrder": 11,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 384,
-    "name": "ml.m5.24xlarge",
-    "vcpuNum": 96
-   },
-   {
-    "_defaultOrder": 12,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 8,
-    "name": "ml.m5d.large",
-    "vcpuNum": 2
-   },
-   {
-    "_defaultOrder": 13,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 16,
-    "name": "ml.m5d.xlarge",
-    "vcpuNum": 4
-   },
-   {
-    "_defaultOrder": 14,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 32,
-    "name": "ml.m5d.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 15,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 64,
-    "name": "ml.m5d.4xlarge",
-    "vcpuNum": 16
-   },
-   {
-    "_defaultOrder": 16,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 128,
-    "name": "ml.m5d.8xlarge",
-    "vcpuNum": 32
-   },
-   {
-    "_defaultOrder": 17,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 192,
-    "name": "ml.m5d.12xlarge",
-    "vcpuNum": 48
-   },
-   {
-    "_defaultOrder": 18,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 256,
-    "name": "ml.m5d.16xlarge",
-    "vcpuNum": 64
-   },
-   {
-    "_defaultOrder": 19,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 384,
-    "name": "ml.m5d.24xlarge",
-    "vcpuNum": 96
-   },
-   {
-    "_defaultOrder": 20,
-    "_isFastLaunch": false,
-    "category": "General purpose",
-    "gpuNum": 0,
-    "hideHardwareSpecs": true,
-    "memoryGiB": 0,
-    "name": "ml.geospatial.interactive",
-    "supportedImageNames": [
-     "sagemaker-geospatial-v1-0"
-    ],
-    "vcpuNum": 0
-   },
-   {
-    "_defaultOrder": 21,
-    "_isFastLaunch": true,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 4,
-    "name": "ml.c5.large",
-    "vcpuNum": 2
-   },
-   {
-    "_defaultOrder": 22,
-    "_isFastLaunch": false,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 8,
-    "name": "ml.c5.xlarge",
-    "vcpuNum": 4
-   },
-   {
-    "_defaultOrder": 23,
-    "_isFastLaunch": false,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 16,
-    "name": "ml.c5.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 24,
-    "_isFastLaunch": false,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 32,
-    "name": "ml.c5.4xlarge",
-    "vcpuNum": 16
-   },
-   {
-    "_defaultOrder": 25,
-    "_isFastLaunch": false,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 72,
-    "name": "ml.c5.9xlarge",
-    "vcpuNum": 36
-   },
-   {
-    "_defaultOrder": 26,
-    "_isFastLaunch": false,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 96,
-    "name": "ml.c5.12xlarge",
-    "vcpuNum": 48
-   },
-   {
-    "_defaultOrder": 27,
-    "_isFastLaunch": false,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 144,
-    "name": "ml.c5.18xlarge",
-    "vcpuNum": 72
-   },
-   {
-    "_defaultOrder": 28,
-    "_isFastLaunch": false,
-    "category": "Compute optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 192,
-    "name": "ml.c5.24xlarge",
-    "vcpuNum": 96
-   },
-   {
-    "_defaultOrder": 29,
-    "_isFastLaunch": true,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 16,
-    "name": "ml.g4dn.xlarge",
-    "vcpuNum": 4
-   },
-   {
-    "_defaultOrder": 30,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 32,
-    "name": "ml.g4dn.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 31,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 64,
-    "name": "ml.g4dn.4xlarge",
-    "vcpuNum": 16
-   },
-   {
-    "_defaultOrder": 32,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 128,
-    "name": "ml.g4dn.8xlarge",
-    "vcpuNum": 32
-   },
-   {
-    "_defaultOrder": 33,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 4,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 192,
-    "name": "ml.g4dn.12xlarge",
-    "vcpuNum": 48
-   },
-   {
-    "_defaultOrder": 34,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 256,
-    "name": "ml.g4dn.16xlarge",
-    "vcpuNum": 64
-   },
-   {
-    "_defaultOrder": 35,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 61,
-    "name": "ml.p3.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 36,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 4,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 244,
-    "name": "ml.p3.8xlarge",
-    "vcpuNum": 32
-   },
-   {
-    "_defaultOrder": 37,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 8,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 488,
-    "name": "ml.p3.16xlarge",
-    "vcpuNum": 64
-   },
-   {
-    "_defaultOrder": 38,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 8,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 768,
-    "name": "ml.p3dn.24xlarge",
-    "vcpuNum": 96
-   },
-   {
-    "_defaultOrder": 39,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 16,
-    "name": "ml.r5.large",
-    "vcpuNum": 2
-   },
-   {
-    "_defaultOrder": 40,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 32,
-    "name": "ml.r5.xlarge",
-    "vcpuNum": 4
-   },
-   {
-    "_defaultOrder": 41,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 64,
-    "name": "ml.r5.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 42,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 128,
-    "name": "ml.r5.4xlarge",
-    "vcpuNum": 16
-   },
-   {
-    "_defaultOrder": 43,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 256,
-    "name": "ml.r5.8xlarge",
-    "vcpuNum": 32
-   },
-   {
-    "_defaultOrder": 44,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 384,
-    "name": "ml.r5.12xlarge",
-    "vcpuNum": 48
-   },
-   {
-    "_defaultOrder": 45,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 512,
-    "name": "ml.r5.16xlarge",
-    "vcpuNum": 64
-   },
-   {
-    "_defaultOrder": 46,
-    "_isFastLaunch": false,
-    "category": "Memory Optimized",
-    "gpuNum": 0,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 768,
-    "name": "ml.r5.24xlarge",
-    "vcpuNum": 96
-   },
-   {
-    "_defaultOrder": 47,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 16,
-    "name": "ml.g5.xlarge",
-    "vcpuNum": 4
-   },
-   {
-    "_defaultOrder": 48,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 32,
-    "name": "ml.g5.2xlarge",
-    "vcpuNum": 8
-   },
-   {
-    "_defaultOrder": 49,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 64,
-    "name": "ml.g5.4xlarge",
-    "vcpuNum": 16
-   },
-   {
-    "_defaultOrder": 50,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 128,
-    "name": "ml.g5.8xlarge",
-    "vcpuNum": 32
-   },
-   {
-    "_defaultOrder": 51,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 1,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 256,
-    "name": "ml.g5.16xlarge",
-    "vcpuNum": 64
-   },
-   {
-    "_defaultOrder": 52,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 4,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 192,
-    "name": "ml.g5.12xlarge",
-    "vcpuNum": 48
-   },
-   {
-    "_defaultOrder": 53,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 4,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 384,
-    "name": "ml.g5.24xlarge",
-    "vcpuNum": 96
-   },
-   {
-    "_defaultOrder": 54,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 8,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 768,
-    "name": "ml.g5.48xlarge",
-    "vcpuNum": 192
-   },
-   {
-    "_defaultOrder": 55,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 8,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 1152,
-    "name": "ml.p4d.24xlarge",
-    "vcpuNum": 96
-   },
-   {
-    "_defaultOrder": 56,
-    "_isFastLaunch": false,
-    "category": "Accelerated computing",
-    "gpuNum": 8,
-    "hideHardwareSpecs": false,
-    "memoryGiB": 1152,
-    "name": "ml.p4de.24xlarge",
-    "vcpuNum": 96
-   }
-  ],
-  "instance_type": "ml.t3.medium",
-  "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.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/document_loaders/azure_ai_data.ipynb

@@ -1,174 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a634365e",
-   "metadata": {},
-   "source": [
-    "# Azure AI Data\n",
-    "\n",
-    ">[Azure AI Studio](https://ai.azure.com/) provides the capability to upload data assets to cloud storage and register existing data assets from the following sources:\n",
-    "\n",
-    "- Microsoft OneLake\n",
-    "- Azure Blob Storage\n",
-    "- Azure Data Lake gen 2\n",
-    "\n",
-    "The benefit of this approach over `AzureBlobStorageContainerLoader` and `AzureBlobStorageFileLoader` is that authentication is handled seamlessly to cloud storage. You can use either *identity-based* data access control to the data or *credential-based* (e.g. SAS token, account key). In the case of credential-based data access you do not need to specify secrets in your code or set up key vaults - the system handles that for you.\n",
-    "\n",
-    "This notebook covers how to load document objects from a data asset in AI Studio."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "49815096",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install azureml-fsspec, azure-ai-generative"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "2f0cd6a5",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from azure.ai.resources.client import AIClient\n",
-    "from azure.identity import DefaultAzureCredential\n",
-    "from langchain.document_loaders import AzureAIDataLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "08d40b11-e87a-426e-a6b0-89f24e47ce2c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create a connection to your project\n",
-    "client = AIClient(\n",
-    "    credential=DefaultAzureCredential(),\n",
-    "    subscription_id=\"<subscription_id>\",\n",
-    "    resource_group_name=\"<resource_group_name>\",\n",
-    "    project_name=\"<project_name>\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "321cc7f1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# get the latest version of your data asset\n",
-    "data_asset = client.data.get(name=\"<data_asset_name>\", label=\"latest\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "25d91cea-c5f2-4a53-ac19-442810451ec6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# load the data asset\n",
-    "loader = AzureAIDataLoader(url=data_asset.path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "2b11d155",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='Lorem ipsum dolor sit amet.', lookup_str='', metadata={'source': '/var/folders/y6/8_bzdg295ld6s1_97_12m4lr0000gn/T/tmpaa9xl6ch/fake.docx'}, lookup_index=0)]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "loader.load()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0690c40a",
-   "metadata": {},
-   "source": [
-    "## Specifying a glob pattern\n",
-    "You can also specify a glob pattern for more finegrained control over what files to load. In the example below, only files with a `pdf` extension will be loaded."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "72d44781",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "loader = AzureAIDataLoader(url=data_asset.path, glob=\"*.pdf\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "2d3c32db",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='Lorem ipsum dolor sit amet.', lookup_str='', metadata={'source': '/var/folders/y6/8_bzdg295ld6s1_97_12m4lr0000gn/T/tmpujbkzf_l/fake.docx'}, lookup_index=0)]"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "loader.load()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "885dc280",
-   "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.11.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/document_loaders/dropbox.ipynb

@@ -15,7 +15,7 @@
     "1. Create a Dropbox app.\n",
     "2. Give the app these scope permissions: `files.metadata.read` and `files.content.read`.\n",
     "3. Generate access token: https://www.dropbox.com/developers/apps/create.\n",
-    "4. `pip install dropbox` (requires `pip install \"unstructured[pdf]\"` for PDF filetype).\n",
+    "4. `pip install dropbox` (requires `pip install unstructured` for PDF filetype).\n",
     "\n",
     "## Instructions\n",
     "\n",

docs/docs/integrations/document_loaders/embaas.ipynb

@@ -0,0 +1,167 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "# Embaas\n",
+    "[embaas](https://embaas.io) is a fully managed NLP API service that offers features like embedding generation, document text extraction, document to embeddings and more. You can choose a [variety of pre-trained models](https://embaas.io/docs/models/embeddings).\n",
+    "\n",
+    "### Prerequisites\n",
+    "Create a free embaas account at [https://embaas.io/register](https://embaas.io/register) and generate an [API key](https://embaas.io/dashboard/api-keys)\n",
+    "\n",
+    "### Document Text Extraction API\n",
+    "The document text extraction API allows you to extract the text from a given document. The API supports a variety of document formats, including PDF, mp3, mp4 and more. For a full list of supported formats, check out the API docs (link below)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# Set API key\n",
+    "embaas_api_key = \"YOUR_API_KEY\"\n",
+    "# or set environment variable\n",
+    "os.environ[\"EMBAAS_API_KEY\"] = \"YOUR_API_KEY\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "#### Using a blob (bytes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders.blob_loaders import Blob\n",
+    "from langchain.document_loaders.embaas import EmbaasBlobLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "blob_loader = EmbaasBlobLoader()\n",
+    "blob = Blob.from_path(\"example.pdf\")\n",
+    "documents = blob_loader.load(blob)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-12T22:19:48.380467Z",
+     "start_time": "2023-06-12T22:19:48.366886Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# You can also directly create embeddings with your preferred embeddings model\n",
+    "blob_loader = EmbaasBlobLoader(params={\"model\": \"e5-large-v2\", \"should_embed\": True})\n",
+    "blob = Blob.from_path(\"example.pdf\")\n",
+    "documents = blob_loader.load(blob)\n",
+    "\n",
+    "print(documents[0][\"metadata\"][\"embedding\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "#### Using a file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders.embaas import EmbaasLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "file_loader = EmbaasLoader(file_path=\"example.pdf\")\n",
+    "documents = file_loader.load()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-06-12T22:24:31.894665Z",
+     "start_time": "2023-06-12T22:24:31.880857Z"
+    },
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "# Disable automatic text splitting\n",
+    "file_loader = EmbaasLoader(file_path=\"example.mp3\", params={\"should_chunk\": False})\n",
+    "documents = file_loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "For more detailed information about the embaas document text extraction API, please refer to [the official embaas API documentation](https://embaas.io/api-reference)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

docs/docs/integrations/llms/amazon_api_gateway.ipynb

@@ -11,9 +11,9 @@
    "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",
+    "[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."
+    "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."
    ]
   },
   {

docs/docs/integrations/llms/bedrock.ipynb

@@ -11,15 +11,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of \n",
-    "> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, \n",
-    "> `Meta`, `Stability AI`, and `Amazon` via a single API, along with a broad set of capabilities you need to \n",
-    "> build generative AI applications with security, privacy, and responsible AI. Using `Amazon Bedrock`, \n",
-    "> you can easily experiment with and evaluate top FMs for your use case, privately customize them with \n",
-    "> your data using techniques such as fine-tuning and `Retrieval Augmented Generation` (`RAG`), and build \n",
-    "> agents that execute tasks using your enterprise systems and data sources. Since `Amazon Bedrock` is \n",
-    "> serverless, you don't have to manage any infrastructure, and you can securely integrate and deploy \n",
-    "> generative AI capabilities into your applications using the AWS services you are already familiar with.\n"
+    "[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that makes FMs from leading AI startups and Amazon available via an API, so you can choose from a wide range of FMs to find the model that is best suited for your use case"
    ]
   },
   {
@@ -124,7 +116,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.11"
   }
  },
  "nbformat": 4,

docs/docs/integrations/llms/databricks.ipynb

@@ -20,121 +20,27 @@
     "This example notebook shows how to wrap Databricks endpoints as LLMs in LangChain.\n",
     "It supports two endpoint types:\n",
     "* Serving endpoint, recommended for production and development,\n",
-    "* Cluster driver proxy app, recommended for interactive development."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Installation\n",
-    "\n",
-    "`mlflow >= 2.9 ` is required to run the code in this notebook. If it's not installed, please install it using this command:\n",
-    "\n",
-    "```\n",
-    "pip install mlflow>=2.9\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Wrapping a serving endpoint: External model\n",
-    "\n",
-    "Prerequisite:\n",
-    "\n",
-    "- Register an OpenAI API key as a secret:\n",
-    "\n",
-    "  ```bash\n",
-    "  databricks secrets create-scope <scope>\n",
-    "  databricks secrets put-secret <scope> openai-api-key --string-value $OPENAI_API_KEY\n",
-    "  ```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The following code creates a new serving endpoint with OpenAI's GPT-4 model for chat and generates a response using the endpoint."
+    "* Cluster driver proxy app, recommended for iteractive development."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "content='Hello! How can I assist you today?'\n"
-     ]
+   "execution_count": null,
+   "metadata": {
+    "application/vnd.databricks.v1+cell": {
+     "cellMetadata": {
+      "byteLimit": 2048000,
+      "rowLimit": 10000
+     },
+     "inputWidgets": {},
+     "nuid": "bf07455f-aac9-4873-a8e7-7952af0f8c82",
+     "showTitle": false,
+     "title": ""
     }
-   ],
+   },
+   "outputs": [],
    "source": [
-    "from langchain.chat_models import ChatDatabricks\n",
-    "from langchain.schema.messages import HumanMessage\n",
-    "from mlflow.deployments import get_deploy_client\n",
-    "\n",
-    "client = get_deploy_client(\"databricks\")\n",
-    "\n",
-    "secret = \"secrets/<scope>/openai-api-key\"  # replace `<scope>` with your scope\n",
-    "name = \"my-chat\"  # rename this if my-chat already exists\n",
-    "client.create_endpoint(\n",
-    "    name=name,\n",
-    "    config={\n",
-    "        \"served_entities\": [\n",
-    "            {\n",
-    "                \"name\": \"my-chat\",\n",
-    "                \"external_model\": {\n",
-    "                    \"name\": \"gpt-4\",\n",
-    "                    \"provider\": \"openai\",\n",
-    "                    \"task\": \"llm/v1/chat\",\n",
-    "                    \"openai_config\": {\n",
-    "                        \"openai_api_key\": \"{{\" + secret + \"}}\",\n",
-    "                    },\n",
-    "                },\n",
-    "            }\n",
-    "        ],\n",
-    "    },\n",
-    ")\n",
-    "\n",
-    "chat = ChatDatabricks(\n",
-    "    target_uri=\"databricks\",\n",
-    "    endpoint=name,\n",
-    "    temperature=0.1,\n",
-    ")\n",
-    "chat([HumanMessage(content=\"hello\")])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Wrapping a serving endpoint: Foundation model\n",
-    "\n",
-    "The following code uses the `databricks-bge-large-en` serving endpoint (no endpoint creation is required) to generate embeddings from input text."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[0.051055908203125, 0.007221221923828125, 0.003879547119140625]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain.embeddings import DatabricksEmbeddings\n",
-    "\n",
-    "embeddings = DatabricksEmbeddings(endpoint=\"databricks-bge-large-en\")\n",
-    "embeddings.embed_query(\"hello\")[:3]"
+    "from langchain.llms import Databricks"
    ]
   },
   {
@@ -150,7 +56,7 @@
     }
    },
    "source": [
-    "## Wrapping a serving endpoint: Custom model\n",
+    "## Wrapping a serving endpoint\n",
     "\n",
     "Prerequisites:\n",
     "* An LLM was registered and deployed to [a Databricks serving endpoint](https://docs.databricks.com/machine-learning/model-serving/index.html).\n",
@@ -191,8 +97,6 @@
     }
    ],
    "source": [
-    "from langchain.llms import Databricks\n",
-    "\n",
     "# If running a Databricks notebook attached to an interactive cluster in \"single user\"\n",
     "# or \"no isolation shared\" mode, you only need to specify the endpoint name to create\n",
     "# a `Databricks` instance to query a serving endpoint in the same workspace.\n",
@@ -620,7 +524,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.18"
+   "version": "3.10.10"
   },
   "orig_nbformat": 4
  },

docs/docs/integrations/llms/volcengine_maas.ipynb

@@ -1,124 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "404758628c7b20f6",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "# Volc Engine Maas\n",
-    "\n",
-    "This notebook provides you with a guide on how to get started with Volc Engine's MaaS llm models."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "946db204b33c2ef7",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# Install the package\n",
-    "!pip install volcengine"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "51e7f967cb78f5b7",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:40:26.897649Z",
-     "start_time": "2023-11-27T10:40:26.552589Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.llms import VolcEngineMaasLLM\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "139667d44689f9e0",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:40:27.938517Z",
-     "start_time": "2023-11-27T10:40:27.861324Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "llm = VolcEngineMaasLLM(volc_engine_maas_ak=\"your ak\", volc_engine_maas_sk=\"your sk\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e84ebc4feedcc739",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "or you can set access_key and secret_key in your environment variables\n",
-    "```bash\n",
-    "export VOLC_ACCESSKEY=YOUR_AK\n",
-    "export VOLC_SECRETKEY=YOUR_SK\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "35da18414ad17aa0",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-11-27T10:41:35.528526Z",
-     "start_time": "2023-11-27T10:41:32.562238Z"
-    },
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": "'好的，下面是一个笑话：\\n\\n大学暑假我配了隐形眼镜，回家给爷爷说，我现在配了隐形眼镜。\\n爷爷让我给他看看，于是，我用小镊子夹了一片给爷爷看。\\n爷爷看完便准备出门，边走还边说：“真高级啊，还真是隐形眼镜！”\\n等爷爷出去后我才发现，我刚没夹起来！'"
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain = PromptTemplate.from_template(\"给我讲个笑话\") | llm | StrOutputParser()\n",
-    "chain.invoke({})"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 2
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/llms/watsonxllm.ipynb

@@ -1,297 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "70996d8a",
-   "metadata": {},
-   "source": [
-    "# WatsonxLLM\n",
-    "\n",
-    "[WatsonxLLM](https://ibm.github.io/watson-machine-learning-sdk/fm_extensions.html) is wrapper for IBM [watsonx.ai](https://www.ibm.com/products/watsonx-ai) foundation models.\n",
-    "This example shows how to communicate with watsonx.ai models using LangChain."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ea35b2b7",
-   "metadata": {},
-   "source": [
-    "Install the package [`ibm_watson_machine_learning`](https://ibm.github.io/watson-machine-learning-sdk/install.html)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2f1fff4e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install ibm_watson_machine_learning"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f406e092",
-   "metadata": {},
-   "source": [
-    "This cell defines the WML credentials required to work with watsonx Foundation Model inferencing.\n",
-    "\n",
-    "**Action:** Provide the IBM Cloud user API key. For details, see\n",
-    "[documentation](https://cloud.ibm.com/docs/account?topic=account-userapikey&interface=ui)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "11d572a1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "from getpass import getpass\n",
-    "\n",
-    "watsonx_api_key = getpass()\n",
-    "os.environ[\"WATSONX_APIKEY\"] = watsonx_api_key"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e36acbef",
-   "metadata": {},
-   "source": [
-    "## Load the model\n",
-    "You might need to adjust model `parameters` for different models or tasks, to do so please refer to [documentation](https://ibm.github.io/watson-machine-learning-sdk/model.html#metanames.GenTextParamsMetaNames)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "407cd500",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ibm_watson_machine_learning.metanames import GenTextParamsMetaNames as GenParams\n",
-    "\n",
-    "parameters = {\n",
-    "    GenParams.DECODING_METHOD: \"sample\",\n",
-    "    GenParams.MAX_NEW_TOKENS: 100,\n",
-    "    GenParams.MIN_NEW_TOKENS: 1,\n",
-    "    GenParams.TEMPERATURE: 0.5,\n",
-    "    GenParams.TOP_K: 50,\n",
-    "    GenParams.TOP_P: 1,\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2b586538",
-   "metadata": {},
-   "source": [
-    "Initialize the `WatsonxLLM` class with previous set params."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "359898de",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.llms import WatsonxLLM\n",
-    "\n",
-    "watsonx_llm = WatsonxLLM(\n",
-    "    model_id=\"google/flan-ul2\",\n",
-    "    url=\"https://us-south.ml.cloud.ibm.com\",\n",
-    "    project_id=\"***\",\n",
-    "    params=parameters,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2202f4e0",
-   "metadata": {},
-   "source": [
-    "Alternatively you can use Cloud Pak for Data credentials. For details, see [documentation](https://ibm.github.io/watson-machine-learning-sdk/setup_cpd.html).\n",
-    "```\n",
-    "watsonx_llm = WatsonxLLM(\n",
-    "    model_id='google/flan-ul2',\n",
-    "    url=\"***\",\n",
-    "    username=\"***\",\n",
-    "    password=\"***\",\n",
-    "    instance_id=\"openshift\",\n",
-    "    version=\"4.8\",\n",
-    "    project_id='***',\n",
-    "    params=parameters\n",
-    ")\n",
-    "```        "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c25ecbd1",
-   "metadata": {},
-   "source": [
-    "## Create Chain\n",
-    "Create `PromptTemplate` objects which will be responsible for creating a random question."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "c7d80c05",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts import PromptTemplate\n",
-    "\n",
-    "template = \"Generate a random question about {topic}: Question: \"\n",
-    "prompt = PromptTemplate.from_template(template)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "79056d8e",
-   "metadata": {},
-   "source": [
-    "Provide a topic and run the `LLMChain`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "dc076c56",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'How many breeds of dog are there?'"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.chains import LLMChain\n",
-    "\n",
-    "llm_chain = LLMChain(prompt=prompt, llm=watsonx_llm)\n",
-    "llm_chain.run(\"dog\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f571001d",
-   "metadata": {},
-   "source": [
-    "## Calling the Model Directly\n",
-    "To obtain completions, you can can the model directly using string prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "beea2b5b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'dog'"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Calling a single prompt\n",
-    "\n",
-    "watsonx_llm(\"Who is man's best friend?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "8ab1a25a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "LLMResult(generations=[[Generation(text='greyhounds', generation_info={'generated_token_count': 4, 'input_token_count': 8, 'finish_reason': 'eos_token'})], [Generation(text='The Basenji is a dog breed from South Africa.', generation_info={'generated_token_count': 13, 'input_token_count': 7, 'finish_reason': 'eos_token'})]], llm_output={'model_id': 'google/flan-ul2'}, run=[RunInfo(run_id=UUID('03c73a42-db68-428e-ab8d-8ae10abc84fc')), RunInfo(run_id=UUID('c289f67a-87d6-4c8b-a8b7-0b5012c94ca8'))])"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Calling multiple prompts\n",
-    "\n",
-    "watsonx_llm.generate(\n",
-    "    [\n",
-    "        \"The fastest dog in the world?\",\n",
-    "        \"Describe your chosen dog breed\",\n",
-    "    ]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d2c9da33",
-   "metadata": {},
-   "source": [
-    "## Streaming the Model output \n",
-    "\n",
-    "You can stream the model output."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "3f63166a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "The golden retriever is my favorite dog because it is very friendly and good with children."
-     ]
-    }
-   ],
-   "source": [
-    "for chunk in watsonx_llm.stream(\n",
-    "    \"Describe your favorite breed of dog and why it is your favorite.\"\n",
-    "):\n",
-    "    print(chunk, end=\"\")"
-   ]
-  }
- ],
- "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.18"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/platforms/aws.mdx

@@ -1,22 +1,11 @@
 # AWS
 
-The `LangChain` integrations related to [Amazon AWS](https://aws.amazon.com/) platform.
+All functionality related to [Amazon AWS](https://aws.amazon.com/) platform
 
 ## LLMs
 
 ### Bedrock
 
->[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of 
-> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, 
-> `Meta`, `Stability AI`, and `Amazon` via a single API, along with a broad set of capabilities you need to 
-> build generative AI applications with security, privacy, and responsible AI. Using `Amazon Bedrock`, 
-> you can easily experiment with and evaluate top FMs for your use case, privately customize them with 
-> your data using techniques such as fine-tuning and `Retrieval Augmented Generation` (`RAG`), and build 
-> agents that execute tasks using your enterprise systems and data sources. Since `Amazon Bedrock` is 
-> serverless, you don't have to manage any infrastructure, and you can securely integrate and deploy 
-> generative AI capabilities into your applications using the AWS services you are already familiar with.
-
- 
 See a [usage example](/docs/integrations/llms/bedrock).
 
 ```python
@@ -25,28 +14,32 @@ from langchain.llms.bedrock import Bedrock
 
 ### 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.
+[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.
 
-See a [usage example](/docs/integrations/llms/amazon_api_gateway).
+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.
+
+See a [usage example](/docs/integrations/llms/amazon_api_gateway_example).
 
 ```python
 from langchain.llms import AmazonAPIGateway
+
+api_url = "https://<api_gateway_id>.execute-api.<region>.amazonaws.com/LATEST/HF"
+# These are sample parameters for Falcon 40B Instruct Deployed from Amazon SageMaker JumpStart
+model_kwargs = {
+    "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,
+}
+llm = AmazonAPIGateway(api_url=api_url, model_kwargs=model_kwargs)
 ```
 
 ### SageMaker Endpoint
 
->[Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a system that can build, train, and deploy 
-> machine learning (ML) models with fully managed infrastructure, tools, and workflows.
+>[Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a system that can build, train, and deploy machine learning (ML) models with fully managed infrastructure, tools, and workflows.
 
 We use `SageMaker` to host our model and expose it as the `SageMaker Endpoint`.
 
@@ -57,16 +50,6 @@ from langchain.llms import SagemakerEndpoint
 from langchain.llms.sagemaker_endpoint import LLMContentHandler
 ```
 
-## Chat models
-
-### Bedrock Chat
-
-See a [usage example](/docs/integrations/chat/bedrock).
-
-```python
-from langchain.chat_models import BedrockChat
-```
-
 ## Text Embedding Models
 
 ### Bedrock
@@ -84,32 +67,11 @@ from langchain.embeddings import SagemakerEndpointEmbeddings
 from langchain.llms.sagemaker_endpoint import ContentHandlerBase
 ```
 
-## Chains
-
-### Amazon Comprehend Moderation Chain
-
->[Amazon Comprehend](https://aws.amazon.com/comprehend/) is a natural-language processing (NLP) service that 
-> uses machine learning to uncover valuable insights and connections in text.
-
-
-We need to install the `boto3` and `nltk` libraries.
-
-```bash
-pip install boto3 nltk
-```
-
-See a [usage example](/docs/guides/safety/amazon_comprehend_chain).
-
-```python
-from langchain_experimental.comprehend_moderation import AmazonComprehendModerationChain
-```
 
 ## Document loaders
 
 ### AWS S3 Directory and File
-
->[Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-folders.html)
-> is an object storage service.
+>[Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-folders.html) is an object storage service.
 >[AWS S3 Directory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-folders.html)
 >[AWS S3 Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html)
 
@@ -121,17 +83,6 @@ See a [usage example for S3FileLoader](/docs/integrations/document_loaders/aws_s
 from langchain.document_loaders import S3DirectoryLoader, S3FileLoader
 ```
 
-### Amazon Textract
-
->[Amazon Textract](https://docs.aws.amazon.com/managedservices/latest/userguide/textract.html) is a machine 
-> learning (ML) service that automatically extracts text, handwriting, and data from scanned documents.
-
-See a [usage example](/docs/integrations/document_loaders/amazon_textract).
-
-```python
-from langchain.document_loaders import AmazonTextractPDFLoader
-```
-
 ## Memory
 
 ### AWS DynamoDB
@@ -152,112 +103,3 @@ See a [usage example](/docs/integrations/memory/aws_dynamodb).
 ```python
 from langchain.memory import DynamoDBChatMessageHistory
 ```
-
-## Retrievers
-
-### Amazon Kendra
-
-> [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html) is an intelligent search service 
-> provided by `Amazon Web Services` (`AWS`). It utilizes advanced natural language processing (NLP) and machine 
-> learning algorithms to enable powerful search capabilities across various data sources within an organization. 
-> `Kendra` is designed to help users find the information they need quickly and accurately, 
-> improving productivity and decision-making.
-
-> With `Kendra`, we can search across a wide range of content types, including documents, FAQs, knowledge bases, 
-> manuals, and websites. It supports multiple languages and can understand complex queries, synonyms, and 
-> contextual meanings to provide highly relevant search results.
-
-We need to install the `boto3` library.
-
-```bash
-pip install boto3
-```
-
-See a [usage example](/docs/integrations/retrievers/amazon_kendra_retriever).
-
-```python
-from langchain.retrievers import AmazonKendraRetriever
-```
-
-### Amazon Bedrock (Knowledge Bases)
-
-> [Knowledge bases for Amazon Bedrock](https://aws.amazon.com/bedrock/knowledge-bases/) is an 
-> `Amazon Web Services` (`AWS`) offering which lets you quickly build RAG applications by using your 
-> private data to customize foundation model response.
-
-We need to install the `boto3` library.
-
-```bash
-pip install boto3
-```
-
-See a [usage example](/docs/integrations/retrievers/amazon_bedrock_knowledge_bases).
-
-```python
-from langchain.retrievers import AmazonKnowledgeBasesRetriever
-```
-
-## Vector stores
-
-### Amazon OpenSearch Service
-
-> [Amazon OpenSearch Service](https://aws.amazon.com/opensearch-service/) performs 
-> interactive log analytics, real-time application monitoring, website search, and more. `OpenSearch` is 
-> an open source, 
-> distributed search and analytics suite derived from `Elasticsearch`. `Amazon OpenSearch Service` offers the 
-> latest versions of `OpenSearch`, support for many versions of `Elasticsearch`, as well as 
-> visualization capabilities powered by `OpenSearch Dashboards` and `Kibana`.
-
-We need to install several python libraries.
-
-```bash
-pip install boto3 requests requests-aws4auth
-```
-
-See a [usage example](/docs/integrations/vectorstores/opensearch#using-aos-amazon-opensearch-service).
-
-```python
-from langchain.vectorstores import OpenSearchVectorSearch
-```
-
-## Tools
-
-### AWS Lambda
-
->[`Amazon AWS Lambda`](https://aws.amazon.com/pm/lambda/) is a serverless computing service provided by 
-> `Amazon Web Services` (`AWS`). It helps developers to build and run applications and services without 
-> provisioning or managing servers. This serverless architecture enables you to focus on writing and 
-> deploying code, while AWS automatically takes care of scaling, patching, and managing the 
-> infrastructure required to run your applications.
-
-We need to install `boto3` python library.
-
-```bash
-pip install boto3
-```
-
-See a [usage example](/docs/integrations/tools/awslambda).
-
-
-## Callbacks
-
-### SageMaker Tracking
-
->[Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a fully managed service that is used to quickly 
-> and easily build, train and deploy machine learning (ML) models.
-
->[Amazon SageMaker Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments.html) is a capability 
-> of `Amazon SageMaker` that lets you organize, track, 
-> compare and evaluate ML experiments and model versions.
- 
-We need to install several python libraries.
-
-```bash
-pip install google-search-results sagemaker
-```
-
-See a [usage example](/docs/integrations/callbacks/sagemaker_tracking).
-
-```python
-from langchain.callbacks import SageMakerCallbackHandler
-```

docs/docs/integrations/platforms/huggingface.mdx

@@ -1,136 +0,0 @@
-# Hugging Face
-
-All functionality related to the [Hugging Face Platform](https://huggingface.co/).
-
-## LLMs
-
-### Hugging Face Hub
-
->The [Hugging Face Hub](https://huggingface.co/docs/hub/index) is a platform 
-> with over 350k models, 75k datasets, and 150k demo apps (Spaces), all open source 
-> and publicly available, in an online platform where people can easily 
-> collaborate and build ML together. The Hub works as a central place where anyone 
-> can explore, experiment, collaborate, and build technology with Machine Learning.
-
-To use, we should have the `huggingface_hub` python [package installed](https://huggingface.co/docs/huggingface_hub/installation).
-
-```bash
-pip install huggingface_hub
-```
-
-See a [usage example](/docs/integrations/llms/huggingface_hub).
-
-```python
-from langchain.llms import HuggingFaceHub
-```
-
-### Hugging Face Local Pipelines
-
-Hugging Face models can be run locally through the `HuggingFacePipeline` class.
-
-We need to install `transformers` python package.
-
-```bash
-pip install transformers
-```
-
-See a [usage example](/docs/integrations/llms/huggingface_pipelines).
-
-```python
-from langchain.llms.huggingface_pipeline import HuggingFacePipeline
-```
-
-### Hugging Face TextGen Inference
-
->[Text Generation Inference](https://github.com/huggingface/text-generation-inference) is 
-> a Rust, Python and gRPC server for text generation inference. Used in production at 
-> [HuggingFace](https://huggingface.co/) to power LLMs api-inference widgets.
-
-We need to install `text_generation` python package.
-
-```bash
-pip install text_generation
-```
-
-See a [usage example](/docs/integrations/llms/huggingface_textgen_inference).
-
-```python
-from langchain.llms import HuggingFaceTextGenInference
-```
-
-
-
-## Document Loaders
-
-### Hugging Face dataset
-
->[Hugging Face Hub](https://huggingface.co/docs/hub/index) is home to over 75,000 
-> [datasets](https://huggingface.co/docs/hub/index#datasets) in more than 100 languages 
-> that can be used for a broad range of tasks across NLP, Computer Vision, and Audio.
-> They used for a diverse range of tasks such as translation, automatic speech 
-> recognition, and image classification.
-
-We need to install `datasets` python package.
-
-```bash
-pip install datasets
-```
-
-See a [usage example](/docs/integrations/document_loaders/hugging_face_dataset).
-
-```python
-from langchain.document_loaders.hugging_face_dataset import HuggingFaceDatasetLoader
-```
-
-
-## Embedding Models
-
-### Hugging Face Hub
-
->The [Hugging Face Hub](https://huggingface.co/docs/hub/index) is a platform 
-> with over 350k models, 75k datasets, and 150k demo apps (Spaces), all open source 
-> and publicly available, in an online platform where people can easily 
-> collaborate and build ML together. The Hub works as a central place where anyone 
-> can explore, experiment, collaborate, and build technology with Machine Learning.
-
-We need to install the `sentence_transformers` python package.
-
-```bash
-pip install sentence_transformers
-```
-
-
-#### HuggingFaceEmbeddings
-
-See a [usage example](/docs/integrations/text_embedding/huggingfacehub).
-
-```python
-from langchain.embeddings import HuggingFaceEmbeddings
-```
-#### HuggingFaceInstructEmbeddings
-
-See a [usage example](/docs/integrations/text_embedding/instruct_embeddings).
-
-```python
-from langchain.embeddings import HuggingFaceInstructEmbeddings
-```
-
-
-## Tools
-
-### Hugging Face Hub Tools
-
->[Hugging Face Tools](https://huggingface.co/docs/transformers/v4.29.0/en/custom_tools) 
-> support text I/O and are loaded using the `load_huggingface_tool` function.
-
-We need to install several python packages.
-
-```bash
-pip install transformers huggingface_hub
-```
-
-See a [usage example](/docs/integrations/tools/huggingface_tools).
-
-```python
-from langchain.agents import load_huggingface_tool
-```

docs/docs/integrations/providers/databricks.md

@@ -7,8 +7,9 @@ Databricks embraces the LangChain ecosystem in various ways:
 
 1. Databricks connector for the SQLDatabase Chain: SQLDatabase.from_databricks() provides an easy way to query your data on Databricks through LangChain
 2. Databricks MLflow integrates with LangChain: Tracking and serving LangChain applications with fewer steps
-3. Databricks as an LLM provider: Deploy your fine-tuned LLMs on Databricks via serving endpoints or cluster driver proxy apps, and query it as langchain.llms.Databricks
-4. Databricks Dolly: Databricks open-sourced Dolly which allows for commercial use, and can be accessed through the Hugging Face Hub
+3. Databricks MLflow AI Gateway
+4. Databricks as an LLM provider: Deploy your fine-tuned LLMs on Databricks via serving endpoints or cluster driver proxy apps, and query it as langchain.llms.Databricks
+5. Databricks Dolly: Databricks open-sourced Dolly which allows for commercial use, and can be accessed through the Hugging Face Hub
 
 Databricks connector for the SQLDatabase Chain
 ----------------------------------------------
@@ -24,58 +25,19 @@ Databricks provides a fully managed and hosted version of MLflow integrated with
 
 Databricks MLflow makes it more convenient to develop LangChain applications on Databricks. For MLflow tracking, you don't need to set the tracking uri. For MLflow Model Serving, you can save LangChain Chains in the MLflow langchain flavor, and then register and serve the Chain with a few clicks on Databricks, with credentials securely managed by MLflow Model Serving.
 
-Databricks External Models
---------------------------
+Databricks MLflow AI Gateway
+----------------------------
 
-[Databricks External Models](https://docs.databricks.com/generative-ai/external-models/index.html) is a service that is designed to streamline the usage and management of various large language model (LLM) providers, such as OpenAI and Anthropic, within an organization. It offers a high-level interface that simplifies the interaction with these services by providing a unified endpoint to handle specific LLM related requests. The following example creates an endpoint that serves OpenAI's GPT-4 model and generates a chat response from it:
-
-```python
-from langchain.chat_models import ChatDatabricks
-from langchain.schema.messages import HumanMessage
-from mlflow.deployments import get_deploy_client
-
-
-client = get_deploy_client("databricks")
-name = f"chat"
-client.create_endpoint(
-    name=name,
-    config={
-        "served_entities": [
-            {
-                "name": "test",
-                "external_model": {
-                    "name": "gpt-4",
-                    "provider": "openai",
-                    "task": "llm/v1/chat",
-                    "openai_config": {
-                        "openai_api_key": "{{secrets/<scope>/<key>}}",
-                    },
-                },
-            }
-        ],
-    },
-)
-chat = ChatDatabricks(endpoint=name, temperature=0.1)
-print(chat([HumanMessage(content="hello")]))
-# -> content='Hello! How can I assist you today?'
-```
-
-Databricks Foundation Model APIs
---------------------------------
-
-[Databricks Foundation Model APIs](https://docs.databricks.com/machine-learning/foundation-models/index.html) allow you to access and query state-of-the-art open source models from dedicated serving endpoints. With Foundation Model APIs, developers can quickly and easily build applications that leverage a high-quality generative AI model without maintaining their own model deployment. The following example uses the `databricks-bge-large-en` endpoint to generate embeddings from  text:
-
-```python
-from langchain.llms import DatabricksEmbeddings
-
-
-embeddings = DatabricksEmbeddings(endpoint="databricks-bge-large-en")
-print(embeddings.embed_query("hello")[:3])
-# -> [0.051055908203125, 0.007221221923828125, 0.003879547119140625, ...]
-```
+See [MLflow AI Gateway](/docs/integrations/providers/mlflow_ai_gateway).
 
 Databricks as an LLM provider
 -----------------------------
 
-The notebook [Wrap Databricks endpoints as LLMs](/docs/integrations/llms/databricks#wrapping-a-serving-endpoint-custom-model) demonstrates how to serve a custom model that has been registered by MLflow as a Databricks endpoint.
-It supports two types of endpoints: the serving endpoint, which is recommended for both production and development, and the cluster driver proxy app, which is recommended for interactive development. 
+The notebook [Wrap Databricks endpoints as LLMs](/docs/integrations/llms/databricks) illustrates the method to wrap Databricks endpoints as LLMs in LangChain. It supports two types of endpoints: the serving endpoint, which is recommended for both production and development, and the cluster driver proxy app, which is recommended for interactive development. 
+
+Databricks endpoints support Dolly, but are also great for hosting models like MPT-7B or any other models from the Hugging Face ecosystem. Databricks endpoints can also be used with proprietary models like OpenAI to provide a governance layer for enterprises.
+
+Databricks Dolly
+----------------
+
+Databricks’ Dolly is an instruction-following large language model trained on the Databricks machine learning platform that is licensed for commercial use. The model is available on Hugging Face Hub as databricks/dolly-v2-12b. See the notebook [Hugging Face Hub](/docs/integrations/llms/huggingface_hub) for instructions to access it through the Hugging Face Hub integration with LangChain. 

docs/docs/integrations/providers/deepsparse.mdx

@@ -5,117 +5,31 @@ It is broken into two parts: installation and setup, and then examples of DeepSp
 
 ## Installation and Setup
 
-- Install the Python packages with `pip install deepsparse-nightly[llm] langchain`
+- Install the Python package with `pip install deepsparse`
 - Choose a [SparseZoo model](https://sparsezoo.neuralmagic.com/?useCase=text_generation) or export a support model to ONNX [using Optimum](https://github.com/neuralmagic/notebooks/blob/main/notebooks/opt-text-generation-deepsparse-quickstart/OPT_Text_Generation_DeepSparse_Quickstart.ipynb)
-- Models hosted on HuggingFace are also supported by prepending `"hf:"` to the model id, such as [`"hf:mgoin/TinyStories-33M-quant-deepsparse"`](https://huggingface.co/mgoin/TinyStories-33M-quant-deepsparse)
 
-## Using DeepSparse With LangChain
+## Wrappers
 
-There is a DeepSparse LLM wrapper, which you can access with:
+### LLM
+
+There exists a DeepSparse LLM wrapper, which you can access with:
 
 ```python
 from langchain.llms import DeepSparse
 ```
 
-It provides a simple, unified interface for all models:
+It provides a unified interface for all models:
 
 ```python
-from langchain.llms import DeepSparse
 llm = DeepSparse(model='zoo:nlg/text_generation/codegen_mono-350m/pytorch/huggingface/bigpython_bigquery_thepile/base-none')
+
 print(llm('def fib():'))
-"""
-a, b = 0, 1
-    while True:
-        yield a
-        a, b = b, a + b
-
-def fib2(n):
-    a, b = 0, 1
-    while a < n:
-        yield a
-        a, b = b, a + b
-
-def primes():
-    yield 2
-    it = fib()
-    while True:
-        try:
-            yield next(it)
-        except StopIteration:
-            return
-"""
 ```
-## Streaming
-The DeepSparse LangChain wrapper also supports per token output streaming:
+
+Additional parameters can be passed using the `config` parameter:
 
 ```python
-from langchain.llms import DeepSparse
-llm = DeepSparse(
-    model="hf:neuralmagic/mpt-7b-chat-pruned50-quant",
-    streaming=True
-)
-for chunk in llm.stream("Tell me a joke", stop=["'","\n"]):
-    print(chunk, end='', flush=True)
+config = {'max_generated_tokens': 256}
+
+llm = DeepSparse(model='zoo:nlg/text_generation/codegen_mono-350m/pytorch/huggingface/bigpython_bigquery_thepile/base-none', config=config)
 ```
-## Using Instruction Fine-tune Models With DeepSparse
-Here's an example of how to prompt an instruction fine-tuned model using DeepSparse and the MPT-Instruct model:
-```python
-prompt="""
-Below is an instruction that describes a task. Write a response that appropriately completes the request. ### Instruction: what is quantization? ### Response:
-"""
-llm = DeepSparse(model='zoo:mpt-7b-dolly_mpt_pretrain-pruned50_quantized')
-print(llm(prompt))
-"""
-In physics, the term "quantization" refers to the process of transforming a continuous variable into a set of discrete values. In the context of quantum mechanics, this process is used to describe the restriction of the degrees of freedom of a system to a set of discrete values. In other words, it is the process of transforming the continuous spectrum of a physical quantity into a set of discrete, or "quantized", values.
-"""
-```
-You can also do all the other things you are used to doing in LangChain such as using `PromptTemplete`s and parsing outputs:
-```python
-from langchain.prompts import PromptTemplate
-from langchain.output_parsers import CommaSeparatedListOutputParser
-
-llm_parser = CommaSeparatedListOutputParser()
-llm = DeepSparse(model='hf:neuralmagic/mpt-7b-chat-pruned50-quant')
-
-prompt = PromptTemplate(
-    template="List how to {do}",
-    input_variables=["do"])
-
-output = llm.predict(text=prompt.format(do="Become a great software engineer"))
-
-print(output)
-"""
-List how to Become a great software engineer
-By TechRadar Staff
-Here are some tips on how to become a great software engineer:
-1. Develop good programming skills: To become a great software engineer, you need to have a strong understanding of programming concepts and techniques. You should be able to write clean, efficient code that meets the requirements of the project.
-2. Learn new technologies: To stay up-to in the field, you should be familiar with new technologies and programming languages. You should also be able to adapt to new environments and work with different tools and platforms.
-3. Build a portfolio: To showcase your skills, you should build a portfolio of your work. This will help you showcase your skills and abilities to potential employers.
-4. Network: Networking is an important aspect of your career. You should attend industry events and conferences to meet other professionals in the field.
-5. Stay up-to-date with industry trends: Stay up-to-date with industry trends and developments. This will help you stay relevant in your field and help you stay ahead of your competition.
-6. Take courses and certifications: Taking courses and certifications can help you gain new skills and knowledge. This will help you stay ahead of your competition and help you grow in your career.
-7. Practice and refine your skills: Practice and refine your skills by working on projects and solving problems. This will help you develop your skills and help you grow in your career.
-"""
-
-```
-## Configuration
-
-The DeepSparse LangChain integration has arguments to control the model loaded, any configs for how the model should be loaded, configs to control how tokens are generated, and then whether to return all tokens at once or to stream them one-by-one.
-
-```python
-model: str
-"""The path to a model file or directory or the name of a SparseZoo model stub."""
-
-model_config: Optional[Dict[str, Any]] = None
-"""Keyword arguments passed to the pipeline construction.
-Common parameters are sequence_length, prompt_sequence_length"""
-
-generation_config: Union[None, str, Dict] = None
-"""GenerationConfig dictionary consisting of parameters used to control
-sequences generated for each prompt. Common parameters are:
-max_length, max_new_tokens, num_return_sequences, output_scores,
-top_p, top_k, repetition_penalty."""
-
-streaming: bool = False
-"""Whether to stream the results, token by token."""
-```

docs/docs/integrations/providers/hologres.mdx

@@ -11,7 +11,7 @@
 Click [here](https://www.alibabacloud.com/zh/product/hologres) to fast deploy a Hologres cloud instance.
 
 ```bash
-pip install hologres-vector
+pip install psycopg2
 ```
 
 ## Vector Store

docs/docs/integrations/providers/huggingface.mdx

@@ -0,0 +1,69 @@
+# Hugging Face
+
+This page covers how to use the Hugging Face ecosystem (including the [Hugging Face Hub](https://huggingface.co)) within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Hugging Face wrappers.
+
+## Installation and Setup
+
+If you want to work with the Hugging Face Hub:
+- Install the Hub client library with `pip install huggingface_hub`
+- Create a Hugging Face account (it's free!)
+- Create an [access token](https://huggingface.co/docs/hub/security-tokens) and set it as an environment variable (`HUGGINGFACEHUB_API_TOKEN`)
+
+If you want work with the Hugging Face Python libraries:
+- Install `pip install transformers` for working with models and tokenizers
+- Install `pip install datasets` for working with datasets
+
+## Wrappers
+
+### LLM
+
+There exists two Hugging Face LLM wrappers, one for a local pipeline and one for a model hosted on Hugging Face Hub.
+Note that these wrappers only work for models that support the following tasks: [`text2text-generation`](https://huggingface.co/models?library=transformers&pipeline_tag=text2text-generation&sort=downloads), [`text-generation`](https://huggingface.co/models?library=transformers&pipeline_tag=text-classification&sort=downloads)
+
+To use the local pipeline wrapper:
+```python
+from langchain.llms import HuggingFacePipeline
+```
+
+To use a the wrapper for a model hosted on Hugging Face Hub:
+```python
+from langchain.llms import HuggingFaceHub
+```
+For a more detailed walkthrough of the Hugging Face Hub wrapper, see [this notebook](/docs/integrations/llms/huggingface_hub)
+
+
+### Embeddings
+
+There exists two Hugging Face Embeddings wrappers, one for a local model and one for a model hosted on Hugging Face Hub.
+Note that these wrappers only work for [`sentence-transformers` models](https://huggingface.co/models?library=sentence-transformers&sort=downloads).
+
+To use the local pipeline wrapper:
+```python
+from langchain.embeddings import HuggingFaceEmbeddings
+```
+
+To use a the wrapper for a model hosted on Hugging Face Hub:
+```python
+from langchain.embeddings import HuggingFaceHubEmbeddings
+```
+For a more detailed walkthrough of this, see [this notebook](/docs/integrations/text_embedding/huggingfacehub)
+
+### Tokenizer
+
+There are several places you can use tokenizers available through the `transformers` package.
+By default, it is used to count tokens for all LLMs.
+
+You can also use it to count tokens when splitting documents with 
+```python
+from langchain.text_splitter import CharacterTextSplitter
+CharacterTextSplitter.from_huggingface_tokenizer(...)
+```
+For a more detailed walkthrough of this, see [this notebook](/docs/modules/data_connection/document_transformers/text_splitters/huggingface_length_function)
+
+
+### Datasets
+
+The Hugging Face Hub has lots of great [datasets](https://huggingface.co/datasets) that can be used to evaluate your LLM chains.
+
+For a detailed walkthrough of how to use them to do so, see [this notebook](/docs/integrations/document_loaders/hugging_face_dataset)

docs/docs/integrations/providers/mlflow.mdx

@@ -1,119 +0,0 @@
-# MLflow Deployments for LLMs
-
->[The MLflow Deployments for LLMs](https://www.mlflow.org/docs/latest/llms/deployments/index.html) is a powerful tool designed to streamline the usage and management of various large
-> language model (LLM) providers, such as OpenAI and Anthropic, within an organization. It offers a high-level interface
-> that simplifies the interaction with these services by providing a unified endpoint to handle specific LLM related requests.
-
-## Installation and Setup
-
-Install `mlflow` with MLflow Deployments dependencies:
-
-```sh
-pip install 'mlflow[genai]'
-```
-
-Set the OpenAI API key as an environment variable:
-
-```sh
-export OPENAI_API_KEY=...
-```
-
-Create a configuration file:
-
-```yaml
-endpoints:
-  - name: completions
-    endpoint_type: llm/v1/completions
-    model:
-      provider: openai
-      name: text-davinci-003
-      config:
-        openai_api_key: $OPENAI_API_KEY
-
-  - name: embeddings
-    endpoint_type: llm/v1/embeddings
-    model:
-      provider: openai
-      name: text-embedding-ada-002
-      config:
-        openai_api_key: $OPENAI_API_KEY
-```
-
-Start the deployments server:
-
-```sh
-mlflow deployments start-server --config-path /path/to/config.yaml
-```
-
-## Example provided by `MLflow`
-
->The `mlflow.langchain` module provides an API for logging and loading `LangChain` models.
-> This module exports multivariate LangChain models in the langchain flavor and univariate LangChain
-> models in the pyfunc flavor.
-
-See the [API documentation and examples](https://www.mlflow.org/docs/latest/python_api/mlflow.langchain) for more information.
-
-## Completions Example
-
-```python
-import mlflow
-from langchain.chains import LLMChain, PromptTemplate
-from langchain.llms import Mlflow
-
-llm = Mlflow(
-    target_uri="http://127.0.0.1:5000",
-    endpoint="completions",
-)
-
-llm_chain = LLMChain(
-    llm=Mlflow,
-    prompt=PromptTemplate(
-        input_variables=["adjective"],
-        template="Tell me a {adjective} joke",
-    ),
-)
-result = llm_chain.run(adjective="funny")
-print(result)
-
-with mlflow.start_run():
-    model_info = mlflow.langchain.log_model(chain, "model")
-
-model = mlflow.pyfunc.load_model(model_info.model_uri)
-print(model.predict([{"adjective": "funny"}]))
-```
-
-## Embeddings Example
-
-```python
-from langchain.embeddings import MlflowEmbeddings
-
-embeddings = MlflowEmbeddings(
-    target_uri="http://127.0.0.1:5000",
-    endpoint="embeddings",
-)
-
-print(embeddings.embed_query("hello"))
-print(embeddings.embed_documents(["hello"]))
-```
-
-## Chat Example
-
-```python
-from langchain.chat_models import ChatMlflow
-from langchain.schema import HumanMessage, SystemMessage
-
-chat = ChatMlflow(
-    target_uri="http://127.0.0.1:5000",
-    endpoint="chat",
-)
-
-messages = [
-    SystemMessage(
-        content="You are a helpful assistant that translates English to French."
-    ),
-    HumanMessage(
-        content="Translate this sentence from English to French: I love programming."
-    ),
-]
-print(chat(messages))
-```

docs/docs/integrations/providers/mlflow_ai_gateway.mdx

@@ -1,11 +1,5 @@
 # MLflow AI Gateway
 
-:::warning
-
-MLflow AI Gateway has been deprecated. Please use [MLflow Deployments for LLMs](./mlflow) instead.
-
-:::
-
 >[The MLflow AI Gateway](https://www.mlflow.org/docs/latest/gateway/index) service is a powerful tool designed to streamline the usage and management of various large 
 > language model (LLM) providers, such as OpenAI and Anthropic, within an organization. It offers a high-level interface 
 > that simplifies the interaction with these services by providing a unified endpoint to handle specific LLM related requests.

docs/docs/integrations/retrievers/amazon_kendra_retriever.ipynb

@@ -7,9 +7,9 @@
    "source": [
     "# Amazon Kendra\n",
     "\n",
-    "> [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html) is an intelligent search service provided by `Amazon Web Services` (`AWS`). It utilizes advanced natural language processing (NLP) and machine learning algorithms to enable powerful search capabilities across various data sources within an organization. `Kendra` is designed to help users find the information they need quickly and accurately, improving productivity and decision-making.\n",
+    "> Amazon Kendra is an intelligent search service provided by Amazon Web Services (AWS). It utilizes advanced natural language processing (NLP) and machine learning algorithms to enable powerful search capabilities across various data sources within an organization. Kendra is designed to help users find the information they need quickly and accurately, improving productivity and decision-making.\n",
     "\n",
-    "> With `Kendra`, users can search across a wide range of content types, including documents, FAQs, knowledge bases, manuals, and websites. It supports multiple languages and can understand complex queries, synonyms, and contextual meanings to provide highly relevant search results."
+    "> With Kendra, users can search across a wide range of content types, including documents, FAQs, knowledge bases, manuals, and websites. It supports multiple languages and can understand complex queries, synonyms, and contextual meanings to provide highly relevant search results."
    ]
   },
   {
@@ -74,24 +74,11 @@
   }
  ],
  "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.12"
-  }
+   "name": "python"
+  },
+  "orig_nbformat": 4
  },
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 2
 }

docs/docs/integrations/retrievers/bedrock.ipynb

@@ -5,13 +5,13 @@
    "id": "b6636c27-35da-4ba7-8313-eca21660cab3",
    "metadata": {},
    "source": [
-    "# Bedrock (Knowledge Bases)\n",
+    "# Amazon Bedrock (Knowledge Bases)\n",
     "\n",
     "> [Knowledge bases for Amazon Bedrock](https://aws.amazon.com/bedrock/knowledge-bases/) is an Amazon Web Services (AWS) offering which lets you quickly build RAG applications by using your private data to customize FM response.\n",
     "\n",
-    "> Implementing `RAG` requires organizations to perform several cumbersome steps to convert data into embeddings (vectors), store the embeddings in a specialized vector database, and build custom integrations into the database to search and retrieve text relevant to the user’s query. This can be time-consuming and inefficient.\n",
+    "> Implementing RAG requires organizations to perform several cumbersome steps to convert data into embeddings (vectors), store the embeddings in a specialized vector database, and build custom integrations into the database to search and retrieve text relevant to the user’s query. This can be time-consuming and inefficient.\n",
     "\n",
-    "> With `Knowledge Bases for Amazon Bedrock`, simply point to the location of your data in `Amazon S3`, and `Knowledge Bases for Amazon Bedrock` takes care of the entire ingestion workflow into your vector database. If you do not have an existing vector database, Amazon Bedrock creates an Amazon OpenSearch Serverless vector store for you. For retrievals, use the Langchain - Amazon Bedrock integration via the Retrieve API to retrieve relevant results for a user query from knowledge bases.\n",
+    "> With Knowledge Bases for Amazon Bedrock, simply point to the location of your data in Amazon S3, and Knowledge Bases for Amazon Bedrock takes care of the entire ingestion workflow into your vector database. If you do not have an existing vector database, Amazon Bedrock creates an Amazon OpenSearch Serverless vector store for you. For retrievals, use the Langchain - Amazon Bedrock integration via the Retrieve API to retrieve relevant results for a user query from knowledge bases.\n",
     "\n",
     "> Knowledge base can be configured through [AWS Console](https://aws.amazon.com/console/) or by using [AWS SDKs](https://aws.amazon.com/developer/tools/)."
    ]
@@ -108,7 +108,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.13"
   }
  },
  "nbformat": 4,

docs/docs/integrations/retrievers/self_query/mongodb_atlas.ipynb

@@ -1,321 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# MongoDB Atlas\n",
-    "\n",
-    "[MongoDB Atlas](https://www.mongodb.com/) is a document database that can be \n",
-    "used as a vector databse.\n",
-    "\n",
-    "In the walkthrough, we'll demo the `SelfQueryRetriever` with a `MongoDB Atlas` vector store."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Creating a MongoDB Atlas vectorstore\n",
-    "First we'll want to create a MongoDB Atlas VectorStore and seed it with some data. We've created a small demo set of documents that contain summaries of movies.\n",
-    "\n",
-    "NOTE: The self-query retriever requires you to have `lark` installed (`pip install lark`). We also need the `pymongo` package."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install lark pymongo"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We want to use `OpenAIEmbeddings` so we have to get the OpenAI API Key."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "OPENAI_API_KEY = \"Use your OpenAI key\"\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.schema import Document\n",
-    "from langchain.vectorstores import MongoDBAtlasVectorSearch\n",
-    "from pymongo import MongoClient\n",
-    "\n",
-    "CONNECTION_STRING = \"Use your MongoDB Atlas connection string\"\n",
-    "DB_NAME = \"Name of your MongoDB Atlas database\"\n",
-    "COLLECTION_NAME = \"Name of your collection in the database\"\n",
-    "INDEX_NAME = \"Name of a search index defined on the collection\"\n",
-    "\n",
-    "MongoClient = MongoClient(CONNECTION_STRING)\n",
-    "collection = MongoClient[DB_NAME][COLLECTION_NAME]\n",
-    "\n",
-    "embeddings = OpenAIEmbeddings()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "docs = [\n",
-    "    Document(\n",
-    "        page_content=\"A bunch of scientists bring back dinosaurs and mayhem breaks loose\",\n",
-    "        metadata={\"year\": 1993, \"rating\": 7.7, \"genre\": \"action\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"Leo DiCaprio gets lost in a dream within a dream within a dream within a ...\",\n",
-    "        metadata={\"year\": 2010, \"genre\": \"thriller\", \"rating\": 8.2},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"A bunch of normal-sized women are supremely wholesome and some men pine after them\",\n",
-    "        metadata={\"year\": 2019, \"rating\": 8.3, \"genre\": \"drama\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"Three men walk into the Zone, three men walk out of the Zone\",\n",
-    "        metadata={\"year\": 1979, \"rating\": 9.9, \"genre\": \"science fiction\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea\",\n",
-    "        metadata={\"year\": 2006, \"genre\": \"thriller\", \"rating\": 9.0},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"Toys come alive and have a blast doing so\",\n",
-    "        metadata={\"year\": 1995, \"genre\": \"animated\", \"rating\": 9.3},\n",
-    "    ),\n",
-    "]\n",
-    "\n",
-    "vectorstore = MongoDBAtlasVectorSearch.from_documents(\n",
-    "    docs,\n",
-    "    embeddings,\n",
-    "    collection=collection,\n",
-    "    index_name=INDEX_NAME,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "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/field-types/knn-vector) to get more details on how to define an Atlas Vector Search index.\n",
-    "You can name the index `{COLLECTION_NAME}` and create the index on the namespace `{DB_NAME}.{COLLECTION_NAME}`. 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",
-    "      \"genre\": {\n",
-    "        \"type\": \"token\"\n",
-    "      },\n",
-    "      \"ratings\": {\n",
-    "        \"type\": \"number\"\n",
-    "      },\n",
-    "      \"year\": {\n",
-    "        \"type\": \"number\"\n",
-    "      }\n",
-    "    }\n",
-    "  }\n",
-    "}\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Creating our self-querying retriever\n",
-    "Now we can instantiate our retriever. To do this we'll need to provide some information upfront about the metadata fields that our documents support and a short description of the document contents."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains.query_constructor.base import AttributeInfo\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.retrievers.self_query.base import SelfQueryRetriever\n",
-    "\n",
-    "metadata_field_info = [\n",
-    "    AttributeInfo(\n",
-    "        name=\"genre\",\n",
-    "        description=\"The genre of the movie\",\n",
-    "        type=\"string\",\n",
-    "    ),\n",
-    "    AttributeInfo(\n",
-    "        name=\"year\",\n",
-    "        description=\"The year the movie was released\",\n",
-    "        type=\"integer\",\n",
-    "    ),\n",
-    "    AttributeInfo(\n",
-    "        name=\"rating\", description=\"A 1-10 rating for the movie\", type=\"float\"\n",
-    "    ),\n",
-    "]\n",
-    "document_content_description = \"Brief summary of a movie\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\n",
-    "retriever = SelfQueryRetriever.from_llm(\n",
-    "    llm, vectorstore, document_content_description, metadata_field_info, verbose=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Testing it out\n",
-    "And now we can try actually using our retriever!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This example only specifies a relevant query\n",
-    "retriever.get_relevant_documents(\"What are some movies about dinosaurs\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This example specifies a filter\n",
-    "retriever.get_relevant_documents(\"What are some highly rated movies (above 9)?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This example only specifies a query and a filter\n",
-    "retriever.get_relevant_documents(\n",
-    "    \"I want to watch a movie about toys rated higher than 9\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This example specifies a composite filter\n",
-    "retriever.get_relevant_documents(\n",
-    "    \"What's a highly rated (above or equal 9) thriller film?\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This example specifies a query and composite filter\n",
-    "retriever.get_relevant_documents(\n",
-    "    \"What's a movie after 1990 but before 2005 that's all about dinosaurs, \\\n",
-    "    and preferably has a lot of action\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Filter k\n",
-    "\n",
-    "We can also use the self query retriever to specify `k`: the number of documents to fetch.\n",
-    "\n",
-    "We can do this by passing `enable_limit=True` to the constructor."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "retriever = SelfQueryRetriever.from_llm(\n",
-    "    llm,\n",
-    "    vectorstore,\n",
-    "    document_content_description,\n",
-    "    metadata_field_info,\n",
-    "    verbose=True,\n",
-    "    enable_limit=True,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This example only specifies a relevant query\n",
-    "retriever.get_relevant_documents(\"What are two movies about dinosaurs?\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/text_embedding/bedrock.ipynb

@@ -7,16 +7,7 @@
    "source": [
     "# Bedrock\n",
     "\n",
-    ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of \n",
-    "> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, \n",
-    "> `Meta`, `Stability AI`, and `Amazon` via a single API, along with a broad set of capabilities you need to \n",
-    "> build generative AI applications with security, privacy, and responsible AI. Using `Amazon Bedrock`, \n",
-    "> you can easily experiment with and evaluate top FMs for your use case, privately customize them with \n",
-    "> your data using techniques such as fine-tuning and `Retrieval Augmented Generation` (`RAG`), and build \n",
-    "> agents that execute tasks using your enterprise systems and data sources. Since `Amazon Bedrock` is \n",
-    "> serverless, you don't have to manage any infrastructure, and you can securely integrate and deploy \n",
-    "> generative AI capabilities into your applications using the AWS services you are already familiar with.\n",
-    "\n"
+    ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that makes FMs from leading AI startups and Amazon available via an API, so you can choose from a wide range of FMs to find the model that is best suited for your use case.\n"
    ]
   },
   {

docs/docs/integrations/toolkits/office365.ipynb

@@ -6,15 +6,9 @@
    "source": [
     "# Office365\n",
     "\n",
-    ">[Microsoft 365](https://www.office.com/) is a product family of productivity software, collaboration and cloud-based services owned by `Microsoft`.\n",
-    ">\n",
-    ">Note: `Office 365` was rebranded as `Microsoft 365`.\n",
-    "\n",
     "This notebook walks through connecting LangChain to `Office365` email and calendar.\n",
     "\n",
-    "To use this toolkit, you need to set up your credentials explained in the [Microsoft Graph authentication and authorization overview](https://learn.microsoft.com/en-us/graph/auth/). Once you've received a CLIENT_ID and CLIENT_SECRET, you can input them as environmental variables below.\n",
-    "\n",
-    "You can also use the [authentication instructions from here](https://o365.github.io/python-o365/latest/getting_started.html#oauth-setup-pre-requisite)."
+    "To use this toolkit, you will need to set up your credentials explained in the [Microsoft Graph authentication and authorization overview](https://learn.microsoft.com/en-us/graph/auth/). Once you've received a CLIENT_ID and CLIENT_SECRET, you can input them as environmental variables below."
    ]
   },
   {
@@ -23,8 +17,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install --upgrade O365\n",
-    "!pip install beautifulsoup4  # This is optional but is useful for parsing HTML messages"
+    "!pip install --upgrade O365 > /dev/null\n",
+    "!pip install beautifulsoup4 > /dev/null # This is optional but is useful for parsing HTML messages"
    ]
   },
   {
@@ -33,7 +27,7 @@
    "source": [
     "## Assign Environmental Variables\n",
     "\n",
-    "The toolkit will read the `CLIENT_ID` and `CLIENT_SECRET` environmental variables to authenticate the user so you need to set them here. You will also need to set your `OPENAI_API_KEY` to use the agent later."
+    "The toolkit will read the CLIENT_ID and CLIENT_SECRET environmental variables to authenticate the user so you need to set them here. You will also need to set your OPENAI_API_KEY to use the agent later."
    ]
   },
   {

docs/docs/integrations/toolkits/openapi.ipynb

@@ -93,9 +93,12 @@
     }
    ],
    "source": [
-    "!wget https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml -O openai_openapi.yaml\n",
-    "!wget https://www.klarna.com/us/shopping/public/openai/v0/api-docs -O klarna_openapi.yaml\n",
-    "!wget https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/spotify.com/1.0.0/openapi.yaml -O spotify_openapi.yaml"
+    "!wget https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml\n",
+    "!mv openapi.yaml openai_openapi.yaml\n",
+    "!wget https://www.klarna.com/us/shopping/public/openai/v0/api-docs\n",
+    "!mv api-docs klarna_openapi.yaml\n",
+    "!wget https://raw.githubusercontent.com/APIs-guru/openapi-directory/main/APIs/spotify.com/1.0.0/openapi.yaml\n",
+    "!mv openapi.yaml spotify_openapi.yaml"
    ]
   },
   {

docs/docs/integrations/toolkits/slack.ipynb

@@ -1,147 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Slack\n",
-    "\n",
-    "This notebook walks through connecting LangChain to your `Slack` account.\n",
-    "\n",
-    "To use this toolkit, you will need to get a token explained in the [Slack API docs](https://api.slack.com/tutorials/tracks/getting-a-token). Once you've received a SLACK_USER_TOKEN, you can input it as an environmental variable below."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install --upgrade slack_sdk > /dev/null\n",
-    "!pip install beautifulsoup4 > /dev/null # This is optional but is useful for parsing HTML messages"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Assign Environmental Variables\n",
-    "\n",
-    "The toolkit will read the SLACK_USER_TOKEN environmental variable to authenticate the user so you need to set them here. You will also need to set your OPENAI_API_KEY to use the agent later."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Set environmental variables here"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create the Toolkit and Get Tools\n",
-    "\n",
-    "To start, you need to create the toolkit, so you can access its tools later."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.agents.agent_toolkits import SlackToolkit\n",
-    "\n",
-    "toolkit = SlackToolkit()\n",
-    "tools = toolkit.get_tools()\n",
-    "tools"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Use within an Agent"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.agents import AgentType, initialize_agent\n",
-    "from langchain.llms import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\n",
-    "agent = initialize_agent(\n",
-    "    tools=toolkit.get_tools(),\n",
-    "    llm=llm,\n",
-    "    verbose=False,\n",
-    "    agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent.run(\"Send a greeting to my coworkers in the #general channel.\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent.run(\"How many channels are in the workspace? Please list out their names.\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent.run(\n",
-    "    \"Tell me the number of messages sent in the #introductions channel from the past month.\"\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

docs/docs/integrations/toolkits/steam.ipynb

@@ -1,105 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Steam Game Recommendation & Game Details Tool"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "from langchain.agents import AgentType, initialize_agent\n",
-    "from langchain.agents.agent_toolkits.steam.toolkit import SteamToolkit\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.utilities.steam import SteamWebAPIWrapper"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "os.environ[\"STEAM_KEY\"] = \"xyz\"\n",
-    "os.environ[\"STEAM_ID\"] = \"123\"\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"abc\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = OpenAI(temperature=0)\n",
-    "Steam = SteamWebAPIWrapper()\n",
-    "toolkit = SteamToolkit.from_steam_api_wrapper(Steam)\n",
-    "agent = initialize_agent(\n",
-    "    toolkit.get_tools(), llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3m I need to find the game details\n",
-      "Action: Get Games Details\n",
-      "Action Input: Terraria\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mThe id is: 105600\n",
-      "The link is: https://store.steampowered.com/app/105600/Terraria/?snr=1_7_15__13\n",
-      "The price is: $9.99\n",
-      "The summary of the game is: Dig, Fight, Explore, Build:  The very world is at your fingertips as you fight for survival, fortune, and glory.   Will you delve deep into cavernous expanses in search of treasure and raw materials with which to craft ever-evolving gear, machinery, and aesthetics?   Perhaps you will choose instead to seek out ever-greater foes to test your mettle in combat?   Maybe you will decide to construct your own city to house the host of mysterious allies you may encounter along your travels? In the World of Terraria, the choice is yours!Blending elements of classic action games with the freedom of sandbox-style creativity, Terraria is a unique gaming experience where both the journey and the destination are completely in the player’s control.   The Terraria adventure is truly as unique as the players themselves!  Are you up for the monumental task of exploring, creating, and defending a world of your own?   Key features: Sandbox Play  Randomly generated worlds Free Content Updates \n",
-      "The supported languages of the game are: English, French, Italian, German, Spanish - Spain, Polish, Portuguese - Brazil, Russian, Simplified Chinese\n",
-      "\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: Terraria is a game with an id of 105600, a link of https://store.steampowered.com/app/105600/Terraria/?snr=1_7_15__13, a price of $9.99, a summary of \"Dig, Fight, Explore, Build:  The very world is at your fingertips as you fight for survival, fortune, and glory.   Will you delve deep into cavernous expanses in search of treasure and raw materials with which to craft ever-evolving gear, machinery, and aesthetics?   Perhaps you will choose instead to seek out ever-greater foes to test your mettle in combat?   Maybe you will decide to construct your own city to house the host of mysterious allies you may encounter along your travels? In the World of Terraria, the choice is yours!Blending elements of classic action games with the freedom of sandbox-style creativity, Terraria is a unique gaming experience where both the journey and the destination are completely in the player’s control.   The Terraria adventure is truly as unique as the players themselves!  Are you up for the monumental task of exploring, creating, and defending a\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      "{'input': 'can you give the information about the game Terraria', 'output': 'Terraria is a game with an id of 105600, a link of https://store.steampowered.com/app/105600/Terraria/?snr=1_7_15__13, a price of $9.99, a summary of \"Dig, Fight, Explore, Build:  The very world is at your fingertips as you fight for survival, fortune, and glory.   Will you delve deep into cavernous expanses in search of treasure and raw materials with which to craft ever-evolving gear, machinery, and aesthetics?   Perhaps you will choose instead to seek out ever-greater foes to test your mettle in combat?   Maybe you will decide to construct your own city to house the host of mysterious allies you may encounter along your travels? In the World of Terraria, the choice is yours!Blending elements of classic action games with the freedom of sandbox-style creativity, Terraria is a unique gaming experience where both the journey and the destination are completely in the player’s control.   The Terraria adventure is truly as unique as the players themselves!  Are you up for the monumental task of exploring, creating, and defending a'}\n"
-     ]
-    }
-   ],
-   "source": [
-    "out = agent(\"can you give the information about the game Terraria\")\n",
-    "print(out)"
-   ]
-  }
- ],
- "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.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/tools/awslambda.ipynb

@@ -11,11 +11,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    ">[`Amazon AWS Lambda`](https://aws.amazon.com/pm/lambda/) is a serverless computing service provided by `Amazon Web Services` (`AWS`). It helps developers to build and run applications and services without provisioning or managing servers. This serverless architecture enables you to focus on writing and deploying code, while AWS automatically takes care of scaling, patching, and managing the infrastructure required to run your applications.\n",
+    ">`Amazon AWS Lambda` is a serverless computing service provided by `Amazon Web Services` (`AWS`). It helps developers to build and run applications and services without provisioning or managing servers. This serverless architecture enables you to focus on writing and deploying code, while AWS automatically takes care of scaling, patching, and managing the infrastructure required to run your applications.\n",
     "\n",
     "This notebook goes over how to use the `AWS Lambda` Tool.\n",
     "\n",
-    "By including the `AWS Lambda` in the list of tools provided to an Agent, you can grant your Agent the ability to invoke code running in your AWS Cloud for whatever purposes you need.\n",
+    "By including a `awslambda` in the list of tools provided to an Agent, you can grant your Agent the ability to invoke code running in your AWS Cloud for whatever purposes you need.\n",
     "\n",
     "When an Agent uses the `AWS Lambda` tool, it will provide an argument of type string which will in turn be passed into the Lambda function via the event parameter.\n",
     "\n",

docs/docs/integrations/tools/google_finance.ipynb

@@ -1,112 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Google Finance\n",
-    "\n",
-    "This notebook goes over how to use the Google Finance Tool to get information from the Google Finance page\n",
-    "\n",
-    "To get an SerpApi key key, sign up at: https://serpapi.com/users/sign_up.\n",
-    "\n",
-    "Then install google-search-results with the command: \n",
-    "\n",
-    "pip install google-search-results\n",
-    "\n",
-    "Then set the environment variable SERPAPI_API_KEY to your SerpApi key\n",
-    "\n",
-    "Or pass the key in as a argument to the wrapper serp_api_key=\"your secret key\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Use the Tool"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install google-search-results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "from langchain.tools.google_finance import GoogleFinanceQueryRun\n",
-    "from langchain.utilities.google_finance import GoogleFinanceAPIWrapper\n",
-    "\n",
-    "os.environ[\"SERPAPI_API_KEY\"] = \"\"\n",
-    "tool = GoogleFinanceQueryRun(api_wrapper=GoogleFinanceAPIWrapper())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tool.run(\"Google\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Using it with Langchain"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "from langchain.agents import AgentType, initialize_agent, load_tools\n",
-    "from langchain.llms import OpenAI\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"\"\n",
-    "os.environ[\"SERP_API_KEY\"] = \"\"\n",
-    "llm = OpenAI()\n",
-    "tools = load_tools([\"google-scholar\", \"google-finance\"], llm=llm)\n",
-    "agent = initialize_agent(\n",
-    "    tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True\n",
-    ")\n",
-    "agent.run(\"what is google's stock\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/tools/google_trends.ipynb

@@ -1,109 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Google Trends\n",
-    "\n",
-    "This notebook goes over how to use the Google Trends Tool to fetch trends information.\n",
-    "\n",
-    "First, you need to sign up for an `SerpApi key` key at: https://serpapi.com/users/sign_up.\n",
-    "\n",
-    "Then you must install `google-search-results` with the command:\n",
-    "\n",
-    "`pip install google-search-results`\n",
-    "\n",
-    "Then you will need to set the environment variable `SERPAPI_API_KEY` to your `SerpApi key`\n",
-    "\n",
-    "[Alternatively you can pass the key in as a argument to the wrapper `serp_api_key=\"your secret key\"`]\n",
-    "\n",
-    "## Use the Tool"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Requirement already satisfied: google-search-results in c:\\python311\\lib\\site-packages (2.4.2)\n",
-      "Requirement already satisfied: requests in c:\\python311\\lib\\site-packages (from google-search-results) (2.31.0)\n",
-      "Requirement already satisfied: charset-normalizer<4,>=2 in c:\\python311\\lib\\site-packages (from requests->google-search-results) (3.3.2)\n",
-      "Requirement already satisfied: idna<4,>=2.5 in c:\\python311\\lib\\site-packages (from requests->google-search-results) (3.4)\n",
-      "Requirement already satisfied: urllib3<3,>=1.21.1 in c:\\python311\\lib\\site-packages (from requests->google-search-results) (2.1.0)\n",
-      "Requirement already satisfied: certifi>=2017.4.17 in c:\\python311\\lib\\site-packages (from requests->google-search-results) (2023.7.22)\n"
-     ]
-    }
-   ],
-   "source": [
-    "!pip install google-search-results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "from langchain.tools.google_trends import GoogleTrendsQueryRun\n",
-    "from langchain.utilities.google_trends import GoogleTrendsAPIWrapper\n",
-    "\n",
-    "os.environ[\"SERPAPI_API_KEY\"] = \"\"\n",
-    "tool = GoogleTrendsQueryRun(api_wrapper=GoogleTrendsAPIWrapper())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Query: Water\\nDate From: Nov 20, 2022\\nDate To: Nov 11, 2023\\nMin Value: 72\\nMax Value: 100\\nAverage Value: 84.25490196078431\\nPrecent Change: 5.555555555555555%\\nTrend values: 72, 72, 74, 77, 86, 80, 82, 88, 79, 79, 85, 82, 81, 84, 83, 77, 80, 85, 82, 80, 88, 84, 82, 84, 83, 85, 92, 92, 100, 92, 100, 96, 94, 95, 94, 98, 96, 84, 86, 84, 85, 83, 83, 76, 81, 85, 78, 77, 81, 75, 76\\nRising Related Queries: avatar way of water, avatar the way of water, owala water bottle, air up water bottle, lake mead water level\\nTop Related Queries: water park, water bottle, water heater, water filter, water tank, water bill, water world, avatar way of water, avatar the way of water, coconut water, deep water, water cycle, water dispenser, water purifier, water pollution, distilled water, hot water heater, water cooler, sparkling water, american water, micellar water, density of water, tankless water heater, tonic water, water jug'"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "tool.run(\"Water\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.9.16 ('langchain')",
-   "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.4"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "15e58ce194949b77a891bd4339ce3d86a9bd138e905926019517993f97db9e6c"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/tools/reddit_search.ipynb

@@ -1,262 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Reddit Search \n",
-    "\n",
-    "In this notebook, we learn how the Reddit search tool works.  \n",
-    "First make sure that you have installed praw with the command below:  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "shellscript"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "!pip install praw"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Then you need to set you need to set up the proper API keys and environment variables. You would need to create a Reddit user account and get credentials. So, create a Reddit user account by going to https://www.reddit.com  and signing up.  \n",
-    "Then get your credentials by going to https://www.reddit.com/prefs/apps and creating an app.  \n",
-    "You should have your client_id and secret from creating the app. Now, you can paste those strings in client_id and client_secret variable.  \n",
-    "Note: You can put any string for user_agent  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "client_id = \"\"\n",
-    "client_secret = \"\"\n",
-    "user_agent = \"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.tools.reddit_search.tool import RedditSearchRun\n",
-    "from langchain.utilities.reddit_search import RedditSearchAPIWrapper\n",
-    "\n",
-    "search = RedditSearchRun(\n",
-    "    api_wrapper=RedditSearchAPIWrapper(\n",
-    "        reddit_client_id=client_id,\n",
-    "        reddit_client_secret=client_secret,\n",
-    "        reddit_user_agent=user_agent,\n",
-    "    )\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can then set your queries for example, what subreddit you want to query, how many posts you want to be returned, how you would like the result to be sorted etc."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.tools.reddit_search.tool import RedditSearchSchema\n",
-    "\n",
-    "search_params = RedditSearchSchema(\n",
-    "    query=\"beginner\", sort=\"new\", time_filter=\"week\", subreddit=\"python\", limit=\"2\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally run the search and get your results"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "result = search.run(tool_input=search_params.dict())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here is an example of printing the result.  \n",
-    "Note: You may get different output depending on the newest post in the subreddit but the formatting should be similar."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "> Searching r/python found 2 posts:\n",
-    "> Post Title: 'Setup Github Copilot in Visual Studio Code'\n",
-    "> User: Feisty-Recording-715\n",
-    "> Subreddit: r/Python:\n",
-    ">                     Text body: 🛠️ This tutorial is perfect for beginners looking to strengthen their understanding of version control or for experienced developers seeking a quick reference for GitHub setup in Visual Studio Code.\n",
-    ">\n",
-    ">🎓 By the end of this video, you'll be equipped with the skills to confidently manage your codebase, collaborate with others, and contribute to open-source projects on GitHub.\n",
-    ">\n",
-    ">\n",
-    ">Video link: https://youtu.be/IdT1BhrSfdo?si=mV7xVpiyuhlD8Zrw\n",
-    ">\n",
-    ">Your feedback is welcome\n",
-    ">                     Post URL: https://www.reddit.com/r/Python/comments/1823wr7/setup_github_copilot_in_visual_studio_code/\n",
-    ">                     Post Category: N/A.\n",
-    ">                     Score: 0\n",
-    ">\n",
-    ">Post Title: 'A Chinese Checkers game made with pygame and PySide6, with custom bots support'\n",
-    ">User: HenryChess\n",
-    ">Subreddit: r/Python:\n",
-    ">                     Text body: GitHub link: https://github.com/henrychess/pygame-chinese-checkers\n",
-    ">\n",
-    ">I'm not sure if this counts as beginner or intermediate. I think I'm still in the beginner zone, so I flair it as beginner.\n",
-    ">\n",
-    ">This is a Chinese Checkers (aka Sternhalma) game for 2 to 3 players. The bots I wrote are easy to beat, as they're mainly for debugging the game logic part of the code. However, you can write up your own custom bots. There is a guide at the github page.\n",
-    ">                     Post URL: https://www.reddit.com/r/Python/comments/181xq0u/a_chinese_checkers_game_made_with_pygame_and/\n",
-    ">                     Post Category: N/A.\n",
-    " >                    Score: 1\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using tool with an agent chain\n",
-    "\n",
-    "Reddit search functionality is also provided as a multi-input tool. In this example, we adapt [existing code from the docs](https://python.langchain.com/docs/modules/agents/how_to/sharedmemory_for_tools), and use ChatOpenAI to create an agent chain with memory. This agent chain is able to pull information from Reddit and use these posts to respond to subsequent input. \n",
-    "\n",
-    "To run the example, add your reddit API access information and also get an OpenAI key from the [OpenAI API](https://help.openai.com/en/articles/4936850-where-do-i-find-my-api-key)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Adapted code from https://python.langchain.com/docs/modules/agents/how_to/sharedmemory_for_tools\n",
-    "\n",
-    "from langchain.agents import AgentExecutor, StructuredChatAgent, Tool\n",
-    "from langchain.chains import LLMChain\n",
-    "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain.tools.reddit_search.tool import RedditSearchRun\n",
-    "from langchain.utilities.reddit_search import RedditSearchAPIWrapper\n",
-    "\n",
-    "# Provide keys for Reddit\n",
-    "client_id = \"\"\n",
-    "client_secret = \"\"\n",
-    "user_agent = \"\"\n",
-    "# Provide key for OpenAI\n",
-    "openai_api_key = \"\"\n",
-    "\n",
-    "template = \"\"\"This is a conversation between a human and a bot:\n",
-    "\n",
-    "{chat_history}\n",
-    "\n",
-    "Write a summary of the conversation for {input}:\n",
-    "\"\"\"\n",
-    "\n",
-    "prompt = PromptTemplate(input_variables=[\"input\", \"chat_history\"], template=template)\n",
-    "memory = ConversationBufferMemory(memory_key=\"chat_history\")\n",
-    "\n",
-    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin!\"\n",
-    "\n",
-    "{chat_history}\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "tools = [\n",
-    "    RedditSearchRun(\n",
-    "        api_wrapper=RedditSearchAPIWrapper(\n",
-    "            reddit_client_id=client_id,\n",
-    "            reddit_client_secret=client_secret,\n",
-    "            reddit_user_agent=user_agent,\n",
-    "        )\n",
-    "    )\n",
-    "]\n",
-    "\n",
-    "prompt = StructuredChatAgent.create_prompt(\n",
-    "    prefix=prefix,\n",
-    "    tools=tools,\n",
-    "    suffix=suffix,\n",
-    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"],\n",
-    ")\n",
-    "\n",
-    "llm = ChatOpenAI(temperature=0, openai_api_key=openai_api_key)\n",
-    "\n",
-    "llm_chain = LLMChain(llm=llm, prompt=prompt)\n",
-    "agent = StructuredChatAgent(llm_chain=llm_chain, verbose=True, tools=tools)\n",
-    "agent_chain = AgentExecutor.from_agent_and_tools(\n",
-    "    agent=agent, verbose=True, memory=memory, tools=tools\n",
-    ")\n",
-    "\n",
-    "# Answering the first prompt requires usage of the Reddit search tool.\n",
-    "agent_chain.run(input=\"What is the newest post on r/langchain for the week?\")\n",
-    "# Answering the subsequent prompt uses memory.\n",
-    "agent_chain.run(input=\"Who is the author of the post?\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.11.5 64-bit ('langchaindev')",
-   "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.5"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "3929050b09828356c9f5ebaf862d05c053d8228eddbc70f990c168e54dd824ba"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/vectorstores/hologres.ipynb

@@ -22,7 +22,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install hologres-vector"
+    "#!pip install psycopg2"
    ]
   },
   {

docs/docs/integrations/vectorstores/opensearch.ipynb

@@ -63,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "aac9563e",
    "metadata": {},
    "outputs": [],
@@ -321,30 +321,12 @@
    "id": "5f590d35",
    "metadata": {
     "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    },
     "pycharm": {
      "name": "#%% md\n"
     }
    },
    "source": [
-    "## Using AOSS (Amazon OpenSearch Service Serverless)\n",
-    "\n",
-    "It is an example of the `AOSS` with `faiss` engine and `efficient_filter`.\n",
-    "\n",
-    "\n",
-    "We need to install several `python` packages."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "279bfc5c-b7f4-4553-ad15-2df7baebec47",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#!pip install requests requests-aws4auth"
+    "## Using AOSS (Amazon OpenSearch Service Serverless)"
    ]
   },
   {
@@ -353,16 +335,13 @@
    "id": "de397be7",
    "metadata": {
     "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    },
     "pycharm": {
      "name": "#%%\n"
     }
    },
    "outputs": [],
    "source": [
-    "from requests_aws4auth import AWS4Auth\n",
+    "# This is just an example to show how to use AOSS with faiss engine and efficient_filter, you need to set proper values.\n",
     "\n",
     "service = \"aoss\"  # must set the service as 'aoss'\n",
     "region = \"us-east-2\"\n",
@@ -395,10 +374,7 @@
    "cell_type": "markdown",
    "id": "0aa012c8",
    "metadata": {
-    "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    }
+    "collapsed": false
    },
    "source": [
     "## Using AOS (Amazon OpenSearch Service)"
@@ -410,9 +386,6 @@
    "id": "2c47e408",
    "metadata": {
     "collapsed": false,
-    "jupyter": {
-     "outputs_hidden": false
-    },
     "pycharm": {
      "name": "#%%\n"
     }
@@ -463,9 +436,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

docs/docs/integrations/vectorstores/vald.ipynb

@@ -149,156 +149,6 @@
    "source": [
     "db.max_marginal_relevance_search(query, k=2, fetch_k=10)"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7dc7ce16-35af-49b7-8009-7eaadb7abbcb",
-   "metadata": {},
-   "source": [
-    "## Example of using secure connection\n",
-    "In order to run this notebook, it is necessary to run a Vald cluster with secure connection.\n",
-    "\n",
-    "Here is an example of a Vald cluster with the following configuration using [Athenz](https://github.com/AthenZ/athenz) authentication.\n",
-    "\n",
-    "ingress(TLS) -> [authorization-proxy](https://github.com/AthenZ/authorization-proxy)(Check athenz-role-auth in grpc metadata) -> vald-lb-gateway"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6894c02d-7a86-4600-bab1-f7e9cce79333",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import grpc\n",
-    "\n",
-    "with open(\"test_root_cacert.crt\", \"rb\") as root:\n",
-    "    credentials = grpc.ssl_channel_credentials(root_certificates=root.read())\n",
-    "\n",
-    "# Refresh is required for server use\n",
-    "with open(\".ztoken\", \"rb\") as ztoken:\n",
-    "    token = ztoken.read().strip()\n",
-    "\n",
-    "metadata = [(b\"athenz-role-auth\", token)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cc15c20b-485d-435e-a2ec-c7dcb9db40b5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.document_loaders import TextLoader\n",
-    "from langchain.embeddings import HuggingFaceEmbeddings\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "from langchain.vectorstores import Vald\n",
-    "\n",
-    "raw_documents = TextLoader(\"state_of_the_union.txt\").load()\n",
-    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
-    "documents = text_splitter.split_documents(raw_documents)\n",
-    "embeddings = HuggingFaceEmbeddings()\n",
-    "\n",
-    "db = Vald.from_documents(\n",
-    "    documents,\n",
-    "    embeddings,\n",
-    "    host=\"localhost\",\n",
-    "    port=443,\n",
-    "    grpc_use_secure=True,\n",
-    "    grpc_credentials=credentials,\n",
-    "    grpc_metadata=metadata,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "069b96c6-6db2-46ce-a820-24e8933156a0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = db.similarity_search(query, grpc_metadata=metadata)\n",
-    "docs[0].page_content"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8327accb-6776-4a20-a325-b5da92e3a049",
-   "metadata": {},
-   "source": [
-    "### Similarity search by vector"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d0ab2a97-83e4-490d-81a5-8aaa032d8811",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "embedding_vector = embeddings.embed_query(query)\n",
-    "docs = db.similarity_search_by_vector(embedding_vector, grpc_metadata=metadata)\n",
-    "docs[0].page_content"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f3f987bd-512e-4e29-acb3-e110e74b51a2",
-   "metadata": {},
-   "source": [
-    "### Similarity search with score"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "88dd39bc-8764-4a8c-ac89-06e2341aefa6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "docs_and_scores = db.similarity_search_with_score(query, grpc_metadata=metadata)\n",
-    "docs_and_scores[0]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fef1bd41-484e-4845-88a9-c7f504068db0",
-   "metadata": {},
-   "source": [
-    "### Maximal Marginal Relevance Search (MMR)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6cf08477-87b0-41ac-9536-52dec1c5d67f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "retriever = db.as_retriever(\n",
-    "    search_kwargs={\"search_type\": \"mmr\", \"grpc_metadata\": metadata}\n",
-    ")\n",
-    "retriever.get_relevant_documents(query, grpc_metadata=metadata)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f994fa57-53e4-4fe6-9418-59a5136c6fe8",
-   "metadata": {},
-   "source": [
-    "Or:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2111ce42-07c7-4ccc-bdbf-459165e3a410",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "db.max_marginal_relevance_search(query, k=2, fetch_k=10, grpc_metadata=metadata)"
-   ]
   }
  ],
  "metadata": {
@@ -317,7 +167,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/modules/data_connection/retrievers/multi_vector.ipynb

@@ -183,7 +183,7 @@
    "id": "cdef8339-f9fa-4b3b-955f-ad9dbdf2734f",
    "metadata": {},
    "source": [
-    "The default search type the retriever performs on the vector database is a similarity search. LangChain Vector Stores also support searching via [Max Marginal Relevance](https://api.python.langchain.com/en/latest/vectorstores/langchain_core.vectorstores.VectorStore.html#langchain_core.vectorstores.VectorStore.max_marginal_relevance_search) so if you want this instead you can just set the `search_type` property as follows:"
+    "The default search type the retriever performs on the vector database is a similarity search. LangChain Vector Stores also support searching via [Max Marginal Relevance](https://api.python.langchain.com/en/latest/schema/langchain.schema.vectorstore.VectorStore.html#langchain.schema.vectorstore.VectorStore.max_marginal_relevance_search) so if you want this instead you can just set the `search_type` property as follows:"
    ]
   },
   {

docs/docs/modules/memory/adding_memory.ipynb

@@ -190,9 +190,9 @@
    "id": "a237bbb8-e448-4238-8420-004e046ef84e",
    "metadata": {},
    "source": [
-    "We will use the [ChatPromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html?highlight=chatprompttemplate) class to set up the chat prompt.\n",
+    "We will use the [ChatPromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.chat.ChatPromptTemplate.html) class to set up the chat prompt.\n",
     "\n",
-    "The [from_messages](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html#langchain_core.prompts.chat.ChatPromptTemplate.from_messages) method creates a `ChatPromptTemplate` from a list of messages (e.g., `SystemMessage`, `HumanMessage`, `AIMessage`, `ChatMessage`, etc.) or message templates, such as the [MessagesPlaceholder](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.MessagesPlaceholder.html#langchain_core.prompts.chat.MessagesPlaceholder) below.\n",
+    "The [from_messages](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.chat.ChatPromptTemplate.html#langchain.prompts.chat.ChatPromptTemplate.from_messages) method creates a `ChatPromptTemplate` from a list of messages (e.g., `SystemMessage`, `HumanMessage`, `AIMessage`, `ChatMessage`, etc.) or message templates, such as the [MessagesPlaceholder](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.chat.MessagesPlaceholder.html#langchain.prompts.chat.MessagesPlaceholder) below.\n",
     "\n",
     "The configuration below makes it so the memory will be injected to the middle of the chat prompt, in the `chat_history` key, and the user's inputs will be added in a human/user message to the end of the chat prompt."
    ]

docs/docs/modules/model_io/output_parsers/pandas_dataframe.ipynb

@@ -1,229 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Pandas DataFrame Parser\n",
-    "\n",
-    "A Pandas DataFrame is a popular data structure in the Python programming language, commonly used for data manipulation and analysis. It provides a comprehensive set of tools for working with structured data, making it a versatile option for tasks such as data cleaning, transformation, and analysis.\n",
-    "\n",
-    "This output parser allows users to specify an arbitrary Pandas DataFrame and query LLMs for data in the form of a formatted dictionary that extracts data from the corresponding DataFrame. Keep in mind that large language models are leaky abstractions! You'll have to use an LLM with sufficient capacity to generate a well-formed query as per the defined format instructions.\n",
-    "\n",
-    "Use Pandas' DataFrame object to declare the DataFrame you wish to perform queries on."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pprint\n",
-    "from typing import Any, Dict\n",
-    "\n",
-    "import pandas as pd\n",
-    "from langchain.llms import OpenAI\n",
-    "from langchain.output_parsers import PandasDataFrameOutputParser\n",
-    "from langchain.prompts import PromptTemplate"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model_name = \"text-davinci-003\"\n",
-    "temperature = 0.5\n",
-    "model = OpenAI(model_name=model_name, temperature=temperature)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Solely for documentation purposes.\n",
-    "def format_parser_output(parser_output: Dict[str, Any]) -> None:\n",
-    "    for key in parser_output.keys():\n",
-    "        parser_output[key] = parser_output[key].to_dict()\n",
-    "    return pprint.PrettyPrinter(width=4, compact=True).pprint(parser_output)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Define your desired Pandas DataFrame.\n",
-    "df = pd.DataFrame(\n",
-    "    {\n",
-    "        \"num_legs\": [2, 4, 8, 0],\n",
-    "        \"num_wings\": [2, 0, 0, 0],\n",
-    "        \"num_specimen_seen\": [10, 2, 1, 8],\n",
-    "    }\n",
-    ")\n",
-    "\n",
-    "# Set up a parser + inject instructions into the prompt template.\n",
-    "parser = PandasDataFrameOutputParser(dataframe=df)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LLM Output: column:num_wings\n",
-      "{'num_wings': {0: 2,\n",
-      "               1: 0,\n",
-      "               2: 0,\n",
-      "               3: 0}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Here's an example of a column operation being performed.\n",
-    "df_query = \"Retrieve the num_wings column.\"\n",
-    "\n",
-    "# Set up the prompt.\n",
-    "prompt = PromptTemplate(\n",
-    "    template=\"Answer the user query.\\n{format_instructions}\\n{query}\\n\",\n",
-    "    input_variables=[\"query\"],\n",
-    "    partial_variables={\"format_instructions\": parser.get_format_instructions()},\n",
-    ")\n",
-    "\n",
-    "_input = prompt.format_prompt(query=df_query)\n",
-    "output = model(_input.to_string())\n",
-    "print(\"LLM Output:\", output)\n",
-    "parser_output = parser.parse(output)\n",
-    "\n",
-    "format_parser_output(parser_output)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LLM Output: row:1\n",
-      "{'1': {'num_legs': 4,\n",
-      "       'num_specimen_seen': 2,\n",
-      "       'num_wings': 0}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Here's an example of a row operation being performed.\n",
-    "df_query = \"Retrieve the first row.\"\n",
-    "\n",
-    "# Set up the prompt.\n",
-    "prompt = PromptTemplate(\n",
-    "    template=\"Answer the user query.\\n{format_instructions}\\n{query}\\n\",\n",
-    "    input_variables=[\"query\"],\n",
-    "    partial_variables={\"format_instructions\": parser.get_format_instructions()},\n",
-    ")\n",
-    "\n",
-    "_input = prompt.format_prompt(query=df_query)\n",
-    "output = model(_input.to_string())\n",
-    "print(\"LLM Output:\", output)\n",
-    "parser_output = parser.parse(output)\n",
-    "\n",
-    "format_parser_output(parser_output)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LLM Output: mean:num_legs[1..3]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'mean': 4.0}"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Here's an example of a random Pandas DataFrame operation limiting the number of rows\n",
-    "df_query = \"Retrieve the average of the num_legs column from rows 1 to 3.\"\n",
-    "\n",
-    "# Set up the prompt.\n",
-    "prompt = PromptTemplate(\n",
-    "    template=\"Answer the user query.\\n{format_instructions}\\n{query}\\n\",\n",
-    "    input_variables=[\"query\"],\n",
-    "    partial_variables={\"format_instructions\": parser.get_format_instructions()},\n",
-    ")\n",
-    "\n",
-    "_input = prompt.format_prompt(query=df_query)\n",
-    "output = model(_input.to_string())\n",
-    "print(\"LLM Output:\", output)\n",
-    "parser.parse(output)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Here's an example of a poorly formatted query\n",
-    "df_query = \"Retrieve the mean of the num_fingers column.\"\n",
-    "\n",
-    "# Set up the prompt.\n",
-    "prompt = PromptTemplate(\n",
-    "    template=\"Answer the user query.\\n{format_instructions}\\n{query}\\n\",\n",
-    "    input_variables=[\"query\"],\n",
-    "    partial_variables={\"format_instructions\": parser.get_format_instructions()},\n",
-    ")\n",
-    "\n",
-    "_input = prompt.format_prompt(query=df_query)\n",
-    "output = model(_input.to_string())  # Expected Output: \"Invalid column: num_fingers\".\n",
-    "print(\"LLM Output:\", output)\n",
-    "parser.parse(output)  # Expected Output: Will raise an OutputParserException."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

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

@@ -7,7 +7,7 @@
    "source": [
     "# Few-shot examples for chat models\n",
     "\n",
-    "This notebook covers how to use few-shot examples in chat models. There does not appear to be solid consensus on how best to do few-shot prompting, and the optimal prompt compilation will likely vary by model. Because of this, we provide few-shot prompt templates like the [FewShotChatMessagePromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.few_shot.FewShotChatMessagePromptTemplate.html?highlight=fewshot#langchain_core.prompts.few_shot.FewShotChatMessagePromptTemplate) as a flexible starting point, and you can modify or replace them as you see fit.\n",
+    "This notebook covers how to use few-shot examples in chat models. There does not appear to be solid consensus on how best to do few-shot prompting, and the optimal prompt compilation will likely vary by model. Because of this, we provide few-shot prompt templates like the [FewShotChatMessagePromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.few_shot.FewShotChatMessagePromptTemplate.html) as a flexible starting point, and you can modify or replace them as you see fit.\n",
     "\n",
     "The goal of few-shot prompt templates are to dynamically select examples based on an input, and then format the examples in a final prompt to provide for the model.\n",
     "\n",
@@ -28,7 +28,7 @@
     "\n",
     "The basic components of the template are:\n",
     "- `examples`: A list of dictionary examples to include in the final prompt.\n",
-    "- `example_prompt`: converts each example into 1 or more messages through its [`format_messages`](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html?highlight=format_messages#langchain_core.prompts.chat.ChatPromptTemplate.format_messages) method. A common example would be to convert each example into one human message and one AI message response, or a human message followed by a function call message.\n",
+    "- `example_prompt`: converts each example into 1 or more messages through its [`format_messages`](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.chat.ChatPromptTemplate.html#langchain.prompts.chat.ChatPromptTemplate.format_messages) method. A common example would be to convert each example into one human message and one AI message response, or a human message followed by a function call message.\n",
     "\n",
     "Below is a simple demonstration. First, import the modules for this example:"
    ]
@@ -176,8 +176,8 @@
     "\n",
     "Sometimes you may want to condition which examples are shown based on the input. For this, you can replace the `examples` with an `example_selector`. The other components remain the same as above! To review, the dynamic few-shot prompt template would look like:\n",
     "\n",
-    "- `example_selector`: responsible for selecting few-shot examples (and the order in which they are returned) for a given input. These implement the [BaseExampleSelector](https://api.python.langchain.com/en/latest/example_selectors/langchain_core.example_selectors.base.BaseExampleSelector.html?highlight=baseexampleselector#langchain_core.example_selectors.base.BaseExampleSelector) interface. A common example is the vectorstore-backed [SemanticSimilarityExampleSelector](https://api.python.langchain.com/en/latest/example_selectors/langchain_core.example_selectors.semantic_similarity.SemanticSimilarityExampleSelector.html?highlight=semanticsimilarityexampleselector#langchain_core.example_selectors.semantic_similarity.SemanticSimilarityExampleSelector)\n",
-    "- `example_prompt`: convert each example into 1 or more messages through its [`format_messages`](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.chat.ChatPromptTemplate.html?highlight=chatprompttemplate#langchain_core.prompts.chat.ChatPromptTemplate.format_messages) method. A common example would be to convert each example into one human message and one AI message response, or a human message followed by a function call message.\n",
+    "- `example_selector`: responsible for selecting few-shot examples (and the order in which they are returned) for a given input. These implement the [BaseExampleSelector](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.example_selector.base.BaseExampleSelector.html#langchain.prompts.example_selector.base.BaseExampleSelector) interface. A common example is the vectorstore-backed [SemanticSimilarityExampleSelector](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.example_selector.semantic_similarity.SemanticSimilarityExampleSelector.html#langchain.prompts.example_selector.semantic_similarity.SemanticSimilarityExampleSelector)\n",
+    "- `example_prompt`: convert each example into 1 or more messages through its [`format_messages`](https://api.python.langchain.com/en/latest/prompts/langchain.prompts.chat.ChatPromptTemplate.html#langchain.prompts.chat.ChatPromptTemplate.format_messages) method. A common example would be to convert each example into one human message and one AI message response, or a human message followed by a function call message.\n",
     "\n",
     "These once again can be composed with other messages and chat templates to assemble your final prompt."
    ]

docs/docs/use_cases/question_answering/index.ipynb

@@ -776,10 +776,10 @@
    "source": [
     "from langchain.prompts import PromptTemplate\n",
     "\n",
-    "template = \"\"\"Use the following pieces of context to answer the question at the end.\n",
-    "If you don't know the answer, just say that you don't know, don't try to make up an answer.\n",
-    "Use three sentences maximum and keep the answer as concise as possible.\n",
-    "Always say \"thanks for asking!\" at the end of the answer.\n",
+    "template = \"\"\"Use the following pieces of context to answer the question at the end. \n",
+    "If you don't know the answer, just say that you don't know, don't try to make up an answer. \n",
+    "Use three sentences maximum and keep the answer as concise as possible. \n",
+    "Always say \"thanks for asking!\" at the end of the answer. \n",
     "{context}\n",
     "Question: {question}\n",
     "Helpful Answer:\"\"\"\n",
@@ -846,7 +846,7 @@
    "source": [
     "from operator import itemgetter\n",
     "\n",
-    "from langchain.schema.runnable import RunnableParallel\n",
+    "from langchain.schema.runnable import RunnableMap\n",
     "\n",
     "rag_chain_from_docs = (\n",
     "    {\n",
@@ -857,7 +857,7 @@
     "    | llm\n",
     "    | StrOutputParser()\n",
     ")\n",
-    "rag_chain_with_source = RunnableParallel(\n",
+    "rag_chain_with_source = RunnableMap(\n",
     "    {\"documents\": retriever, \"question\": RunnablePassthrough()}\n",
     ") | {\n",
     "    \"documents\": lambda input: [doc.metadata for doc in input[\"documents\"]],\n",

docs/docs/use_cases/summarization.ipynb

@@ -181,7 +181,7 @@
    "source": [
     "We can use `chain_type=\"stuff\"`, especially if using larger context window models such as:\n",
     "\n",
-    "* 16k token OpenAI `gpt-3.5-turbo-1106` \n",
+    "* 16k token OpenAI `gpt-3.5-turbo-16k` \n",
     "* 100k token Anthropic [Claude-2](https://www.anthropic.com/index/claude-2)\n",
     "\n",
     "We can also supply `chain_type=\"map_reduce\"` or `chain_type=\"refine\"` (read more [here](/docs/modules/chains/document/refine))."
@@ -212,7 +212,7 @@
     "loader = WebBaseLoader(\"https://lilianweng.github.io/posts/2023-06-23-agent/\")\n",
     "docs = loader.load()\n",
     "\n",
-    "llm = ChatOpenAI(temperature=0, model_name=\"gpt-3.5-turbo-1106\")\n",
+    "llm = ChatOpenAI(temperature=0, model_name=\"gpt-3.5-turbo-16k\")\n",
     "chain = load_summarize_chain(llm, chain_type=\"stuff\")\n",
     "\n",
     "chain.run(docs)"
@@ -672,7 +672,7 @@
     "summarize_document_chain = AnalyzeDocumentChain(\n",
     "    combine_docs_chain=chain, text_splitter=text_splitter\n",
     ")\n",
-    "summarize_document_chain.run(docs[0].page_content)"
+    "summarize_document_chain.run(docs[0])"
    ]
   },
   {

docs/docs/use_cases/tagging.ipynb

@@ -58,7 +58,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "id": "bafb496a",
    "metadata": {},
    "outputs": [],
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "id": "39f3ce3e",
    "metadata": {},
    "outputs": [],
@@ -98,7 +98,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "5509b6a6",
    "metadata": {},
    "outputs": [
@@ -108,7 +108,7 @@
        "{'sentiment': 'positive', 'language': 'Spanish'}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -120,7 +120,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "9154474c",
    "metadata": {},
    "outputs": [
@@ -130,7 +130,7 @@
        "{'sentiment': 'enojado', 'aggressiveness': 1, 'language': 'es'}"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -178,7 +178,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "id": "6a5f7961",
    "metadata": {},
    "outputs": [],
@@ -201,7 +201,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "id": "e5a5881f",
    "metadata": {},
    "outputs": [],
@@ -318,17 +318,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 13,
    "id": "bf1f367e",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.pydantic_v1 import BaseModel, Field"
+    "from pydantic import BaseModel, Field"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 14,
    "id": "83a2e826",
    "metadata": {},
    "outputs": [],
@@ -347,7 +347,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 15,
    "id": "6e404892",
    "metadata": {},
    "outputs": [],
@@ -357,7 +357,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 16,
    "id": "b5fc43c4",
    "metadata": {},
    "outputs": [],
@@ -368,7 +368,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 17,
    "id": "5074bcc3",
    "metadata": {},
    "outputs": [
@@ -378,7 +378,7 @@
        "Tags(sentiment='sad', aggressiveness=5, language='spanish')"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -415,7 +415,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docusaurus.config.js

@@ -26,11 +26,6 @@ const config = {
   onBrokenLinks: "warn",
   onBrokenMarkdownLinks: "throw",
 
-  themes: ["@docusaurus/theme-mermaid"],
-  markdown: {
-    mermaid: true,
-  },
-
   plugins: [
     () => ({
       name: "custom-webpack-config",
@@ -237,10 +232,6 @@ const config = {
                 href: "https://github.com/langchain-ai/langchain/tree/master/templates",
                 label: "Templates GitHub",
               },
-              {
-                label: "Templates Hub",
-                href: "https://templates.langchain.com",
-              },
               {
                 href: "https://smith.langchain.com/hub",
                 label: "LangChain Hub",

docs/package.json

@@ -22,7 +22,6 @@
     "@docusaurus/core": "2.4.0",
     "@docusaurus/preset-classic": "2.4.0",
     "@docusaurus/remark-plugin-npm2yarn": "^2.4.0",
-    "@docusaurus/theme-mermaid": "2.4.0",
     "@mdx-js/react": "^1.6.22",
     "@mendable/search": "^0.0.160",
     "clsx": "^1.2.1",

docs/src/theme/Columns.js

@@ -1,17 +0,0 @@
-import React from "react";
-
-export function ColumnContainer({children}) {
-    return (
-        <div style={{ display: "flex", flexWrap: "wrap" }}>
-            {children}
-        </div>
-    )
-}
-
-export function Column({children}) {
-    return (
-        <div style={{ flex: "1 0 300px", padding: "10px", overflowX: "clip" }}>
-            {children}
-        </div>
-    )
-}

docs/vercel.json

@@ -56,6 +56,10 @@
       "source": "/docs/modules/model_io/chat/human_input_chat_model",
       "destination": "/cookbook"
     },
+    {
+      "source": "/docs/expression_language/why",
+      "destination": "/docs/expression_language/"
+    },
     {
       "source": "/docs/modules/model_io/chat/llm_chain",
       "destination":  "/docs/modules/chains/foundational/llm_chain"
@@ -304,10 +308,6 @@
       "source":  "/docs/integrations/providers/amazon_api_gateway",
       "destination": "/docs/integrations/platforms/aws"
     },
-    {
-      "source":  "/docs/integrations/providers/huggingface",
-      "destination": "/docs/integrations/platforms/huggingface"
-    },
     {
       "source":  "/docs/integrations/providers/azure_blob_storage",
       "destination": "/docs/integrations/platforms/microsoft"
@@ -492,10 +492,6 @@
       "source": "/docs/integrations/providers/cassandra",
       "destination": "/docs/integrations/providers/astradb"
     },
-    {
-      "source": "/docs/integrations/providers/providers/semadb",
-      "destination": "/docs/integrations/providers/semadb"
-    },
     {
       "source": "/docs/integrations/vectorstores/vectorstores/semadb",
       "destination": "/docs/integrations/vectorstores/semadb"
@@ -1576,10 +1572,6 @@
       "source": "/en/latest/modules/chains/generic/serialization.html",
       "destination": "/docs/modules/chains/how_to/serialization"
     },
-    {
-      "source": "/docs/integrations/document_loaders/pdf-amazonTextractPDFLoader",
-      "destination": "/docs/integrations/document_loaders/amazon_textract"
-    },
     {
       "source": "/en/latest/modules/indexes/document_loaders/examples/acreom.html",
       "destination": "/docs/integrations/document_loaders/acreom"

docs/vercel_build.sh

@@ -53,5 +53,5 @@ python3.11 scripts/copy_templates.py
 cp ../cookbook/README.md src/pages/cookbook.mdx
 cp ../.github/CONTRIBUTING.md docs/contributing.md
 wget https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md -O docs/langserve.md
-nbdoc_build --srcdir docs --pause 0
+nbdoc_build --srcdir docs
 python3.11 scripts/generate_api_reference_links.py

libs/core/langchain_core/callbacks/stdout.py

@@ -1,13 +1,14 @@
 """Callback Handler that prints to std out."""
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from langchain_core.callbacks.base import BaseCallbackHandler
 from langchain_core.utils import print_text
 
 if TYPE_CHECKING:
     from langchain_core.agents import AgentAction, AgentFinish
+    from langchain_core.outputs import LLMResult
 
 
 class StdOutCallbackHandler(BaseCallbackHandler):
@@ -17,6 +18,24 @@ class StdOutCallbackHandler(BaseCallbackHandler):
         """Initialize callback handler."""
         self.color = color
 
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Print out the prompts."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
     def on_chain_start(
         self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
     ) -> None:
@@ -28,6 +47,19 @@ class StdOutCallbackHandler(BaseCallbackHandler):
         """Print out that we finished a chain."""
         print("\n\033[1m> Finished chain.\033[0m")
 
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing."""
+        pass
+
     def on_agent_action(
         self, action: AgentAction, color: Optional[str] = None, **kwargs: Any
     ) -> Any:
@@ -49,6 +81,10 @@ class StdOutCallbackHandler(BaseCallbackHandler):
         if llm_prefix is not None:
             print_text(f"\n{llm_prefix}")
 
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
     def on_text(
         self,
         text: str,

libs/core/langchain_core/load/dump.py

@@ -13,15 +13,12 @@ def default(obj: Any) -> Any:
         return to_json_not_implemented(obj)
 
 
-def dumps(obj: Any, *, pretty: bool = False, **kwargs: Any) -> str:
+def dumps(obj: Any, *, pretty: bool = False) -> str:
     """Return a json string representation of an object."""
-    if "default" in kwargs:
-        raise ValueError("`default` should not be passed to dumps")
     if pretty:
-        indent = kwargs.pop("indent", 2)
-        return json.dumps(obj, default=default, indent=indent, **kwargs)
+        return json.dumps(obj, default=default, indent=2)
     else:
-        return json.dumps(obj, default=default, **kwargs)
+        return json.dumps(obj, default=default)
 
 
 def dumpd(obj: Any) -> Dict[str, Any]:

libs/core/langchain_core/messages/base.py

@@ -71,17 +71,7 @@ class BaseMessageChunk(BaseMessage):
     def _merge_kwargs_dict(
         self, left: Dict[str, Any], right: Dict[str, Any]
     ) -> Dict[str, Any]:
-        """Merge additional_kwargs from another BaseMessageChunk into this one,
-        handling specific scenarios where a key exists in both dictionaries
-        but has a value of None in 'left'. In such cases, the method uses the
-        value from 'right' for that key in the merged dictionary.
-        Example:
-        If left = {"function_call": {"arguments": None}} and
-        right = {"function_call": {"arguments": "{\n"}}
-        then, after merging, for the key "function_call",
-        the value from 'right' is used,
-        resulting in merged = {"function_call": {"arguments": "{\n"}}.
-        """
+        """Merge additional_kwargs from another BaseMessageChunk into this one."""
         merged = left.copy()
         for k, v in right.items():
             if k not in merged:

libs/core/langchain_core/prompts/base.py

@@ -67,27 +67,13 @@ class BasePromptTemplate(RunnableSerializable[Dict, PromptValue], ABC):
             **{k: (self.input_types.get(k, str), None) for k in self.input_variables},
         )
 
-    def _format_prompt_with_error_handling(self, inner_input: Dict) -> PromptValue:
-        try:
-            input_dict = {key: inner_input[key] for key in self.input_variables}
-        except TypeError as e:
-            raise TypeError(
-                f"Expected mapping type as input to {self.__class__.__name__}. "
-                f"Received {type(inner_input)}."
-            ) from e
-        except KeyError as e:
-            raise KeyError(
-                f"Input to {self.__class__.__name__} is missing variable {e}. "
-                f" Expected: {self.input_variables}"
-                f" Received: {list(inner_input.keys())}"
-            ) from e
-        return self.format_prompt(**input_dict)
-
     def invoke(
         self, input: Dict, config: Optional[RunnableConfig] = None
     ) -> PromptValue:
         return self._call_with_config(
-            self._format_prompt_with_error_handling,
+            lambda inner_input: self.format_prompt(
+                **{key: inner_input[key] for key in self.input_variables}
+            ),
             input,
             config,
             run_type="prompt",

libs/core/langchain_core/tracers/base.py

@@ -92,17 +92,6 @@ class BaseTracer(BaseCallbackHandler, ABC):
 
         return parent_run.child_execution_order + 1
 
-    def _get_run(self, run_id: UUID, run_type: str | None = None) -> Run:
-        try:
-            run = self.run_map[str(run_id)]
-        except KeyError as exc:
-            raise TracerException(f"No indexed run ID {run_id}.") from exc
-        if run_type is not None and run.run_type != run_type:
-            raise TracerException(
-                f"Found {run.run_type} run at ID {run_id}, but expected {run_type} run."
-            )
-        return run
-
     def on_llm_start(
         self,
         serialized: Dict[str, Any],
@@ -149,7 +138,13 @@ class BaseTracer(BaseCallbackHandler, ABC):
         **kwargs: Any,
     ) -> Run:
         """Run on new LLM token. Only available when streaming is enabled."""
-        llm_run = self._get_run(run_id, run_type="llm")
+        if not run_id:
+            raise TracerException("No run_id provided for on_llm_new_token callback.")
+
+        run_id_ = str(run_id)
+        llm_run = self.run_map.get(run_id_)
+        if llm_run is None or llm_run.run_type != "llm":
+            raise TracerException(f"No LLM Run found to be traced for {run_id}")
         event_kwargs: Dict[str, Any] = {"token": token}
         if chunk:
             event_kwargs["chunk"] = chunk
@@ -170,7 +165,12 @@ class BaseTracer(BaseCallbackHandler, ABC):
         run_id: UUID,
         **kwargs: Any,
     ) -> Run:
-        llm_run = self._get_run(run_id)
+        if not run_id:
+            raise TracerException("No run_id provided for on_retry callback.")
+        run_id_ = str(run_id)
+        llm_run = self.run_map.get(run_id_)
+        if llm_run is None:
+            raise TracerException("No Run found to be traced for on_retry")
         retry_d: Dict[str, Any] = {
             "slept": retry_state.idle_for,
             "attempt": retry_state.attempt_number,
@@ -196,7 +196,13 @@ class BaseTracer(BaseCallbackHandler, ABC):
 
     def on_llm_end(self, response: LLMResult, *, run_id: UUID, **kwargs: Any) -> Run:
         """End a trace for an LLM run."""
-        llm_run = self._get_run(run_id, run_type="llm")
+        if not run_id:
+            raise TracerException("No run_id provided for on_llm_end callback.")
+
+        run_id_ = str(run_id)
+        llm_run = self.run_map.get(run_id_)
+        if llm_run is None or llm_run.run_type != "llm":
+            raise TracerException(f"No LLM Run found to be traced for {run_id}")
         llm_run.outputs = response.dict()
         for i, generations in enumerate(response.generations):
             for j, generation in enumerate(generations):
@@ -219,7 +225,13 @@ class BaseTracer(BaseCallbackHandler, ABC):
         **kwargs: Any,
     ) -> Run:
         """Handle an error for an LLM run."""
-        llm_run = self._get_run(run_id, run_type="llm")
+        if not run_id:
+            raise TracerException("No run_id provided for on_llm_error callback.")
+
+        run_id_ = str(run_id)
+        llm_run = self.run_map.get(run_id_)
+        if llm_run is None or llm_run.run_type != "llm":
+            raise TracerException(f"No LLM Run found to be traced for {run_id}")
         llm_run.error = repr(error)
         llm_run.end_time = datetime.utcnow()
         llm_run.events.append({"name": "error", "time": llm_run.end_time})
@@ -274,7 +286,12 @@ class BaseTracer(BaseCallbackHandler, ABC):
         **kwargs: Any,
     ) -> Run:
         """End a trace for a chain run."""
-        chain_run = self._get_run(run_id)
+        if not run_id:
+            raise TracerException("No run_id provided for on_chain_end callback.")
+        chain_run = self.run_map.get(str(run_id))
+        if chain_run is None:
+            raise TracerException(f"No chain Run found to be traced for {run_id}")
+
         chain_run.outputs = (
             outputs if isinstance(outputs, dict) else {"output": outputs}
         )
@@ -295,7 +312,12 @@ class BaseTracer(BaseCallbackHandler, ABC):
         **kwargs: Any,
     ) -> Run:
         """Handle an error for a chain run."""
-        chain_run = self._get_run(run_id)
+        if not run_id:
+            raise TracerException("No run_id provided for on_chain_error callback.")
+        chain_run = self.run_map.get(str(run_id))
+        if chain_run is None:
+            raise TracerException(f"No chain Run found to be traced for {run_id}")
+
         chain_run.error = repr(error)
         chain_run.end_time = datetime.utcnow()
         chain_run.events.append({"name": "error", "time": chain_run.end_time})
@@ -344,7 +366,12 @@ class BaseTracer(BaseCallbackHandler, ABC):
 
     def on_tool_end(self, output: str, *, run_id: UUID, **kwargs: Any) -> Run:
         """End a trace for a tool run."""
-        tool_run = self._get_run(run_id, run_type="tool")
+        if not run_id:
+            raise TracerException("No run_id provided for on_tool_end callback.")
+        tool_run = self.run_map.get(str(run_id))
+        if tool_run is None or tool_run.run_type != "tool":
+            raise TracerException(f"No tool Run found to be traced for {run_id}")
+
         tool_run.outputs = {"output": output}
         tool_run.end_time = datetime.utcnow()
         tool_run.events.append({"name": "end", "time": tool_run.end_time})
@@ -360,7 +387,12 @@ class BaseTracer(BaseCallbackHandler, ABC):
         **kwargs: Any,
     ) -> Run:
         """Handle an error for a tool run."""
-        tool_run = self._get_run(run_id, run_type="tool")
+        if not run_id:
+            raise TracerException("No run_id provided for on_tool_error callback.")
+        tool_run = self.run_map.get(str(run_id))
+        if tool_run is None or tool_run.run_type != "tool":
+            raise TracerException(f"No tool Run found to be traced for {run_id}")
+
         tool_run.error = repr(error)
         tool_run.end_time = datetime.utcnow()
         tool_run.events.append({"name": "error", "time": tool_run.end_time})
@@ -413,7 +445,12 @@ class BaseTracer(BaseCallbackHandler, ABC):
         **kwargs: Any,
     ) -> Run:
         """Run when Retriever errors."""
-        retrieval_run = self._get_run(run_id, run_type="retriever")
+        if not run_id:
+            raise TracerException("No run_id provided for on_retriever_error callback.")
+        retrieval_run = self.run_map.get(str(run_id))
+        if retrieval_run is None or retrieval_run.run_type != "retriever":
+            raise TracerException(f"No retriever Run found to be traced for {run_id}")
+
         retrieval_run.error = repr(error)
         retrieval_run.end_time = datetime.utcnow()
         retrieval_run.events.append({"name": "error", "time": retrieval_run.end_time})
@@ -425,7 +462,11 @@ class BaseTracer(BaseCallbackHandler, ABC):
         self, documents: Sequence[Document], *, run_id: UUID, **kwargs: Any
     ) -> Run:
         """Run when Retriever ends running."""
-        retrieval_run = self._get_run(run_id, run_type="retriever")
+        if not run_id:
+            raise TracerException("No run_id provided for on_retriever_end callback.")
+        retrieval_run = self.run_map.get(str(run_id))
+        if retrieval_run is None or retrieval_run.run_type != "retriever":
+            raise TracerException(f"No retriever Run found to be traced for {run_id}")
         retrieval_run.outputs = {"documents": documents}
         retrieval_run.end_time = datetime.utcnow()
         retrieval_run.events.append({"name": "end", "time": retrieval_run.end_time})

libs/core/pyproject.toml

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

libs/core/tests/unit_tests/test_messages.py

@@ -42,9 +42,6 @@ def test_message_chunks() -> None:
         AIMessageChunk(
             content="", additional_kwargs={"function_call": {"name": "web_search"}}
         )
-        + AIMessageChunk(
-            content="", additional_kwargs={"function_call": {"arguments": None}}
-        )
         + AIMessageChunk(
             content="", additional_kwargs={"function_call": {"arguments": "{\n"}}
         )

libs/experimental/langchain_experimental/autonomous_agents/autogpt/prompt.py

@@ -1,5 +1,5 @@
 import time
-from typing import Any, Callable, List, cast
+from typing import Any, Callable, List
 
 from langchain.prompts.chat import (
     BaseChatPromptTemplate,
@@ -68,9 +68,9 @@ class AutoGPTPrompt(BaseChatPromptTemplate, BaseModel):  # type: ignore[misc]
         time_prompt = SystemMessage(
             content=f"The current time and date is {time.strftime('%c')}"
         )
-        used_tokens = self.token_counter(
-            cast(str, base_prompt.content)
-        ) + self.token_counter(cast(str, time_prompt.content))
+        used_tokens = self.token_counter(base_prompt.content) + self.token_counter(
+            time_prompt.content
+        )
         memory: VectorStoreRetriever = kwargs["memory"]
         previous_messages = kwargs["messages"]
         relevant_docs = memory.get_relevant_documents(str(previous_messages[-10:]))
@@ -88,7 +88,7 @@ class AutoGPTPrompt(BaseChatPromptTemplate, BaseModel):  # type: ignore[misc]
             f"from your past:\n{relevant_memory}\n\n"
         )
         memory_message = SystemMessage(content=content_format)
-        used_tokens += self.token_counter(cast(str, memory_message.content))
+        used_tokens += self.token_counter(memory_message.content)
         historical_messages: List[BaseMessage] = []
         for message in previous_messages[-10:][::-1]:
             message_tokens = self.token_counter(message.content)

libs/experimental/langchain_experimental/chat_models/llm_wrapper.py

@@ -1,7 +1,7 @@
 """Generic Wrapper for chat LLMs, with sample implementations
 for Llama-2-chat, Llama-2-instruct and Vicuna models.
 """
-from typing import Any, List, Optional, cast
+from typing import Any, List, Optional
 
 from langchain.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
@@ -90,12 +90,8 @@ class ChatWrapper(BaseChatModel):
         if self.usr_0_end is None:
             self.usr_0_end = self.usr_n_end
 
-        prompt_parts.append(
-            self.sys_beg + cast(str, messages[0].content) + self.sys_end
-        )
-        prompt_parts.append(
-            self.usr_0_beg + cast(str, messages[1].content) + self.usr_0_end
-        )
+        prompt_parts.append(self.sys_beg + messages[0].content + self.sys_end)
+        prompt_parts.append(self.usr_0_beg + messages[1].content + self.usr_0_end)
 
         for ai_message, human_message in zip(messages[2::2], messages[3::2]):
             if not isinstance(ai_message, AIMessage) or not isinstance(
@@ -106,12 +102,8 @@ class ChatWrapper(BaseChatModel):
                     "optionally prepended by a system message"
                 )
 
-            prompt_parts.append(
-                self.ai_n_beg + cast(str, ai_message.content) + self.ai_n_end
-            )
-            prompt_parts.append(
-                self.usr_n_beg + cast(str, human_message.content) + self.usr_n_end
-            )
+            prompt_parts.append(self.ai_n_beg + ai_message.content + self.ai_n_end)
+            prompt_parts.append(self.usr_n_beg + human_message.content + self.usr_n_end)
 
         return "".join(prompt_parts)
 

libs/experimental/langchain_experimental/comprehend_moderation/base_moderation.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import Any, Callable, Optional, cast
+from typing import Any, Callable, Optional
 
 from langchain.callbacks.manager import CallbackManagerForChainRun
 from langchain.schema import AIMessage, HumanMessage
@@ -54,10 +54,10 @@ class BaseModeration:
             message = prompt.messages[-1]
             self.chat_message_index = len(prompt.messages) - 1
             if isinstance(message, HumanMessage):
-                input_text = cast(str, message.content)
+                input_text = message.content
 
             if isinstance(message, AIMessage):
-                input_text = cast(str, message.content)
+                input_text = message.content
         else:
             raise ValueError(
                 f"Invalid input type {type(input_text)}. "

libs/experimental/langchain_experimental/llms/anthropic_functions.py

@@ -1,7 +1,7 @@
 import json
 from collections import defaultdict
 from html.parser import HTMLParser
-from typing import Any, DefaultDict, Dict, List, Optional, cast
+from typing import Any, DefaultDict, Dict, List, Optional
 
 from langchain.callbacks.manager import (
     CallbackManagerForLLMRun,
@@ -176,7 +176,7 @@ class AnthropicFunctions(BaseChatModel):
         response = self.model.predict_messages(
             messages, stop=stop, callbacks=run_manager, **kwargs
         )
-        completion = cast(str, response.content)
+        completion = response.content
         if forced:
             tag_parser = TagParser()
 
@@ -210,7 +210,7 @@ class AnthropicFunctions(BaseChatModel):
             message = AIMessage(content=msg, additional_kwargs=kwargs)
             return ChatResult(generations=[ChatGeneration(message=message)])
         else:
-            response.content = cast(str, response.content).strip()
+            response.content = response.content.strip()
             return ChatResult(generations=[ChatGeneration(message=response)])
 
     @property

libs/experimental/langchain_experimental/llms/ollama_functions.py

@@ -1,141 +0,0 @@
-import json
-from typing import Any, Dict, List, Optional
-
-from langchain.chat_models.ollama import ChatOllama
-from langchain_core.callbacks import CallbackManagerForLLMRun
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, BaseMessage
-from langchain_core.outputs import ChatGeneration, ChatResult
-from langchain_core.prompts import SystemMessagePromptTemplate
-
-from langchain_experimental.pydantic_v1 import root_validator
-
-DEFAULT_SYSTEM_TEMPLATE = """You have access to the following tools:
-
-{tools}
-
-You must always select one of the above tools and respond with only a JSON object matching the following schema:
-
-{{
-  "tool": <name of the selected tool>,
-  "tool_input": <parameters for the selected tool, matching the tool's JSON schema>
-}}
-"""  # noqa: E501
-
-
-DEFAULT_RESPONSE_FUNCTION = {
-    "name": "__conversational_response",
-    "description": (
-        "Respond conversationally if no other tools should be called for a given query."
-    ),
-    "parameters": {
-        "type": "object",
-        "properties": {
-            "response": {
-                "type": "string",
-                "description": "Conversational response to the user.",
-            },
-        },
-        "required": ["response"],
-    },
-}
-
-
-class OllamaFunctions(BaseChatModel):
-    llm: ChatOllama
-
-    tool_system_prompt_template: str
-
-    @root_validator(pre=True)
-    def validate_environment(cls, values: Dict) -> Dict:
-        values["llm"] = values.get("llm") or ChatOllama(**values, format="json")
-        values["tool_system_prompt_template"] = (
-            values.get("tool_system_prompt_template") or DEFAULT_SYSTEM_TEMPLATE
-        )
-        return values
-
-    @property
-    def model(self) -> BaseChatModel:
-        """For backwards compatibility."""
-        return self.llm
-
-    def _generate(
-        self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
-        **kwargs: Any,
-    ) -> ChatResult:
-        functions = kwargs.get("functions", [])
-        if "function_call" in kwargs:
-            functions = [
-                fn for fn in functions if fn["name"] == kwargs["function_call"]["name"]
-            ]
-            if not functions:
-                raise ValueError(
-                    'If "function_call" is specified, you must also pass a matching \
-function in "functions".'
-                )
-            del kwargs["function_call"]
-        elif not functions:
-            functions.append(DEFAULT_RESPONSE_FUNCTION)
-        system_message_prompt_template = SystemMessagePromptTemplate.from_template(
-            self.tool_system_prompt_template
-        )
-        system_message = system_message_prompt_template.format(
-            tools=json.dumps(functions, indent=2)
-        )
-        if "functions" in kwargs:
-            del kwargs["functions"]
-        response_message = self.llm.predict_messages(
-            [system_message] + messages, stop=stop, callbacks=run_manager, **kwargs
-        )
-        chat_generation_content = response_message.content
-        if not isinstance(chat_generation_content, str):
-            raise ValueError("OllamaFunctions does not support non-string output.")
-        try:
-            parsed_chat_result = json.loads(chat_generation_content)
-        except json.JSONDecodeError:
-            raise ValueError(
-                f'"{self.llm.model}" did not respond with valid JSON. Please try again.'
-            )
-        called_tool_name = parsed_chat_result["tool"]
-        called_tool_arguments = parsed_chat_result["tool_input"]
-        called_tool = next(
-            (fn for fn in functions if fn["name"] == called_tool_name), None
-        )
-        if called_tool is None:
-            raise ValueError(
-                f"Failed to parse a function call from {self.llm.model} \
-output: {chat_generation_content}"
-            )
-        if called_tool["name"] == DEFAULT_RESPONSE_FUNCTION["name"]:
-            return ChatResult(
-                generations=[
-                    ChatGeneration(
-                        message=AIMessage(
-                            content=called_tool_arguments["response"],
-                        )
-                    )
-                ]
-            )
-
-        response_message_with_functions = AIMessage(
-            content="",
-            additional_kwargs={
-                "function_call": {
-                    "name": called_tool_name,
-                    "arguments": json.dumps(called_tool_arguments)
-                    if called_tool_arguments
-                    else "",
-                },
-            },
-        )
-
-        return ChatResult(
-            generations=[ChatGeneration(message=response_message_with_functions)]
-        )
-
-    @property
-    def _llm_type(self) -> str:
-        return "ollama_functions"

libs/experimental/langchain_experimental/open_clip/open_clip.py

@@ -19,8 +19,8 @@ class OpenCLIPEmbeddings(BaseModel, Embeddings):
             # model_name = "ViT-B-32"
             # checkpoint = "laion2b_s34b_b79k"
             ### Larger, more performant
-            model_name = "ViT-H-14"
-            checkpoint = "laion2b_s32b_b79k"
+            model_name = "ViT-g-14"
+            checkpoint = "laion2b_s34b_b88k"
             model, _, preprocess = open_clip.create_model_and_transforms(
                 model_name=model_name, pretrained=checkpoint
             )

libs/experimental/langchain_experimental/sql/base.py

@@ -17,7 +17,6 @@ from langchain.utilities.sql_database import SQLDatabase
 from langchain_experimental.pydantic_v1 import Extra, Field, root_validator
 
 INTERMEDIATE_STEPS_KEY = "intermediate_steps"
-SQL_QUERY = "SQLQuery:"
 
 
 class SQLDatabaseChain(Chain):
@@ -111,7 +110,7 @@ class SQLDatabaseChain(Chain):
         run_manager: Optional[CallbackManagerForChainRun] = None,
     ) -> Dict[str, Any]:
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        input_text = f"{inputs[self.input_key]}\n{SQL_QUERY}"
+        input_text = f"{inputs[self.input_key]}\nSQLQuery:"
         _run_manager.on_text(input_text, verbose=self.verbose)
         # If not present, then defaults to None which is all tables.
         table_names_to_use = inputs.get("table_names_to_use")
@@ -141,8 +140,6 @@ class SQLDatabaseChain(Chain):
                     sql_cmd
                 )  # output: sql generation (no checker)
                 intermediate_steps.append({"sql_cmd": sql_cmd})  # input: sql exec
-                if SQL_QUERY in sql_cmd:
-                    sql_cmd = sql_cmd.split(SQL_QUERY)[1].strip()
                 result = self.database.run(sql_cmd)
                 intermediate_steps.append(str(result))  # output: sql exec
             else: