bump ver to 198 (#6026)

Co-authored-by: Fabrizio Ruocco <ruoccofabrizio@gmail.com>

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -46,7 +46,7 @@ body:
         - @agola11
 
         Tools / Toolkits
-        - @vowelparrot
+        - ...
 
       placeholder: "@Username ..."
 

.github/PULL_REQUEST_TEMPLATE.md

@@ -48,7 +48,7 @@ Tag maintainers/contributors who might be interested:
   - @agola11
 
   Agents / Tools / Toolkits
-  - @vowelparrot
+  - @hwchase17
 
   VectorStores / Retrievers / Memory
   - @dev2049

docs/integrations/awadb.md

@@ -0,0 +1,21 @@
+# AwaDB
+
+>[AwaDB](https://github.com/awa-ai/awadb) is an AI Native database for the search and storage of embedding vectors used by LLM Applications.
+
+## Installation and Setup
+
+```bash
+pip install awadb
+```
+
+
+## VectorStore
+
+There exists a wrapper around AwaDB vector databases, allowing you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+```python
+from langchain.vectorstores import AwaDB
+```
+
+For a more detailed walkthrough of the AwaDB wrapper, see [this notebook](../modules/indexes/vectorstores/examples/awadb.ipynb)

docs/integrations/databricks.md

@@ -8,7 +8,7 @@ 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-managed 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 HuggingFace Hub
+4. 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
 ----------------------------------------------
@@ -28,9 +28,9 @@ Databricks as an LLM provider
 
 The notebook [Wrap Databricks endpoints as LLMs](../modules/models/llms/integrations/databricks.html) 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 HuggingFace ecosystem. Databricks endpoints can also be used with proprietary models like OpenAI to provide a governance layer for enterprises.
+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 [HuggingFace Hub](../modules/models/llms/integrations/huggingface_hub.html) for instructions to access it through the HuggingFace Hub integration with LangChain. 
+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](../modules/models/llms/integrations/huggingface_hub.html) for instructions to access it through the Hugging Face Hub integration with LangChain. 

docs/integrations/langchain_decorators.md

@@ -0,0 +1,368 @@
+# LangChain Decorators ✨
+
+lanchchain decorators is a layer on the top of LangChain that provides syntactic sugar 🍭 for writing custom langchain prompts and chains
+
+For Feedback, Issues, Contributions - please raise an issue here: 
+[ju-bezdek/langchain-decorators](https://github.com/ju-bezdek/langchain-decorators)
+
+
+
+Main principles and benefits:
+
+- more `pythonic` way of writing code
+- write multiline prompts that wont break your code flow with indentation
+- making use of IDE in-built support for **hinting**, **type checking** and **popup with docs** to quickly peek in the function to see the prompt, parameters it consumes etc.
+- leverage all the power of 🦜🔗 LangChain ecosystem
+- adding support for **optional parameters**
+- easily share parameters between the prompts by binding them to one class
+
+
+
+Here is a simple example of a code written with **LangChain Decorators ✨**
+
+``` python
+
+@llm_prompt
+def write_me_short_post(topic:str, platform:str="twitter", audience:str = "developers")->str:
+    """
+    Write me a short header for my post about {topic} for {platform} platform. 
+    It should be for {audience} audience.
+    (Max 15 words)
+    """
+    return
+
+# run it naturaly
+write_me_short_post(topic="starwars")
+# or
+write_me_short_post(topic="starwars", platform="redit")
+```
+
+# Quick start
+## Installation
+```bash
+pip install langchain_decorators
+```
+
+## Examples
+
+Good idea on how to start is to review the examples here:
+ - [jupyter notebook](https://github.com/ju-bezdek/langchain-decorators/blob/main/example_notebook.ipynb)
+ - [colab notebook](https://colab.research.google.com/drive/1no-8WfeP6JaLD9yUtkPgym6x0G9ZYZOG#scrollTo=N4cf__D0E2Yk)
+
+# Defining other parameters
+Here we are just marking a function as a prompt with `llm_prompt` decorator, turning it effectively into a LLMChain. Instead of running it 
+
+
+Standard LLMchain takes much more init parameter than just inputs_variables and prompt... here is this implementation detail hidden in the decorator.
+Here is how it works:
+
+1. Using **Global settings**:
+
+``` python
+# define global settings for all prompty (if not set - chatGPT is the current default)
+from langchain_decorators import GlobalSettings
+
+GlobalSettings.define_settings(
+    default_llm=ChatOpenAI(temperature=0.0), this is default... can change it here globally
+    default_streaming_llm=ChatOpenAI(temperature=0.0,streaming=True), this is default... can change it here for all ... will be used for streaming
+)
+```
+
+2. Using predefined **prompt types**
+
+``` python
+#You can change the default prompt types
+from langchain_decorators import PromptTypes, PromptTypeSettings
+
+PromptTypes.AGENT_REASONING.llm = ChatOpenAI()
+
+# Or you can just define your own ones:
+class MyCustomPromptTypes(PromptTypes):
+    GPT4=PromptTypeSettings(llm=ChatOpenAI(model="gpt-4"))
+
+@llm_prompt(prompt_type=MyCustomPromptTypes.GPT4) 
+def write_a_complicated_code(app_idea:str)->str:
+    ...
+
+```
+
+3.  Define the settings **directly in the decorator**
+
+``` python
+from langchain.llms import OpenAI
+
+@llm_prompt(
+    llm=OpenAI(temperature=0.7),
+    stop_tokens=["\nObservation"],
+    ...
+    )
+def creative_writer(book_title:str)->str:
+    ...
+```
+
+## Passing a memory and/or callbacks:
+
+To pass any of these, just declare them in the function (or use kwargs to pass anything)
+
+```python
+
+@llm_prompt()
+async def write_me_short_post(topic:str, platform:str="twitter", memory:SimpleMemory = None):
+    """
+    {history_key}
+    Write me a short header for my post about {topic} for {platform} platform. 
+    It should be for {audience} audience.
+    (Max 15 words)
+    """
+    pass
+
+await write_me_short_post(topic="old movies")
+
+```
+
+# Simplified streaming
+
+If we wan't to leverage streaming:
+ - we need to define prompt as async function 
+ - turn on the streaming on the decorator, or we can define PromptType with streaming on
+ - capture the stream using StreamingContext
+
+This way we just mark which prompt should be streamed, not needing to tinker with what LLM should we use, passing around the creating and distribute streaming handler into particular part of our chain... just turn the streaming on/off on prompt/prompt type...
+
+The streaming will happen only if we call it in streaming context ... there we can define a simple function to handle the stream
+
+``` python
+# this code example is complete and should run as it is
+
+from langchain_decorators import StreamingContext, llm_prompt
+
+# this will mark the prompt for streaming (useful if we want stream just some prompts in our app... but don't want to pass distribute the callback handlers)
+# note that only async functions can be streamed (will get an error if it's not)
+@llm_prompt(capture_stream=True) 
+async def write_me_short_post(topic:str, platform:str="twitter", audience:str = "developers"):
+    """
+    Write me a short header for my post about {topic} for {platform} platform. 
+    It should be for {audience} audience.
+    (Max 15 words)
+    """
+    pass
+
+
+
+# just an arbitrary  function to demonstrate the streaming... wil be some websockets code in the real world
+tokens=[]
+def capture_stream_func(new_token:str):
+    tokens.append(new_token)
+
+# if we want to capture the stream, we need to wrap the execution into StreamingContext... 
+# this will allow us to capture the stream even if the prompt call is hidden inside higher level method
+# only the prompts marked with capture_stream will be captured here
+with StreamingContext(stream_to_stdout=True, callback=capture_stream_func):
+    result = await run_prompt()
+    print("Stream finished ... we can distinguish tokens thanks to alternating colors")
+
+
+print("\nWe've captured",len(tokens),"tokens🎉\n")
+print("Here is the result:")
+print(result)
+```
+
+
+# Prompt declarations
+By default the prompt is is the whole function docs, unless you mark your prompt 
+
+## Documenting your prompt
+
+We can specify what part of our docs is the prompt definition, by specifying a code block with **<prompt>** language tag
+
+``` python
+@llm_prompt
+def write_me_short_post(topic:str, platform:str="twitter", audience:str = "developers"):
+    """
+    Here is a good way to write a prompt as part of a function docstring, with additional documentation for devs.
+
+    It needs to be a code block, marked as a `<prompt>` language
+    ```<prompt>
+    Write me a short header for my post about {topic} for {platform} platform. 
+    It should be for {audience} audience.
+    (Max 15 words)
+    ```
+
+    Now only to code block above will be used as a prompt, and the rest of the docstring will be used as a description for developers.
+    (It has also a nice benefit that IDE (like VS code) will display the prompt properly (not trying to parse it as markdown, and thus not showing new lines properly))
+    """
+    return 
+```
+
+## Chat messages prompt
+
+For chat models is very useful to define prompt as a set of message templates... here is how to do it:
+
+``` python
+@llm_prompt
+def simulate_conversation(human_input:str, agent_role:str="a pirate"):
+    """
+    ## System message
+     - note the `:system` sufix inside the <prompt:_role_> tag
+     
+
+    ```<prompt:system>
+    You are a {agent_role} hacker. You mus act like one.
+    You reply always in code, using python or javascript code block...
+    for example:
+    
+    ... do not reply with anything else.. just with code - respecting your role.
+    ```
+
+    # human message 
+    (we are using the real role that are enforced by the LLM - GPT supports system, assistant, user)
+    ``` <prompt:user>
+    Helo, who are you
+    ```
+    a reply:
+    
+
+    ``` <prompt:assistant>
+    \``` python <<- escaping inner code block with \ that should be part of the prompt
+    def hello():
+        print("Argh... hello you pesky pirate")
+    \```
+    ```
+    
+    we can also add some history using placeholder
+    ```<prompt:placeholder>
+    {history}
+    ```
+    ```<prompt:user>
+    {human_input}
+    ```
+
+    Now only to code block above will be used as a prompt, and the rest of the docstring will be used as a description for developers.
+    (It has also a nice benefit that IDE (like VS code) will display the prompt properly (not trying to parse it as markdown, and thus not showing new lines properly))
+    """
+    pass
+
+```
+
+the roles here are model native roles (assistant, user, system for chatGPT)
+
+
+
+# Optional sections
+- you can define a whole sections of your prompt that should be optional
+- if any input in the section is missing, the whole section wont be rendered
+
+the syntax for this is as follows:
+
+``` python
+@llm_prompt
+def prompt_with_optional_partials():
+    """
+    this text will be rendered always, but
+
+    {? anything inside this block will be rendered only if all the {value}s parameters are not empty (None | "")   ?}
+
+    you can also place it in between the words
+    this too will be rendered{? , but
+        this  block will be rendered only if {this_value} and {this_value}
+        is not empty?} !
+    """
+```
+
+
+# Output parsers
+
+- llm_prompt decorator natively tries to detect the best output parser based on the output type. (if not set, it returns the raw string)
+- list, dict and pydantic outputs are also supported natively (automaticaly)
+
+``` python
+# this code example is complete and should run as it is
+
+from langchain_decorators import llm_prompt
+
+@llm_prompt
+def write_name_suggestions(company_business:str, count:int)->list:
+    """ Write me {count} good name suggestions for company that {company_business}
+    """
+    pass
+
+write_name_suggestions(company_business="sells cookies", count=5)
+```
+
+## More complex structures
+
+for dict / pydantic you need to specify the formatting instructions... 
+this can be tedious, that's why you can let the output parser gegnerate you the instructions based on the model (pydantic)
+
+``` python
+from langchain_decorators import llm_prompt
+from pydantic import BaseModel, Field
+
+
+class TheOutputStructureWeExpect(BaseModel):
+    name:str = Field (description="The name of the company")
+    headline:str = Field( description="The description of the company (for landing page)")
+    employees:list[str] = Field(description="5-8 fake employee names with their positions")
+
+@llm_prompt()
+def fake_company_generator(company_business:str)->TheOutputStructureWeExpect:
+    """ Generate a fake company that {company_business}
+    {FORMAT_INSTRUCTIONS}
+    """
+    return
+
+company = fake_company_generator(company_business="sells cookies")
+
+# print the result nicely formatted
+print("Company name: ",company.name)
+print("company headline: ",company.headline)
+print("company employees: ",company.employees)
+
+```
+
+
+# Binding the prompt to an object
+
+``` python
+from pydantic import BaseModel
+from langchain_decorators import llm_prompt
+
+class AssistantPersonality(BaseModel):
+    assistant_name:str
+    assistant_role:str
+    field:str
+
+    @property
+    def a_property(self):
+        return "whatever"
+
+    def hello_world(self, function_kwarg:str=None):
+        """
+        We can reference any {field} or {a_property} inside our prompt... and combine it with {function_kwarg} in the method
+        """
+
+    
+    @llm_prompt
+    def introduce_your_self(self)->str:
+        """
+        ``` <prompt:system>
+        You are an assistant named {assistant_name}. 
+        Your role is to act as {assistant_role}
+        ```
+        ```<prompt:user>
+        Introduce your self (in less than 20 words)
+        ```
+        """
+
+    
+
+personality = AssistantPersonality(assistant_name="John", assistant_role="a pirate")
+
+print(personality.introduce_your_self(personality))
+```
+
+
+# More examples:
+
+- these and few more examples are also available in the [colab notebook here](https://colab.research.google.com/drive/1no-8WfeP6JaLD9yUtkPgym6x0G9ZYZOG#scrollTo=N4cf__D0E2Yk)
+- including the [ReAct Agent re-implementation](https://colab.research.google.com/drive/1no-8WfeP6JaLD9yUtkPgym6x0G9ZYZOG#scrollTo=3bID5fryE2Yp) using purely langchain decorators

docs/integrations/vectara.md

@@ -4,7 +4,7 @@
 What is Vectara?
 
 **Vectara Overview:**
-- Vectara is developer-first API platform for building conversational search applications
+- Vectara is developer-first API platform for building GenAI applications
 - To use Vectara - first [sign up](https://console.vectara.com/signup) and create an account. Then create a corpus and an API key for indexing and searching.
 - You can use Vectara's [indexing API](https://docs.vectara.com/docs/indexing-apis/indexing) to add documents into Vectara's index
 - You can use Vectara's [Search API](https://docs.vectara.com/docs/search-apis/search) to query Vectara's index (which also supports Hybrid search implicitly).
@@ -13,6 +13,13 @@ What is Vectara?
 ## Installation and Setup
 To use Vectara with LangChain no special installation steps are required. You just have to provide your customer_id, corpus ID, and an API key created within the Vectara console to enable indexing and searching.
 
+Alternatively these can be provided as environment variables
+- export `VECTARA_CUSTOMER_ID`="your_customer_id"
+- export `VECTARA_CORPUS_ID`="your_corpus_id"
+- export `VECTARA_API_KEY`="your-vectara-api-key"
+
+## Usage
+
 ### VectorStore
 
 There exists a wrapper around the Vectara platform, allowing you to use it as a vectorstore, whether for semantic search or example selection.
@@ -32,8 +39,21 @@ vectara = Vectara(
 ```
 The customer_id, corpus_id and api_key are optional, and if they are not supplied will be read from the environment variables `VECTARA_CUSTOMER_ID`, `VECTARA_CORPUS_ID` and `VECTARA_API_KEY`, respectively.
 
+To query the vectorstore, you can use the `similarity_search` method (or `similarity_search_with_score`), which takes a query string and returns a list of results:
+```python
+results = vectara.similarity_score("what is LangChain?")
+```
 
-For a more detailed walkthrough of the Vectara wrapper, see one of the two example notebooks:
+`similarity_search_with_score` also supports the following additional arguments:
+- `k`: number of results to return (defaults to 5)
+- `lambda_val`: the [lexical matching](https://docs.vectara.com/docs/api-reference/search-apis/lexical-matching) factor for hybrid search (defaults to 0.025)
+- `filter`: a [filter](https://docs.vectara.com/docs/common-use-cases/filtering-by-metadata/filter-overview) to apply to the results (default None)
+- `n_sentence_context`: number of sentences to include before/after the actual matching segment when returning results. This defaults to 0 so as to return the exact text segment that matches, but can be used with other values e.g. 2 or 3 to return adjacent text segments.
+
+The results are returned as a list of relevant documents, and a relevance score of each document.
+
+
+For a more detailed examples of using the Vectara wrapper, see one of these two sample notebooks:
 * [Chat Over Documents with Vectara](./vectara/vectara_chat.html)
 * [Vectara Text Generation](./vectara/vectara_text_generation.html)
 

docs/integrations/vectara/vectara_chat.ipynb

@@ -102,21 +102,11 @@
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'langchain.vectorstores.vectara.Vectara'>\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "openai_api_key = os.environ['OPENAI_API_KEY']\n",
     "llm = OpenAI(openai_api_key=openai_api_key, temperature=0)\n",
-    "retriever = VectaraRetriever(vectorstore, alpha=0.025, k=5, filter=None)\n",
-    "\n",
-    "print(type(vectorstore))\n",
+    "retriever = vectorstore.as_retriever(lambda_val=0.025, k=5, filter=None)\n",
     "d = retriever.get_relevant_documents('What did the president say about Ketanji Brown Jackson')\n",
     "\n",
     "qa = ConversationalRetrievalChain.from_llm(llm, retriever, memory=memory)"
@@ -142,7 +132,7 @@
     {
      "data": {
       "text/plain": [
-       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds, a former top litigator in private practice, and a former federal public defender.\""
+       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and that she will continue Justice Breyer's legacy of excellence.\""
       ]
      },
      "execution_count": 7,
@@ -174,7 +164,7 @@
     {
      "data": {
       "text/plain": [
-       "' Justice Stephen Breyer.'"
+       "' Justice Stephen Breyer'"
       ]
      },
      "execution_count": 9,
@@ -241,7 +231,7 @@
     {
      "data": {
       "text/plain": [
-       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds, a former top litigator in private practice, and a former federal public defender.\""
+       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and that she will continue Justice Breyer's legacy of excellence.\""
       ]
      },
      "execution_count": 12,
@@ -286,7 +276,7 @@
     {
      "data": {
       "text/plain": [
-       "' Justice Stephen Breyer.'"
+       "' Justice Stephen Breyer'"
       ]
      },
      "execution_count": 14,
@@ -344,7 +334,7 @@
     {
      "data": {
       "text/plain": [
-       "Document(page_content='Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice. A former federal public defender.', metadata={'source': '../../modules/state_of_the_union.txt'})"
+       "Document(page_content='Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \\n\\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', metadata={'source': '../../../state_of_the_union.txt'})"
       ]
      },
      "execution_count": 17,
@@ -392,6 +382,24 @@
     "result = qa({\"question\": query, \"chat_history\": chat_history, \"vectordbkwargs\": vectordbkwargs})"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "24ebdaec",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " The president said that Ketanji Brown Jackson is one of the nation's top legal minds and that she will continue Justice Breyer's legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(result['answer'])"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "99b96dae",
@@ -459,7 +467,7 @@
     {
      "data": {
       "text/plain": [
-       "' The president did not mention Ketanji Brown Jackson.'"
+       "\" The president said that he nominated Circuit Court of Appeals Judge Ketanji Brown Jackson, who he described as one of the nation's top legal minds, to continue Justice Breyer's legacy of excellence.\""
       ]
      },
      "execution_count": 23,
@@ -538,7 +546,7 @@
     {
      "data": {
       "text/plain": [
-       "' The president did not mention Ketanji Brown Jackson.\\nSOURCES: ../../modules/state_of_the_union.txt'"
+       "\" The president said that he nominated Circuit Court of Appeals Judge Ketanji Brown Jackson, who he described as one of the nation's top legal minds, and that she will continue Justice Breyer's legacy of excellence.\\nSOURCES: ../../../state_of_the_union.txt\""
       ]
      },
      "execution_count": 27,
@@ -598,7 +606,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " The president said that Ketanji Brown Jackson is one of the nation's top legal minds, a former top litigator in private practice, and a former federal public defender."
+      " The president said that Ketanji Brown Jackson is one of the nation's top legal minds and that she will continue Justice Breyer's legacy of excellence."
      ]
     }
    ],
@@ -620,7 +628,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " Justice Stephen Breyer."
+      " Justice Stephen Breyer"
      ]
     }
    ],
@@ -681,7 +689,7 @@
     {
      "data": {
       "text/plain": [
-       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds, a former top litigator in private practice, and a former federal public defender.\""
+       "\" The president said that Ketanji Brown Jackson is one of the nation's top legal minds and that she will continue Justice Breyer's legacy of excellence.\""
       ]
      },
      "execution_count": 33,

docs/integrations/vectara/vectara_text_generation.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Vectara Text Generation\n",
     "\n",
-    "This notebook is based on [chat_vector_db](https://github.com/hwchase17/langchain/blob/master/docs/modules/chains/index_examples/question_answering.ipynb) and adapted to Vectara."
+    "This notebook is based on [text generation](https://github.com/hwchase17/langchain/blob/master/docs/modules/chains/index_examples/vector_db_text_generation.ipynb) notebook and adapted to Vectara."
    ]
   },
   {
@@ -24,6 +24,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import os\n",
     "from langchain.llms import OpenAI\n",
     "from langchain.docstore.document import Document\n",
     "import requests\n",
@@ -159,7 +160,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[{'text': '\\n\\nEnvironment variables are an essential part of any development workflow. They provide a way to store and access information that is specific to the environment in which the code is running. This can be especially useful when working with different versions of a language or framework, or when running code on different machines.\\n\\nThe Deno CLI tasks extension provides a way to easily manage environment variables when running Deno commands. This extension provides a task definition for allowing you to create tasks that execute the `deno` CLI from within the editor. The template for the Deno CLI tasks has the following interface, which can be configured in a `tasks.json` within your workspace:\\n\\nThe task definition includes the `type` field, which should be set to `deno`, and the `command` field, which is the `deno` command to run (e.g. `run`, `test`, `cache`, etc.). Additionally, you can specify additional arguments to pass on the command line, the current working directory to execute the command, and any environment variables.\\n\\nUsing environment variables with the Deno CLI tasks extension is a great way to ensure that your code is running in the correct environment. For example, if you are running a test suite,'}, {'text': '\\n\\nEnvironment variables are an important part of any programming language, and they can be used to store and access data in a variety of ways. In this blog post, we\\'ll be taking a look at environment variables specifically for the shell.\\n\\nShell variables are similar to environment variables, but they won\\'t be exported to spawned commands. They are defined with the following syntax:\\n\\n```sh\\nVAR_NAME=value\\n```\\n\\nShell variables can be used to store and access data in a variety of ways. For example, you can use them to store values that you want to re-use, but don\\'t want to be available in any spawned processes.\\n\\nFor example, if you wanted to store a value and then use it in a command, you could do something like this:\\n\\n```sh\\nVAR=hello && echo $VAR && deno eval \"console.log(\\'Deno: \\' + Deno.env.get(\\'VAR\\'))\"\\n```\\n\\nThis would output the following:\\n\\n```\\nhello\\nDeno: undefined\\n```\\n\\nAs you can see, the value stored in the shell variable is not available in the spawned process.\\n\\n'}, {'text': '\\n\\nWhen it comes to developing applications, environment variables are an essential part of the process. Environment variables are used to store information that can be used by applications and scripts to customize their behavior. This is especially important when it comes to developing applications with Deno, as there are several environment variables that can impact the behavior of Deno.\\n\\nThe most important environment variable for Deno is `DENO_AUTH_TOKENS`. This environment variable is used to store authentication tokens that are used to access remote resources. This is especially important when it comes to accessing remote APIs or databases. Without the proper authentication tokens, Deno will not be able to access the remote resources.\\n\\nAnother important environment variable for Deno is `DENO_DIR`. This environment variable is used to store the directory where Deno will store its files. This includes the Deno executable, the Deno cache, and the Deno configuration files. By setting this environment variable, you can ensure that Deno will always be able to find the files it needs.\\n\\nFinally, there is the `DENO_PLUGINS` environment variable. This environment variable is used to store the list of plugins that Deno will use. This is important for customizing the'}, {'text': '\\n\\nEnvironment variables are a great way to store and access sensitive information in your Deno applications. Deno offers built-in support for environment variables with `Deno.env`, and you can also use a `.env` file to store and access environment variables. In this blog post, we\\'ll explore both of these options and how to use them in your Deno applications.\\n\\n## Built-in `Deno.env`\\n\\nThe Deno runtime offers built-in support for environment variables with [`Deno.env`](https://deno.land/api@v1.25.3?s=Deno.env). `Deno.env` has getter and setter methods. Here is example usage:\\n\\n```ts\\nDeno.env.set(\"FIREBASE_API_KEY\", \"examplekey123\");\\nDeno.env.set(\"FIREBASE_AUTH_DOMAIN\", \"firebasedomain.com\");\\n\\nconsole.log(Deno.env.get(\"FIREBASE_API_KEY\")); // examplekey123\\nconsole.log(Deno.env.get(\"FIREBASE_AUTH_'}]\n"
+      "[{'text': '\\n\\nEnvironment variables are a powerful tool for managing configuration settings in your applications. They allow you to store and access values from anywhere in your code, making it easier to keep your codebase organized and maintainable.\\n\\nHowever, there are times when you may want to use environment variables specifically for a single command. This is where shell variables come in. Shell variables are similar to environment variables, but they won\\'t be exported to spawned commands. They are defined with the following syntax:\\n\\n```sh\\nVAR_NAME=value\\n```\\n\\nFor example, if you wanted to use a shell variable instead of an environment variable in a command, you could do something like this:\\n\\n```sh\\nVAR=hello && echo $VAR && deno eval \"console.log(\\'Deno: \\' + Deno.env.get(\\'VAR\\'))\"\\n```\\n\\nThis would output the following:\\n\\n```\\nhello\\nDeno: undefined\\n```\\n\\nShell variables can be useful when you want to re-use a value, but don\\'t want it available in any spawned processes.\\n\\nAnother way to use environment variables is through pipelines. Pipelines provide a way to pipe the'}, {'text': '\\n\\nEnvironment variables are a great way to store and access sensitive information in your applications. They are also useful for configuring applications and managing different environments. In Deno, there are two ways to use environment variables: the built-in `Deno.env` and the `.env` file.\\n\\nThe `Deno.env` is a built-in feature of the Deno runtime that allows you to set and get environment variables. It has getter and setter methods that you can use to access and set environment variables. For example, you can set the `FIREBASE_API_KEY` and `FIREBASE_AUTH_DOMAIN` environment variables like this:\\n\\n```ts\\nDeno.env.set(\"FIREBASE_API_KEY\", \"examplekey123\");\\nDeno.env.set(\"FIREBASE_AUTH_DOMAIN\", \"firebasedomain.com\");\\n\\nconsole.log(Deno.env.get(\"FIREBASE_API_KEY\")); // examplekey123\\nconsole.log(Deno.env.get(\"FIREBASE_AUTH_DOMAIN\")); // firebasedomain'}, {'text': \"\\n\\nEnvironment variables are a powerful tool for managing configuration and settings in your applications. They allow you to store and access values that can be used in your code, and they can be set and changed without having to modify your code.\\n\\nIn Deno, environment variables are defined using the `export` command. For example, to set a variable called `VAR_NAME` to the value `value`, you would use the following command:\\n\\n```sh\\nexport VAR_NAME=value\\n```\\n\\nYou can then access the value of the environment variable in your code using the `Deno.env.get()` method. For example, if you wanted to log the value of the `VAR_NAME` variable, you could use the following code:\\n\\n```js\\nconsole.log(Deno.env.get('VAR_NAME'));\\n```\\n\\nYou can also set environment variables for a single command. To do this, you can list the environment variables before the command, like so:\\n\\n```\\nVAR=hello VAR2=bye deno run main.ts\\n```\\n\\nThis will set the environment variables `VAR` and `V\"}, {'text': \"\\n\\nEnvironment variables are a powerful tool for managing settings and configuration in your applications. They can be used to store information such as user preferences, application settings, and even passwords. In this blog post, we'll discuss how to make Deno scripts executable with a hashbang (shebang).\\n\\nA hashbang is a line of code that is placed at the beginning of a script. It tells the system which interpreter to use when running the script. In the case of Deno, the hashbang should be `#!/usr/bin/env -S deno run --allow-env`. This tells the system to use the Deno interpreter and to allow the script to access environment variables.\\n\\nOnce the hashbang is in place, you may need to give the script execution permissions. On Linux, this can be done with the command `sudo chmod +x hashbang.ts`. After that, you can execute the script by calling it like any other command: `./hashbang.ts`.\\n\\nIn the example program, we give the context permission to access the environment variables and print the Deno installation path. This is done by using the `Deno.env.get()` function, which returns the value of the specified environment\"}]\n"
      ]
     }
    ],

docs/modules/agents/agent_executors/examples/agent_vectorstore.ipynb

@@ -14,6 +14,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "9b22020a",
    "metadata": {},
@@ -139,6 +140,7 @@
    "source": []
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "c0a6c031",
    "metadata": {},
@@ -229,7 +231,7 @@
     }
    ],
    "source": [
-    "agent.run(\"What did biden say about ketanji brown jackson is the state of the union address?\")"
+    "agent.run(\"What did biden say about ketanji brown jackson in the state of the union address?\")"
    ]
   },
   {
@@ -271,6 +273,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "787a9b5e",
    "metadata": {},
@@ -279,6 +282,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "9161ba91",
    "metadata": {},
@@ -396,6 +400,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "49a0cbbe",
    "metadata": {},

docs/modules/agents/toolkits/examples/vectorstore.ipynb

@@ -1,6 +1,7 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "18ada398-dce6-4049-9b56-fc0ede63da9c",
    "metadata": {},
@@ -11,6 +12,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "eecb683b-3a46-4b9d-81a3-7caefbfec1a1",
    "metadata": {},
@@ -88,6 +90,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "f4814175-964d-42f1-aa9d-22801ce1e912",
    "metadata": {},
@@ -123,6 +126,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "8a38ad10",
    "metadata": {},
@@ -165,7 +169,7 @@
     }
    ],
    "source": [
-    "agent_executor.run(\"What did biden say about ketanji brown jackson is the state of the union address?\")"
+    "agent_executor.run(\"What did biden say about ketanji brown jackson in the state of the union address?\")"
    ]
   },
   {
@@ -203,10 +207,11 @@
     }
    ],
    "source": [
-    "agent_executor.run(\"What did biden say about ketanji brown jackson is the state of the union address? List the source.\")"
+    "agent_executor.run(\"What did biden say about ketanji brown jackson in the state of the union address? List the source.\")"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "7ca07707",
    "metadata": {},
@@ -255,6 +260,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "71680984-edaf-4a63-90f5-94edbd263550",
    "metadata": {},
@@ -299,7 +305,7 @@
     }
    ],
    "source": [
-    "agent_executor.run(\"What did biden say about ketanji brown jackson is the state of the union address?\")"
+    "agent_executor.run(\"What did biden say about ketanji brown jackson in the state of the union address?\")"
    ]
   },
   {

docs/modules/chains/examples/graph_cypher_qa.ipynb

@@ -177,7 +177,7 @@
       "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie {name: 'Top Gun'})\n",
       "RETURN a.name\u001b[0m\n",
       "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Tom Cruise'}]\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -185,7 +185,7 @@
     {
      "data": {
       "text/plain": [
-       "'Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan played in Top Gun.'"
+       "'Val Kilmer, Anthony Edwards, Meg Ryan, and Tom Cruise played in Top Gun.'"
       ]
      },
      "execution_count": 7,
@@ -197,10 +197,180 @@
     "chain.run(\"Who played in Top Gun?\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "2d28c4df",
+   "metadata": {},
+   "source": [
+    "## Limit the number of results\n",
+    "You can limit the number of results from the Cypher QA Chain using the `top_k` parameter.\n",
+    "The default is 10."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "df230946",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0), graph=graph, verbose=True, top_k=2\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3f1600ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie {name: 'Top Gun'})\n",
+      "RETURN a.name\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Val Kilmer and Anthony Edwards played in Top Gun.'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(\"Who played in Top Gun?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88c16206",
+   "metadata": {},
+   "source": [
+    "## Return intermediate results\n",
+    "You can return intermediate steps from the Cypher QA Chain using the `return_intermediate_steps` parameter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e412f36b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0), graph=graph, verbose=True, return_intermediate_steps=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "4f4699dc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie {name: 'Top Gun'})\n",
+      "RETURN a.name\u001b[0m\n",
+      "Full Context:\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Tom Cruise'}]\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "Intermediate steps: [{'query': \"MATCH (a:Actor)-[:ACTED_IN]->(m:Movie {name: 'Top Gun'})\\nRETURN a.name\"}, {'context': [{'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Tom Cruise'}]}]\n",
+      "Final answer: Val Kilmer, Anthony Edwards, Meg Ryan, and Tom Cruise played in Top Gun.\n"
+     ]
+    }
+   ],
+   "source": [
+    "result = chain(\"Who played in Top Gun?\")\n",
+    "print(f\"Intermediate steps: {result['intermediate_steps']}\")\n",
+    "print(f\"Final answer: {result['result']}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6e1b054",
+   "metadata": {},
+   "source": [
+    "## Return direct results\n",
+    "You can return direct results from the Cypher QA Chain using the `return_direct` parameter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2d3acf10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = GraphCypherQAChain.from_llm(\n",
+    "    ChatOpenAI(temperature=0), graph=graph, verbose=True, return_direct=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b0a9d143",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
+      "Generated Cypher:\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie {name: 'Top Gun'})\n",
+      "RETURN a.name\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[{'a.name': 'Val Kilmer'},\n",
+       " {'a.name': 'Anthony Edwards'},\n",
+       " {'a.name': 'Meg Ryan'},\n",
+       " {'a.name': 'Tom Cruise'}]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.run(\"Who played in Top Gun?\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "b4825316",
+   "id": "74d0a36f",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -222,7 +392,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.8.8"
   }
  },
  "nbformat": 4,

docs/modules/indexes/document_loaders.rst

@@ -30,6 +30,7 @@ For detailed instructions on how to get set up with Unstructured, see installati
    :maxdepth: 1
    :glob:
 
+   ./document_loaders/examples/airtable.ipynb
    ./document_loaders/examples/audio.ipynb
    ./document_loaders/examples/conll-u.ipynb
    ./document_loaders/examples/copypaste.ipynb

docs/modules/indexes/document_loaders/examples/airtable.ipynb

@@ -0,0 +1,142 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7ae421e6",
+   "metadata": {},
+   "source": [
+    "# Airtable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "98aea00d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install pyairtable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "592483eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import AirtableLoader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "637e1205",
+   "metadata": {},
+   "source": [
+    "* Get your API key [here](https://support.airtable.com/docs/creating-and-using-api-keys-and-access-tokens).\n",
+    "* Get ID of your base [here](https://airtable.com/developers/web/api/introduction).\n",
+    "* Get your table ID from the table url as shown [here](https://www.highviewapps.com/kb/where-can-i-find-the-airtable-base-id-and-table-id/#:~:text=Both%20the%20Airtable%20Base%20ID,URL%20that%20begins%20with%20tbl)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c12a7aff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "api_key=\"xxx\"\n",
+    "base_id=\"xxx\"\n",
+    "table_id=\"xxx\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ccddd5a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = AirtableLoader(api_key,table_id,base_id)\n",
+    "docs = loader.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae76c25c",
+   "metadata": {},
+   "source": [
+    "Returns each table row as `dict`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7abec7ce",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "403c95da",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'id': 'recF3GbGZCuh9sXIQ',\n",
+       " 'createdTime': '2023-06-09T04:47:21.000Z',\n",
+       " 'fields': {'Priority': 'High',\n",
+       "  'Status': 'In progress',\n",
+       "  'Name': 'Document Splitters'}}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eval(docs[0].page_content)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/indexes/document_loaders/examples/example_data/factbook.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<factbook>
+  <country>
+    <name>United States</name>
+    <capital>Washington, DC</capital>
+    <leader>Joe Biden</leader>
+    <sport>Baseball</sport>
+  </country>
+  <country>
+    <name>Canada</name>
+    <capital>Ottawa</capital>
+    <leader>Justin Trudeau</leader>
+    <sport>Hockey</sport>
+  </country>
+  <country>
+    <name>France</name>
+    <capital>Paris</capital>
+    <leader>Emmanuel Macron</leader>
+    <sport>Soccer</sport>
+  </country>
+  <country>
+    <name>Trinidad &amp; Tobado</name>
+    <capital>Port of Spain</capital>
+    <leader>Keith Rowley</leader>
+    <sport>Track &amp; Field</sport>
+  </country>
+</factbook>

docs/modules/indexes/document_loaders/examples/xml.ipynb

@@ -0,0 +1,78 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "22a849cc",
+   "metadata": {},
+   "source": [
+    "# XML\n",
+    "\n",
+    "The `UnstructuredXMLLoader` is used to load `XML` files. The loader works with `.xml` files. The page content will be the text extracted from the XML tags."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e6616e3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import UnstructuredXMLLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a654e4d9",
+   "metadata": {},
+   "outputs": [
+    {
+      "data": {
+        "text/plain": [
+          "Document(page_content='United States\\n\\nWashington, DC\\n\\nJoe Biden\\n\\nBaseball\\n\\nCanada\\n\\nOttawa\\n\\nJustin Trudeau\\n\\nHockey\\n\\nFrance\\n\\nParis\\n\\nEmmanuel Macron\\n\\nSoccer\\n\\nTrinidad & Tobado\\n\\nPort of Spain\\n\\nKeith Rowley\\n\\nTrack & Field', metadata={'source': 'example_data/factbook.xml'})"
+        ]
+      },
+      "execution_count": 2,
+      "metadata": {},
+      "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "loader = UnstructuredXMLLoader(\n",
+    "    \"example_data/factbook.xml\",\n",
+    ")\n",
+    "docs = loader.load()\n",
+    "docs[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a54342bb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/indexes/retrievers/examples/merger_retriever.ipynb

@@ -0,0 +1,121 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "fc0db1bc",
+   "metadata": {},
+   "source": [
+    "# LOTR (Merger Retriever)\n",
+    "\n",
+    "Lord of the Retrievers, also known as MergerRetriever, takes a list of retrievers as input and merges the results of their get_relevant_documents() methods into a single list. The merged results will be a list of documents that are relevant to the query and that have been ranked by the different retrievers.\n",
+    "\n",
+    "The MergerRetriever class can be used to improve the accuracy of document retrieval in a number of ways. First, it can combine the results of multiple retrievers, which can help to reduce the risk of bias in the results. Second, it can rank the results of the different retrievers, which can help to ensure that the most relevant documents are returned first."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9fbcc58f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import chromadb\n",
+    "from langchain.retrievers.merger_retriever import MergerRetriever\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain.embeddings import HuggingFaceEmbeddings\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.document_transformers import EmbeddingsRedundantFilter\n",
+    "from langchain.retrievers.document_compressors import DocumentCompressorPipeline\n",
+    "from langchain.retrievers import ContextualCompressionRetriever\n",
+    "\n",
+    "# Get 3 diff embeddings.\n",
+    "all_mini = HuggingFaceEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
+    "multi_qa_mini = HuggingFaceEmbeddings(model_name=\"multi-qa-MiniLM-L6-dot-v1\")\n",
+    "filter_embeddings = OpenAIEmbeddings()\n",
+    "\n",
+    "ABS_PATH = os.path.dirname(os.path.abspath(__file__))\n",
+    "DB_DIR = os.path.join(ABS_PATH, \"db\")\n",
+    "\n",
+    "# Instantiate 2 diff cromadb indexs, each one with a diff embedding.\n",
+    "client_settings = chromadb.config.Settings(\n",
+    "    chroma_db_impl=\"duckdb+parquet\",\n",
+    "    persist_directory=DB_DIR,\n",
+    "    anonymized_telemetry=False,\n",
+    ")\n",
+    "db_all = Chroma(\n",
+    "    collection_name=\"project_store_all\",\n",
+    "    persist_directory=DB_DIR,\n",
+    "    client_settings=client_settings,\n",
+    "    embedding_function=all_mini,\n",
+    ")\n",
+    "db_multi_qa = Chroma(\n",
+    "    collection_name=\"project_store_multi\",\n",
+    "    persist_directory=DB_DIR,\n",
+    "    client_settings=client_settings,\n",
+    "    embedding_function=multi_qa_mini,\n",
+    ")\n",
+    "\n",
+    "# Define 2 diff retrievers with 2 diff embeddings and diff search type.\n",
+    "retriever_all = db_all.as_retriever(\n",
+    "    search_type=\"similarity\", search_kwargs={\"k\": 5, \"include_metadata\": True}\n",
+    ")\n",
+    "retriever_multi_qa = db_multi_qa.as_retriever(\n",
+    "    search_type=\"mmr\", search_kwargs={\"k\": 5, \"include_metadata\": True}\n",
+    ")\n",
+    "\n",
+    "# The Lord of the Retrievers will hold the ouput of boths retrievers and can be used as any other \n",
+    "# retriever on different types of chains.\n",
+    "lotr = MergerRetriever(retrievers=[retriever_all, retriever_multi_qa])\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "c152339d",
+   "metadata": {},
+   "source": [
+    "## Remove redundant results from the merged retrievers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "039faea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# We can remove redundant results from both retrievers using yet another embedding. \n",
+    "# Using multiples embeddings in diff steps could help reduce biases.\n",
+    "filter = EmbeddingsRedundantFilter(embeddings=filter_embeddings)\n",
+    "pipeline = DocumentCompressorPipeline(transformers=[filter])\n",
+    "compression_retriever = ContextualCompressionRetriever(\n",
+    "    base_compressor=pipeline, base_retriever=lotr\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/indexes/retrievers/examples/vectorstore.ipynb

@@ -99,13 +99,14 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "2d958271",
    "metadata": {},
    "source": [
     "## Similarity Score Threshold Retrieval\n",
     "\n",
-    "You can also a retrieval method that sets a similarity score threshold and only returns documents with a score above that threshold"
+    "You can also use a retrieval method that sets a similarity score threshold and only returns documents with a score above that threshold"
    ]
   },
   {

docs/modules/indexes/vectorstores/examples/awadb.ipynb

@@ -0,0 +1,194 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "833c4789",
+   "metadata": {},
+   "source": [
+    "# AwaDB\n",
+    "[AwaDB](https://github.com/awa-ai/awadb) is an AI Native database for the search and storage of embedding vectors used by LLM Applications.\n",
+    "This notebook shows how to use functionality related to the AwaDB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "252930ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install awadb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f2b71a47",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import AwaDB\n",
+    "from langchain.document_loaders import TextLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49be0bac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = TextLoader('../../../state_of_the_union.txt')\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size= 100, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "18714278",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db = AwaDB.from_documents(docs)\n",
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = db.similarity_search(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62b7a4c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a9b4be48",
+   "metadata": {},
+   "source": [
+    "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "87fec6b5",
+   "metadata": {},
+   "source": [
+    "## Similarity search with score"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "17231924",
+   "metadata": {},
+   "source": [
+    "The returned distance score is between 0-1. 0 is dissimilar, 1 is the most similar"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f40ddae1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs = db.similarity_search_with_score(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f0045583",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(docs[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c2da99d",
+   "metadata": {},
+   "source": [
+    "(Document(page_content='And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', metadata={'source': '../../../state_of_the_union.txt'}), 0.561813814013747)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b49fb59",
+   "metadata": {},
+   "source": [
+    "## Restore the table created and added data before"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1bfa6e25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "AwaDB automatically persists added document data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a0f3b35",
+   "metadata": {},
+   "source": [
+    "If you can restore the table you created and added before, you can just do this as below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1fd4b5b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "awadb_client = awadb.Client()\n",
+    "ret = awadb_client.Load('langchain_awadb')\n",
+    "if ret : print('awadb load table success')\n",
+    "else:\n",
+    "    print('awadb load table failed')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5ae9a9dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "awadb load table success"
+   ]
+  }
+ ],
+ "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.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/indexes/vectorstores/examples/azuresearch.ipynb

@@ -0,0 +1,245 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Azure Cognitive Search"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Install Azure Cognitive Search SDK"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install --index-url=https://pkgs.dev.azure.com/azure-sdk/public/_packaging/azure-sdk-for-python/pypi/simple/ azure-search-documents==11.4.0a20230509004\n",
+    "!pip install azure-identity"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import required libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os, json\n",
+    "import openai\n",
+    "from dotenv import load_dotenv\n",
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.schema import BaseRetriever\n",
+    "from langchain.vectorstores.azuresearch import AzureSearch"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Configure OpenAI settings\n",
+    "Configure the OpenAI settings to use Azure OpenAI or OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load environment variables from a .env file using load_dotenv():\n",
+    "load_dotenv()\n",
+    "\n",
+    "openai.api_type = \"azure\"\n",
+    "openai.api_base = \"YOUR_OPENAI_ENDPOINT\"\n",
+    "openai.api_version = \"2023-05-15\"\n",
+    "openai.api_key = \"YOUR_OPENAI_API_KEY\"\n",
+    "model: str = \"text-embedding-ada-002\""
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Configure vector store settings\n",
+    " \n",
+    "Set up the vector store settings using environment variables:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vector_store_address: str = 'YOUR_AZURE_SEARCH_ENDPOINT'\n",
+    "vector_store_password: str = 'YOUR_AZURE_SEARCH_ADMIN_KEY'\n",
+    "index_name: str = \"langchain-vector-demo\""
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create embeddings and vector store instances\n",
+    " \n",
+    "Create instances of the OpenAIEmbeddings and AzureSearch classes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embeddings: OpenAIEmbeddings = OpenAIEmbeddings(model=model, chunk_size=1)  \n",
+    "vector_store: AzureSearch = AzureSearch(azure_search_endpoint=vector_store_address,  \n",
+    "                                        azure_search_key=vector_store_password,  \n",
+    "                                        index_name=index_name,  \n",
+    "                                        embedding_function=embeddings.embed_query)  \n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Insert text and embeddings into vector store\n",
+    " \n",
+    "Add texts and metadata from the JSON data to the vector store:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TextLoader\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "loader = TextLoader('../../../state_of_the_union.txt', encoding='utf-8')\n",
+    "\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "vector_store.add_documents(documents=docs)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Perform a vector similarity search\n",
+    " \n",
+    "Execute a pure vector similarity search using the similarity_search() method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Perform a similarity search\n",
+    "docs = vector_store.similarity_search(query=\"What did the president say about Ketanji Brown Jackson\", k=3, search_type='similarity')\n",
+    "print(docs[0].page_content)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Perform a Hybrid Search\n",
+    "\n",
+    "Execute hybrid search using the hybrid_search() method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Perform a hybrid search \n",
+    "docs = vector_store.similarity_search(query=\"What did the president say about Ketanji Brown Jackson\", k=3)\n",
+    "print(docs[0].page_content)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.13 ('.venv': 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.3"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "645053d6307d413a1a75681b5ebb6449bb2babba4bcb0bf65a1ddc3dbefb108a"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/modules/indexes/vectorstores/examples/faiss.ipynb

@@ -40,20 +40,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "id": "47f9b495-88f1-4286-8d5d-1416103931a7",
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OpenAI API Key: ········\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import getpass\n",
@@ -66,7 +58,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "aac9563e",
    "metadata": {
     "tags": []
@@ -81,7 +73,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
    "id": "a3c3999a",
    "metadata": {
     "tags": []
@@ -99,7 +91,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 11,
    "id": "5eabdb75",
    "metadata": {
     "tags": []
@@ -114,7 +106,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 12,
    "id": "4b172de8",
    "metadata": {
     "tags": []
@@ -150,7 +142,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 13,
    "id": "186ee1d8",
    "metadata": {},
    "outputs": [],
@@ -160,18 +152,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 14,
    "id": "284e04b5",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(Document(page_content='In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections. \\n\\nWe cannot let this happen. \\n\\nTonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \\n\\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', lookup_str='', metadata={'source': '../../state_of_the_union.txt'}, lookup_index=0),\n",
-       " 0.3914415)"
+       "(Document(page_content='Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \\n\\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " 0.36913747)"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -191,7 +183,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 15,
    "id": "b558ebb7",
    "metadata": {},
    "outputs": [],
@@ -212,7 +204,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 16,
    "id": "428a6816",
    "metadata": {},
    "outputs": [],
@@ -222,7 +214,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 17,
    "id": "56d1841c",
    "metadata": {},
    "outputs": [],
@@ -232,7 +224,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 18,
    "id": "39055525",
    "metadata": {},
    "outputs": [],
@@ -242,17 +234,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 19,
    "id": "98378c4e",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Document(page_content='In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections. \\n\\nWe cannot let this happen. \\n\\nTonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \\n\\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', lookup_str='', metadata={'source': '../../state_of_the_union.txt'}, lookup_index=0)"
+       "Document(page_content='Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \\n\\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', metadata={'source': '../../../state_of_the_union.txt'})"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -273,7 +265,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 20,
    "id": "6dfd2b78",
    "metadata": {},
    "outputs": [],
@@ -284,17 +276,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 21,
    "id": "29960da7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'e0b74348-6c93-4893-8764-943139ec1d17': Document(page_content='foo', lookup_str='', metadata={}, lookup_index=0)}"
+       "{'068c473b-d420-487a-806b-fb0ccea7f711': Document(page_content='foo', metadata={})}"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -305,17 +297,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 22,
    "id": "83392605",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'bdc50ae3-a1bb-4678-9260-1b0979578f40': Document(page_content='bar', lookup_str='', metadata={}, lookup_index=0)}"
+       "{'807e0c63-13f6-4070-9774-5c6f0fbb9866': Document(page_content='bar', metadata={})}"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -326,7 +318,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 23,
    "id": "a3fcc1c7",
    "metadata": {},
    "outputs": [],
@@ -336,18 +328,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 24,
    "id": "41c51f89",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'e0b74348-6c93-4893-8764-943139ec1d17': Document(page_content='foo', lookup_str='', metadata={}, lookup_index=0),\n",
-       " 'd5211050-c777-493d-8825-4800e74cfdb6': Document(page_content='bar', lookup_str='', metadata={}, lookup_index=0)}"
+       "{'068c473b-d420-487a-806b-fb0ccea7f711': Document(page_content='foo', metadata={}),\n",
+       " '807e0c63-13f6-4070-9774-5c6f0fbb9866': Document(page_content='bar', metadata={})}"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -357,12 +349,139 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f80b60de",
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "f4294b96",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "source": [
+    "## Similarity Search with filtering\n",
+    "FAISS vectorstore can also support filtering, since the FAISS does not natively support filtering we have to do it manually. This is done by first fetching more results than `k` and then filtering them. You can filter the documents based on metadata. You can also set the `fetch_k` parameter when calling any search method to set how many documents you want to fetch before filtering. Here is a small example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "d5bf812c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Content: foo, Metadata: {'page': 1}, Score: 5.159960813797904e-15\n",
+      "Content: foo, Metadata: {'page': 2}, Score: 5.159960813797904e-15\n",
+      "Content: foo, Metadata: {'page': 3}, Score: 5.159960813797904e-15\n",
+      "Content: foo, Metadata: {'page': 4}, Score: 5.159960813797904e-15\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.schema import Document\n",
+    "list_of_documents = [\n",
+    "    Document(page_content=\"foo\", metadata=dict(page=1)),\n",
+    "    Document(page_content=\"bar\", metadata=dict(page=1)),\n",
+    "    Document(page_content=\"foo\", metadata=dict(page=2)),\n",
+    "    Document(page_content=\"barbar\", metadata=dict(page=2)),\n",
+    "    Document(page_content=\"foo\", metadata=dict(page=3)),\n",
+    "    Document(page_content=\"bar burr\", metadata=dict(page=3)),\n",
+    "    Document(page_content=\"foo\", metadata=dict(page=4)),\n",
+    "    Document(page_content=\"bar bruh\", metadata=dict(page=4))\n",
+    "]\n",
+    "db = FAISS.from_documents(list_of_documents, embeddings)\n",
+    "results_with_scores = db.similarity_search_with_score(\"foo\")\n",
+    "for doc, score in results_with_scores:\n",
+    "    print(f\"Content: {doc.page_content}, Metadata: {doc.metadata}, Score: {score}\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "3d33c126",
+   "metadata": {},
+   "source": [
+    "Now we make the same query call but we filter for only `page = 1` "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "83159330",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Content: foo, Metadata: {'page': 1}, Score: 5.159960813797904e-15\n",
+      "Content: bar, Metadata: {'page': 1}, Score: 0.3131446838378906\n"
+     ]
+    }
+   ],
+   "source": [
+    "results_with_scores = db.similarity_search_with_score(\"foo\", filter=dict(page=1))\n",
+    "for doc, score in results_with_scores:\n",
+    "    print(f\"Content: {doc.page_content}, Metadata: {doc.metadata}, Score: {score}\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "0be136e0",
+   "metadata": {},
+   "source": [
+    "Same thing can be done with the `max_marginal_relevance_search` as well."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "432c6980",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Content: foo, Metadata: {'page': 1}\n",
+      "Content: bar, Metadata: {'page': 1}\n"
+     ]
+    }
+   ],
+   "source": [
+    "results = db.max_marginal_relevance_search(\"foo\", filter=dict(page=1))\n",
+    "for doc in results:\n",
+    "    print(f\"Content: {doc.page_content}, Metadata: {doc.metadata}\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "1b4ecd86",
+   "metadata": {},
+   "source": [
+    "Here is an example of how to set `fetch_k` parameter when calling `similarity_search`. Usually you would want the `fetch_k` parameter >> `k` parameter. This is because the `fetch_k` parameter is the number of documents that will be fetched before filtering. If you set `fetch_k` to a low number, you might not get enough documents to filter from."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "1fd60fd1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Content: foo, Metadata: {'page': 1}, Score: 5.159960813797904e-15\n",
+      "Content: bar, Metadata: {'page': 1}, Score: 0.3131446838378906\n"
+     ]
+    }
+   ],
+   "source": [
+    "results = db.similarity_search(\"foo\", filter=dict(page=1), k=1, fetch_k=4)\n",
+    "for doc, score in results_with_scores:\n",
+    "    print(f\"Content: {doc.page_content}, Metadata: {doc.metadata}, Score: {score}\")"
+   ]
   }
  ],
  "metadata": {
@@ -381,7 +500,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,

docs/modules/indexes/vectorstores/examples/hologres.ipynb

@@ -0,0 +1,157 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Hologres\n",
+    "\n",
+    ">[Hologres](https://www.alibabacloud.com/help/en/hologres/latest/introduction) is a unified real-time data warehousing service developed by Alibaba Cloud. You can use Hologres to write, update, process, and analyze large amounts of data in real time. \n",
+    ">Hologres supports standard SQL syntax, is compatible with PostgreSQL, and supports most PostgreSQL functions. Hologres supports online analytical processing (OLAP) and ad hoc analysis for up to petabytes of data, and provides high-concurrency and low-latency online data services. \n",
+    "\n",
+    ">Hologres provides **vector database** functionality by adopting [Proxima](https://www.alibabacloud.com/help/en/hologres/latest/vector-processing).\n",
+    ">Proxima is a high-performance software library developed by Alibaba DAMO Academy. It allows you to search for the nearest neighbors of vectors. Proxima provides higher stability and performance than similar open source software such as Faiss. Proxima allows you to search for similar text or image embeddings with high throughput and low latency. Hologres is deeply integrated with Proxima to provide a high-performance vector search service.\n",
+    "\n",
+    "This notebook shows how to use functionality related to the `Hologres Proxima` vector database.\n",
+    "Click [here](https://www.alibabacloud.com/zh/product/hologres) to fast deploy a Hologres cloud instance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import Hologres"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Split documents and get embeddings by call OpenAI API"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders import TextLoader\n",
+    "\n",
+    "loader = TextLoader(\"../../../state_of_the_union.txt\")\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Connect to Hologres by setting related ENVIRONMENTS.\n",
+    "```\n",
+    "export PG_HOST={host}\n",
+    "export PG_PORT={port} # Optional, default is 80\n",
+    "export PG_DATABASE={db_name} # Optional, default is postgres\n",
+    "export PG_USER={username}\n",
+    "export PG_PASSWORD={password}\n",
+    "```\n",
+    "\n",
+    "Then store your embeddings and documents into Hologres"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "connection_string = Hologres.connection_string_from_db_params(\n",
+    "    host=os.environ.get(\"PGHOST\", \"localhost\"),\n",
+    "    port=int(os.environ.get(\"PGPORT\", \"80\")),\n",
+    "    database=os.environ.get(\"PGDATABASE\", \"postgres\"),\n",
+    "    user=os.environ.get(\"PGUSER\", \"postgres\"),\n",
+    "    password=os.environ.get(\"PGPASSWORD\", \"postgres\"),\n",
+    ")\n",
+    "\n",
+    "vector_db = Hologres.from_documents(\n",
+    "    docs,\n",
+    "    embeddings,\n",
+    "    connection_string=connection_string,\n",
+    "    table_name=\"langchain_example_embeddings\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Query and retrieve data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs = vector_db.similarity_search(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(docs[0].page_content)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/modules/indexes/vectorstores/examples/mongodb_atlas_vector_search.ipynb

@@ -1,6 +1,7 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "683953b3",
    "metadata": {},
@@ -8,14 +9,14 @@
     "#### Commented out until further notice\n",
     "MongoDB Atlas Vector Search\n",
     "\n",
-    ">[MongoDB Atlas](https://www.mongodb.com/docs/atlas/) is a document database managed in the cloud. It also enables Lucene and its vector search feature.\n",
+    ">[MongoDB Atlas](https://www.mongodb.com/docs/atlas/) is a fully-managed cloud database offered in the cloud service provider of your choice (AWS , Azure, and GCP).  It now has support for native Vector Search ontop of your MongoDB document data.\n",
     "\n",
-    "This notebook shows how to use the functionality related to the `MongoDB Atlas Vector Search` feature where you can store your embeddings in MongoDB documents and create a Lucene vector index to perform a KNN search.\n",
+    "This notebook shows how to use `MongoDB Atlas Vector Search` to store your embeddings in MongoDB documents, create a vector search index, and perform KNN search with and approximate nearest neighbor algorithm.\n",
     "\n",
-    "It uses the [knnBeta Operator](https://www.mongodb.com/docs/atlas/atlas-search/knn-beta) available in MongoDB Atlas Search. This feature is in early access and available only for evaluation purposes, to validate functionality, and to gather feedback from a small closed group of early access users. It is not recommended for production deployments as we may introduce breaking changes.\n",
+    "It uses the [knnBeta Operator](https://www.mongodb.com/docs/atlas/atlas-search/knn-beta) available in MongoDB Atlas Search. This feature is in Public Preview and available only for evaluation purposes, to validate functionality, and to gather feedback from public preview users. It is not recommended for production deployments as we may introduce breaking changes.\n",
     "\n",
-    "To use MongoDB Atlas, you must have first deployed a cluster. Free clusters are available. \n",
-    "Here is the MongoDB Atlas [quick start](https://www.mongodb.com/docs/atlas/getting-started/)."
+    "To use MongoDB Atlas, you must have first deployed a cluster. We have a Forever Free tier of clusters available. \n",
+    "To get started head over to Atlas here: [quick start](https://www.mongodb.com/docs/atlas/getting-started/)."
    ]
   },
   {
@@ -38,24 +39,39 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "import getpass\n",
     "\n",
-    "MONGODB_ATLAS_URI = os.environ['MONGODB_ATLAS_URI']"
+    "MONGODB_ATLAS_CLUSTER_URI = getpass.getpass('MongoDB Atlas Cluster URI:')\n",
+    "MONGODB_ATLAS_CLUSTER_URI = os.environ['MONGODB_ATLAS_CLUSTER_URI']"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "457ace44-1d95-4001-9dd5-78811ab208ad",
    "metadata": {},
    "source": [
-    "We want to use `OpenAIEmbeddings` so we have to get the OpenAI API Key. Make sure the environment variable `OPENAI_API_KEY` is set up before proceeding."
+    "We want to use `OpenAIEmbeddings` so we have setup the OpenAI API Key. "
    ]
   },
   {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d8f240d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:')\n",
+    "OPENAI_API_KEY = os.environ['OPENAI_API_KEY']"
+   ]
+  },
+  {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "1f3ecc42",
    "metadata": {},
    "source": [
-    "Now, let's create a Lucene vector index on your cluster. In the below example, `embedding` is the name of the field that contains the embedding vector. Please refer to the [documentation](https://www.mongodb.com/docs/atlas/atlas-search/define-field-mappings-for-vector-search) to get more details on how to define an Atlas Search index.\n",
+    "Now, let's create a vector index on your cluster. In the below example, `embedding` is the name of the field that contains the embedding vector. Please refer to the [documentation](https://www.mongodb.com/docs/atlas/atlas-search/define-field-mappings-for-vector-search) to get more details on how to define an Atlas Vector Search index.\n",
     "You can name the index `langchain_demo` and create the index on the namespace `lanchain_db.langchain_col`. Finally, write the following definition in the JSON editor:\n",
     "\n",
     "```json\n",
@@ -115,7 +131,7 @@
     "from pymongo import MongoClient\n",
     "\n",
     "# initialize MongoDB python client\n",
-    "client = MongoClient(MONGODB_ATLAS_CONNECTION_STRING)\n",
+    "client = MongoClient(MONGODB_ATLAS_CLUSTER_URI)\n",
     "\n",
     "db_name = \"lanchain_db\"\n",
     "collection_name = \"langchain_col\"\n",
@@ -146,11 +162,12 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "id": "851a2ec9-9390-49a4-8412-3e132c9f789d",
    "metadata": {},
    "source": [
-    "You can reuse vector index you created before, make sure environment variable `OPENAI_API_KEY` is set up, then create another file."
+    "You can reuse the vector index you created before, make sure environment variable `OPENAI_API_KEY` is set up, then create another file."
    ]
   },
   {

docs/modules/indexes/vectorstores/examples/vectara.ipynb

@@ -101,7 +101,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "8429667e",
    "metadata": {
     "ExecuteTime": {
@@ -133,7 +133,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "a8c513ab",
    "metadata": {
     "ExecuteTime": {
@@ -145,12 +145,12 @@
    "outputs": [],
    "source": [
     "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "found_docs = vectara.similarity_search(query)"
+    "found_docs = vectara.similarity_search(query, n_sentence_context=0)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "fc516993",
    "metadata": {
     "ExecuteTime": {
@@ -164,7 +164,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice. A former federal public defender.\n"
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
+      "\n",
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n"
      ]
     }
    ],
@@ -185,7 +191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "id": "8804a21d",
    "metadata": {
     "ExecuteTime": {
@@ -201,7 +207,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "756a6887",
    "metadata": {
     "ExecuteTime": {
@@ -214,9 +220,15 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice. A former federal public defender.\n",
+      "Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n",
       "\n",
-      "Score: 1.0046461\n"
+      "Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n",
+      "\n",
+      "One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n",
+      "\n",
+      "And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.\n",
+      "\n",
+      "Score: 0.7129974\n"
      ]
     }
    ],
@@ -239,7 +251,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 9,
    "id": "9427195f",
    "metadata": {
     "ExecuteTime": {
@@ -251,10 +263,10 @@
     {
      "data": {
       "text/plain": [
-       "VectorStoreRetriever(vectorstore=<langchain.vectorstores.vectara.Vectara object at 0x156d3e830>, search_type='similarity', search_kwargs={})"
+       "VectaraRetriever(vectorstore=<langchain.vectorstores.vectara.Vectara object at 0x122db2830>, search_type='similarity', search_kwargs={'lambda_val': 0.025, 'k': 5, 'filter': '', 'n_sentence_context': '0'})"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -266,7 +278,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 10,
    "id": "f3c70c31",
    "metadata": {
     "ExecuteTime": {
@@ -278,10 +290,10 @@
     {
      "data": {
       "text/plain": [
-       "Document(page_content='Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence. A former top litigator in private practice. A former federal public defender.', metadata={'source': '../../modules/state_of_the_union.txt'})"
+       "Document(page_content='Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \\n\\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \\n\\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', metadata={'source': '../../../state_of_the_union.txt'})"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -316,7 +328,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

docs/modules/indexes/vectorstores/examples/weaviate.ipynb

@@ -209,7 +209,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "8fc3487b",
    "metadata": {},
@@ -218,7 +217,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "281c0fcc",
    "metadata": {},
@@ -236,7 +234,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "503e2e75",
    "metadata": {},
@@ -273,7 +270,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "fbd7a6cb",
    "metadata": {},
@@ -282,7 +278,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "f349acb9",
    "metadata": {},
@@ -384,7 +379,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

docs/modules/models/text_embedding/examples/dashscope.ipynb

@@ -0,0 +1,83 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DashScope\n",
+    "\n",
+    "Let's load the DashScope Embedding class."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import DashScopeEmbeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embeddings = DashScopeEmbeddings(model='text-embedding-v1', dashscope_api_key='your-dashscope-api-key')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "text = \"This is a test document.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query_result = embeddings.embed_query(text)\n",
+    "print(query_result)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "doc_results = embeddings.embed_documents([\"foo\"])\n",
+    "print(doc_results)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "chatgpt",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/modules/models/text_embedding/examples/embaas.ipynb

@@ -0,0 +1,159 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [
+    "[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",
+    "In this tutorial, we will show you how to use the embaas Embeddings API to generate embeddings for a given text.\n",
+    "\n",
+    "### Prerequisites\n",
+    "Create your free embaas account at [https://embaas.io/register](https://embaas.io/register) and generate an [API key](https://embaas.io/dashboard/api-keys)."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "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\""
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import EmbaasEmbeddings"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "embeddings = EmbaasEmbeddings()"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# Create embeddings for a single document\n",
+    "doc_text = \"This is a test document.\"\n",
+    "doc_text_embedding = embeddings.embed_query(doc_text)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "start_time": "2023-06-10T11:17:55.938517Z",
+     "end_time": "2023-06-10T11:17:55.940265Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# Print created embedding\n",
+    "print(doc_text_embedding)"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "outputs": [],
+   "source": [
+    "# Create embeddings for multiple documents\n",
+    "doc_texts = [\"This is a test document.\", \"This is another test document.\"]\n",
+    "doc_texts_embeddings = embeddings.embed_documents(doc_texts)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "start_time": "2023-06-10T11:19:25.235320Z",
+     "end_time": "2023-06-10T11:19:25.237161Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "# Print created embeddings\n",
+    "for i, doc_text_embedding in enumerate(doc_texts_embeddings):\n",
+    "    print(f\"Embedding for document {i + 1}: {doc_text_embedding}\")"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "outputs": [],
+   "source": [
+    "# Using a different model and/or custom instruction\n",
+    "embeddings = EmbaasEmbeddings(model=\"instructor-large\", instruction=\"Represent the Wikipedia document for retrieval\")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "start_time": "2023-06-10T11:22:26.138357Z",
+     "end_time": "2023-06-10T11:22:26.139769Z"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "For more detailed information about the embaas Embeddings API, please refer to [the official embaas API documentation](https://embaas.io/api-reference)."
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "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
+}

langchain/agents/agent.py

@@ -864,7 +864,11 @@ class AgentExecutor(Chain):
                 raise e
             text = str(e)
             if isinstance(self.handle_parsing_errors, bool):
-                observation = "Invalid or incomplete response"
+                if e.send_to_llm:
+                    observation = str(e.observation)
+                    text = str(e.llm_output)
+                else:
+                    observation = "Invalid or incomplete response"
             elif isinstance(self.handle_parsing_errors, str):
                 observation = self.handle_parsing_errors
             elif callable(self.handle_parsing_errors):

langchain/base_language.py

@@ -2,11 +2,10 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import List, Optional, Sequence, Set
-
-from pydantic import BaseModel
+from typing import Any, List, Optional, Sequence, Set
 
 from langchain.callbacks.manager import Callbacks
+from langchain.load.serializable import Serializable
 from langchain.schema import BaseMessage, LLMResult, PromptValue, get_buffer_string
 
 
@@ -29,13 +28,14 @@ def _get_token_ids_default_method(text: str) -> List[int]:
     return tokenizer.encode(text)
 
 
-class BaseLanguageModel(BaseModel, ABC):
+class BaseLanguageModel(Serializable, ABC):
     @abstractmethod
     def generate_prompt(
         self,
         prompts: List[PromptValue],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Take in a list of prompt values and return an LLMResult."""
 
@@ -45,26 +45,39 @@ class BaseLanguageModel(BaseModel, ABC):
         prompts: List[PromptValue],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Take in a list of prompt values and return an LLMResult."""
 
     @abstractmethod
-    def predict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
+    def predict(
+        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
+    ) -> str:
         """Predict text from text."""
 
     @abstractmethod
     def predict_messages(
-        self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
+        self,
+        messages: List[BaseMessage],
+        *,
+        stop: Optional[Sequence[str]] = None,
+        **kwargs: Any,
     ) -> BaseMessage:
         """Predict message from messages."""
 
     @abstractmethod
-    async def apredict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
+    async def apredict(
+        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
+    ) -> str:
         """Predict text from text."""
 
     @abstractmethod
     async def apredict_messages(
-        self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
+        self,
+        messages: List[BaseMessage],
+        *,
+        stop: Optional[Sequence[str]] = None,
+        **kwargs: Any,
     ) -> BaseMessage:
         """Predict message from messages."""
 

langchain/callbacks/manager.py

@@ -204,7 +204,7 @@ def _handle_event(
         except Exception as e:
             if handler.raise_error:
                 raise e
-            logging.warning(f"Error in {event_name} callback: {e}")
+            logger.warning(f"Error in {event_name} callback: {e}")
 
 
 async def _ahandle_event_for_handler(
@@ -238,6 +238,8 @@ async def _ahandle_event_for_handler(
         else:
             logger.warning(f"Error in {event_name} callback: {e}")
     except Exception as e:
+        if handler.raise_error:
+            raise e
         logger.warning(f"Error in {event_name} callback: {e}")
 
 

langchain/callbacks/tracers/base.py

@@ -93,7 +93,6 @@ class BaseTracer(BaseCallbackHandler, ABC):
         execution_order = self._get_execution_order(parent_run_id_)
         llm_run = Run(
             id=run_id,
-            name=serialized.get("name"),
             parent_run_id=parent_run_id,
             serialized=serialized,
             inputs={"prompts": prompts},
@@ -154,7 +153,6 @@ class BaseTracer(BaseCallbackHandler, ABC):
         execution_order = self._get_execution_order(parent_run_id_)
         chain_run = Run(
             id=run_id,
-            name=serialized.get("name"),
             parent_run_id=parent_run_id,
             serialized=serialized,
             inputs=inputs,
@@ -216,7 +214,6 @@ class BaseTracer(BaseCallbackHandler, ABC):
         execution_order = self._get_execution_order(parent_run_id_)
         tool_run = Run(
             id=run_id,
-            name=serialized.get("name"),
             parent_run_id=parent_run_id,
             serialized=serialized,
             inputs={"input": input_str},

langchain/callbacks/tracers/langchain.py

@@ -53,7 +53,6 @@ class LangChainTracer(BaseTracer):
         execution_order = self._get_execution_order(parent_run_id_)
         chat_model_run = Run(
             id=run_id,
-            name=serialized.get("name"),
             parent_run_id=parent_run_id,
             serialized=serialized,
             inputs={"messages": [messages_to_dict(batch) for batch in messages]},

langchain/callbacks/tracers/schemas.py

@@ -123,8 +123,11 @@ class Run(RunBase):
     @root_validator(pre=True)
     def assign_name(cls, values: dict) -> dict:
         """Assign name to the run."""
-        if "name" not in values:
-            values["name"] = values["serialized"]["name"]
+        if values.get("name") is None:
+            if "name" in values["serialized"]:
+                values["name"] = values["serialized"]["name"]
+            elif "id" in values["serialized"]:
+                values["name"] = values["serialized"]["id"][-1]
         return values
 
 

langchain/chains/api/base.py

@@ -78,6 +78,7 @@ class APIChain(Chain):
             callbacks=_run_manager.get_child(),
         )
         _run_manager.on_text(api_url, color="green", end="\n", verbose=self.verbose)
+        api_url = api_url.strip()
         api_response = self.requests_wrapper.get(api_url)
         _run_manager.on_text(
             api_response, color="yellow", end="\n", verbose=self.verbose
@@ -106,6 +107,7 @@ class APIChain(Chain):
         await _run_manager.on_text(
             api_url, color="green", end="\n", verbose=self.verbose
         )
+        api_url = api_url.strip()
         api_response = await self.requests_wrapper.aget(api_url)
         await _run_manager.on_text(
             api_response, color="yellow", end="\n", verbose=self.verbose

langchain/chains/base.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
 import yaml
-from pydantic import BaseModel, Field, root_validator, validator
+from pydantic import Field, root_validator, validator
 
 import langchain
 from langchain.callbacks.base import BaseCallbackManager
@@ -18,6 +18,8 @@ from langchain.callbacks.manager import (
     CallbackManagerForChainRun,
     Callbacks,
 )
+from langchain.load.dump import dumpd
+from langchain.load.serializable import Serializable
 from langchain.schema import RUN_KEY, BaseMemory, RunInfo
 
 
@@ -25,7 +27,7 @@ def _get_verbosity() -> bool:
     return langchain.verbose
 
 
-class Chain(BaseModel, ABC):
+class Chain(Serializable, ABC):
     """Base interface that all chains should implement."""
 
     memory: Optional[BaseMemory] = None
@@ -131,7 +133,7 @@ class Chain(BaseModel, ABC):
         )
         new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
         run_manager = callback_manager.on_chain_start(
-            {"name": self.__class__.__name__},
+            dumpd(self),
             inputs,
         )
         try:
@@ -179,7 +181,7 @@ class Chain(BaseModel, ABC):
         )
         new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
         run_manager = await callback_manager.on_chain_start(
-            {"name": self.__class__.__name__},
+            dumpd(self),
             inputs,
         )
         try:

langchain/chains/graph_qa/cypher.py

@@ -14,6 +14,8 @@ from langchain.chains.llm import LLMChain
 from langchain.graphs.neo4j_graph import Neo4jGraph
 from langchain.prompts.base import BasePromptTemplate
 
+INTERMEDIATE_STEPS_KEY = "intermediate_steps"
+
 
 def extract_cypher(text: str) -> str:
     # The pattern to find Cypher code enclosed in triple backticks
@@ -33,6 +35,12 @@ class GraphCypherQAChain(Chain):
     qa_chain: LLMChain
     input_key: str = "query"  #: :meta private:
     output_key: str = "result"  #: :meta private:
+    top_k: int = 10
+    """Number of results to return from the query"""
+    return_intermediate_steps: bool = False
+    """Whether or not to return the intermediate steps along with the final answer."""
+    return_direct: bool = False
+    """Whether or not to return the result of querying the graph directly."""
 
     @property
     def input_keys(self) -> List[str]:
@@ -74,12 +82,14 @@ class GraphCypherQAChain(Chain):
         self,
         inputs: Dict[str, Any],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> Dict[str, Any]:
         """Generate Cypher statement, use it to look up in db and answer question."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         callbacks = _run_manager.get_child()
         question = inputs[self.input_key]
 
+        intermediate_steps: List = []
+
         generated_cypher = self.cypher_generation_chain.run(
             {"question": question, "schema": self.graph.get_schema}, callbacks=callbacks
         )
@@ -91,14 +101,30 @@ class GraphCypherQAChain(Chain):
         _run_manager.on_text(
             generated_cypher, color="green", end="\n", verbose=self.verbose
         )
-        context = self.graph.query(generated_cypher)
 
-        _run_manager.on_text("Full Context:", end="\n", verbose=self.verbose)
-        _run_manager.on_text(
-            str(context), color="green", end="\n", verbose=self.verbose
-        )
-        result = self.qa_chain(
-            {"question": question, "context": context},
-            callbacks=callbacks,
-        )
-        return {self.output_key: result[self.qa_chain.output_key]}
+        intermediate_steps.append({"query": generated_cypher})
+
+        # Retrieve and limit the number of results
+        context = self.graph.query(generated_cypher)[: self.top_k]
+
+        if self.return_direct:
+            final_result = context
+        else:
+            _run_manager.on_text("Full Context:", end="\n", verbose=self.verbose)
+            _run_manager.on_text(
+                str(context), color="green", end="\n", verbose=self.verbose
+            )
+
+            intermediate_steps.append({"context": context})
+
+            result = self.qa_chain(
+                {"question": question, "context": context},
+                callbacks=callbacks,
+            )
+            final_result = result[self.qa_chain.output_key]
+
+        chain_result: Dict[str, Any] = {self.output_key: final_result}
+        if self.return_intermediate_steps:
+            chain_result[INTERMEDIATE_STEPS_KEY] = intermediate_steps
+
+        return chain_result

langchain/chains/llm.py

@@ -15,6 +15,7 @@ from langchain.callbacks.manager import (
 )
 from langchain.chains.base import Chain
 from langchain.input import get_colored_text
+from langchain.load.dump import dumpd
 from langchain.prompts.base import BasePromptTemplate
 from langchain.prompts.prompt import PromptTemplate
 from langchain.schema import LLMResult, PromptValue
@@ -34,6 +35,10 @@ class LLMChain(Chain):
             llm = LLMChain(llm=OpenAI(), prompt=prompt)
     """
 
+    @property
+    def lc_serializable(self) -> bool:
+        return True
+
     prompt: BasePromptTemplate
     """Prompt object to use."""
     llm: BaseLanguageModel
@@ -147,7 +152,7 @@ class LLMChain(Chain):
             callbacks, self.callbacks, self.verbose
         )
         run_manager = callback_manager.on_chain_start(
-            {"name": self.__class__.__name__},
+            dumpd(self),
             {"input_list": input_list},
         )
         try:
@@ -167,7 +172,7 @@ class LLMChain(Chain):
             callbacks, self.callbacks, self.verbose
         )
         run_manager = await callback_manager.on_chain_start(
-            {"name": self.__class__.__name__},
+            dumpd(self),
             {"input_list": input_list},
         )
         try:

langchain/chat_models/anthropic.py

@@ -94,9 +94,10 @@ class ChatAnthropic(BaseChatModel, _AnthropicCommon):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         prompt = self._convert_messages_to_prompt(messages)
-        params: Dict[str, Any] = {"prompt": prompt, **self._default_params}
+        params: Dict[str, Any] = {"prompt": prompt, **self._default_params, **kwargs}
         if stop:
             params["stop_sequences"] = stop
 
@@ -121,9 +122,10 @@ class ChatAnthropic(BaseChatModel, _AnthropicCommon):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         prompt = self._convert_messages_to_prompt(messages)
-        params: Dict[str, Any] = {"prompt": prompt, **self._default_params}
+        params: Dict[str, Any] = {"prompt": prompt, **self._default_params, **kwargs}
         if stop:
             params["stop_sequences"] = stop
 

langchain/chat_models/base.py

@@ -17,6 +17,7 @@ from langchain.callbacks.manager import (
     CallbackManagerForLLMRun,
     Callbacks,
 )
+from langchain.load.dump import dumpd
 from langchain.schema import (
     AIMessage,
     BaseMessage,
@@ -64,17 +65,19 @@ class BaseChatModel(BaseLanguageModel, ABC):
         messages: List[List[BaseMessage]],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Top Level call"""
 
         params = self.dict()
         params["stop"] = stop
+        options = {"stop": stop}
 
         callback_manager = CallbackManager.configure(
             callbacks, self.callbacks, self.verbose
         )
         run_manager = callback_manager.on_chat_model_start(
-            {"name": self.__class__.__name__}, messages, invocation_params=params
+            dumpd(self), messages, invocation_params=params, options=options
         )
 
         new_arg_supported = inspect.signature(self._generate).parameters.get(
@@ -82,7 +85,7 @@ class BaseChatModel(BaseLanguageModel, ABC):
         )
         try:
             results = [
-                self._generate(m, stop=stop, run_manager=run_manager)
+                self._generate(m, stop=stop, run_manager=run_manager, **kwargs)
                 if new_arg_supported
                 else self._generate(m, stop=stop)
                 for m in messages
@@ -103,16 +106,18 @@ class BaseChatModel(BaseLanguageModel, ABC):
         messages: List[List[BaseMessage]],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Top Level call"""
         params = self.dict()
         params["stop"] = stop
+        options = {"stop": stop}
 
         callback_manager = AsyncCallbackManager.configure(
             callbacks, self.callbacks, self.verbose
         )
         run_manager = await callback_manager.on_chat_model_start(
-            {"name": self.__class__.__name__}, messages, invocation_params=params
+            dumpd(self), messages, invocation_params=params, options=options
         )
 
         new_arg_supported = inspect.signature(self._agenerate).parameters.get(
@@ -121,7 +126,7 @@ class BaseChatModel(BaseLanguageModel, ABC):
         try:
             results = await asyncio.gather(
                 *[
-                    self._agenerate(m, stop=stop, run_manager=run_manager)
+                    self._agenerate(m, stop=stop, run_manager=run_manager, **kwargs)
                     if new_arg_supported
                     else self._agenerate(m, stop=stop)
                     for m in messages
@@ -143,18 +148,22 @@ class BaseChatModel(BaseLanguageModel, ABC):
         prompts: List[PromptValue],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         prompt_messages = [p.to_messages() for p in prompts]
-        return self.generate(prompt_messages, stop=stop, callbacks=callbacks)
+        return self.generate(prompt_messages, stop=stop, callbacks=callbacks, **kwargs)
 
     async def agenerate_prompt(
         self,
         prompts: List[PromptValue],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         prompt_messages = [p.to_messages() for p in prompts]
-        return await self.agenerate(prompt_messages, stop=stop, callbacks=callbacks)
+        return await self.agenerate(
+            prompt_messages, stop=stop, callbacks=callbacks, **kwargs
+        )
 
     @abstractmethod
     def _generate(
@@ -162,6 +171,7 @@ class BaseChatModel(BaseLanguageModel, ABC):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         """Top Level call"""
 
@@ -171,6 +181,7 @@ class BaseChatModel(BaseLanguageModel, ABC):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         """Top Level call"""
 
@@ -193,18 +204,25 @@ class BaseChatModel(BaseLanguageModel, ABC):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> BaseMessage:
-        result = await self.agenerate([messages], stop=stop, callbacks=callbacks)
+        result = await self.agenerate(
+            [messages], stop=stop, callbacks=callbacks, **kwargs
+        )
         generation = result.generations[0][0]
         if isinstance(generation, ChatGeneration):
             return generation.message
         else:
             raise ValueError("Unexpected generation type")
 
-    def call_as_llm(self, message: str, stop: Optional[List[str]] = None) -> str:
-        return self.predict(message, stop=stop)
+    def call_as_llm(
+        self, message: str, stop: Optional[List[str]] = None, **kwargs: Any
+    ) -> str:
+        return self.predict(message, stop=stop, **kwargs)
 
-    def predict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
+    def predict(
+        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
+    ) -> str:
         if stop is None:
             _stop = None
         else:
@@ -213,30 +231,42 @@ class BaseChatModel(BaseLanguageModel, ABC):
         return result.content
 
     def predict_messages(
-        self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
+        self,
+        messages: List[BaseMessage],
+        *,
+        stop: Optional[Sequence[str]] = None,
+        **kwargs: Any,
     ) -> BaseMessage:
         if stop is None:
             _stop = None
         else:
             _stop = list(stop)
-        return self(messages, stop=_stop)
+        return self(messages, stop=_stop, **kwargs)
 
-    async def apredict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
+    async def apredict(
+        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
+    ) -> str:
         if stop is None:
             _stop = None
         else:
             _stop = list(stop)
-        result = await self._call_async([HumanMessage(content=text)], stop=_stop)
+        result = await self._call_async(
+            [HumanMessage(content=text)], stop=_stop, **kwargs
+        )
         return result.content
 
     async def apredict_messages(
-        self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
+        self,
+        messages: List[BaseMessage],
+        *,
+        stop: Optional[Sequence[str]] = None,
+        **kwargs: Any,
     ) -> BaseMessage:
         if stop is None:
             _stop = None
         else:
             _stop = list(stop)
-        return await self._call_async(messages, stop=_stop)
+        return await self._call_async(messages, stop=_stop, **kwargs)
 
     @property
     def _identifying_params(self) -> Mapping[str, Any]:
@@ -261,8 +291,9 @@ class SimpleChatModel(BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
-        output_str = self._call(messages, stop=stop, run_manager=run_manager)
+        output_str = self._call(messages, stop=stop, run_manager=run_manager, **kwargs)
         message = AIMessage(content=output_str)
         generation = ChatGeneration(message=message)
         return ChatResult(generations=[generation])
@@ -273,6 +304,7 @@ class SimpleChatModel(BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Simpler interface."""
 
@@ -281,6 +313,9 @@ class SimpleChatModel(BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
-        func = partial(self._generate, messages, stop=stop, run_manager=run_manager)
+        func = partial(
+            self._generate, messages, stop=stop, run_manager=run_manager, **kwargs
+        )
         return await asyncio.get_event_loop().run_in_executor(None, func)

langchain/chat_models/google_palm.py

@@ -280,6 +280,7 @@ class ChatGooglePalm(BaseChatModel, BaseModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         prompt = _messages_to_prompt_dict(messages)
 
@@ -291,6 +292,7 @@ class ChatGooglePalm(BaseChatModel, BaseModel):
             top_p=self.top_p,
             top_k=self.top_k,
             candidate_count=self.n,
+            **kwargs,
         )
 
         return _response_to_result(response, stop)
@@ -300,6 +302,7 @@ class ChatGooglePalm(BaseChatModel, BaseModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         prompt = _messages_to_prompt_dict(messages)
 

langchain/chat_models/openai.py

@@ -136,6 +136,10 @@ class ChatOpenAI(BaseChatModel):
             openai = ChatOpenAI(model_name="gpt-3.5-turbo")
     """
 
+    @property
+    def lc_serializable(self) -> bool:
+        return True
+
     client: Any  #: :meta private:
     model_name: str = Field(default="gpt-3.5-turbo", alias="model")
     """Model name to use."""
@@ -302,8 +306,10 @@ class ChatOpenAI(BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         message_dicts, params = self._create_message_dicts(messages, stop)
+        params = {**params, **kwargs}
         if self.streaming:
             inner_completion = ""
             role = "assistant"
@@ -348,8 +354,10 @@ class ChatOpenAI(BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         message_dicts, params = self._create_message_dicts(messages, stop)
+        params = {**params, **kwargs}
         if self.streaming:
             inner_completion = ""
             role = "assistant"

langchain/chat_models/promptlayer_openai.py

@@ -42,6 +42,7 @@ class PromptLayerChatOpenAI(ChatOpenAI):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any
     ) -> ChatResult:
         """Call ChatOpenAI generate and then call PromptLayer API to log the request."""
         from promptlayer.utils import get_api_key, promptlayer_api_request
@@ -54,6 +55,7 @@ class PromptLayerChatOpenAI(ChatOpenAI):
             response_dict, params = super()._create_message_dicts(
                 [generation.message], stop
             )
+            params = {**params, **kwargs}
             pl_request_id = promptlayer_api_request(
                 "langchain.PromptLayerChatOpenAI",
                 "langchain",
@@ -79,6 +81,7 @@ class PromptLayerChatOpenAI(ChatOpenAI):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any
     ) -> ChatResult:
         """Call ChatOpenAI agenerate and then call PromptLayer to log."""
         from promptlayer.utils import get_api_key, promptlayer_api_request_async
@@ -91,6 +94,7 @@ class PromptLayerChatOpenAI(ChatOpenAI):
             response_dict, params = super()._create_message_dicts(
                 [generation.message], stop
             )
+            params = {**params, **kwargs}
             pl_request_id = await promptlayer_api_request_async(
                 "langchain.PromptLayerChatOpenAI.async",
                 "langchain",

langchain/chat_models/vertexai.py

@@ -1,6 +1,6 @@
 """Wrapper around Google VertexAI chat-based models."""
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import root_validator
 
@@ -93,6 +93,7 @@ class ChatVertexAI(_VertexAICommon, BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         """Generate next turn in the conversation.
 
@@ -119,7 +120,8 @@ class ChatVertexAI(_VertexAICommon, BaseChatModel):
 
         history = _parse_chat_history(messages[:-1])
         context = history.system_message.content if history.system_message else None
-        chat = self.client.start_chat(context=context, **self._default_params)
+        params = {**self._default_params, **kwargs}
+        chat = self.client.start_chat(context=context, **params)
         for pair in history.history:
             chat._history.append((pair.question.content, pair.answer.content))
         response = chat.send_message(question.content, **self._default_params)
@@ -131,6 +133,7 @@ class ChatVertexAI(_VertexAICommon, BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> ChatResult:
         raise NotImplementedError(
             """Vertex AI doesn't support async requests at the moment."""

langchain/document_loaders/__init__.py

@@ -1,6 +1,7 @@
 """All different types of document loaders."""
 
 from langchain.document_loaders.airbyte_json import AirbyteJSONLoader
+from langchain.document_loaders.airtable import AirtableLoader
 from langchain.document_loaders.apify_dataset import ApifyDatasetLoader
 from langchain.document_loaders.arxiv import ArxivLoader
 from langchain.document_loaders.azlyrics import AZLyricsLoader
@@ -120,6 +121,7 @@ from langchain.document_loaders.word_document import (
     Docx2txtLoader,
     UnstructuredWordDocumentLoader,
 )
+from langchain.document_loaders.xml import UnstructuredXMLLoader
 from langchain.document_loaders.youtube import (
     GoogleApiClient,
     GoogleApiYoutubeLoader,
@@ -135,6 +137,7 @@ TelegramChatLoader = TelegramChatFileLoader
 __all__ = [
     "AZLyricsLoader",
     "AirbyteJSONLoader",
+    "AirtableLoader",
     "ApifyDatasetLoader",
     "ArxivLoader",
     "AzureBlobStorageContainerLoader",
@@ -240,6 +243,7 @@ __all__ = [
     "UnstructuredRTFLoader",
     "UnstructuredURLLoader",
     "UnstructuredWordDocumentLoader",
+    "UnstructuredXMLLoader",
     "WeatherDataLoader",
     "WebBaseLoader",
     "WhatsAppChatLoader",

langchain/document_loaders/airtable.py

@@ -0,0 +1,36 @@
+from typing import Iterator, List
+
+from langchain.docstore.document import Document
+from langchain.document_loaders.base import BaseLoader
+
+
+class AirtableLoader(BaseLoader):
+    """Loader that loads local airbyte json files."""
+
+    def __init__(self, api_token: str, table_id: str, base_id: str):
+        """Initialize with API token and the IDs for table and base"""
+        self.api_token = api_token
+        self.table_id = table_id
+        self.base_id = base_id
+
+    def lazy_load(self) -> Iterator[Document]:
+        """Load Table."""
+
+        from pyairtable import Table
+
+        table = Table(self.api_token, self.base_id, self.table_id)
+        records = table.all()
+        for record in records:
+            # Need to convert record from dict to str
+            yield Document(
+                page_content=str(record),
+                metadata={
+                    "source": self.base_id + "_" + self.table_id,
+                    "base_id": self.base_id,
+                    "table_id": self.table_id,
+                },
+            )
+
+    def load(self) -> List[Document]:
+        """Load Table."""
+        return list(self.lazy_load())

langchain/document_loaders/confluence.py

@@ -1,7 +1,7 @@
 """Load Data from a Confluence Space"""
 import logging
 from io import BytesIO
-from typing import Any, Callable, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 from tenacity import (
     before_sleep_log,
@@ -180,6 +180,7 @@ class ConfluenceLoader(BaseLoader):
         include_comments: bool = False,
         limit: Optional[int] = 50,
         max_pages: Optional[int] = 1000,
+        ocr_languages: Optional[str] = None,
     ) -> List[Document]:
         """
         :param space_key: Space key retrieved from a confluence URL, defaults to None
@@ -203,6 +204,10 @@ class ConfluenceLoader(BaseLoader):
         :type limit: int, optional
         :param max_pages: Maximum number of pages to retrieve in total, defaults 1000
         :type max_pages: int, optional
+        :param ocr_languages: The languages to use for the Tesseract agent. To use a
+                              language, you'll first need to install the appropriate
+                              Tesseract language pack.
+        :type ocr_languages: str, optional
         :raises ValueError: _description_
         :raises ImportError: _description_
         :return: _description_
@@ -226,7 +231,11 @@ class ConfluenceLoader(BaseLoader):
                 expand="body.storage.value",
             )
             docs += self.process_pages(
-                pages, include_restricted_content, include_attachments, include_comments
+                pages,
+                include_restricted_content,
+                include_attachments,
+                include_comments,
+                ocr_languages,
             )
 
         if label:
@@ -244,7 +253,7 @@ class ConfluenceLoader(BaseLoader):
 
         if cql:
             pages = self.paginate_request(
-                self.confluence.cql,
+                self._search_content_by_cql,
                 cql=cql,
                 limit=limit,
                 max_pages=max_pages,
@@ -252,7 +261,11 @@ class ConfluenceLoader(BaseLoader):
                 expand="body.storage.value",
             )
             docs += self.process_pages(
-                pages, include_restricted_content, include_attachments, include_comments
+                pages,
+                include_restricted_content,
+                include_attachments,
+                include_comments,
+                ocr_languages,
             )
 
         if page_ids:
@@ -272,11 +285,26 @@ class ConfluenceLoader(BaseLoader):
                 page = get_page(page_id=page_id, expand="body.storage.value")
                 if not include_restricted_content and not self.is_public_page(page):
                     continue
-                doc = self.process_page(page, include_attachments, include_comments)
+                doc = self.process_page(
+                    page, include_attachments, include_comments, ocr_languages
+                )
                 docs.append(doc)
 
         return docs
 
+    def _search_content_by_cql(
+        self, cql: str, include_archived_spaces: Optional[bool] = None, **kwargs: Any
+    ) -> List[dict]:
+        url = "rest/api/content/search"
+
+        params: Dict[str, Any] = {"cql": cql}
+        params.update(kwargs)
+        if include_archived_spaces is not None:
+            params["includeArchivedSpaces"] = include_archived_spaces
+
+        response = self.confluence.get(url, params=params)
+        return response.get("results", [])
+
     def paginate_request(self, retrieval_method: Callable, **kwargs: Any) -> List:
         """Paginate the various methods to retrieve groups of pages.
 
@@ -335,13 +363,16 @@ class ConfluenceLoader(BaseLoader):
         include_restricted_content: bool,
         include_attachments: bool,
         include_comments: bool,
+        ocr_languages: Optional[str] = None,
     ) -> List[Document]:
         """Process a list of pages into a list of documents."""
         docs = []
         for page in pages:
             if not include_restricted_content and not self.is_public_page(page):
                 continue
-            doc = self.process_page(page, include_attachments, include_comments)
+            doc = self.process_page(
+                page, include_attachments, include_comments, ocr_languages
+            )
             docs.append(doc)
 
         return docs
@@ -351,6 +382,7 @@ class ConfluenceLoader(BaseLoader):
         page: dict,
         include_attachments: bool,
         include_comments: bool,
+        ocr_languages: Optional[str] = None,
     ) -> Document:
         try:
             from bs4 import BeautifulSoup  # type: ignore
@@ -361,7 +393,7 @@ class ConfluenceLoader(BaseLoader):
             )
 
         if include_attachments:
-            attachment_texts = self.process_attachment(page["id"])
+            attachment_texts = self.process_attachment(page["id"], ocr_languages)
         else:
             attachment_texts = []
         text = BeautifulSoup(page["body"]["storage"]["value"], "lxml").get_text(
@@ -388,7 +420,11 @@ class ConfluenceLoader(BaseLoader):
             },
         )
 
-    def process_attachment(self, page_id: str) -> List[str]:
+    def process_attachment(
+        self,
+        page_id: str,
+        ocr_languages: Optional[str] = None,
+    ) -> List[str]:
         try:
             from PIL import Image  # noqa: F401
         except ImportError:
@@ -405,13 +441,13 @@ class ConfluenceLoader(BaseLoader):
             absolute_url = self.base_url + attachment["_links"]["download"]
             title = attachment["title"]
             if media_type == "application/pdf":
-                text = title + self.process_pdf(absolute_url)
+                text = title + self.process_pdf(absolute_url, ocr_languages)
             elif (
                 media_type == "image/png"
                 or media_type == "image/jpg"
                 or media_type == "image/jpeg"
             ):
-                text = title + self.process_image(absolute_url)
+                text = title + self.process_image(absolute_url, ocr_languages)
             elif (
                 media_type == "application/vnd.openxmlformats-officedocument"
                 ".wordprocessingml.document"
@@ -420,14 +456,18 @@ class ConfluenceLoader(BaseLoader):
             elif media_type == "application/vnd.ms-excel":
                 text = title + self.process_xls(absolute_url)
             elif media_type == "image/svg+xml":
-                text = title + self.process_svg(absolute_url)
+                text = title + self.process_svg(absolute_url, ocr_languages)
             else:
                 continue
             texts.append(text)
 
         return texts
 
-    def process_pdf(self, link: str) -> str:
+    def process_pdf(
+        self,
+        link: str,
+        ocr_languages: Optional[str] = None,
+    ) -> str:
         try:
             import pytesseract  # noqa: F401
             from pdf2image import convert_from_bytes  # noqa: F401
@@ -452,12 +492,16 @@ class ConfluenceLoader(BaseLoader):
             return text
 
         for i, image in enumerate(images):
-            image_text = pytesseract.image_to_string(image)
+            image_text = pytesseract.image_to_string(image, lang=ocr_languages)
             text += f"Page {i + 1}:\n{image_text}\n\n"
 
         return text
 
-    def process_image(self, link: str) -> str:
+    def process_image(
+        self,
+        link: str,
+        ocr_languages: Optional[str] = None,
+    ) -> str:
         try:
             import pytesseract  # noqa: F401
             from PIL import Image  # noqa: F401
@@ -481,7 +525,7 @@ class ConfluenceLoader(BaseLoader):
         except OSError:
             return text
 
-        return pytesseract.image_to_string(image)
+        return pytesseract.image_to_string(image, lang=ocr_languages)
 
     def process_doc(self, link: str) -> str:
         try:
@@ -531,7 +575,11 @@ class ConfluenceLoader(BaseLoader):
 
         return text
 
-    def process_svg(self, link: str) -> str:
+    def process_svg(
+        self,
+        link: str,
+        ocr_languages: Optional[str] = None,
+    ) -> str:
         try:
             import pytesseract  # noqa: F401
             from PIL import Image  # noqa: F401
@@ -560,4 +608,4 @@ class ConfluenceLoader(BaseLoader):
         img_data.seek(0)
         image = Image.open(img_data)
 
-        return pytesseract.image_to_string(image)
+        return pytesseract.image_to_string(image, lang=ocr_languages)

langchain/document_loaders/snowflake_loader.py

@@ -53,13 +53,14 @@ class SnowflakeLoader(BaseLoader):
         self.database = database
         self.schema = schema
         self.parameters = parameters
-        self.page_content_columns = page_content_columns
-        self.metadata_columns = metadata_columns
+        self.page_content_columns = (
+            page_content_columns if page_content_columns is not None else ["*"]
+        )
+        self.metadata_columns = metadata_columns if metadata_columns is not None else []
 
     def _execute_query(self) -> List[Dict[str, Any]]:
         try:
             import snowflake.connector
-            from snowflake.connector import DictCursor
         except ImportError as ex:
             raise ValueError(
                 "Could not import snowflake-connector-python package. "
@@ -77,14 +78,13 @@ class SnowflakeLoader(BaseLoader):
             parameters=self.parameters,
         )
         try:
-            cur = conn.cursor(DictCursor)
+            cur = conn.cursor()
             cur.execute("USE DATABASE " + self.database)
             cur.execute("USE SCHEMA " + self.schema)
             cur.execute(self.query, self.parameters)
             query_result = cur.fetchall()
-            query_result = [
-                {k.lower(): v for k, v in item.items()} for item in query_result
-            ]
+            column_names = [column[0] for column in cur.description]
+            query_result = [dict(zip(column_names, row)) for row in query_result]
         except Exception as e:
             print(f"An error occurred: {e}")
             query_result = []
@@ -111,6 +111,8 @@ class SnowflakeLoader(BaseLoader):
             print(f"An error occurred during the query: {query_result}")
             return []
         page_content_columns, metadata_columns = self._get_columns(query_result)
+        if "*" in page_content_columns:
+            page_content_columns = list(query_result[0].keys())
         for row in query_result:
             page_content = "\n".join(
                 f"{k}: {v}" for k, v in row.items() if k in page_content_columns
@@ -118,3 +120,7 @@ class SnowflakeLoader(BaseLoader):
             metadata = {k: v for k, v in row.items() if k in metadata_columns}
             doc = Document(page_content=page_content, metadata=metadata)
             yield doc
+
+    def load(self) -> List[Document]:
+        """Load data into document objects."""
+        return list(self.lazy_load())

langchain/document_loaders/xml.py

@@ -0,0 +1,22 @@
+"""Loader that loads Microsoft Excel files."""
+from typing import Any, List
+
+from langchain.document_loaders.unstructured import (
+    UnstructuredFileLoader,
+    validate_unstructured_version,
+)
+
+
+class UnstructuredXMLLoader(UnstructuredFileLoader):
+    """Loader that uses unstructured to load XML files."""
+
+    def __init__(
+        self, file_path: str, mode: str = "single", **unstructured_kwargs: Any
+    ):
+        validate_unstructured_version(min_unstructured_version="0.6.7")
+        super().__init__(file_path=file_path, mode=mode, **unstructured_kwargs)
+
+    def _get_elements(self) -> List:
+        from unstructured.partition.xml import partition_xml
+
+        return partition_xml(filename=self.file_path, **self.unstructured_kwargs)

langchain/embeddings/__init__.py

@@ -8,8 +8,10 @@ from langchain.embeddings.aleph_alpha import (
 )
 from langchain.embeddings.bedrock import BedrockEmbeddings
 from langchain.embeddings.cohere import CohereEmbeddings
+from langchain.embeddings.dashscope import DashScopeEmbeddings
 from langchain.embeddings.deepinfra import DeepInfraEmbeddings
 from langchain.embeddings.elasticsearch import ElasticsearchEmbeddings
+from langchain.embeddings.embaas import EmbaasEmbeddings
 from langchain.embeddings.fake import FakeEmbeddings
 from langchain.embeddings.google_palm import GooglePalmEmbeddings
 from langchain.embeddings.huggingface import (
@@ -60,6 +62,8 @@ __all__ = [
     "VertexAIEmbeddings",
     "BedrockEmbeddings",
     "DeepInfraEmbeddings",
+    "DashScopeEmbeddings",
+    "EmbaasEmbeddings",
 ]
 
 

langchain/embeddings/dashscope.py

@@ -0,0 +1,155 @@
+"""Wrapper around DashScope embedding models."""
+from __future__ import annotations
+
+import logging
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+)
+
+from pydantic import BaseModel, Extra, root_validator
+from requests.exceptions import HTTPError
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from langchain.embeddings.base import Embeddings
+from langchain.utils import get_from_dict_or_env
+
+logger = logging.getLogger(__name__)
+
+
+def _create_retry_decorator(embeddings: DashScopeEmbeddings) -> Callable[[Any], Any]:
+    multiplier = 1
+    min_seconds = 1
+    max_seconds = 4
+    # Wait 2^x * 1 second between each retry starting with
+    # 1 seconds, then up to 4 seconds, then 4 seconds afterwards
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(embeddings.max_retries),
+        wait=wait_exponential(multiplier, min=min_seconds, max=max_seconds),
+        retry=(retry_if_exception_type(HTTPError)),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def embed_with_retry(embeddings: DashScopeEmbeddings, **kwargs: Any) -> Any:
+    """Use tenacity to retry the embedding call."""
+    retry_decorator = _create_retry_decorator(embeddings)
+
+    @retry_decorator
+    def _embed_with_retry(**kwargs: Any) -> Any:
+        resp = embeddings.client.call(**kwargs)
+        if resp.status_code == 200:
+            return resp.output["embeddings"]
+        elif resp.status_code in [400, 401]:
+            raise ValueError(
+                f"status_code: {resp.status_code} \n "
+                f"code: {resp.code} \n message: {resp.message}"
+            )
+        else:
+            raise HTTPError(
+                f"HTTP error occurred: status_code: {resp.status_code} \n "
+                f"code: {resp.code} \n message: {resp.message}"
+            )
+
+    return _embed_with_retry(**kwargs)
+
+
+class DashScopeEmbeddings(BaseModel, Embeddings):
+    """Wrapper around DashScope embedding models.
+
+    To use, you should have the ``dashscope`` python package installed, and the
+    environment variable ``DASHSCOPE_API_KEY`` set with your API key or pass it
+    as a named parameter to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain.embeddings import DashScopeEmbeddings
+            embeddings = DashScopeEmbeddings(dashscope_api_key="my-api-key")
+
+    Example:
+        .. code-block:: python
+
+            import os
+            os.environ["DASHSCOPE_API_KEY"] = "your DashScope API KEY"
+
+            from langchain.embeddings.dashscope import DashScopeEmbeddings
+            embeddings = DashScopeEmbeddings(
+                model="text-embedding-v1",
+            )
+            text = "This is a test query."
+            query_result = embeddings.embed_query(text)
+
+    """
+
+    client: Any  #: :meta private:
+    model: str = "text-embedding-v1"
+    dashscope_api_key: Optional[str] = None
+    """Maximum number of retries to make when generating."""
+    max_retries: int = 5
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        extra = Extra.forbid
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        import dashscope
+
+        """Validate that api key and python package exists in environment."""
+        values["dashscope_api_key"] = get_from_dict_or_env(
+            values, "dashscope_api_key", "DASHSCOPE_API_KEY"
+        )
+        dashscope.api_key = values["dashscope_api_key"]
+        try:
+            import dashscope
+
+            values["client"] = dashscope.TextEmbedding
+        except ImportError:
+            raise ImportError(
+                "Could not import dashscope python package. "
+                "Please install it with `pip install dashscope`."
+            )
+        return values
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to DashScope's embedding endpoint for embedding search docs.
+
+        Args:
+            texts: The list of texts to embed.
+            chunk_size: The chunk size of embeddings. If None, will use the chunk size
+                specified by the class.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings = embed_with_retry(
+            self, input=texts, text_type="document", model=self.model
+        )
+        embedding_list = [item["embedding"] for item in embeddings]
+        return embedding_list
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to DashScope's embedding endpoint for embedding query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+        embedding = embed_with_retry(
+            self, input=text, text_type="query", model=self.model
+        )[0]["embedding"]
+        return embedding

langchain/embeddings/embaas.py

@@ -0,0 +1,140 @@
+"""Wrapper around embaas embeddings API."""
+from typing import Any, Dict, List, Mapping, Optional
+
+import requests
+from pydantic import BaseModel, Extra, root_validator
+from typing_extensions import NotRequired, TypedDict
+
+from langchain.embeddings.base import Embeddings
+from langchain.utils import get_from_dict_or_env
+
+# Currently supported maximum batch size for embedding requests
+MAX_BATCH_SIZE = 256
+EMBAAS_API_URL = "https://api.embaas.io/v1/embeddings/"
+
+
+class EmbaasEmbeddingsPayload(TypedDict):
+    """Payload for the embaas embeddings API."""
+
+    model: str
+    texts: List[str]
+    instruction: NotRequired[str]
+
+
+class EmbaasEmbeddings(BaseModel, Embeddings):
+    """Wrapper around embaas's embedding service.
+
+    To use, you should have the
+    environment variable ``EMBAAS_API_KEY`` set with your API key, or pass
+    it as a named parameter to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            # Initialise with default model and instruction
+            from langchain.llms import EmbaasEmbeddings
+            emb = EmbaasEmbeddings()
+
+            # Initialise with custom model and instruction
+            from langchain.llms import EmbaasEmbeddings
+            emb_model = "instructor-large"
+            emb_inst = "Represent the Wikipedia document for retrieval"
+            emb = EmbaasEmbeddings(
+                model=emb_model,
+                instruction=emb_inst,
+                embaas_api_key="your-api-key"
+            )
+    """
+
+    model: str = "e5-large-v2"
+    """The model used for embeddings."""
+    instruction: Optional[str] = None
+    """Instruction used for domain-specific embeddings."""
+    api_url: str = EMBAAS_API_URL
+    """The URL for the embaas embeddings API."""
+    embaas_api_key: Optional[str] = None
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        extra = Extra.forbid
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        embaas_api_key = get_from_dict_or_env(
+            values, "embaas_api_key", "EMBAAS_API_KEY"
+        )
+        values["embaas_api_key"] = embaas_api_key
+        return values
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying params."""
+        return {"model": self.model, "instruction": self.instruction}
+
+    def _generate_payload(self, texts: List[str]) -> EmbaasEmbeddingsPayload:
+        """Generates payload for the API request."""
+        payload = EmbaasEmbeddingsPayload(texts=texts, model=self.model)
+        if self.instruction:
+            payload["instruction"] = self.instruction
+        return payload
+
+    def _handle_request(self, payload: EmbaasEmbeddingsPayload) -> List[List[float]]:
+        """Sends a request to the Embaas API and handles the response."""
+        headers = {
+            "Authorization": f"Bearer {self.embaas_api_key}",
+            "Content-Type": "application/json",
+        }
+
+        response = requests.post(self.api_url, headers=headers, json=payload)
+        response.raise_for_status()
+
+        parsed_response = response.json()
+        embeddings = [item["embedding"] for item in parsed_response["data"]]
+
+        return embeddings
+
+    def _generate_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """Generate embeddings using the Embaas API."""
+        payload = self._generate_payload(texts)
+        try:
+            return self._handle_request(payload)
+        except requests.exceptions.RequestException as e:
+            if e.response is None or not e.response.text:
+                raise ValueError(f"Error raised by embaas embeddings API: {e}")
+
+            parsed_response = e.response.json()
+            if "message" in parsed_response:
+                raise ValueError(
+                    "Validation Error raised by embaas embeddings API:"
+                    f"{parsed_response['message']}"
+                )
+            raise
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Get embeddings for a list of texts.
+
+        Args:
+            texts: The list of texts to get embeddings for.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        batches = [
+            texts[i : i + MAX_BATCH_SIZE] for i in range(0, len(texts), MAX_BATCH_SIZE)
+        ]
+        embeddings = [self._generate_embeddings(batch) for batch in batches]
+        # flatten the list of lists into a single list
+        return [embedding for batch in embeddings for embedding in batch]
+
+    def embed_query(self, text: str) -> List[float]:
+        """Get embeddings for a single text.
+
+        Args:
+            text: The text to get embeddings for.
+
+        Returns:
+            List of embeddings.
+        """
+        return self.embed_documents([text])[0]

langchain/experimental/llms/jsonformer_decoder.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, List, Optional, cast
+from typing import TYPE_CHECKING, Any, List, Optional, cast
 
 from pydantic import Field, root_validator
 
@@ -42,6 +42,7 @@ class JsonFormer(HuggingFacePipeline):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         jsonformer = import_jsonformer()
         from transformers import Text2TextGenerationPipeline

langchain/experimental/llms/rellm_decoder.py

@@ -1,7 +1,7 @@
 """Experimental implementation of RELLM wrapped LLM."""
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional, cast
+from typing import TYPE_CHECKING, Any, List, Optional, cast
 
 from pydantic import Field, root_validator
 
@@ -47,6 +47,7 @@ class RELLM(HuggingFacePipeline):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         rellm = import_rellm()
         from transformers import Text2TextGenerationPipeline

langchain/graphs/neo4j_graph.py

@@ -78,8 +78,7 @@ class Neo4jGraph:
         with self._driver.session(database=self._database) as session:
             try:
                 data = session.run(query, params)
-                # Hard limit of 50 results
-                return [r.data() for r in data][:50]
+                return [r.data() for r in data]
             except CypherSyntaxError as e:
                 raise ValueError("Generated Cypher Statement is not valid\n" f"{e}")
 

langchain/llms/ai21.py

@@ -112,6 +112,7 @@ class AI21(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to AI21's complete endpoint.
 
@@ -140,10 +141,11 @@ class AI21(LLM):
                 base_url = "https://api.ai21.com/studio/v1/experimental"
             else:
                 base_url = "https://api.ai21.com/studio/v1"
+        params = {**self._default_params, **kwargs}
         response = requests.post(
             url=f"{base_url}/{self.model}/complete",
             headers={"Authorization": f"Bearer {self.ai21_api_key}"},
-            json={"prompt": prompt, "stopSequences": stop, **self._default_params},
+            json={"prompt": prompt, "stopSequences": stop, **params},
         )
         if response.status_code != 200:
             optional_detail = response.json().get("error")

langchain/llms/aleph_alpha.py

@@ -206,6 +206,7 @@ class AlephAlpha(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Aleph Alpha's completion endpoint.
 
@@ -232,6 +233,7 @@ class AlephAlpha(LLM):
             params["stop_sequences"] = self.stop_sequences
         else:
             params["stop_sequences"] = stop
+        params = {**params, **kwargs}
         request = CompletionRequest(prompt=Prompt.from_text(prompt), **params)
         response = self.client.complete(model=self.model, request=request)
         text = response.completions[0].completion

langchain/llms/anthropic.py

@@ -162,6 +162,7 @@ class Anthropic(LLM, _AnthropicCommon):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         r"""Call out to Anthropic's completion endpoint.
 
@@ -181,11 +182,12 @@ class Anthropic(LLM, _AnthropicCommon):
 
         """
         stop = self._get_anthropic_stop(stop)
+        params = {**self._default_params, **kwargs}
         if self.streaming:
             stream_resp = self.client.completion_stream(
                 prompt=self._wrap_prompt(prompt),
                 stop_sequences=stop,
-                **self._default_params,
+                **params,
             )
             current_completion = ""
             for data in stream_resp:
@@ -197,7 +199,7 @@ class Anthropic(LLM, _AnthropicCommon):
         response = self.client.completion(
             prompt=self._wrap_prompt(prompt),
             stop_sequences=stop,
-            **self._default_params,
+            **params,
         )
         return response["completion"]
 
@@ -206,14 +208,16 @@ class Anthropic(LLM, _AnthropicCommon):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Anthropic's completion endpoint asynchronously."""
         stop = self._get_anthropic_stop(stop)
+        params = {**self._default_params, **kwargs}
         if self.streaming:
             stream_resp = await self.client.acompletion_stream(
                 prompt=self._wrap_prompt(prompt),
                 stop_sequences=stop,
-                **self._default_params,
+                **params,
             )
             current_completion = ""
             async for data in stream_resp:
@@ -225,7 +229,7 @@ class Anthropic(LLM, _AnthropicCommon):
         response = await self.client.acompletion(
             prompt=self._wrap_prompt(prompt),
             stop_sequences=stop,
-            **self._default_params,
+            **params,
         )
         return response["completion"]
 

langchain/llms/anyscale.py

@@ -88,6 +88,7 @@ class Anyscale(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Anyscale Service endpoint.
         Args:

langchain/llms/aviary.py

@@ -105,6 +105,7 @@ class Aviary(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Aviary
         Args:

langchain/llms/bananadev.py

@@ -87,6 +87,7 @@ class Banana(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call to Banana endpoint."""
         try:
@@ -97,6 +98,7 @@ class Banana(LLM):
                 "Please install it with `pip install banana-dev`."
             )
         params = self.model_kwargs or {}
+        params = {**params, **kwargs}
         api_key = self.banana_api_key
         model_key = self.model_key
         model_inputs = {

langchain/llms/base.py

@@ -19,6 +19,7 @@ from langchain.callbacks.manager import (
     CallbackManagerForLLMRun,
     Callbacks,
 )
+from langchain.load.dump import dumpd
 from langchain.schema import (
     AIMessage,
     BaseMessage,
@@ -113,6 +114,7 @@ class BaseLLM(BaseLanguageModel, ABC):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompts."""
 
@@ -122,6 +124,7 @@ class BaseLLM(BaseLanguageModel, ABC):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompts."""
 
@@ -130,24 +133,29 @@ class BaseLLM(BaseLanguageModel, ABC):
         prompts: List[PromptValue],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         prompt_strings = [p.to_string() for p in prompts]
-        return self.generate(prompt_strings, stop=stop, callbacks=callbacks)
+        return self.generate(prompt_strings, stop=stop, callbacks=callbacks, **kwargs)
 
     async def agenerate_prompt(
         self,
         prompts: List[PromptValue],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         prompt_strings = [p.to_string() for p in prompts]
-        return await self.agenerate(prompt_strings, stop=stop, callbacks=callbacks)
+        return await self.agenerate(
+            prompt_strings, stop=stop, callbacks=callbacks, **kwargs
+        )
 
     def generate(
         self,
         prompts: List[str],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompt and input."""
         # If string is passed in directly no errors will be raised but outputs will
@@ -159,6 +167,7 @@ class BaseLLM(BaseLanguageModel, ABC):
             )
         params = self.dict()
         params["stop"] = stop
+        options = {"stop": stop}
         (
             existing_prompts,
             llm_string,
@@ -179,13 +188,15 @@ class BaseLLM(BaseLanguageModel, ABC):
                     "Asked to cache, but no cache found at `langchain.cache`."
                 )
             run_manager = callback_manager.on_llm_start(
-                {"name": self.__class__.__name__}, prompts, invocation_params=params
+                dumpd(self), prompts, invocation_params=params, options=options
             )
             try:
                 output = (
-                    self._generate(prompts, stop=stop, run_manager=run_manager)
+                    self._generate(
+                        prompts, stop=stop, run_manager=run_manager, **kwargs
+                    )
                     if new_arg_supported
-                    else self._generate(prompts, stop=stop)
+                    else self._generate(prompts, stop=stop, **kwargs)
                 )
             except (KeyboardInterrupt, Exception) as e:
                 run_manager.on_llm_error(e)
@@ -196,15 +207,18 @@ class BaseLLM(BaseLanguageModel, ABC):
             return output
         if len(missing_prompts) > 0:
             run_manager = callback_manager.on_llm_start(
-                {"name": self.__class__.__name__},
+                dumpd(self),
                 missing_prompts,
                 invocation_params=params,
+                options=options,
             )
             try:
                 new_results = (
-                    self._generate(missing_prompts, stop=stop, run_manager=run_manager)
+                    self._generate(
+                        missing_prompts, stop=stop, run_manager=run_manager, **kwargs
+                    )
                     if new_arg_supported
-                    else self._generate(missing_prompts, stop=stop)
+                    else self._generate(missing_prompts, stop=stop, **kwargs)
                 )
             except (KeyboardInterrupt, Exception) as e:
                 run_manager.on_llm_error(e)
@@ -227,10 +241,12 @@ class BaseLLM(BaseLanguageModel, ABC):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompt and input."""
         params = self.dict()
         params["stop"] = stop
+        options = {"stop": stop}
         (
             existing_prompts,
             llm_string,
@@ -251,13 +267,15 @@ class BaseLLM(BaseLanguageModel, ABC):
                     "Asked to cache, but no cache found at `langchain.cache`."
                 )
             run_manager = await callback_manager.on_llm_start(
-                {"name": self.__class__.__name__}, prompts, invocation_params=params
+                dumpd(self), prompts, invocation_params=params, options=options
             )
             try:
                 output = (
-                    await self._agenerate(prompts, stop=stop, run_manager=run_manager)
+                    await self._agenerate(
+                        prompts, stop=stop, run_manager=run_manager, **kwargs
+                    )
                     if new_arg_supported
-                    else await self._agenerate(prompts, stop=stop)
+                    else await self._agenerate(prompts, stop=stop, **kwargs)
                 )
             except (KeyboardInterrupt, Exception) as e:
                 await run_manager.on_llm_error(e, verbose=self.verbose)
@@ -268,17 +286,18 @@ class BaseLLM(BaseLanguageModel, ABC):
             return output
         if len(missing_prompts) > 0:
             run_manager = await callback_manager.on_llm_start(
-                {"name": self.__class__.__name__},
+                dumpd(self),
                 missing_prompts,
                 invocation_params=params,
+                options=options,
             )
             try:
                 new_results = (
                     await self._agenerate(
-                        missing_prompts, stop=stop, run_manager=run_manager
+                        missing_prompts, stop=stop, run_manager=run_manager, **kwargs
                     )
                     if new_arg_supported
-                    else await self._agenerate(missing_prompts, stop=stop)
+                    else await self._agenerate(missing_prompts, stop=stop, **kwargs)
                 )
             except (KeyboardInterrupt, Exception) as e:
                 await run_manager.on_llm_error(e)
@@ -297,7 +316,11 @@ class BaseLLM(BaseLanguageModel, ABC):
         return LLMResult(generations=generations, llm_output=llm_output, run=run_info)
 
     def __call__(
-        self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> str:
         """Check Cache and run the LLM on the given prompt and input."""
         if not isinstance(prompt, str):
@@ -307,52 +330,70 @@ class BaseLLM(BaseLanguageModel, ABC):
                 "`generate` instead."
             )
         return (
-            self.generate([prompt], stop=stop, callbacks=callbacks)
+            self.generate([prompt], stop=stop, callbacks=callbacks, **kwargs)
             .generations[0][0]
             .text
         )
 
     async def _call_async(
-        self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> str:
         """Check Cache and run the LLM on the given prompt and input."""
-        result = await self.agenerate([prompt], stop=stop, callbacks=callbacks)
+        result = await self.agenerate(
+            [prompt], stop=stop, callbacks=callbacks, **kwargs
+        )
         return result.generations[0][0].text
 
-    def predict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
+    def predict(
+        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
+    ) -> str:
         if stop is None:
             _stop = None
         else:
             _stop = list(stop)
-        return self(text, stop=_stop)
+        return self(text, stop=_stop, **kwargs)
 
     def predict_messages(
-        self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
+        self,
+        messages: List[BaseMessage],
+        *,
+        stop: Optional[Sequence[str]] = None,
+        **kwargs: Any,
     ) -> BaseMessage:
         text = get_buffer_string(messages)
         if stop is None:
             _stop = None
         else:
             _stop = list(stop)
-        content = self(text, stop=_stop)
+        content = self(text, stop=_stop, **kwargs)
         return AIMessage(content=content)
 
-    async def apredict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
+    async def apredict(
+        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
+    ) -> str:
         if stop is None:
             _stop = None
         else:
             _stop = list(stop)
-        return await self._call_async(text, stop=_stop)
+        return await self._call_async(text, stop=_stop, **kwargs)
 
     async def apredict_messages(
-        self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
+        self,
+        messages: List[BaseMessage],
+        *,
+        stop: Optional[Sequence[str]] = None,
+        **kwargs: Any,
     ) -> BaseMessage:
         text = get_buffer_string(messages)
         if stop is None:
             _stop = None
         else:
             _stop = list(stop)
-        content = await self._call_async(text, stop=_stop)
+        content = await self._call_async(text, stop=_stop, **kwargs)
         return AIMessage(content=content)
 
     @property
@@ -422,6 +463,7 @@ class LLM(BaseLLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Run the LLM on the given prompt and input."""
 
@@ -430,6 +472,7 @@ class LLM(BaseLLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Run the LLM on the given prompt and input."""
         raise NotImplementedError("Async generation not implemented for this LLM.")
@@ -439,6 +482,7 @@ class LLM(BaseLLM):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompt and input."""
         # TODO: add caching here.
@@ -446,9 +490,9 @@ class LLM(BaseLLM):
         new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
         for prompt in prompts:
             text = (
-                self._call(prompt, stop=stop, run_manager=run_manager)
+                self._call(prompt, stop=stop, run_manager=run_manager, **kwargs)
                 if new_arg_supported
-                else self._call(prompt, stop=stop)
+                else self._call(prompt, stop=stop, **kwargs)
             )
             generations.append([Generation(text=text)])
         return LLMResult(generations=generations)
@@ -458,15 +502,16 @@ class LLM(BaseLLM):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompt and input."""
         generations = []
         new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
         for prompt in prompts:
             text = (
-                await self._acall(prompt, stop=stop, run_manager=run_manager)
+                await self._acall(prompt, stop=stop, run_manager=run_manager, **kwargs)
                 if new_arg_supported
-                else await self._acall(prompt, stop=stop)
+                else await self._acall(prompt, stop=stop, **kwargs)
             )
             generations.append([Generation(text=text)])
         return LLMResult(generations=generations)

langchain/llms/baseten.py

@@ -54,6 +54,7 @@ class Baseten(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call to Baseten deployed model endpoint."""
         try:

langchain/llms/beam.py

@@ -251,10 +251,12 @@ class Beam(LLM):
         prompt: str,
         stop: Optional[list] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call to Beam."""
         url = "https://apps.beam.cloud/" + self.app_id if self.app_id else self.url
         payload = {"prompt": prompt, "max_length": self.max_length}
+        payload.update(kwargs)
         headers = {
             "Accept": "*/*",
             "Accept-Encoding": "gzip, deflate",

langchain/llms/bedrock.py

@@ -155,6 +155,7 @@ class Bedrock(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Bedrock service model.
 
@@ -173,10 +174,8 @@ class Bedrock(LLM):
         _model_kwargs = self.model_kwargs or {}
 
         provider = self.model_id.split(".")[0]
-
-        input_body = LLMInputOutputAdapter.prepare_input(
-            provider, prompt, _model_kwargs
-        )
+        params = {**_model_kwargs, **kwargs}
+        input_body = LLMInputOutputAdapter.prepare_input(provider, prompt, params)
         body = json.dumps(input_body)
         accept = "application/json"
         contentType = "application/json"

langchain/llms/cerebriumai.py

@@ -88,6 +88,7 @@ class CerebriumAI(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call to CerebriumAI endpoint."""
         try:
@@ -100,7 +101,9 @@ class CerebriumAI(LLM):
 
         params = self.model_kwargs or {}
         response = model_api_request(
-            self.endpoint_url, {"prompt": prompt, **params}, self.cerebriumai_api_key
+            self.endpoint_url,
+            {"prompt": prompt, **params, **kwargs},
+            self.cerebriumai_api_key,
         )
         text = response["data"]["result"]
         if stop is not None:

langchain/llms/cohere.py

@@ -145,6 +145,7 @@ class Cohere(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Cohere's generate endpoint.
 
@@ -167,7 +168,7 @@ class Cohere(LLM):
             params["stop_sequences"] = self.stop
         else:
             params["stop_sequences"] = stop
-
+        params = {**params, **kwargs}
         response = completion_with_retry(
             self, model=self.model, prompt=prompt, **params
         )

langchain/llms/ctransformers.py

@@ -81,6 +81,7 @@ class CTransformers(LLM):
         prompt: str,
         stop: Optional[Sequence[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Generate text from a prompt.
 

langchain/llms/databricks.py

@@ -303,12 +303,14 @@ class Databricks(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Queries the LLM endpoint with the given prompt and stop sequence."""
 
         # TODO: support callbacks
 
         request = {"prompt": prompt, "stop": stop}
+        request.update(kwargs)
         if self.model_kwargs:
             request.update(self.model_kwargs)
 

langchain/llms/deepinfra.py

@@ -66,6 +66,7 @@ class DeepInfra(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to DeepInfra's inference API endpoint.
 
@@ -82,6 +83,7 @@ class DeepInfra(LLM):
                 response = di("Tell me a joke.")
         """
         _model_kwargs = self.model_kwargs or {}
+        _model_kwargs = {**_model_kwargs, **kwargs}
         # HTTP headers for authorization
         headers = {
             "Authorization": f"bearer {self.deepinfra_api_token}",

langchain/llms/fake.py

@@ -24,6 +24,7 @@ class FakeListLLM(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Return next response"""
         response = self.responses[self.i]
@@ -35,6 +36,7 @@ class FakeListLLM(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Return next response"""
         response = self.responses[self.i]

langchain/llms/forefrontai.py

@@ -87,6 +87,7 @@ class ForefrontAI(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to ForefrontAI's complete endpoint.
 
@@ -108,7 +109,7 @@ class ForefrontAI(LLM):
                 "Authorization": f"Bearer {self.forefrontai_api_key}",
                 "Content-Type": "application/json",
             },
-            json={"text": prompt, **self._default_params},
+            json={"text": prompt, **self._default_params, **kwargs},
         )
         response_json = response.json()
         text = response_json["result"][0]["completion"]

langchain/llms/google_palm.py

@@ -134,6 +134,7 @@ class GooglePalm(BaseLLM, BaseModel):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         generations = []
         for prompt in prompts:
@@ -147,6 +148,7 @@ class GooglePalm(BaseLLM, BaseModel):
                 top_k=self.top_k,
                 max_output_tokens=self.max_output_tokens,
                 candidate_count=self.n,
+                **kwargs,
             )
 
             prompt_generations = []
@@ -163,6 +165,7 @@ class GooglePalm(BaseLLM, BaseModel):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         raise NotImplementedError()
 

langchain/llms/gooseai.py

@@ -137,6 +137,7 @@ class GooseAI(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call the GooseAI API."""
         params = self._default_params
@@ -145,6 +146,8 @@ class GooseAI(LLM):
                 raise ValueError("`stop` found in both the input and default params.")
             params["stop"] = stop
 
+        params = {**params, **kwargs}
+
         response = self.client.create(engine=self.model_name, prompt=prompt, **params)
         text = response.choices[0].text
         return text

langchain/llms/gpt4all.py

@@ -183,6 +183,7 @@ class GPT4All(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         r"""Call out to GPT4All's generate method.
 
@@ -203,7 +204,8 @@ class GPT4All(LLM):
         if run_manager:
             text_callback = partial(run_manager.on_llm_new_token, verbose=self.verbose)
         text = ""
-        for token in self.client.generate(prompt, **self._default_params()):
+        params = {**self._default_params(), **kwargs}
+        for token in self.client.generate(prompt, **params):
             if text_callback:
                 text_callback(token)
             text += token

langchain/llms/huggingface_endpoint.py

@@ -96,6 +96,7 @@ class HuggingFaceEndpoint(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to HuggingFace Hub's inference endpoint.
 
@@ -114,7 +115,8 @@ class HuggingFaceEndpoint(LLM):
         _model_kwargs = self.model_kwargs or {}
 
         # payload samples
-        parameter_payload = {"inputs": prompt, "parameters": _model_kwargs}
+        params = {**_model_kwargs, **kwargs}
+        parameter_payload = {"inputs": prompt, "parameters": params}
 
         # HTTP headers for authorization
         headers = {

langchain/llms/huggingface_hub.py

@@ -91,6 +91,7 @@ class HuggingFaceHub(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to HuggingFace Hub's inference endpoint.
 
@@ -107,7 +108,8 @@ class HuggingFaceHub(LLM):
                 response = hf("Tell me a joke.")
         """
         _model_kwargs = self.model_kwargs or {}
-        response = self.client(inputs=prompt, params=_model_kwargs)
+        params = {**_model_kwargs, **kwargs}
+        response = self.client(inputs=prompt, params=params)
         if "error" in response:
             raise ValueError(f"Error raised by inference API: {response['error']}")
         if self.client.task == "text-generation":

langchain/llms/huggingface_pipeline.py

@@ -164,6 +164,7 @@ class HuggingFacePipeline(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         response = self.pipeline(prompt)
         if self.pipeline.task == "text-generation":

langchain/llms/huggingface_text_gen_inference.py

@@ -113,6 +113,7 @@ class HuggingFaceTextGenInference(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         if stop is None:
             stop = self.stop_sequences
@@ -130,6 +131,7 @@ class HuggingFaceTextGenInference(LLM):
                 temperature=self.temperature,
                 repetition_penalty=self.repetition_penalty,
                 seed=self.seed,
+                **kwargs,
             )
             # remove stop sequences from the end of the generated text
             for stop_seq in stop:

langchain/llms/human.py

@@ -60,6 +60,7 @@ class HumanInputLLM(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """
         Displays the prompt to the user and returns their input as a response.

langchain/llms/llamacpp.py

@@ -200,6 +200,7 @@ class LlamaCpp(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call the Llama model and return the output.
 
@@ -227,6 +228,7 @@ class LlamaCpp(LLM):
             return combined_text_output
         else:
             params = self._get_parameters(stop)
+            params = {**params, **kwargs}
             result = self.client(prompt=prompt, **params)
             return result["choices"][0]["text"]
 

langchain/llms/manifest.py

@@ -48,13 +48,15 @@ class ManifestWrapper(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to LLM through Manifest."""
         if stop is not None and len(stop) != 1:
             raise NotImplementedError(
                 f"Manifest currently only supports a single stop token, got {stop}"
             )
-        kwargs = self.llm_kwargs or {}
+        params = self.llm_kwargs or {}
+        params = {**params, **kwargs}
         if stop is not None:
-            kwargs["stop_token"] = stop
-        return self.client.run(prompt, **kwargs)
+            params["stop_token"] = stop
+        return self.client.run(prompt, **params)

langchain/llms/modal.py

@@ -76,9 +76,11 @@ class Modal(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call to Modal endpoint."""
         params = self.model_kwargs or {}
+        params = {**params, **kwargs}
         response = requests.post(
             url=self.endpoint_url,
             headers={

langchain/llms/mosaicml.py

@@ -102,6 +102,7 @@ class MosaicML(LLM):
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         is_retry: bool = False,
+        **kwargs: Any,
     ) -> str:
         """Call out to a MosaicML LLM inference endpoint.
 
@@ -123,6 +124,7 @@ class MosaicML(LLM):
 
         payload = {"input_strings": [prompt]}
         payload.update(_model_kwargs)
+        payload.update(kwargs)
 
         # HTTP headers for authorization
         headers = {

langchain/llms/nlpcloud.py

@@ -117,6 +117,7 @@ class NLPCloud(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to NLPCloud's create endpoint.
 
@@ -141,7 +142,6 @@ class NLPCloud(LLM):
             end_sequence = stop[0]
         else:
             end_sequence = None
-        response = self.client.generation(
-            prompt, end_sequence=end_sequence, **self._default_params
-        )
+        params = {**self._default_params, **kwargs}
+        response = self.client.generation(prompt, end_sequence=end_sequence, **params)
         return response["generated_text"]

langchain/llms/openai.py

@@ -123,6 +123,14 @@ async def acompletion_with_retry(
 class BaseOpenAI(BaseLLM):
     """Wrapper around OpenAI large language models."""
 
+    @property
+    def lc_secrets(self) -> Dict[str, str]:
+        return {"openai_api_key": "OPENAI_API_KEY"}
+
+    @property
+    def lc_serializable(self) -> bool:
+        return True
+
     client: Any  #: :meta private:
     model_name: str = Field("text-davinci-003", alias="model")
     """Model name to use."""
@@ -273,6 +281,7 @@ class BaseOpenAI(BaseLLM):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Call out to OpenAI's endpoint with k unique prompts.
 
@@ -290,6 +299,7 @@ class BaseOpenAI(BaseLLM):
         """
         # TODO: write a unit test for this
         params = self._invocation_params
+        params = {**params, **kwargs}
         sub_prompts = self.get_sub_prompts(params, prompts, stop)
         choices = []
         token_usage: Dict[str, int] = {}
@@ -326,9 +336,11 @@ class BaseOpenAI(BaseLLM):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Call out to OpenAI's endpoint async with k unique prompts."""
         params = self._invocation_params
+        params = {**params, **kwargs}
         sub_prompts = self.get_sub_prompts(params, prompts, stop)
         choices = []
         token_usage: Dict[str, int] = {}
@@ -771,8 +783,10 @@ class OpenAIChat(BaseLLM):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         messages, params = self._get_chat_params(prompts, stop)
+        params = {**params, **kwargs}
         if self.streaming:
             response = ""
             params["stream"] = True
@@ -804,8 +818,10 @@ class OpenAIChat(BaseLLM):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         messages, params = self._get_chat_params(prompts, stop)
+        params = {**params, **kwargs}
         if self.streaming:
             response = ""
             params["stream"] = True

langchain/llms/petals.py

@@ -137,9 +137,11 @@ class Petals(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call the Petals API."""
         params = self._default_params
+        params = {**params, **kwargs}
         inputs = self.tokenizer(prompt, return_tensors="pt")["input_ids"]
         outputs = self.client.generate(inputs, **params)
         text = self.tokenizer.decode(outputs[0])

langchain/llms/pipelineai.py

@@ -87,6 +87,7 @@ class PipelineAI(LLM, BaseModel):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call to Pipeline Cloud endpoint."""
         try:
@@ -98,6 +99,7 @@ class PipelineAI(LLM, BaseModel):
             )
         client = PipelineCloud(token=self.pipeline_api_key)
         params = self.pipeline_kwargs or {}
+        params = {**params, **kwargs}
 
         run = client.run_pipeline(self.pipeline_key, [prompt, params])
         try:

langchain/llms/predictionguard.py

@@ -91,6 +91,7 @@ class PredictionGuard(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Prediction Guard's model API.
         Args:
@@ -117,6 +118,7 @@ class PredictionGuard(LLM):
             output=self.output,
             temperature=params["temperature"],
             max_tokens=params["max_tokens"],
+            **kwargs,
         )
         text = response["choices"][0]["text"]
 

langchain/llms/promptlayer_openai.py

@@ -1,6 +1,6 @@
 """PromptLayer wrapper."""
 import datetime
-from typing import List, Optional
+from typing import Any, List, Optional
 
 from langchain.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
@@ -42,6 +42,7 @@ class PromptLayerOpenAI(OpenAI):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Call OpenAI generate and then call PromptLayer API to log the request."""
         from promptlayer.utils import get_api_key, promptlayer_api_request
@@ -56,11 +57,12 @@ class PromptLayerOpenAI(OpenAI):
                 "text": generation.text,
                 "llm_output": generated_responses.llm_output,
             }
+            params = {**self._identifying_params, **kwargs}
             pl_request_id = promptlayer_api_request(
                 "langchain.PromptLayerOpenAI",
                 "langchain",
                 [prompt],
-                self._identifying_params,
+                params,
                 self.pl_tags,
                 resp,
                 request_start_time,
@@ -81,6 +83,7 @@ class PromptLayerOpenAI(OpenAI):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         from promptlayer.utils import get_api_key, promptlayer_api_request_async
 
@@ -94,11 +97,12 @@ class PromptLayerOpenAI(OpenAI):
                 "text": generation.text,
                 "llm_output": generated_responses.llm_output,
             }
+            params = {**self._identifying_params, **kwargs}
             pl_request_id = await promptlayer_api_request_async(
                 "langchain.PromptLayerOpenAI.async",
                 "langchain",
                 [prompt],
-                self._identifying_params,
+                params,
                 self.pl_tags,
                 resp,
                 request_start_time,
@@ -147,6 +151,7 @@ class PromptLayerOpenAIChat(OpenAIChat):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         """Call OpenAI generate and then call PromptLayer API to log the request."""
         from promptlayer.utils import get_api_key, promptlayer_api_request
@@ -161,11 +166,12 @@ class PromptLayerOpenAIChat(OpenAIChat):
                 "text": generation.text,
                 "llm_output": generated_responses.llm_output,
             }
+            params = {**self._identifying_params, **kwargs}
             pl_request_id = promptlayer_api_request(
                 "langchain.PromptLayerOpenAIChat",
                 "langchain",
                 [prompt],
-                self._identifying_params,
+                params,
                 self.pl_tags,
                 resp,
                 request_start_time,
@@ -186,6 +192,7 @@ class PromptLayerOpenAIChat(OpenAIChat):
         prompts: List[str],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> LLMResult:
         from promptlayer.utils import get_api_key, promptlayer_api_request_async
 
@@ -199,11 +206,12 @@ class PromptLayerOpenAIChat(OpenAIChat):
                 "text": generation.text,
                 "llm_output": generated_responses.llm_output,
             }
+            params = {**self._identifying_params, **kwargs}
             pl_request_id = await promptlayer_api_request_async(
                 "langchain.PromptLayerOpenAIChat.async",
                 "langchain",
                 [prompt],
-                self._identifying_params,
+                params,
                 self.pl_tags,
                 resp,
                 request_start_time,

langchain/llms/replicate.py

@@ -85,6 +85,7 @@ class Replicate(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call to replicate endpoint."""
         try:
@@ -110,6 +111,6 @@ class Replicate(LLM):
         first_input_name = input_properties[0][0]
 
         inputs = {first_input_name: prompt, **self.input}
-        iterator = replicate_python.run(self.model, input={**inputs})
+        iterator = replicate_python.run(self.model, input={**inputs, **kwargs})
 
         return "".join([output for output in iterator])

langchain/llms/rwkv.py

@@ -210,6 +210,7 @@ class RWKV(LLM, BaseModel):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         r"""RWKV generation
 

langchain/llms/sagemaker_endpoint.py

@@ -207,6 +207,7 @@ class SagemakerEndpoint(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Sagemaker inference endpoint.
 
@@ -223,6 +224,7 @@ class SagemakerEndpoint(LLM):
                 response = se("Tell me a joke.")
         """
         _model_kwargs = self.model_kwargs or {}
+        _model_kwargs = {**_model_kwargs, **kwargs}
         _endpoint_kwargs = self.endpoint_kwargs or {}
 
         body = self.content_handler.transform_input(prompt, _model_kwargs)

langchain/llms/self_hosted.py

@@ -214,5 +214,8 @@ class SelfHostedPipeline(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
-        return self.client(pipeline=self.pipeline_ref, prompt=prompt, stop=stop)
+        return self.client(
+            pipeline=self.pipeline_ref, prompt=prompt, stop=stop, **kwargs
+        )

langchain/llms/self_hosted_hugging_face.py

@@ -207,5 +207,8 @@ class SelfHostedHuggingFaceLLM(SelfHostedPipeline):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
-        return self.client(pipeline=self.pipeline_ref, prompt=prompt, stop=stop)
+        return self.client(
+            pipeline=self.pipeline_ref, prompt=prompt, stop=stop, **kwargs
+        )

langchain/llms/stochasticai.py

@@ -86,6 +86,7 @@ class StochasticAI(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to StochasticAI's complete endpoint.
 
@@ -102,6 +103,7 @@ class StochasticAI(LLM):
                 response = StochasticAI("Tell me a joke.")
         """
         params = self.model_kwargs or {}
+        params = {**params, **kwargs}
         response_post = requests.post(
             url=self.api_url,
             json={"prompt": prompt, "params": params},

langchain/llms/vertexai.py

@@ -50,8 +50,11 @@ class _VertexAICommon(BaseModel):
         }
         return {**base_params}
 
-    def _predict(self, prompt: str, stop: Optional[List[str]] = None) -> str:
-        res = self.client.predict(prompt, **self._default_params)
+    def _predict(
+        self, prompt: str, stop: Optional[List[str]] = None, **kwargs: Any
+    ) -> str:
+        params = {**self._default_params, **kwargs}
+        res = self.client.predict(prompt, **params)
         return self._enforce_stop_words(res.text, stop)
 
     def _enforce_stop_words(self, text: str, stop: Optional[List[str]] = None) -> str:
@@ -100,6 +103,7 @@ class VertexAI(_VertexAICommon, LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call Vertex model to get predictions based on the prompt.
 
@@ -111,4 +115,4 @@ class VertexAI(_VertexAICommon, LLM):
         Returns:
             The string generated by the model.
         """
-        return self._predict(prompt, stop)
+        return self._predict(prompt, stop, **kwargs)

langchain/llms/writer.py

@@ -118,6 +118,7 @@ class Writer(LLM):
         prompt: str,
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
     ) -> str:
         """Call out to Writer's completions endpoint.
 
@@ -141,7 +142,7 @@ class Writer(LLM):
                 f"/organization/{self.writer_org_id}"
                 f"/model/{self.model_id}/completions"
             )
-
+        params = {**self._default_params, **kwargs}
         response = requests.post(
             url=base_url,
             headers={
@@ -149,7 +150,7 @@ class Writer(LLM):
                 "Content-Type": "application/json",
                 "Accept": "application/json",
             },
-            json={"prompt": prompt, **self._default_params},
+            json={"prompt": prompt, **params},
         )
         text = response.text
         if stop is not None:

langchain/load/dump.py

@@ -0,0 +1,22 @@
+import json
+from typing import Any, Dict
+
+from langchain.load.serializable import Serializable, to_json_not_implemented
+
+
+def default(obj: Any) -> Any:
+    if isinstance(obj, Serializable):
+        return obj.to_json()
+    else:
+        return to_json_not_implemented(obj)
+
+
+def dumps(obj: Any, *, pretty: bool = False) -> str:
+    if pretty:
+        return json.dumps(obj, default=default, indent=2)
+    else:
+        return json.dumps(obj, default=default)
+
+
+def dumpd(obj: Any) -> Dict[str, Any]:
+    return json.loads(dumps(obj))

langchain/load/load.py

@@ -0,0 +1,65 @@
+import importlib
+import json
+from typing import Any, Dict, Optional
+
+from langchain.load.serializable import Serializable
+
+
+class Reviver:
+    def __init__(self, secrets_map: Optional[Dict[str, str]] = None) -> None:
+        self.secrets_map = secrets_map or dict()
+
+    def __call__(self, value: Dict[str, Any]) -> Any:
+        if (
+            value.get("lc", None) == 1
+            and value.get("type", None) == "secret"
+            and value.get("id", None) is not None
+        ):
+            [key] = value["id"]
+            if key in self.secrets_map:
+                return self.secrets_map[key]
+            else:
+                raise KeyError(f'Missing key "{key}" in load(secrets_map)')
+
+        if (
+            value.get("lc", None) == 1
+            and value.get("type", None) == "not_implemented"
+            and value.get("id", None) is not None
+        ):
+            raise NotImplementedError(
+                "Trying to load an object that doesn't implement "
+                f"serialization: {value}"
+            )
+
+        if (
+            value.get("lc", None) == 1
+            and value.get("type", None) == "constructor"
+            and value.get("id", None) is not None
+        ):
+            [*namespace, name] = value["id"]
+
+            # Currently, we only support langchain imports.
+            if namespace[0] != "langchain":
+                raise ValueError(f"Invalid namespace: {value}")
+
+            # The root namespace "langchain" is not a valid identifier.
+            if len(namespace) == 1:
+                raise ValueError(f"Invalid namespace: {value}")
+
+            mod = importlib.import_module(".".join(namespace))
+            cls = getattr(mod, name)
+
+            # The class must be a subclass of Serializable.
+            if not issubclass(cls, Serializable):
+                raise ValueError(f"Invalid namespace: {value}")
+
+            # We don't need to recurse on kwargs
+            # as json.loads will do that for us.
+            kwargs = value.get("kwargs", dict())
+            return cls(**kwargs)
+
+        return value
+
+
+def loads(text: str, *, secrets_map: Optional[Dict[str, str]] = None) -> Any:
+    return json.loads(text, object_hook=Reviver(secrets_map))