docs: rm convert to openai tool

.github/scripts/check_diff.py

@@ -53,10 +53,6 @@ if __name__ == "__main__":
             dirs_to_run["lint"].add("libs/standard-tests")
             dirs_to_run["test"].add("libs/partners/mistralai")
             dirs_to_run["test"].add("libs/partners/openai")
-            dirs_to_run["test"].add("libs/partners/anthropic")
-            dirs_to_run["test"].add("libs/partners/ai21")
-            dirs_to_run["test"].add("libs/partners/fireworks")
-            dirs_to_run["test"].add("libs/partners/groq")
 
         elif file.startswith("libs/cli"):
             # todo: add cli makefile

.github/workflows/_integration_test.yml

@@ -58,7 +58,6 @@ jobs:
           MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
           TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
           NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
           GOOGLE_SEARCH_API_KEY: ${{ secrets.GOOGLE_SEARCH_API_KEY }}
           GOOGLE_CSE_ID: ${{ secrets.GOOGLE_CSE_ID }}
@@ -78,7 +77,6 @@ jobs:
           MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
           VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
           COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
-          UPSTAGE_API_KEY: ${{ secrets.UPSTAGE_API_KEY }}
         run: |
           make integration_tests
 

.github/workflows/_release.yml

@@ -215,7 +215,6 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # for airbyte
           MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
           VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
-          UPSTAGE_API_KEY: ${{ secrets.UPSTAGE_API_KEY }}
         run: make integration_tests
         working-directory: ${{ inputs.working-directory }}
 

.github/workflows/scheduled_test.yml

@@ -10,21 +10,19 @@ env:
 
 jobs:
   build:
+    defaults:
+      run:
+        working-directory: libs/langchain
     runs-on: ubuntu-latest
+    environment: Scheduled testing
     strategy:
       matrix:
         python-version:
           - "3.8"
+          - "3.9"
+          - "3.10"
           - "3.11"
-        working-directory:
-          - "libs/partners/openai"
-          - "libs/partners/anthropic"
-          # - "libs/partners/ai21"  # standard-tests broken
-          - "libs/partners/fireworks"
-          # - "libs/partners/groq"  # rate-limited
-          - "libs/partners/mistralai"
-          # - "libs/partners/together"  # rate-limited
-    name: Python ${{ matrix.python-version }} - ${{ matrix.working-directory }}
+    name: Python ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@v4
 
@@ -33,7 +31,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ matrix.working-directory }}
+          working-directory: libs/langchain
           cache-key: scheduled
 
       - name: 'Authenticate to Google Cloud'
@@ -42,15 +40,26 @@ jobs:
         with:
           credentials_json: '${{ secrets.GOOGLE_CREDENTIALS }}'
 
+      - name: Configure AWS Credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ vars.AWS_REGION }}
+
       - name: Install dependencies
-        working-directory: ${{ matrix.working-directory }}
+        working-directory: libs/langchain
         shell: bash
         run: |
           echo "Running scheduled tests, installing dependencies with poetry..."
           poetry install --with=test_integration,test
 
-      - name: Run integration tests
-        working-directory: ${{ matrix.working-directory }}
+      - name: Install deps outside pyproject
+        if: ${{ startsWith(inputs.working-directory, 'libs/community/') }}
+        shell: bash
+        run: poetry run pip install "boto3<2" "google-cloud-aiplatform<2"
+
+      - name: Run tests
         shell: bash
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
@@ -61,16 +70,11 @@ jobs:
           AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_CHAT_DEPLOYMENT_NAME }}
           AZURE_OPENAI_LLM_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_LLM_DEPLOYMENT_NAME }}
           AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME }}
-          AI21_API_KEY: ${{ secrets.AI21_API_KEY }}
           FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
-          GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
-          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
-          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
         run: |
-          make integration_test
+          make scheduled_tests
 
       - name: Ensure the tests did not create any additional files
-        working-directory: ${{ matrix.working-directory }}
         shell: bash
         run: |
           set -eu

README.md

@@ -47,7 +47,7 @@ For these applications, LangChain simplifies the entire application lifecycle:
 - **`langchain-community`**: Third party integrations.
   - Some integrations have been further split into **partner packages** that only rely on **`langchain-core`**. Examples include **`langchain_openai`** and **`langchain_anthropic`**.
 - **`langchain`**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
-- **[LangGraph](https://python.langchain.com/docs/langgraph)**: A library for building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
+- **`[LangGraph](https://python.langchain.com/docs/langgraph)`**: A library for building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
 
 ### Productionization:
 - **[LangSmith](https://python.langchain.com/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.

cookbook/RAPTOR.ipynb

@@ -535,9 +535,9 @@
     "    print(f\"--Generated {len(all_clusters)} clusters--\")\n",
     "\n",
     "    # Summarization\n",
-    "    template = \"\"\"Here is a sub-set of LangChain Expression Language doc. \n",
+    "    template = \"\"\"Here is a sub-set of LangChain Expression Langauge doc. \n",
     "    \n",
-    "    LangChain Expression Language provides a way to compose chain in LangChain.\n",
+    "    LangChain Expression Langauge provides a way to compose chain in LangChain.\n",
     "    \n",
     "    Give a detailed summary of the documentation provided.\n",
     "    \n",

docs/docs/additional_resources/tutorials.mdx

@@ -9,10 +9,6 @@
 
 ##  Tutorials
 
-### [LangChain v 0.1 by LangChain.ai](https://www.youtube.com/playlist?list=PLfaIDFEXuae0gBSJ9T0w7cu7iJZbH3T31)
-### [Build with Langchain - Advanced by LangChain.ai](https://www.youtube.com/playlist?list=PLfaIDFEXuae06tclDATrMYY0idsTdLg9v)
-### [LangGraph by LangChain.ai](https://www.youtube.com/playlist?list=PLfaIDFEXuae16n2TWUkKq5PgJ0w6Pkwtg)
-
 ### [by Greg Kamradt](https://www.youtube.com/playlist?list=PLqZXAkvF1bPNQER9mLmDbntNfSpzdDIU5)
 ### [by Sam Witteveen](https://www.youtube.com/playlist?list=PL8motc6AQftk1Bs42EW45kwYbyJ4jOdiZ)
 ### [by James Briggs](https://www.youtube.com/playlist?list=PLIUOU7oqGTLieV9uTIFMm6_4PXg-hlN6F)
@@ -39,7 +35,6 @@
 - [Udacity](https://www.udacity.com/catalog/all/any-price/any-school/any-skill/any-difficulty/any-duration/any-type/relevance/page-1?searchValue=langchain)
 - [LinkedIn Learning](https://www.linkedin.com/search/results/learning/?keywords=langchain)
 - [edX](https://www.edx.org/search?q=langchain)
-- [freeCodeCamp](https://www.youtube.com/@freecodecamp/search?query=langchain)
 
 ## Short Tutorials
 

docs/docs/get_started/quickstart.mdx

@@ -293,7 +293,7 @@ embeddings = OllamaEmbeddings()
 Make sure you have the `cohere` package installed and the appropriate environment variables set (these are the same as needed for the LLM).
 
 ```python
-from langchain_cohere.embeddings import CohereEmbeddings
+from langchain_community.embeddings import CohereEmbeddings
 
 embeddings = CohereEmbeddings()
 ```

docs/docs/integrations/callbacks/confident.ipynb

@@ -42,7 +42,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai deepeval langchain-chroma"
+    "%pip install --upgrade --quiet  langchain langchain-openai deepeval"
    ]
   },
   {
@@ -215,8 +215,8 @@
    "source": [
     "import requests\n",
     "from langchain.chains import RetrievalQA\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import TextLoader\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAI, OpenAIEmbeddings\n",
     "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",

docs/docs/integrations/callbacks/uptrain.ipynb

@@ -1,421 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a target=\"_blank\" href=\"https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/docs/integrations/callbacks/uptrain.ipynb\">\n",
-    "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
-    "</a>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# UpTrain\n",
-    "\n",
-    "> UpTrain [[github](https://github.com/uptrain-ai/uptrain) || [website](https://uptrain.ai/) || [docs](https://docs.uptrain.ai/getting-started/introduction)] is an open-source platform to evaluate and improve LLM applications. It provides grades for 20+ preconfigured checks (covering language, code, embedding use cases), performs root cause analyses on instances of failure cases and provides guidance for resolving them."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## UpTrain Callback Handler\n",
-    "\n",
-    "This notebook showcases the UpTrain callback handler seamlessly integrating into your pipeline, facilitating diverse evaluations. We have chosen a few evaluations that we deemed apt for evaluating the chains. These evaluations run automatically, with results displayed in the output. More details on UpTrain's evaluations can be found [here](https://github.com/uptrain-ai/uptrain?tab=readme-ov-file#pre-built-evaluations-we-offer-). \n",
-    "\n",
-    "Selected retievers from Langchain are highlighted for demonstration:\n",
-    "\n",
-    "### 1. **Vanilla RAG**:\n",
-    "RAG plays a crucial role in retrieving context and generating responses. To ensure its performance and response quality, we conduct the following evaluations:\n",
-    "\n",
-    "- **[Context Relevance](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-relevance)**: Determines if the context extracted from the query is relevant to the response.\n",
-    "- **[Factual Accuracy](https://docs.uptrain.ai/predefined-evaluations/context-awareness/factual-accuracy)**: Assesses if the LLM is hallcuinating or providing incorrect information.\n",
-    "- **[Response Completeness](https://docs.uptrain.ai/predefined-evaluations/response-quality/response-completeness)**: Checks if the response contains all the information requested by the query.\n",
-    "\n",
-    "### 2. **Multi Query Generation**:\n",
-    "MultiQueryRetriever creates multiple variants of a question having a similar meaning to the original question. Given the complexity, we include the previous evaluations and add:\n",
-    "\n",
-    "- **[Multi Query Accuracy](https://docs.uptrain.ai/predefined-evaluations/query-quality/multi-query-accuracy)**: Assures that the multi-queries generated mean the same as the original query.\n",
-    "\n",
-    "### 3. **Context Compression and Reranking**:\n",
-    "Re-ranking involves reordering nodes based on relevance to the query and choosing top n nodes. Since the number of nodes can reduce once the re-ranking is complete, we perform the following evaluations:\n",
-    "\n",
-    "- **[Context Reranking](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-reranking)**: Checks if the order of re-ranked nodes is more relevant to the query than the original order.\n",
-    "- **[Context Conciseness](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-conciseness)**: Examines whether the reduced number of nodes still provides all the required information.\n",
-    "\n",
-    "These evaluations collectively ensure the robustness and effectiveness of the RAG, MultiQueryRetriever, and the Reranking process in the chain."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Install Dependencies"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install -qU langchain langchain_openai uptrain faiss-cpu flashrank"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "NOTE: that you can also install `faiss-gpu` instead of `faiss-cpu` if you want to use the GPU enabled version of the library."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Import Libraries"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from getpass import getpass\n",
-    "\n",
-    "from langchain.chains import RetrievalQA\n",
-    "from langchain.retrievers import ContextualCompressionRetriever\n",
-    "from langchain.retrievers.document_compressors import FlashrankRerank\n",
-    "from langchain.retrievers.multi_query import MultiQueryRetriever\n",
-    "from langchain_community.callbacks.uptrain_callback import UpTrainCallbackHandler\n",
-    "from langchain_community.document_loaders import TextLoader\n",
-    "from langchain_community.vectorstores import FAISS\n",
-    "from langchain_core.output_parsers.string import StrOutputParser\n",
-    "from langchain_core.prompts.chat import ChatPromptTemplate\n",
-    "from langchain_core.runnables.passthrough import RunnablePassthrough\n",
-    "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
-    "from langchain_text_splitters import (\n",
-    "    RecursiveCharacterTextSplitter,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load the documents"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "loader = TextLoader(\"../../modules/state_of_the_union.txt\")\n",
-    "documents = loader.load()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Split the document into chunks"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
-    "chunks = text_splitter.split_documents(documents)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create the retriever"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "embeddings = OpenAIEmbeddings()\n",
-    "db = FAISS.from_documents(chunks, embeddings)\n",
-    "retriever = db.as_retriever()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Define the LLM"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = ChatOpenAI(temperature=0, model=\"gpt-4\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Set the openai API key\n",
-    "This key is required to perform the evaluations. UpTrain uses the GPT models to evaluate the responses generated by the LLM."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "OPENAI_API_KEY = getpass()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setup\n",
-    "\n",
-    "For each of the retrievers below, it is better to define the callback handler again to avoid interference. You can choose between the following options for evaluating using UpTrain:\n",
-    "\n",
-    "### 1. **UpTrain's Open-Source Software (OSS)**: \n",
-    "You can use the open-source evaluation service to evaluate your model.\n",
-    "In this case, you will need to provie an OpenAI API key. You can get yours [here](https://platform.openai.com/account/api-keys).\n",
-    "\n",
-    "Parameters:\n",
-    "- key_type=\"openai\"\n",
-    "- api_key=\"OPENAI_API_KEY\"\n",
-    "- project_name_prefix=\"PROJECT_NAME_PREFIX\"\n",
-    "\n",
-    "\n",
-    "### 2. **UpTrain Managed Service and Dashboards**: \n",
-    "You can create a free UpTrain account [here](https://uptrain.ai/) and get free trial credits. If you want more trial credits, [book a call with the maintainers of UpTrain here](https://calendly.com/uptrain-sourabh/30min).\n",
-    "\n",
-    "UpTrain Managed service provides:\n",
-    "1. Dashboards with advanced drill-down and filtering options\n",
-    "1. Insights and common topics among failing cases\n",
-    "1. Observability and real-time monitoring of production data\n",
-    "1. Regression testing via seamless integration with your CI/CD pipelines\n",
-    "\n",
-    "The notebook contains some screenshots of the dashboards and the insights that you can get from the UpTrain managed service.\n",
-    "\n",
-    "Parameters:\n",
-    "- key_type=\"uptrain\"\n",
-    "- api_key=\"UPTRAIN_API_KEY\"\n",
-    "- project_name_prefix=\"PROJECT_NAME_PREFIX\"\n",
-    "\n",
-    "\n",
-    "**Note:** The `project_name_prefix` will be used as prefix for the project names in the UpTrain dashboard. These will be different for different types of evals. For example, if you set project_name_prefix=\"langchain\" and perform the multi_query evaluation, the project name will be \"langchain_multi_query\"."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 1. Vanilla RAG"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "UpTrain callback handler will automatically capture the query, context and response once generated and will run the following three evaluations *(Graded from 0 to 1)* on the response:\n",
-    "- **[Context Relevance](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-relevance)**: Check if the context extractedfrom the query is relevant to the response.\n",
-    "- **[Factual Accuracy](https://docs.uptrain.ai/predefined-evaluations/context-awareness/factual-accuracy)**: Check how factually accurate the response is.\n",
-    "- **[Response Completeness](https://docs.uptrain.ai/predefined-evaluations/response-quality/response-completeness)**: Check if the response contains all the information that the query is asking for."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create the RAG prompt\n",
-    "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",
-    "{context}\n",
-    "Question: {question}\n",
-    "\"\"\"\n",
-    "rag_prompt_text = ChatPromptTemplate.from_template(template)\n",
-    "\n",
-    "# Create the chain\n",
-    "chain = (\n",
-    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
-    "    | rag_prompt_text\n",
-    "    | llm\n",
-    "    | StrOutputParser()\n",
-    ")\n",
-    "\n",
-    "# Create the uptrain callback handler\n",
-    "uptrain_callback = UpTrainCallbackHandler(key_type=\"openai\", api_key=OPENAI_API_KEY)\n",
-    "config = {\"callbacks\": [uptrain_callback]}\n",
-    "\n",
-    "# Invoke the chain with a query\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = chain.invoke(query, config=config)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 2. Multi Query Generation\n",
-    "\n",
-    "The **MultiQueryRetriever** is used to tackle the problem that the RAG pipeline might not return the best set of documents based on the query. It generates multiple queries that mean the same as the original query and then fetches documents for each.\n",
-    "\n",
-    "To evluate this retriever, UpTrain will run the following evaluation:\n",
-    "- **[Multi Query Accuracy](https://docs.uptrain.ai/predefined-evaluations/query-quality/multi-query-accuracy)**: Checks if the multi-queries generated mean the same as the original query."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m2024-04-10 14:09:15.887\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate_on_server\u001b[0m:\u001b[36m376\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n",
-      "\u001b[32m2024-04-10 14:09:21.367\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m365\u001b[0m - \u001b[1mLocal server not running, start the server to log data and visualize in the dashboard!\u001b[0m\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Question: What did the president say about Ketanji Brown Jackson\n",
-      "Multi Queries:\n",
-      "  - How did the president comment on Ketanji Brown Jackson?\n",
-      "  - What were the president's remarks regarding Ketanji Brown Jackson?\n",
-      "  - What statements has the president made about Ketanji Brown Jackson?\n",
-      "\n",
-      "Multi Query Accuracy Score: 1.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\u001b[32m2024-04-10 14:09:29.142\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate_on_server\u001b[0m:\u001b[36m376\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n",
-      "\u001b[32m2024-04-10 14:09:53.095\u001b[0m | \u001b[1mINFO    \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m365\u001b[0m - \u001b[1mLocal server not running, start the server to log data and visualize in the dashboard!\u001b[0m\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "Question: What did the president say about Ketanji Brown Jackson\n",
-      "Response: The president mentioned that he had nominated Ketanji Brown Jackson to serve on the United States Supreme Court 4 days ago. He described her as one of the nation's top legal minds who will continue Justice Breyer’s legacy of excellence. He also mentioned that she is a former top litigator in private practice, a former federal public defender, and comes from a family of public school educators and police officers. Since her nomination, she has received a broad range of support, including from the Fraternal Order of Police and former judges appointed by both Democrats and Republicans.\n",
-      "\n",
-      "Context Relevance Score: 1.0\n",
-      "Factual Accuracy Score: 1.0\n",
-      "Response Completeness Score: 1.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Create the retriever\n",
-    "multi_query_retriever = MultiQueryRetriever.from_llm(retriever=retriever, llm=llm)\n",
-    "\n",
-    "# Create the uptrain callback\n",
-    "uptrain_callback = UpTrainCallbackHandler(key_type=\"openai\", api_key=OPENAI_API_KEY)\n",
-    "config = {\"callbacks\": [uptrain_callback]}\n",
-    "\n",
-    "# Create the RAG prompt\n",
-    "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",
-    "{context}\n",
-    "Question: {question}\n",
-    "\"\"\"\n",
-    "rag_prompt_text = ChatPromptTemplate.from_template(template)\n",
-    "\n",
-    "chain = (\n",
-    "    {\"context\": multi_query_retriever, \"question\": RunnablePassthrough()}\n",
-    "    | rag_prompt_text\n",
-    "    | llm\n",
-    "    | StrOutputParser()\n",
-    ")\n",
-    "\n",
-    "# Invoke the chain with a query\n",
-    "question = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = chain.invoke(question, config=config)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 3. Context Compression and Reranking\n",
-    "\n",
-    "The reranking process involves reordering nodes based on relevance to the query and choosing the top n nodes. Since the number of nodes can reduce once the reranking is complete, we perform the following evaluations:\n",
-    "- **[Context Reranking](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-reranking)**: Check if the order of re-ranked nodes is more relevant to the query than the original order.\n",
-    "- **[Context Conciseness](https://docs.uptrain.ai/predefined-evaluations/context-awareness/context-conciseness)**: Check if the reduced number of nodes still provides all the required information."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create the retriever\n",
-    "compressor = FlashrankRerank()\n",
-    "compression_retriever = ContextualCompressionRetriever(\n",
-    "    base_compressor=compressor, base_retriever=retriever\n",
-    ")\n",
-    "\n",
-    "# Create the chain\n",
-    "chain = RetrievalQA.from_chain_type(llm=llm, retriever=compression_retriever)\n",
-    "\n",
-    "# Create the uptrain callback\n",
-    "uptrain_callback = UpTrainCallbackHandler(key_type=\"openai\", api_key=OPENAI_API_KEY)\n",
-    "config = {\"callbacks\": [uptrain_callback]}\n",
-    "\n",
-    "# Invoke the chain with a query\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "result = chain.invoke(query, config=config)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/chat/azure_chat_openai.ipynb

@@ -19,85 +19,59 @@
     "\n",
     ">[Azure OpenAI Service](https://learn.microsoft.com/en-us/azure/ai-services/openai/overview) provides REST API access to OpenAI's powerful language models including the GPT-4, GPT-3.5-Turbo, and Embeddings model series. These models can be easily adapted to your specific task including but not limited to content generation, summarization, semantic search, and natural language to code translation. Users can access the service through REST APIs, Python SDK, or a web-based interface in the Azure OpenAI Studio.\n",
     "\n",
-    "This notebook goes over how to connect to an Azure-hosted OpenAI endpoint. First, we need to install the `langchain-openai` package."
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "id": "d83ba7de",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
-   "source": [
-    "%pip install -qU langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e39133c8",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
-   "source": [
-    "Next, let's set some environment variables to help us connect to the Azure OpenAI service. You can find these values in the Azure portal."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "1d8d73bd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"AZURE_OPENAI_API_KEY\"] = \"...\"\n",
-    "os.environ[\"AZURE_OPENAI_ENDPOINT\"] = \"https://<your-endpoint>.openai.azure.com/\"\n",
-    "os.environ[\"AZURE_OPENAI_API_VERSION\"] = \"2023-06-01-preview\"\n",
-    "os.environ[\"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"] = \"chat\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e7b160f8",
-   "metadata": {},
-   "source": [
-    "Next, let's construct our model and chat with it:"
+    "This notebook goes over how to connect to an Azure-hosted OpenAI endpoint. We recommend having version `openai>=1` installed."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
-   "id": "cbe4bb58-ba13-4355-8af9-cd990dc47a64",
+   "id": "96164b42",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_core.messages import HumanMessage\n",
-    "from langchain_openai import AzureChatOpenAI\n",
+    "import os\n",
     "\n",
-    "model = AzureChatOpenAI(\n",
-    "    openai_api_version=os.environ[\"AZURE_OPENAI_API_VERSION\"],\n",
-    "    azure_deployment=os.environ[\"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"],\n",
-    ")"
+    "from langchain_core.messages import HumanMessage\n",
+    "from langchain_openai import AzureChatOpenAI"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
+   "id": "cbe4bb58-ba13-4355-8af9-cd990dc47a64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"AZURE_OPENAI_API_KEY\"] = \"...\"\n",
+    "os.environ[\"AZURE_OPENAI_ENDPOINT\"] = \"https://<your-endpoint>.openai.azure.com/\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "8161278f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = AzureChatOpenAI(\n",
+    "    openai_api_version=\"2023-05-15\",\n",
+    "    azure_deployment=\"your-deployment-name\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
    "id": "99509140",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=\"J'adore programmer.\", response_metadata={'token_usage': {'completion_tokens': 6, 'prompt_tokens': 19, 'total_tokens': 25}, 'model_name': 'gpt-35-turbo', 'system_fingerprint': None, 'prompt_filter_results': [{'prompt_index': 0, 'content_filter_results': {'hate': {'filtered': False, 'severity': 'safe'}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}}}], 'finish_reason': 'stop', 'logprobs': None, 'content_filter_results': {'hate': {'filtered': False, 'severity': 'safe'}, 'self_harm': {'filtered': False, 'severity': 'safe'}, 'sexual': {'filtered': False, 'severity': 'safe'}, 'violence': {'filtered': False, 'severity': 'safe'}}}, id='run-25ed88db-38f2-4b0c-a943-a03f217711a9-0')"
+       "AIMessage(content=\"J'adore la programmation.\")"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -106,7 +80,7 @@
     "message = HumanMessage(\n",
     "    content=\"Translate this sentence from English to French. I love programming.\"\n",
     ")\n",
-    "model.invoke([message])"
+    "model([message])"
    ]
   },
   {
@@ -122,7 +96,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "id": "0531798a",
    "metadata": {},
    "outputs": [],
@@ -132,29 +106,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "aceddb72",
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Total Cost (USD): $0.000041\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "model = AzureChatOpenAI(\n",
-    "    openai_api_version=os.environ[\"AZURE_OPENAI_API_VERSION\"],\n",
-    "    azure_deployment=os.environ[\n",
-    "        \"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"\n",
-    "    ],  # in Azure, this deployment has version 0613 - input and output tokens are counted separately\n",
+    "    openai_api_version=\"2023-05-15\",\n",
+    "    azure_deployment=\"gpt-35-turbo\",  # in Azure, this deployment has version 0613 - input and output tokens are counted separately\n",
     ")\n",
     "with get_openai_callback() as cb:\n",
-    "    model.invoke([message])\n",
+    "    model([message])\n",
     "    print(\n",
     "        f\"Total Cost (USD): ${format(cb.total_cost, '.6f')}\"\n",
     "    )  # without specifying the model version, flat-rate 0.002 USD per 1k input and output tokens is used"
@@ -170,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 17,
    "id": "8d5e54e9",
    "metadata": {},
    "outputs": [
@@ -183,13 +147,13 @@
     }
    ],
    "source": [
-    "model0301 = AzureChatOpenAI(\n",
-    "    openai_api_version=os.environ[\"AZURE_OPENAI_API_VERSION\"],\n",
-    "    azure_deployment=os.environ[\"AZURE_OPENAI_CHAT_DEPLOYMENT_NAME\"],\n",
-    "    model_version=\"0301\",\n",
+    "model0613 = AzureChatOpenAI(\n",
+    "    openai_api_version=\"2023-05-15\",\n",
+    "    deployment_name=\"gpt-35-turbo\",\n",
+    "    model_version=\"0613\",\n",
     ")\n",
     "with get_openai_callback() as cb:\n",
-    "    model0301.invoke([message])\n",
+    "    model0613([message])\n",
     "    print(f\"Total Cost (USD): ${format(cb.total_cost, '.6f')}\")"
    ]
   }
@@ -210,7 +174,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/bedrock.ipynb

@@ -3,14 +3,10 @@
   {
    "cell_type": "raw",
    "id": "fbc66410",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
+   "metadata": {},
    "source": [
     "---\n",
-    "sidebar_label: Bedrock\n",
+    "sidebar_label: Bedrock Chat\n",
     "---"
    ]
   },
@@ -19,7 +15,7 @@
    "id": "bf733a38-db84-4363-89e2-de6735c37230",
    "metadata": {},
    "source": [
-    "# ChatBedrock\n",
+    "# BedrockChat\n",
     "\n",
     ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of \n",
     "> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, \n",
@@ -34,53 +30,42 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "d51edc81",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "%pip install --upgrade --quiet  langchain-aws"
+    "%pip install --upgrade --quiet  boto3"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "d4a7c55d-b235-4ca4-a579-c90cc9570da9",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain_aws import ChatBedrock\n",
+    "from langchain_community.chat_models import BedrockChat\n",
     "from langchain_core.messages import HumanMessage"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 2,
    "id": "70cf04e8-423a-4ff6-8b09-f11fb711c817",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "chat = ChatBedrock(\n",
-    "    model_id=\"anthropic.claude-3-sonnet-20240229-v1:0\",\n",
-    "    model_kwargs={\"temperature\": 0.1},\n",
-    ")"
+    "chat = BedrockChat(model_id=\"anthropic.claude-v2\", model_kwargs={\"temperature\": 0.1})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 3,
    "id": "8199ef8f-eb8b-4253-9ea0-6c24a013ca4c",
    "metadata": {
     "tags": []
@@ -89,10 +74,10 @@
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=\"Voici la traduction en français :\\n\\nJ'aime la programmation.\", additional_kwargs={'usage': {'prompt_tokens': 20, 'completion_tokens': 21, 'total_tokens': 41}}, response_metadata={'model_id': 'anthropic.claude-3-sonnet-20240229-v1:0', 'usage': {'prompt_tokens': 20, 'completion_tokens': 21, 'total_tokens': 41}}, id='run-994f0362-0e50-4524-afad-3c4f5bb11328-0')"
+       "AIMessage(content=\" Voici la traduction en français : J'adore programmer.\", additional_kwargs={}, example=False)"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -103,7 +88,7 @@
     "        content=\"Translate this sentence from English to French. I love programming.\"\n",
     "    )\n",
     "]\n",
-    "chat.invoke(messages)"
+    "chat(messages)"
    ]
   },
   {
@@ -112,30 +97,39 @@
    "id": "a4a4f4d4",
    "metadata": {},
    "source": [
-    "### Streaming\n",
-    "\n",
-    "To stream responses, you can use the runnable `.stream()` method."
+    "### For BedrockChat with Streaming"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
+   "id": "c253883f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "\n",
+    "chat = BedrockChat(\n",
+    "    model_id=\"anthropic.claude-v2\",\n",
+    "    streaming=True,\n",
+    "    callbacks=[StreamingStdOutCallbackHandler()],\n",
+    "    model_kwargs={\"temperature\": 0.1},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "id": "d9e52838",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Voici la traduction en français :\n",
-      "\n",
-      "J'aime la programmation."
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "for chunk in chat.stream(messages):\n",
-    "    print(chunk.content, end=\"\", flush=True)"
+    "messages = [\n",
+    "    HumanMessage(\n",
+    "        content=\"Translate this sentence from English to French. I love programming.\"\n",
+    "    )\n",
+    "]\n",
+    "chat(messages)"
    ]
   }
  ],
@@ -155,7 +149,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/google_vertex_ai_palm.ipynb

@@ -51,7 +51,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -261,46 +261,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pprint import pprint\n",
-    "\n",
-    "from langchain_core.messages import HumanMessage\n",
-    "from langchain_google_vertexai import HarmBlockThreshold, HarmCategory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'citation_metadata': None,\n",
-      " 'is_blocked': False,\n",
-      " 'safety_ratings': [{'blocked': False,\n",
-      "                     'category': 'HARM_CATEGORY_HATE_SPEECH',\n",
+      "{'is_blocked': False,\n",
+      " 'safety_ratings': [{'category': 'HARM_CATEGORY_HARASSMENT',\n",
       "                     'probability_label': 'NEGLIGIBLE'},\n",
-      "                    {'blocked': False,\n",
-      "                     'category': 'HARM_CATEGORY_DANGEROUS_CONTENT',\n",
+      "                    {'category': 'HARM_CATEGORY_HATE_SPEECH',\n",
       "                     'probability_label': 'NEGLIGIBLE'},\n",
-      "                    {'blocked': False,\n",
-      "                     'category': 'HARM_CATEGORY_HARASSMENT',\n",
+      "                    {'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT',\n",
       "                     'probability_label': 'NEGLIGIBLE'},\n",
-      "                    {'blocked': False,\n",
-      "                     'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT',\n",
-      "                     'probability_label': 'NEGLIGIBLE'}],\n",
-      " 'usage_metadata': {'candidates_token_count': 6,\n",
-      "                    'prompt_token_count': 12,\n",
-      "                    'total_token_count': 18}}\n"
+      "                    {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT',\n",
+      "                     'probability_label': 'NEGLIGIBLE'}]}\n"
      ]
     }
    ],
    "source": [
+    "from pprint import pprint\n",
+    "\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "from langchain_google_vertexai import ChatVertexAI, HarmBlockThreshold, HarmCategory\n",
+    "\n",
     "human = \"Translate this sentence from English to French. I love programming.\"\n",
     "messages = [HumanMessage(content=human)]\n",
     "\n",
@@ -330,21 +315,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'errors': (),\n",
-      " 'grounding_metadata': {'citations': [], 'search_queries': []},\n",
-      " 'is_blocked': False,\n",
-      " 'safety_attributes': [{'Derogatory': 0.1, 'Insult': 0.1, 'Sexual': 0.2}],\n",
-      " 'usage_metadata': {'candidates_billable_characters': 88.0,\n",
-      "                    'candidates_token_count': 24.0,\n",
-      "                    'prompt_billable_characters': 58.0,\n",
-      "                    'prompt_token_count': 12.0}}\n"
+      "{'is_blocked': False,\n",
+      " 'safety_attributes': {'Derogatory': 0.1,\n",
+      "                       'Finance': 0.3,\n",
+      "                       'Insult': 0.1,\n",
+      "                       'Sexual': 0.1}}\n"
      ]
     }
    ],
@@ -359,149 +341,40 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Tool calling (a.k.a. function calling) with Gemini\n",
+    "## Function Calling with Gemini\n",
     "\n",
-    "We can pass tool definitions to Gemini models to get the model to invoke those tools when appropriate. This is useful not only for LLM-powered tool use but also for getting structured outputs out of models more generally.\n",
-    "\n",
-    "With `ChatVertexAI.bind_tools()`, we can easily pass in Pydantic classes, dict schemas, LangChain tools, or even functions as tools to the model. Under the hood these are converted to a Gemini tool schema, which looks like:\n",
-    "```python\n",
-    "{\n",
-    "    \"name\": \"...\",  # tool name\n",
-    "    \"description\": \"...\",  # tool description\n",
-    "    \"parameters\": {...}  # tool input schema as JSONSchema\n",
-    "}\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='', additional_kwargs={'function_call': {'name': 'GetWeather', 'arguments': '{\"location\": \"San Francisco, CA\"}'}}, response_metadata={'is_blocked': False, 'safety_ratings': [{'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_HARASSMENT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT', 'probability_label': 'NEGLIGIBLE', 'blocked': False}], 'citation_metadata': None, 'usage_metadata': {'prompt_token_count': 41, 'candidates_token_count': 7, 'total_token_count': 48}}, id='run-05e760dc-0682-4286-88e1-5b23df69b083-0', tool_calls=[{'name': 'GetWeather', 'args': {'location': 'San Francisco, CA'}, 'id': 'cd2499c4-4513-4059-bfff-5321b6e922d0'}])"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.pydantic_v1 import BaseModel, Field\n",
-    "\n",
-    "\n",
-    "class GetWeather(BaseModel):\n",
-    "    \"\"\"Get the current weather in a given location\"\"\"\n",
-    "\n",
-    "    location: str = Field(..., description=\"The city and state, e.g. San Francisco, CA\")\n",
-    "\n",
-    "\n",
-    "llm = ChatVertexAI(model_name=\"gemini-pro\", temperature=0)\n",
-    "llm_with_tools = llm.bind_tools([GetWeather])\n",
-    "ai_msg = llm_with_tools.invoke(\n",
-    "    \"what is the weather like in San Francisco\",\n",
-    ")\n",
-    "ai_msg"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The tool calls can be access via the `AIMessage.tool_calls` attribute, where they are extracted in a model-agnostic format:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'name': 'GetWeather',\n",
-       "  'args': {'location': 'San Francisco, CA'},\n",
-       "  'id': 'cd2499c4-4513-4059-bfff-5321b6e922d0'}]"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ai_msg.tool_calls"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For a complete guide on tool calling [head here](/docs/modules/model_io/chat/function_calling/)."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Structured outputs\n",
-    "\n",
-    "Many applications require structured model outputs. Tool calling makes it much easier to do this reliably. The [with_structured_outputs](https://api.python.langchain.com/en/latest/chat_models/langchain_google_vertexai.chat_models.ChatVertexAI.html) constructor provides a simple interface built on top of tool calling for getting structured outputs out of a model. For a complete guide on structured outputs [head here](/docs/modules/model_io/chat/structured_output/).\n",
-    "\n",
-    "###  ChatVertexAI.with_structured_outputs()\n",
-    "\n",
-    "To get structured outputs from our Gemini model all we need to do is to specify a desired schema, either as a Pydantic class or as a JSON schema, "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Person(name='Stefan', age=13)"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "class Person(BaseModel):\n",
-    "    \"\"\"Save information about a person.\"\"\"\n",
-    "\n",
-    "    name: str = Field(..., description=\"The person's name.\")\n",
-    "    age: int = Field(..., description=\"The person's age.\")\n",
-    "\n",
-    "\n",
-    "structured_llm = llm.with_structured_output(Person)\n",
-    "structured_llm.invoke(\"Stefan is already 13 years old\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### [Legacy] Using `create_structured_runnable()`\n",
-    "\n",
-    "The legacy wasy to get structured outputs is using the `create_structured_runnable` constructor:"
+    "We can call Gemini models with tools."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "MyModel(name='Erick', age=27)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
+    "from langchain.pydantic_v1 import BaseModel\n",
     "from langchain_google_vertexai import create_structured_runnable\n",
     "\n",
-    "chain = create_structured_runnable(Person, llm)\n",
+    "llm = ChatVertexAI(model_name=\"gemini-pro\")\n",
+    "\n",
+    "\n",
+    "class MyModel(BaseModel):\n",
+    "    name: str\n",
+    "    age: int\n",
+    "\n",
+    "\n",
+    "chain = create_structured_runnable(MyModel, llm)\n",
     "chain.invoke(\"My name is Erick and I'm 27 years old\")"
    ]
   },
@@ -611,21 +484,11 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "poetry-venv-2",
-   "language": "python",
-   "name": "poetry-venv-2"
+   "display_name": "",
+   "name": ""
   },
   "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "name": "python"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/octoai.ipynb

@@ -1,112 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# ChatOctoAI\n",
-    "\n",
-    "[OctoAI](https://docs.octoai.cloud/docs) offers easy access to efficient compute and enables users to integrate their choice of AI models into applications. The `OctoAI` compute service helps you run, tune, and scale AI applications easily.\n",
-    "\n",
-    "This notebook demonstrates the use of `langchain.chat_models.ChatOctoAI` for [OctoAI endpoints](https://octoai.cloud/text).\n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "To run our example app, there are two simple steps to take:\n",
-    "\n",
-    "1. Get an API Token from [your OctoAI account page](https://octoai.cloud/settings).\n",
-    "   \n",
-    "2. Paste your API token in in the code cell below or use the `octoai_api_token` keyword argument.\n",
-    "\n",
-    "Note: If you want to use a different model than the [available models](https://octoai.cloud/text?selectedTags=Chat), you can containerize the model and make a custom OctoAI endpoint yourself, by following [Build a Container from Python](https://octo.ai/docs/bring-your-own-model/advanced-build-a-container-from-scratch-in-python) and [Create a Custom Endpoint from a Container](https://octo.ai/docs/bring-your-own-model/create-custom-endpoints-from-a-container/create-custom-endpoints-from-a-container) and then updating your `OCTOAI_API_BASE` environment variable.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"OCTOAI_API_TOKEN\"] = \"OCTOAI_API_TOKEN\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.chat_models import ChatOctoAI\n",
-    "from langchain_core.messages import HumanMessage, SystemMessage"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chat = ChatOctoAI(max_tokens=300, model_name=\"mixtral-8x7b-instruct\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [\n",
-    "    SystemMessage(content=\"You are a helpful assistant.\"),\n",
-    "    HumanMessage(content=\"Tell me about Leonardo da Vinci briefly.\"),\n",
-    "]\n",
-    "print(chat(messages).content)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Leonardo da Vinci (1452-1519) was an Italian polymath who is often considered one of the greatest painters in history. However, his genius extended far beyond art. He was also a scientist, inventor, mathematician, engineer, anatomist, geologist, and cartographer.\n",
-    "\n",
-    "Da Vinci is best known for his paintings such as the Mona Lisa, The Last Supper, and The Virgin of the Rocks. His scientific studies were ahead of his time, and his notebooks contain detailed drawings and descriptions of various machines, human anatomy, and natural phenomena.\n",
-    "\n",
-    "Despite never receiving a formal education, da Vinci's insatiable curiosity and observational skills made him a pioneer in many fields. His work continues to inspire and influence artists, scientists, and thinkers today."
-   ]
-  }
- ],
- "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.7"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "97697b63fdcee0a640856f91cb41326ad601964008c341809e43189d1cab1047"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

docs/docs/integrations/chat/solar.ipynb

@@ -0,0 +1,80 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a9667088-04e1-4f67-8221-a0072a2d635f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-06T17:04:59.273702Z",
+     "iopub.status.busy": "2024-03-06T17:04:59.272602Z",
+     "iopub.status.idle": "2024-03-06T17:05:00.129177Z",
+     "shell.execute_reply": "2024-03-06T17:05:00.124594Z",
+     "shell.execute_reply.started": "2024-03-06T17:04:59.273646Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='저는 대형 언어 모델 프로젝트를 구축하고 싶습니다.')"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"SOLAR_API_KEY\"] = \"SOLAR_API_KEY\"\n",
+    "\n",
+    "from langchain_community.chat_models.solar import SolarChat\n",
+    "from langchain_core.messages import HumanMessage, SystemMessage\n",
+    "\n",
+    "chat = SolarChat(max_tokens=1024)\n",
+    "\n",
+    "messages = [\n",
+    "    SystemMessage(\n",
+    "        content=\"You are a helpful assistant who translates English to Korean.\"\n",
+    "    ),\n",
+    "    HumanMessage(\n",
+    "        content=\"Translate this sentence from English to Korean. I want to build a project of large language model.\"\n",
+    "    ),\n",
+    "]\n",
+    "\n",
+    "chat.invoke(messages)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8cb792fe-2844-4969-a9e9-f4c0f97b1699",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/integrations/chat/upstage.ipynb

@@ -1,157 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "910f5772b6af13c9",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "---\n",
-    "sidebar_label: Upstage\n",
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "433f5422ad8e1efa",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "# ChatUpstage\n",
-    "\n",
-    "This notebook covers how to get started with Upstage chat models.\n",
-    "\n",
-    "## Installation\n",
-    "\n",
-    "Install `langchain-upstage` package.\n",
-    "\n",
-    "```bash\n",
-    "pip install -U langchain-upstage\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b3c5c4627fe95eae",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "## Environment Setup\n",
-    "\n",
-    "Make sure to set the following environment variables:\n",
-    "\n",
-    "- `UPSTAGE_API_KEY`: Your Upstage API key from [Upstage console](https://console.upstage.ai/).\n",
-    "\n",
-    "## Usage"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "20a0067b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"UPSTAGE_API_KEY\"] = \"YOUR_API_KEY\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8a4d650d76a33494",
-   "metadata": {
-    "collapsed": false,
-    "is_executing": true
-   },
-   "outputs": [],
-   "source": [
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_upstage import ChatUpstage\n",
-    "\n",
-    "chat = ChatUpstage()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a1679b5cafaf88b9",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# using chat invoke\n",
-    "chat.invoke(\"Hello, how are you?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "698a788a63b5c3e5",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# using chat stream\n",
-    "for m in chat.stream(\"Hello, how are you?\"):\n",
-    "    print(m)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "36f8a703",
-   "metadata": {},
-   "source": [
-    "## Chaining"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "efa06617e5d4f6b2",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# using chain\n",
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\"system\", \"You are a helpful assistant that translates English to French.\"),\n",
-    "        (\"human\", \"Translate this sentence from English to French. {english_text}.\"),\n",
-    "    ]\n",
-    ")\n",
-    "chain = prompt | chat\n",
-    "\n",
-    "chain.invoke({\"english_text\": \"Hello, how are you?\"})"
-   ]
-  }
- ],
- "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": "3.9.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/chat/zhipuai.ipynb

@@ -17,7 +17,9 @@
     "\n",
     "This notebook shows how to use [ZHIPU AI API](https://open.bigmodel.cn/dev/api) in LangChain with the langchain.chat_models.ChatZhipuAI.\n",
     "\n",
-    ">[*GLM-4*](https://open.bigmodel.cn/) is a multi-lingual large language model aligned with human intent, featuring capabilities in Q&A, multi-turn dialogue, and code generation. The overall performance of the new generation base model GLM-4 has been significantly improved compared to the previous generation, supporting longer contexts; Stronger multimodality; Support faster inference speed, more concurrency, greatly reducing inference costs; Meanwhile, GLM-4 enhances the capabilities of intelligent agents.\n",
+    ">[*ZHIPU AI*](https://open.bigmodel.cn/) is a multi-lingual large language model aligned with human intent, featuring capabilities in Q&A, multi-turn dialogue, and code generation, developed on the foundation of the ChatGLM3. \n",
+    "\n",
+    ">It's co-developed with Tsinghua University's KEG Laboratory under the ChatGLM3 project, signifying a new era in dialogue pre-training models. The open-source [ChatGLM3](https://github.com/THUDM/ChatGLM3) variant boasts a robust foundation, comprehensive functional support, and widespread availability for both academic and commercial uses. \n",
     "\n",
     "## Getting started\n",
     "### Installation\n",
@@ -26,11 +28,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
-    "#!pip install --upgrade httpx httpx-sse PyJWT"
+    "%pip install --quiet httpx[socks]==0.24.1 httpx-sse PyJWT"
    ]
   },
   {
@@ -43,7 +45,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -61,13 +63,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"ZHIPUAI_API_KEY\"] = \"zhipuai_api_key\""
+    "zhipuai_api_key = \"your_api_key\""
    ]
   },
   {
@@ -80,11 +80,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "chat = ChatZhipuAI(\n",
+    "    api_key=zhipuai_api_key,\n",
     "    model=\"glm-4\",\n",
     "    temperature=0.5,\n",
     ")"
@@ -100,7 +101,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {
     "scrolled": true
    },
@@ -115,9 +116,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\" Formed from bits and bytes,\\nA virtual mind takes flight,\\nConversing, learning fast,\\nEmpathy and wisdom sought.\"\n"
+     ]
+    }
+   ],
    "source": [
     "response = chat(messages)\n",
     "print(response.content)  # Displays the AI-generated poem"
@@ -134,7 +143,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -144,11 +153,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
     "streaming_chat = ChatZhipuAI(\n",
+    "    api_key=zhipuai_api_key,\n",
     "    model=\"glm-4\",\n",
     "    temperature=0.5,\n",
     "    streaming=True,\n",
@@ -158,9 +168,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " Formed from data's embrace,\n",
+      "A digital soul to grace,\n",
+      "AI, our trusted guide,\n",
+      "Shaping minds, sides by side."
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\" Formed from data's embrace,\\nA digital soul to grace,\\nAI, our trusted guide,\\nShaping minds, sides by side.\")"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "streaming_chat(messages)"
    ]
@@ -175,11 +206,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
     "async_chat = ChatZhipuAI(\n",
+    "    api_key=zhipuai_api_key,\n",
     "    model=\"glm-4\",\n",
     "    temperature=0.5,\n",
     ")"
@@ -187,11 +219,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "generations=[[ChatGeneration(text=\" Formed from data's embrace,\\nA digital soul to grace,\\nAutomation's tender touch,\\nHarmony of man and machine.\", message=AIMessage(content=\" Formed from data's embrace,\\nA digital soul to grace,\\nAutomation's tender touch,\\nHarmony of man and machine.\"))]] llm_output={} run=[RunInfo(run_id=UUID('25fa687f-3961-4c63-b370-22f7647a4d42'))]\n"
+     ]
+    }
+   ],
    "source": [
     "response = await async_chat.agenerate([messages])\n",
     "print(response)"
@@ -199,58 +239,47 @@
   },
   {
    "cell_type": "markdown",
+   "metadata": {},
    "source": [
-    "### Using With Functions Call\n",
-    "\n",
-    "GLM-4 Model can be used with the function call as well，use the following code to run a simple LangChain json_chat_agent."
-   ],
-   "metadata": {
-    "collapsed": false
-   }
+    "### Role Play Model\n",
+    "Supports character role-playing based on personas, ultra-long multi-turn memory, and personalized dialogues for thousands of unique characters, widely applied in emotional companionship, game intelligent NPCs, virtual avatars for celebrities/stars/movie and TV IPs, digital humans/virtual anchors, text adventure games, and other anthropomorphic dialogue or gaming scenarios."
+   ]
   },
   {
    "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "os.environ[\"TAVILY_API_KEY\"] = \"tavily_api_key\""
-   ],
-   "metadata": {
-    "collapsed": false
-   },
-   "execution_count": null
+    "meta = {\n",
+    "    \"user_info\": \"My name is Lu Xingchen, a male, and a renowned director. I am also the collaborative director with Su Mengyuan. I specialize in directing movies with musical themes. Su Mengyuan respects me and regards me as a mentor and good friend.\",\n",
+    "    \"bot_info\": \"Su Mengyuan, whose real name is Su Yuanxin, is a popular domestic female singer and actress. She rose to fame quickly with her unique voice and exceptional stage presence after participating in a talent show, making her way into the entertainment industry. She is beautiful and charming, but her real allure lies in her talent and diligence. Su Mengyuan is a distinguished graduate of a music academy, skilled in songwriting, and has several popular original songs. Beyond her musical achievements, she is passionate about charity work, actively participating in public welfare activities, and spreading positive energy through her actions. In her work, she is very dedicated and immerses herself fully in her roles during filming, earning praise from industry professionals and love from fans. Despite being in the entertainment industry, she always maintains a low profile and a humble attitude, earning respect from her peers. In expression, Su Mengyuan likes to use 'we' and 'together,' emphasizing team spirit.\",\n",
+    "    \"bot_name\": \"Su Mengyuan\",\n",
+    "    \"user_name\": \"Lu Xingchen\",\n",
+    "}"
+   ]
   },
   {
    "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain import hub\n",
-    "from langchain.agents import AgentExecutor, create_json_chat_agent\n",
-    "from langchain_community.tools.tavily_search import TavilySearchResults\n",
-    "\n",
-    "tools = [TavilySearchResults(max_results=1)]\n",
-    "prompt = hub.pull(\"hwchase17/react-chat-json\")\n",
-    "llm = ChatZhipuAI(temperature=0.01, model=\"glm-4\")\n",
-    "\n",
-    "agent = create_json_chat_agent(llm, tools, prompt)\n",
-    "agent_executor = AgentExecutor(\n",
-    "    agent=agent, tools=tools, verbose=True, handle_parsing_errors=True\n",
-    ")"
-   ],
-   "metadata": {
-    "collapsed": false
-   },
-   "execution_count": null
-  },
-  {
-   "cell_type": "code",
-   "outputs": [],
-   "source": [
-    "agent_executor.invoke({\"input\": \"what is LangChain?\"})"
-   ],
-   "metadata": {
-    "collapsed": false
-   },
-   "execution_count": null
+    "messages = [\n",
+    "    AIMessage(\n",
+    "        content=\"(Narration: Su Mengyuan stars in a music-themed movie directed by Lu Xingchen. During filming, they have a disagreement over the performance of a particular scene.) Director, about this scene, I think we can try to start from the character's inner emotions to make the performance more authentic.\"\n",
+    "    ),\n",
+    "    HumanMessage(\n",
+    "        content=\"I understand your idea, but I believe that if we emphasize the inner emotions too much, it might overshadow the musical elements.\"\n",
+    "    ),\n",
+    "    AIMessage(\n",
+    "        content=\"Hmm, I understand. But the key to this scene is the character's emotional transformation. Could we try to express these emotions through music, so the audience can better feel the character's growth?\"\n",
+    "    ),\n",
+    "    HumanMessage(\n",
+    "        content=\"That sounds good. Let's try to combine the character's emotional transformation with the musical elements and see if we can achieve a better effect.\"\n",
+    "    ),\n",
+    "]"
+   ]
   }
  ],
  "metadata": {

docs/docs/integrations/document_loaders/glue_catalog.ipynb

@@ -1,118 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "id": "MwTWzDxYgbrR"
-   },
-   "source": [
-    "# Glue Catalog\n",
-    "\n",
-    "\n",
-    "The [AWS Glue Data Catalog](https://docs.aws.amazon.com/en_en/glue/latest/dg/catalog-and-crawler.html) is a centralized metadata repository that allows you to manage, access, and share metadata about your data stored in AWS. It acts as a metadata store for your data assets, enabling various AWS services and your applications to query and connect to the data they need efficiently.\n",
-    "\n",
-    "When you define data sources, transformations, and targets in AWS Glue, the metadata about these elements is stored in the Data Catalog. This includes information about data locations, schema definitions, runtime metrics, and more. It supports various data store types, such as Amazon S3, Amazon RDS, Amazon Redshift, and external databases compatible with JDBC. It is also directly integrated with Amazon Athena, Amazon Redshift Spectrum, and Amazon EMR, allowing these services to directly access and query the data.\n",
-    "\n",
-    "The Langchain GlueCatalogLoader will get the schema of all tables inside the given Glue database in the same format as Pandas dtype."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setting up\n",
-    "\n",
-    "- Follow [instructions to set up an AWS accoung](https://docs.aws.amazon.com/athena/latest/ug/setting-up.html).\n",
-    "- Install the boto3 library: `pip install boto3`\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "076NLjfngoWJ"
-   },
-   "outputs": [],
-   "source": [
-    "from langchain_community.document_loaders.glue_catalog import GlueCatalogLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "id": "XpMRQwU9gu44"
-   },
-   "outputs": [],
-   "source": [
-    "database_name = \"my_database\"\n",
-    "profile_name = \"my_profile\"\n",
-    "\n",
-    "loader = GlueCatalogLoader(\n",
-    "    database=database_name,\n",
-    "    profile_name=profile_name,\n",
-    ")\n",
-    "\n",
-    "schemas = loader.load()\n",
-    "print(schemas)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example with table filtering\n",
-    "\n",
-    "Table filtering allows you to selectively retrieve schema information for a specific subset of tables within a Glue database. Instead of loading the schemas for all tables, you can use the `table_filter` argument to specify exactly which tables you're interested in."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.document_loaders.glue_catalog import GlueCatalogLoader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "database_name = \"my_database\"\n",
-    "profile_name = \"my_profile\"\n",
-    "table_filter = [\"table1\", \"table2\", \"table3\"]\n",
-    "\n",
-    "loader = GlueCatalogLoader(\n",
-    "    database=database_name, profile_name=profile_name, table_filter=table_filter\n",
-    ")\n",
-    "\n",
-    "schemas = loader.load()\n",
-    "print(schemas)"
-   ]
-  }
- ],
- "metadata": {
-  "colab": {
-   "provenance": []
-  },
-  "kernelspec": {
-   "display_name": "Python 3",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

docs/docs/integrations/document_loaders/google_drive.ipynb

@@ -322,52 +322,6 @@
     "    print(doc.page_content.strip()[:60] + \"...\")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "7bde486a",
-   "metadata": {},
-   "source": [
-    "### Loading auth Identities\n",
-    "\n",
-    "Authorized identities for each file ingested by Google Drive Loader can be loaded along with metadata per Document."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e1d91045",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.document_loaders import GoogleDriveLoader\n",
-    "\n",
-    "loader = GoogleDriveLoader(\n",
-    "    folder_id=folder_id,\n",
-    "    load_auth=True,\n",
-    "    # Optional: configure whether to load authorized identities for each Document.\n",
-    ")\n",
-    "\n",
-    "doc = loader.load()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "83557b75",
-   "metadata": {},
-   "source": [
-    "You can pass load_auth=True, to add Google Drive document access identities to metadata."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "7ac1a43b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "doc[0].metadata"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "cd13d7d1-db7a-498d-ac98-76ccd9ad9019",
@@ -576,7 +530,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/document_loaders/microsoft_sharepoint.ipynb

@@ -21,7 +21,7 @@
     "7. To find your `Tenant Name` follow the instructions at this [document](https://learn.microsoft.com/en-us/azure/active-directory-b2c/tenant-management-read-tenant-name). Once you got this, just remove `.onmicrosoft.com` from the value and hold the rest as your `Tenant Name`.\n",
     "8. To obtain your `Collection ID` and `Subsite ID`, you will need your **SharePoint** `site-name`. Your `SharePoint` site URL has the following format `https://<tenant-name>.sharepoint.com/sites/<site-name>`. The last part of this URL is the `site-name`.\n",
     "9. To Get the Site `Collection ID`, hit this URL in the browser: `https://<tenant>.sharepoint.com/sites/<site-name>/_api/site/id` and copy the value of the `Edm.Guid` property.\n",
-    "10. To get the `Subsite ID` (or web ID) use: `https://<tenant>.sharepoint.com/sites/<site-name>/_api/web/id` and copy the value of the `Edm.Guid` property.\n",
+    "10. To get the `Subsite ID` (or web ID) use: `https://<tenant>.sharepoint.com/<site-name>/_api/web/id` and copy the value of the `Edm.Guid` property.\n",
     "11. The `SharePoint site ID` has the following format: `<tenant-name>.sharepoint.com,<Collection ID>,<subsite ID>`. You can hold that value to use in the next step.\n",
     "12. Visit the [Graph Explorer Playground](https://developer.microsoft.com/en-us/graph/graph-explorer) to obtain your `Document Library ID`. The first step is to ensure you are logged in with the account associated with your **SharePoint** site. Then you need to make a request to `https://graph.microsoft.com/v1.0/sites/<SharePoint site ID>/drive` and the response will return a payload with a field `id` that holds the ID of your `Document Library ID`.\n",
     "\n",
@@ -65,30 +65,6 @@
     "documents = loader.load()\n",
     "```\n",
     "\n",
-    "If you are receiving the error `Resource not found for the segment`, try using the `folder_id` instead of the folder path, which can be obtained from the [Microsoft Graph API](https://developer.microsoft.com/en-us/graph/graph-explorer)\n",
-    "\n",
-    "```python\n",
-    "loader = SharePointLoader(document_library_id=\"YOUR DOCUMENT LIBRARY ID\", auth_with_token=True\n",
-    "                          folder_id=\"<folder-id>\")\n",
-    "documents = loader.load()\n",
-    "```\n",
-    "\n",
-    "If you wish to load documents from the root directory, you can omit `folder_id`, `folder_path` and `documents_ids` and loader will load root directory.\n",
-    "```python\n",
-    "# loads documents from root directory\n",
-    "loader = SharePointLoader(document_library_id=\"YOUR DOCUMENT LIBRARY ID\", auth_with_token=True)\n",
-    "documents = loader.load()\n",
-    "```\n",
-    "\n",
-    "Combined with `recursive=True` you can simply load all documents from whole SharePoint:\n",
-    "```python\n",
-    "# loads documents from root directory\n",
-    "loader = SharePointLoader(document_library_id=\"YOUR DOCUMENT LIBRARY ID\",\n",
-    "                          recursive=True,\n",
-    "                          auth_with_token=True)\n",
-    "documents = loader.load()\n",
-    "```\n",
-    "\n",
     "#### 📑 Loading documents from a list of Documents IDs\n",
     "\n",
     "Another possibility is to provide a list of `object_id` for each document you want to load. For that, you will need to query the [Microsoft Graph API](https://developer.microsoft.com/en-us/graph/graph-explorer) to find all the documents ID that you are interested in. This [link](https://learn.microsoft.com/en-us/graph/api/resources/onedrive?view=graph-rest-1.0#commonly-accessed-resources) provides a list of endpoints that will be helpful to retrieve the documents ID.\n",

docs/docs/integrations/document_loaders/psychic.ipynb

@@ -39,7 +39,7 @@
    ],
    "source": [
     "# Uncomment this to install psychicapi if you don't already have it installed\n",
-    "!poetry run pip -q install psychicapi langchain-chroma"
+    "!poetry run pip -q install psychicapi"
    ]
   },
   {
@@ -78,7 +78,7 @@
    "outputs": [],
    "source": [
     "from langchain.chains import RetrievalQAWithSourcesChain\n",
-    "from langchain_chroma import Chroma\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAI, OpenAIEmbeddings\n",
     "from langchain_text_splitters import CharacterTextSplitter"
    ]

docs/docs/integrations/document_loaders/web_base.ipynb

@@ -7,9 +7,7 @@
    "source": [
     "# WebBaseLoader\n",
     "\n",
-    "This covers how to use `WebBaseLoader` to load all text from `HTML` webpages into a document format that we can use downstream. For more custom logic for loading webpages look at some child class examples such as `IMSDbLoader`, `AZLyricsLoader`, and `CollegeConfidentialLoader`. \n",
-    "\n",
-    "If you don't want to worry about website crawling, bypassing JS-blocking sites, and data cleaning, consider using `FireCrawlLoader`.\n"
+    "This covers how to use `WebBaseLoader` to load all text from `HTML` webpages into a document format that we can use downstream. For more custom logic for loading webpages look at some child class examples such as `IMSDbLoader`, `AZLyricsLoader`, and `CollegeConfidentialLoader`"
    ]
   },
   {
@@ -279,4 +277,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

docs/docs/integrations/document_transformers/cross_encoder_reranker.ipynb

@@ -175,7 +175,7 @@
    "source": [
     "## Uploading Hugging Face model to SageMaker endpoint\n",
     "\n",
-    "Here is a sample `inference.py` for creating an endpoint that works with `SagemakerEndpointCrossEncoder`. For more details with step-by-step guidance, refer to [this article](https://huggingface.co/blog/kchoe/deploy-any-huggingface-model-to-sagemaker). \n",
+    "Refer to [this article](https://www.philschmid.de/custom-inference-huggingface-sagemaker) for general guideline. Here is a simple `inference.py` for creating an endpoint that works with `SagemakerEndpointCrossEncoder`.\n",
     "\n",
     "It downloads Hugging Face model on the fly, so you do not need to keep the model artifacts such as `pytorch_model.bin` in your `model.tar.gz`."
    ]

docs/docs/integrations/document_transformers/openvino_rerank.ipynb

@@ -18,7 +18,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {
     "collapsed": false,
     "jupyter": {
@@ -28,7 +28,42 @@
      "is_executing": true
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
    "source": [
     "%pip install --upgrade-strategy eager \"optimum[openvino,nncf]\" --quiet\n",
     "%pip install --upgrade --quiet  faiss-cpu"
@@ -369,23 +404,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {
     "collapsed": false,
     "jupyter": {
      "outputs_hidden": false
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Framework not specified. Using pt to export the model.\n",
+      "Using the export variant default. Available variants are:\n",
+      "    - default: The default ONNX variant.\n",
+      "Using framework PyTorch: 2.2.1+cu121\n",
+      "Overriding 1 configuration item(s)\n",
+      "\t- use_cache -> False\n",
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/modeling_utils.py:4193: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
+      "  warnings.warn(\n",
+      "Compiling the model to CPU ...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 16, 18, 6]\n"
+     ]
+    }
+   ],
    "source": [
     "from langchain.retrievers import ContextualCompressionRetriever\n",
     "from langchain_community.document_compressors.openvino_rerank import OpenVINOReranker\n",
     "\n",
     "model_name = \"BAAI/bge-reranker-large\"\n",
     "\n",
-    "ov_compressor = OpenVINOReranker(model_name_or_path=model_name, top_n=4)\n",
+    "compressor = OpenVINOReranker(model_name_or_path=model_name)\n",
     "compression_retriever = ContextualCompressionRetriever(\n",
-    "    base_compressor=ov_compressor, base_retriever=retriever\n",
+    "    base_compressor=compressor, base_retriever=retriever\n",
     ")\n",
     "\n",
     "compressed_docs = compression_retriever.get_relevant_documents(\n",
@@ -403,7 +461,7 @@
     }
    },
    "source": [
-    "After reranking, the top 4 documents are different from the top 4 documents retrieved by the base retriever."
+    "After reranking, the top 3 documents are different from the top 3 documents retrieved by the base retriever."
    ]
   },
   {
@@ -474,13 +532,37 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Framework not specified. Using pt to export the model.\n",
+      "Using the export variant default. Available variants are:\n",
+      "    - default: The default ONNX variant.\n",
+      "Using framework PyTorch: 2.2.1+cu121\n",
+      "Overriding 1 configuration item(s)\n",
+      "\t- use_cache -> False\n",
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/modeling_utils.py:4193: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "from pathlib import Path\n",
     "\n",
     "ov_model_dir = \"bge-reranker-large-ov\"\n",
     "if not Path(ov_model_dir).exists():\n",
-    "    ov_compressor.save_model(ov_model_dir)"
+    "    from optimum.intel.openvino import OVModelForSequenceClassification\n",
+    "    from transformers import AutoTokenizer\n",
+    "\n",
+    "    ov_model = OVModelForSequenceClassification.from_pretrained(\n",
+    "        model_name, compile=False, export=True\n",
+    "    )\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "    ov_model.half()\n",
+    "    ov_model.save_pretrained(ov_model_dir)\n",
+    "    tokenizer.save_pretrained(ov_model_dir)"
    ]
   },
   {
@@ -497,7 +579,7 @@
     }
    ],
    "source": [
-    "ov_compressor = OpenVINOReranker(model_name_or_path=ov_model_dir)"
+    "compressor = OpenVINOReranker(model_name_or_path=ov_model_dir)"
    ]
   },
   {

docs/docs/integrations/graphs/amazon_neptune_sparql.ipynb

@@ -118,7 +118,25 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!pip install --upgrade --quiet langchain langchain-community langchain-aws"
+    "!pip install --upgrade --force-reinstall langchain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install --upgrade --force-reinstall langchain-core"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install --upgrade --force-reinstall langchain-community"
    ]
   },
   {
@@ -246,7 +264,7 @@
    "source": [
     "import boto3\n",
     "from langchain.chains.graph_qa.neptune_sparql import NeptuneSparqlQAChain\n",
-    "from langchain_aws import ChatBedrock\n",
+    "from langchain_community.chat_models import BedrockChat\n",
     "from langchain_community.graphs import NeptuneRdfGraph\n",
     "\n",
     "host = \"<your host>\"\n",
@@ -261,7 +279,7 @@
     "\n",
     "MODEL_ID = \"anthropic.claude-v2\"\n",
     "bedrock_client = boto3.client(\"bedrock-runtime\")\n",
-    "llm = ChatBedrock(model_id=MODEL_ID, client=bedrock_client)\n",
+    "llm = BedrockChat(model_id=MODEL_ID, client=bedrock_client)\n",
     "\n",
     "chain = NeptuneSparqlQAChain.from_llm(\n",
     "    llm=llm,\n",

docs/docs/integrations/llms/google_vertex_ai_palm.ipynb

@@ -347,7 +347,7 @@
     "from langchain_core.messages import HumanMessage\n",
     "from langchain_google_vertexai import ChatVertexAI\n",
     "\n",
-    "llm = ChatVertexAI(model_name=\"gemini-pro-vision\")\n",
+    "llm = ChatVertexAI(model_name=\"gemini-ultra-vision\")\n",
     "\n",
     "image_message = {\n",
     "    \"type\": \"image_url\",\n",

docs/docs/integrations/llms/ibm_watsonx.ipynb

@@ -124,7 +124,7 @@
     "In this example, we’ll use the `project_id` and Dallas url.\n",
     "\n",
     "\n",
-    "You need to specify `model_id` that will be used for inferencing. All available models you can find in [documentation](https://ibm.github.io/watsonx-ai-python-sdk/fm_model.html#ibm_watsonx_ai.foundation_models.utils.enums.ModelTypes)."
+    "You need to specify `model_id` that will be used for inferencing. All avaliable models you can find in [documentation](https://ibm.github.io/watsonx-ai-python-sdk/fm_model.html#ibm_watsonx_ai.foundation_models.utils.enums.ModelTypes)."
    ]
   },
   {

docs/docs/integrations/llms/octoai.ipynb

@@ -18,7 +18,7 @@
     "   \n",
     "2. Paste your API key in in the code cell below.\n",
     "\n",
-    "Note: If you want to use a different LLM model, you can containerize the model and make a custom OctoAI endpoint yourself, by following [Build a Container from Python](https://octo.ai/docs/bring-your-own-model/advanced-build-a-container-from-scratch-in-python) and [Create a Custom Endpoint from a Container](https://octo.ai/docs/bring-your-own-model/create-custom-endpoints-from-a-container/create-custom-endpoints-from-a-container) and then updating your `OCTOAI_API_BASE` environment variable.\n"
+    "Note: If you want to use a different LLM model, you can containerize the model and make a custom OctoAI endpoint yourself, by following [Build a Container from Python](https://octo.ai/docs/bring-your-own-model/advanced-build-a-container-from-scratch-in-python) and [Create a Custom Endpoint from a Container](https://octo.ai/docs/bring-your-own-model/create-custom-endpoints-from-a-container/create-custom-endpoints-from-a-container) and then update your Endpoint URL in the code cell below.\n"
    ]
   },
   {
@@ -29,7 +29,8 @@
    "source": [
     "import os\n",
     "\n",
-    "os.environ[\"OCTOAI_API_TOKEN\"] = \"OCTOAI_API_TOKEN\""
+    "os.environ[\"OCTOAI_API_TOKEN\"] = \"OCTOAI_API_TOKEN\"\n",
+    "os.environ[\"ENDPOINT_URL\"] = \"https://text.octoai.run/v1/chat/completions\""
    ]
   },
   {
@@ -67,33 +68,44 @@
    "outputs": [],
    "source": [
     "llm = OctoAIEndpoint(\n",
-    "    model=\"llama-2-13b-chat-fp16\",\n",
-    "    max_tokens=200,\n",
-    "    presence_penalty=0,\n",
-    "    temperature=0.1,\n",
-    "    top_p=0.9,\n",
+    "    model_kwargs={\n",
+    "        \"model\": \"llama-2-13b-chat-fp16\",\n",
+    "        \"max_tokens\": 128,\n",
+    "        \"presence_penalty\": 0,\n",
+    "        \"temperature\": 0.1,\n",
+    "        \"top_p\": 0.9,\n",
+    "        \"messages\": [\n",
+    "            {\n",
+    "                \"role\": \"system\",\n",
+    "                \"content\": \"You are a helpful assistant. Keep your responses limited to one short paragraph if possible.\",\n",
+    "            },\n",
+    "        ],\n",
+    "    },\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  Sure thing! Here's my response:\n",
+      "\n",
+      "Leonardo da Vinci was a true Renaissance man - an Italian polymath who excelled in various fields, including painting, sculpture, engineering, mathematics, anatomy, and geology. He is widely considered one of the greatest painters of all time, and his inventive and innovative works continue to inspire and influence artists and thinkers to this day. Some of his most famous works include the Mona Lisa, The Last Supper, and Vitruvian Man. \n"
+     ]
+    }
+   ],
    "source": [
-    "question = \"Who was Leonardo da Vinci?\"\n",
+    "question = \"Who was leonardo davinci?\"\n",
     "\n",
     "llm_chain = LLMChain(prompt=prompt, llm=llm)\n",
     "\n",
     "print(llm_chain.run(question))"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Leonardo da Vinci was a true Renaissance man. He was born in 1452 in Vinci, Italy and was known for his work in various fields, including art, science, engineering, and mathematics. He is considered one of the greatest painters of all time, and his most famous works include the Mona Lisa and The Last Supper. In addition to his art, da Vinci made significant contributions to engineering and anatomy, and his designs for machines and inventions were centuries ahead of his time. He is also known for his extensive journals and drawings, which provide valuable insights into his thoughts and ideas. Da Vinci's legacy continues to inspire and influence artists, scientists, and thinkers around the world today."
-   ]
   }
  ],
  "metadata": {

docs/docs/integrations/llms/predibase.ipynb

@@ -63,24 +63,7 @@
    "source": [
     "from langchain_community.llms import Predibase\n",
     "\n",
-    "# With a fine-tuned adapter hosted at Predibase (adapter_version can be specified; omitting it is equivalent to the most recent version).\n",
-    "model = Predibase(\n",
-    "    model=\"mistral-7b\",\n",
-    "    adapter_id=\"e2e_nlg\",\n",
-    "    adapter_version=1,\n",
-    "    predibase_api_key=os.environ.get(\"PREDIBASE_API_TOKEN\"),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.llms import Predibase\n",
-    "\n",
-    "# With a fine-tuned adapter hosted at HuggingFace (adapter_version does not apply and will be ignored).\n",
+    "# With an adapter, fine-tuned on the specified model\n",
     "model = Predibase(\n",
     "    model=\"mistral-7b\",\n",
     "    adapter_id=\"predibase/e2e_nlg\",\n",
@@ -126,32 +109,13 @@
     ")"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "vscode": {
-     "languageId": "plaintext"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# With a fine-tuned adapter hosted at Predibase (adapter_version can be specified; omitting it is equivalent to the most recent version).\n",
-    "model = Predibase(\n",
-    "    model=\"mistral-7b\",\n",
-    "    adapter_id=\"e2e_nlg\",\n",
-    "    adapter_version=1,\n",
-    "    predibase_api_key=os.environ.get(\"PREDIBASE_API_TOKEN\"),\n",
-    ")"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "# With a fine-tuned adapter hosted at HuggingFace (adapter_version does not apply and will be ignored).\n",
+    "# With an adapter, fine-tuned on the specified model\n",
     "llm = Predibase(\n",
     "    model=\"mistral-7b\",\n",
     "    adapter_id=\"predibase/e2e_nlg\",\n",
@@ -247,8 +211,7 @@
     "\n",
     "model = Predibase(\n",
     "    model=\"my-base-LLM\",\n",
-    "    adapter_id=\"my-finetuned-adapter-id\",  # Supports both, Predibase-hosted and HuggingFace-hosted model repositories.\n",
-    "    # adapter_version=1,  # optional (returns the latest, if omitted)\n",
+    "    adapter_id=\"my-finetuned-adapter-id\",\n",
     "    predibase_api_key=os.environ.get(\n",
     "        \"PREDIBASE_API_TOKEN\"\n",
     "    ),  # Adapter argument is optional.\n",

docs/docs/integrations/llms/solar.ipynb

@@ -1,19 +1,30 @@
 {
  "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Solar\n",
-    "\n",
-    "*This community integration is deprecated. You should use [`ChatUpstage`](../../chat/upstage) instead to access Solar LLM via the chat model connector.*"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 1,
+   "id": "2ff00e23-1a90-4a39-b220-83ebfffd96d6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-06T17:10:57.375714Z",
+     "iopub.status.busy": "2024-03-06T17:10:57.375261Z",
+     "iopub.status.idle": "2024-03-06T17:11:03.473978Z",
+     "shell.execute_reply": "2024-03-06T17:11:03.472875Z",
+     "shell.execute_reply.started": "2024-03-06T17:10:57.375670Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Once upon a time, in a far-off land, there was a young girl named Lily. Lily was a kind and curious girl who loved to explore the world around her. One day, while wandering through the forest, she came across a small, shimmering pond.\\n\\nAs she approached the pond, she saw a beautiful, glowing flower floating on the water's surface. Lily reached out to touch the flower, and as she did, she felt a strange tingling sensation. Suddenly, the flower began to glow even brighter, and Lily was transported to a magical world filled with talking animals and enchanted forests.\\n\\nIn this world, Lily met a wise old owl named Winston who told her that the flower she had touched was a magical one that could grant her any wish she desired. Lily was overjoyed and asked Winston to show her around the magical world.\\n\\nTogether, they explored the enchanted forests, met friendly animals, and discovered hidden treasures. Lily was having the time of her life, but she knew that she couldn't stay in this magical world forever. Eventually, she had to return home.\\n\\nAs she said goodbye to Winston and the magical world, Lily realized that she had learned an important lesson. She had discovered that sometimes, the most magical things in life are the ones that are right in front of us, if we only take the time to look.\\n\\nFrom that day on, Lily always kept her eyes open for the magic in the world around her, and she never forgot the adventure she had in the enchanted forest.\""
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "import os\n",
     "\n",
@@ -26,9 +37,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
+   "execution_count": 2,
+   "id": "67fa1711-f08f-43fa-a3bd-75ae5bc6b988",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-03-06T17:11:11.359924Z",
+     "iopub.status.busy": "2024-03-06T17:11:11.358357Z",
+     "iopub.status.idle": "2024-03-06T17:11:16.692138Z",
+     "shell.execute_reply": "2024-03-06T17:11:16.686492Z",
+     "shell.execute_reply.started": "2024-03-06T17:11:11.359835Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/ary/dev/llm/langchain/libs/core/langchain_core/_api/deprecation.py:117: LangChainDeprecationWarning: The function `run` was deprecated in LangChain 0.1.0 and will be removed in 0.2.0. Use invoke instead.\n",
+      "  warn_deprecated(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Step 1: Determine the year Justin Bieber was born.\\nJustin Bieber was born on March 1, 1994.\\n\\nStep 2: Determine the Super Bowl held in 1994.\\nSuper Bowl XXVIII was held in 1994.\\n\\nStep 3: Determine the winning team of Super Bowl XXVIII.\\nThe Dallas Cowboys won Super Bowl XXVIII in 1994.\\n\\nFinal Answer: The Dallas Cowboys won the Super Bowl in the year Justin Bieber was born (1994).'"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "from langchain.chains import LLMChain\n",
     "from langchain.prompts import PromptTemplate\n",
@@ -47,13 +86,35 @@
     "\n",
     "llm_chain.run(question)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "91961983-d0d5-4901-b854-531e158c0416",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
   "language_info": {
-   "name": "python"
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.0"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 5
 }

docs/docs/integrations/llms/titan_takeoff.ipynb

@@ -1,15 +1,75 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Titan Takeoff\n",
     "\n",
-    "`TitanML` helps businesses build and deploy better, smaller, cheaper, and faster NLP models through our training, compression, and inference optimization platform.\n",
+    ">`TitanML` helps businesses build and deploy better, smaller, cheaper, and faster NLP models through our training, compression, and inference optimization platform. \n",
     "\n",
-    "Our inference server, [Titan Takeoff](https://docs.titanml.co/docs/intro) enables deployment of LLMs locally on your hardware in a single command. Most generative model architectures are supported, such as Falcon, Llama 2, GPT2, T5 and many more. If you experience trouble with a specific model, please let us know at hello@titanml.co."
+    ">Our inference server, [Titan Takeoff](https://docs.titanml.co/docs/titan-takeoff/getting-started) enables deployment of LLMs locally on your hardware in a single command. Most generative model architectures are supported, such as Falcon, Llama 2, GPT2, T5 and many more."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Installation\n",
+    "\n",
+    "To get started with Iris Takeoff, all you need is to have docker and python installed on your local system. If you wish to use the server with gpu support, then you will need to install docker with cuda support.\n",
+    "\n",
+    "For Mac and Windows users, make sure you have the docker daemon running! You can check this by running docker ps in your terminal. To start the daemon, open the docker desktop app.\n",
+    "\n",
+    "Run the following command to install the Iris CLI that will enable you to run the takeoff server:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "vscode": {
+     "languageId": "shellscript"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%pip install --upgrade --quiet  titan-iris"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Choose a Model\n",
+    "Takeoff supports many of the most powerful generative text models, such as Falcon, MPT, and Llama. See the [supported models](https://docs.titanml.co/docs/titan-takeoff/supported-models) for more information. For information about using your own models, see the [custom models](https://docs.titanml.co/docs/titan-takeoff/Advanced/custom-models).\n",
+    "\n",
+    "Going forward in this demo we will be using the falcon 7B instruct model. This is a good open-source model that is trained to follow instructions, and is small enough to easily inference even on CPUs.\n",
+    "\n",
+    "## Taking off\n",
+    "Models are referred to by their model id on HuggingFace. Takeoff uses port 8000 by default, but can be configured to use another port. There is also support to use a Nvidia GPU by specifying cuda for the device flag.\n",
+    "\n",
+    "To start the takeoff server, run:\n",
+    "\n",
+    "```shell\n",
+    "iris takeoff --model tiiuae/falcon-7b-instruct --device cpu\n",
+    "iris takeoff --model tiiuae/falcon-7b-instruct --device cuda # Nvidia GPU required\n",
+    "iris takeoff --model tiiuae/falcon-7b-instruct --device cpu --port 5000 # run on port 5000 (default: 8000)\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You will then be directed to a login page, where you will need to create an account to proceed.\n",
+    "After logging in, run the command onscreen to check whether the server is ready. When it is ready, you can start using the Takeoff integration.\n",
+    "\n",
+    "To shutdown the server, run the following command. You will be presented with options on which Takeoff server to shut down, in case you have multiple running servers.\n",
+    "\n",
+    "```shell\n",
+    "iris takeoff --shutdown # shutdown the server\n",
+    "```"
    ]
   },
   {
@@ -17,8 +77,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Example usage\n",
-    "Here are some helpful examples to get started using Titan Takeoff Server. You need to make sure Takeoff Server has been started in the background before running these commands. For more information see [docs page for launching Takeoff](https://docs.titanml.co/docs/Docs/launching/)."
+    "## Inferencing your model\n",
+    "To access your LLM, use the TitanTakeoff LLM wrapper:"
    ]
   },
   {
@@ -27,119 +87,50 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import time\n",
+    "from langchain_community.llms import TitanTakeoff\n",
     "\n",
+    "llm = TitanTakeoff(\n",
+    "    base_url=\"http://localhost:8000\", generate_max_length=128, temperature=1.0\n",
+    ")\n",
+    "\n",
+    "prompt = \"What is the largest planet in the solar system?\"\n",
+    "\n",
+    "llm(prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "No parameters are needed by default, but a baseURL that points to your desired URL where Takeoff is running can be specified and [generation parameters](https://docs.titanml.co/docs/titan-takeoff/Advanced/generation-parameters) can be supplied.\n",
+    "\n",
+    "### Streaming\n",
+    "Streaming is also supported via the streaming flag:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "from langchain.callbacks.manager import CallbackManager\n",
     "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
-    "from langchain.prompts import PromptTemplate\n",
     "\n",
-    "# Note importing TitanTakeoffPro instead of TitanTakeoff will work as well both use same object under the hood\n",
-    "from langchain_community.llms import TitanTakeoff"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Example 1\n",
-    "\n",
-    "Basic use assuming Takeoff is running on your machine using its default ports (ie localhost:3000).\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = TitanTakeoff()\n",
-    "output = llm.invoke(\"What is the weather in London in August?\")\n",
-    "print(output)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Example 2\n",
-    "\n",
-    "Specifying a port and other generation parameters"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = TitanTakeoff(port=3000)\n",
-    "# A comprehensive list of parameters can be found at https://docs.titanml.co/docs/next/apis/Takeoff%20inference_REST_API/generate#request\n",
-    "output = llm.invoke(\n",
-    "    \"What is the largest rainforest in the world?\",\n",
-    "    consumer_group=\"primary\",\n",
-    "    min_new_tokens=128,\n",
-    "    max_new_tokens=512,\n",
-    "    no_repeat_ngram_size=2,\n",
-    "    sampling_topk=1,\n",
-    "    sampling_topp=1.0,\n",
-    "    sampling_temperature=1.0,\n",
-    "    repetition_penalty=1.0,\n",
-    "    regex_string=\"\",\n",
-    "    json_schema=None,\n",
-    ")\n",
-    "print(output)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Example 3\n",
-    "\n",
-    "Using generate for multiple inputs"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm = TitanTakeoff()\n",
-    "rich_output = llm.generate([\"What is Deep Learning?\", \"What is Machine Learning?\"])\n",
-    "print(rich_output.generations)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Example 4\n",
-    "\n",
-    "Streaming output"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
     "llm = TitanTakeoff(\n",
-    "    streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()])\n",
+    "    callback_manager=CallbackManager([StreamingStdOutCallbackHandler()]), streaming=True\n",
     ")\n",
+    "\n",
     "prompt = \"What is the capital of France?\"\n",
-    "output = llm.invoke(prompt)\n",
-    "print(output)"
+    "\n",
+    "llm(prompt)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Example 5\n",
-    "\n",
-    "Using LCEL"
+    "### Integration with LLMChain"
    ]
   },
   {
@@ -148,48 +139,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from langchain.chains import LLMChain\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "\n",
     "llm = TitanTakeoff()\n",
-    "prompt = PromptTemplate.from_template(\"Tell me about {topic}\")\n",
-    "chain = prompt | llm\n",
-    "output = chain.invoke({\"topic\": \"the universe\"})\n",
-    "print(output)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Example 6\n",
     "\n",
-    "Starting readers using TitanTakeoff Python Wrapper. If you haven't created any readers with first launching Takeoff, or you want to add another you can do so when you initialize the TitanTakeoff object. Just pass a list of model configs you want to start as the `models` parameter."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Model config for the llama model, where you can specify the following parameters:\n",
-    "#   model_name (str): The name of the model to use\n",
-    "#   device: (str): The device to use for inference, cuda or cpu\n",
-    "#   consumer_group (str): The consumer group to place the reader into\n",
-    "#   tensor_parallel (Optional[int]): The number of gpus you would like your model to be split across\n",
-    "#   max_seq_length (int): The maximum sequence length to use for inference, defaults to 512\n",
-    "#   max_batch_size (int_: The max batch size for continuous batching of requests\n",
-    "llama_model = {\n",
-    "    \"model_name\": \"TheBloke/Llama-2-7b-Chat-AWQ\",\n",
-    "    \"device\": \"cuda\",\n",
-    "    \"consumer_group\": \"llama\",\n",
-    "}\n",
-    "llm = TitanTakeoff(models=[llama_model])\n",
+    "template = \"What is the capital of {country}\"\n",
     "\n",
-    "# The model needs time to spin up, length of time need will depend on the size of model and your network connection speed\n",
-    "time.sleep(60)\n",
+    "prompt = PromptTemplate.from_template(template)\n",
     "\n",
-    "prompt = \"What is the capital of France?\"\n",
-    "output = llm.invoke(prompt, consumer_group=\"llama\")\n",
-    "print(output)"
+    "llm_chain = LLMChain(llm=llm, prompt=prompt)\n",
+    "\n",
+    "generated = llm_chain.run(country=\"Belgium\")\n",
+    "print(generated)"
    ]
   }
  ],

docs/docs/integrations/llms/titan_takeoff_pro.ipynb

@@ -0,0 +1,102 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Titan Takeoff Pro\n",
+    "\n",
+    "`TitanML` helps businesses build and deploy better, smaller, cheaper, and faster NLP models through our training, compression, and inference optimization platform.\n",
+    "\n",
+    ">Note: These docs are for the Pro version of Titan Takeoff. For the community version, see the page for Titan Takeoff.\n",
+    "\n",
+    "Our inference server, [Titan Takeoff (Pro Version)](https://docs.titanml.co/docs/titan-takeoff/pro-features/feature-comparison) enables deployment of LLMs locally on your hardware in a single command. Most generative model architectures are supported, such as Falcon, Llama 2, GPT2, T5 and many more."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example usage\n",
+    "Here are some helpful examples to get started using the Pro version of Titan Takeoff Server.\n",
+    "No parameters are needed by default, but a baseURL that points to your desired URL where Takeoff is running can be specified and generation parameters can be supplied."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.callbacks.manager import CallbackManager\n",
+    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "from langchain_community.llms import TitanTakeoffPro\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "\n",
+    "# Example 1: Basic use\n",
+    "llm = TitanTakeoffPro()\n",
+    "output = llm(\"What is the weather in London in August?\")\n",
+    "print(output)\n",
+    "\n",
+    "\n",
+    "# Example 2: Specifying a port and other generation parameters\n",
+    "llm = TitanTakeoffPro(\n",
+    "    base_url=\"http://localhost:3000\",\n",
+    "    min_new_tokens=128,\n",
+    "    max_new_tokens=512,\n",
+    "    no_repeat_ngram_size=2,\n",
+    "    sampling_topk=1,\n",
+    "    sampling_topp=1.0,\n",
+    "    sampling_temperature=1.0,\n",
+    "    repetition_penalty=1.0,\n",
+    "    regex_string=\"\",\n",
+    ")\n",
+    "output = llm(\"What is the largest rainforest in the world?\")\n",
+    "print(output)\n",
+    "\n",
+    "\n",
+    "# Example 3: Using generate for multiple inputs\n",
+    "llm = TitanTakeoffPro()\n",
+    "rich_output = llm.generate([\"What is Deep Learning?\", \"What is Machine Learning?\"])\n",
+    "print(rich_output.generations)\n",
+    "\n",
+    "\n",
+    "# Example 4: Streaming output\n",
+    "llm = TitanTakeoffPro(\n",
+    "    streaming=True, callback_manager=CallbackManager([StreamingStdOutCallbackHandler()])\n",
+    ")\n",
+    "prompt = \"What is the capital of France?\"\n",
+    "llm(prompt)\n",
+    "\n",
+    "# Example 5: Using LCEL\n",
+    "llm = TitanTakeoffPro()\n",
+    "prompt = PromptTemplate.from_template(\"Tell me about {topic}\")\n",
+    "chain = prompt | llm\n",
+    "chain.invoke({\"topic\": \"the universe\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/docs/integrations/platforms/aws.mdx

@@ -2,28 +2,6 @@
 
 The `LangChain` integrations related to [Amazon AWS](https://aws.amazon.com/) platform.
 
-First-party AWS integrations are available in the `langchain_aws` package.
-
-```bash
-pip install langchain-aws
-```
-
-And there are also some community integrations available in the `langchain_community` package with the `boto3` optional dependency.
-
-```bash
-pip install langchain-community boto3
-```
-
-## Chat models
-
-### Bedrock Chat
-
-See a [usage example](/docs/integrations/chat/bedrock).
-
-```python
-from langchain_aws import ChatBedrock
-```
-
 ## LLMs
 
 ### Bedrock
@@ -42,7 +20,7 @@ from langchain_aws import ChatBedrock
 See a [usage example](/docs/integrations/llms/bedrock).
 
 ```python
-from langchain_aws import BedrockLLM
+from langchain_community.llms.bedrock import Bedrock
 ```
 
 ### Amazon API Gateway
@@ -75,7 +53,18 @@ We use `SageMaker` to host our model and expose it as the `SageMaker Endpoint`.
 See a [usage example](/docs/integrations/llms/sagemaker).
 
 ```python
-from langchain_aws import SagemakerEndpoint
+from langchain_community.llms import SagemakerEndpoint
+from langchain_community.llms.sagemaker_endpoint import LLMContentHandler
+```
+
+## Chat models
+
+### Bedrock Chat
+
+See a [usage example](/docs/integrations/chat/bedrock).
+
+```python
+from langchain_community.chat_models import BedrockChat
 ```
 
 ## Embedding Models
@@ -199,16 +188,16 @@ from langchain.vectorstores import DocumentDBVectorSearch
 > manuals, and websites. It supports multiple languages and can understand complex queries, synonyms, and 
 > contextual meanings to provide highly relevant search results.
 
-We need to install the `langchain-aws` library.
+We need to install the `boto3` library.
 
 ```bash
-pip install langchain-aws
+pip install boto3
 ```
 
 See a [usage example](/docs/integrations/retrievers/amazon_kendra_retriever).
 
 ```python
-from langchain_aws import AmazonKendraRetriever
+from langchain.retrievers import AmazonKendraRetriever
 ```
 
 ### Amazon Bedrock (Knowledge Bases)
@@ -217,16 +206,16 @@ from langchain_aws import AmazonKendraRetriever
 > `Amazon Web Services` (`AWS`) offering which lets you quickly build RAG applications by using your 
 > private data to customize foundation model response.
 
-We need to install the `langchain-aws` library.
+We need to install the `boto3` library.
 
 ```bash
-pip install langchain-aws
+pip install boto3
 ```
 
 See a [usage example](/docs/integrations/retrievers/bedrock).
 
 ```python
-from langchain_aws import AmazonKnowledgeBasesRetriever
+from langchain.retrievers import AmazonKnowledgeBasesRetriever
 ```
 
 ## Tools

docs/docs/integrations/platforms/google.mdx

@@ -229,7 +229,7 @@ pip install langchain-google-cloud-sql-pg
 See [usage example](/docs/integrations/document_loaders/google_cloud_sql_pg).
 
 ```python
-from langchain_google_cloud_sql_pg import PostgresEngine, PostgresLoader
+from langchain_google_cloud_sql_pg import PostgreSQLEngine, PostgreSQLLoader
 ```
 
 ### Cloud Storage
@@ -486,36 +486,6 @@ See [usage example](/docs/integrations/vectorstores/google_spanner).
 from langchain_google_spanner import SpannerVectorStore
 ```
 
-### Firestore (Native Mode)
-
-> [Google Cloud Firestore](https://cloud.google.com/firestore/docs/) is a NoSQL document database built for automatic scaling, high performance, and ease of application development.
-Install the python package:
-
-```bash
-pip install langchain-google-firestore
-```
-
-See [usage example](/docs/integrations/vectorstores/google_firestore).
-
-```python
-from langchain_google_firestore import FirestoreVectorstore
-```
-
-### Cloud SQL for MySQL
-
-> [Google Cloud SQL for MySQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your MySQL relational databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-mysql
-```
-
-See [usage example](/docs/integrations/vectorstores/google_cloud_sql_mysql).
-
-```python
-from langchain_google_cloud_sql_mysql import MySQLEngine, MySQLVectorStore
-```
-
 ### Cloud SQL for PostgreSQL
 
 > [Google Cloud SQL for PostgreSQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your PostgreSQL relational databases on Google Cloud.
@@ -528,7 +498,7 @@ pip install langchain-google-cloud-sql-pg
 See [usage example](/docs/integrations/vectorstores/google_cloud_sql_pg).
 
 ```python
-from langchain_google_cloud_sql_pg import PostgresEngine, PostgresVectorStore
+from langchain_google_cloud_sql_pg import PostgreSQLEngine, PostgresVectorStore
 ```
 
 ### Vertex AI Vector Search
@@ -813,7 +783,7 @@ See [usage example](/docs/integrations/memory/google_sql_pg).
 
 
 ```python
-from langchain_google_cloud_sql_pg import PostgresEngine, PostgresChatMessageHistory
+from langchain_google_cloud_sql_pg import PostgreSQLEngine, PostgreSQLChatMessageHistory
 ```
 
 ### Cloud SQL for MySQL

docs/docs/integrations/platforms/index.mdx

@@ -13,7 +13,6 @@ These providers have standalone `langchain-{provider}` packages for improved ver
 
 - [AI21](/docs/integrations/providers/ai21)
 - [Airbyte](/docs/integrations/providers/airbyte)
-- [Amazon Web Services](/docs/integrations/platforms/aws)
 - [Anthropic](/docs/integrations/platforms/anthropic)
 - [Astra DB](/docs/integrations/providers/astradb)
 - [Cohere](/docs/integrations/providers/cohere)
@@ -31,7 +30,6 @@ These providers have standalone `langchain-{provider}` packages for improved ver
 - [Pinecone](/docs/integrations/providers/pinecone)
 - [Robocorp](/docs/integrations/providers/robocorp)
 - [Together AI](/docs/integrations/providers/together)
-- [Upstage](/docs/integrations/providers/upstage)
 - [Voyage AI](/docs/integrations/providers/voyageai)
 
 

docs/docs/integrations/providers/chroma.mdx

@@ -5,7 +5,7 @@
 ## Installation and Setup
 
 ```bash
-pip install langchain-chroma
+pip install chromadb
 ```
 
 
@@ -15,7 +15,7 @@ There exists a wrapper around Chroma vector databases, allowing you to use it as
 whether for semantic search or example selection.
 
 ```python
-from langchain_chroma import Chroma
+from langchain_community.vectorstores import Chroma
 ```
 
 For a more detailed walkthrough of the Chroma wrapper, see [this notebook](/docs/integrations/vectorstores/chroma)

docs/docs/integrations/providers/dataherald.mdx

@@ -1,64 +0,0 @@
-# Dataherald
-
->[Dataherald](https://www.dataherald.com) is a natural language-to-SQL.
-
-This page covers how to use the `Dataherald API` within LangChain.
-
-## Installation and Setup
-- Install requirements with 
-```bash
-pip install dataherald
-```
-- Go to dataherald and sign up [here](https://www.dataherald.com)
-- Create an app and get your `API KEY`
-- Set your `API KEY` as an environment variable `DATAHERALD_API_KEY`
-
-
-## Wrappers
-
-### Utility
-
-There exists a DataheraldAPIWrapper utility which wraps this API. To import this utility:
-
-```python
-from langchain_community.utilities.dataherald import DataheraldAPIWrapper
-```
-
-For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/dataherald).
-
-### Tool
-
-You can use the tool in an agent like this:
-```python
-from langchain_community.utilities.dataherald import DataheraldAPIWrapper
-from langchain_community.tools.dataherald.tool import DataheraldTextToSQL
-from langchain_openai import ChatOpenAI
-from langchain import hub
-from langchain.agents import AgentExecutor, create_react_agent, load_tools
-
-api_wrapper = DataheraldAPIWrapper(db_connection_id="<db_connection_id>")
-tool = DataheraldTextToSQL(api_wrapper=api_wrapper)
-llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
-prompt = hub.pull("hwchase17/react")
-agent = create_react_agent(llm, tools, prompt)
-agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
-agent_executor.invoke({"input":"Return the sql for this question: How many employees are in the company?"})
-```
-
-Output
-```shell
-> Entering new AgentExecutor chain...
-I need to use a tool that can convert this question into SQL.
-Action: dataherald
-Action Input: How many employees are in the company?Answer: SELECT
-    COUNT(*) FROM employeesI now know the final answer
-Final Answer: SELECT
-    COUNT(*)
-FROM
-    employees
-
-> Finished chain.
-{'input': 'Return the sql for this question: How many employees are in the company?', 'output': "SELECT \n    COUNT(*)\nFROM \n    employees"}
-```
-
-For more information on tools, see [this page](/docs/modules/tools/).

docs/docs/integrations/providers/portkey/index.md

@@ -1,174 +1,113 @@
 # Portkey
 
-[Portkey](https://portkey.ai) is the Control Panel for AI apps. With it's popular AI Gateway and Observability Suite, hundreds of teams ship **reliable**, **cost-efficient**, and **fast** apps.
+>[Portkey](https://docs.portkey.ai/overview/introduction) is a platform designed to streamline the deployment 
+> and management of Generative AI applications. 
+> It provides comprehensive features for monitoring, managing models,
+> and improving the performance of your AI applications.
 
 ## LLMOps for Langchain
 
 Portkey brings production readiness to Langchain. With Portkey, you can 
-- [x] Connect to 150+ models through a unified API,
-- [x] View 42+ **metrics & logs** for all requests, 
-- [x] Enable **semantic cache** to reduce latency & costs, 
-- [x] Implement automatic **retries & fallbacks** for failed requests, 
-- [x] Add **custom tags** to requests for better tracking and analysis and [more](https://portkey.ai/docs).
+- [x] view detailed **metrics & logs** for all requests, 
+- [x] enable **semantic cache** to reduce latency & costs, 
+- [x] implement automatic **retries & fallbacks** for failed requests, 
+- [x] add **custom tags** to requests for better tracking and analysis and [more](https://docs.portkey.ai).
 
+### Using Portkey with Langchain
+Using Portkey is as simple as just choosing which Portkey features you want, enabling them via `headers=Portkey.Config` and passing it in your LLM calls.
 
-## Quickstart - Portkey & Langchain
-Since Portkey is fully compatible with the OpenAI signature, you can connect to the Portkey AI Gateway through the `ChatOpenAI` interface.
+To start, get your Portkey API key by [signing up here](https://app.portkey.ai/login). (Click the profile icon on the top left, then click on "Copy API Key")
 
-- Set the `base_url` as `PORTKEY_GATEWAY_URL`
-- Add `default_headers` to consume the headers needed by Portkey using the `createHeaders` helper method.
-
-To start, get your Portkey API key by [signing up here](https://app.portkey.ai/signup). (Click the profile icon on the bottom left, then click on "Copy API Key") or deploy the open source AI gateway in [your own environment](https://github.com/Portkey-AI/gateway/blob/main/docs/installation-deployments.md).
-
-Next, install the Portkey SDK
+For OpenAI, a simple integration with logging feature would look like this:
 ```python
-pip install -U portkey_ai
-```
+from langchain_openai import OpenAI
+from langchain_community.utilities import Portkey
 
-We can now connect to the Portkey AI Gateway by updating the `ChatOpenAI` model in Langchain
-```python
-from langchain_openai import ChatOpenAI
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-PORTKEY_API_KEY = "..." # Not needed when hosting your own gateway
-PROVIDER_API_KEY = "..." # Add the API key of the AI provider being used 
-
-portkey_headers = createHeaders(api_key=PORTKEY_API_KEY,provider="openai")
-
-llm = ChatOpenAI(api_key=PROVIDER_API_KEY, base_url=PORTKEY_GATEWAY_URL, default_headers=portkey_headers)
-
-llm.invoke("What is the meaning of life, universe and everything?")
-```
-
-The request is routed through your Portkey AI Gateway to the specified `provider`. Portkey will also start logging all the requests in your account that makes debugging extremely simple.
-
-![View logs from Langchain in Portkey](https://assets.portkey.ai/docs/langchain-logs.gif)
-
-## Using 150+ models through the AI Gateway
-The power of the AI gateway comes when you're able to use the above code snippet to connect with 150+ models across 20+ providers supported through the AI gateway.
-
-Let's modify the code above to make a call to Anthropic's `claude-3-opus-20240229` model.
-
-Portkey supports **[Virtual Keys](https://docs.portkey.ai/docs/product/ai-gateway-streamline-llm-integrations/virtual-keys)** which are an easy way to store and manage API keys in a secure vault. Lets try using a Virtual Key to make LLM calls. You can navigate to the Virtual Keys tab in Portkey and create a new key for Anthropic.
-
-The `virtual_key` parameter sets the authentication and provider for the AI provider being used. In our case we're using the Anthropic Virtual key.
-
-> Notice that the `api_key` can be left blank as that authentication won't be used.
-
-```python
-from langchain_openai import ChatOpenAI
-from portkey_ai import createHeaders, PORTKEY_GATEWAY_URL
-
-PORTKEY_API_KEY = "..."
-VIRTUAL_KEY = "..." # Anthropic's virtual key we copied above
-
-portkey_headers = createHeaders(api_key=PORTKEY_API_KEY,virtual_key=VIRTUAL_KEY)
-
-llm = ChatOpenAI(api_key="X", base_url=PORTKEY_GATEWAY_URL, default_headers=portkey_headers, model="claude-3-opus-20240229")
-
-llm.invoke("What is the meaning of life, universe and everything?")
-```
-
-The Portkey AI gateway will authenticate the API request to Anthropic and get the response back in the OpenAI format for you to consume.
-
-The AI gateway extends Langchain's `ChatOpenAI` class making it a single interface to call any provider and any model.
-
-## Advanced Routing - Load Balancing, Fallbacks, Retries
-The Portkey AI Gateway brings capabilities like load-balancing, fallbacks, experimentation and canary testing to Langchain through a configuration-first approach.
-
-Let's take an **example** where we might want to split traffic between `gpt-4` and `claude-opus` 50:50 to test the two large models. The gateway configuration for this would look like the following:
-
-```python
-config = {
-    "strategy": {
-         "mode": "loadbalance"
-    },
-    "targets": [{
-        "virtual_key": "openai-25654", # OpenAI's virtual key
-        "override_params": {"model": "gpt4"},
-        "weight": 0.5
-    }, {
-        "virtual_key": "anthropic-25654", # Anthropic's virtual key
-        "override_params": {"model": "claude-3-opus-20240229"},
-        "weight": 0.5
-    }]
-}
-```
-
-We can then use this config in our requests being made from langchain.
-
-```python
-portkey_headers = createHeaders(
-    api_key=PORTKEY_API_KEY,
-    config=config
+# Add the Portkey API Key from your account
+headers = Portkey.Config(
+    api_key = "<PORTKEY_API_KEY>"
 )
 
-llm = ChatOpenAI(api_key="X", base_url=PORTKEY_GATEWAY_URL, default_headers=portkey_headers)
-
-llm.invoke("What is the meaning of life, universe and everything?")
+llm = OpenAI(temperature=0.9, headers=headers)
+llm.predict("What would be a good company name for a company that makes colorful socks?")
 ```
+Your logs will be captured on your [Portkey dashboard](https://app.portkey.ai).
 
-When the LLM is invoked, Portkey will distribute the requests to `gpt-4` and `claude-3-opus-20240229` in the ratio of the defined weights.
+A common Portkey X Langchain use case is to **trace a chain or an agent** and view all the LLM calls originating from that request. 
 
-You can find more config examples [here](https://docs.portkey.ai/docs/api-reference/config-object#examples).
-
-## **Tracing Chains & Agents**
-
-Portkey's Langchain integration gives you full visibility into the running of an agent. Let's take an example of a [popular agentic workflow](https://python.langchain.com/docs/use_cases/tool_use/quickstart/#agents).
-
-We only need to modify the `ChatOpenAI` class to use the AI Gateway as above.
+### **Tracing Chains & Agents**
 
 ```python
-from langchain import hub  
-from langchain.agents import AgentExecutor, create_openai_tools_agent  
-from langchain_openai import ChatOpenAI
-from langchain_core.tools import tool
-from portkey_ai import PORTKEY_GATEWAY_URL, createHeaders
- 
-prompt = hub.pull("hwchase17/openai-tools-agent")
+from langchain.agents import AgentType, initialize_agent, load_tools  
+from langchain_openai import OpenAI
+from langchain_community.utilities import Portkey
 
-portkey_headers = createHeaders(
-    api_key=PORTKEY_API_KEY,
-    virtual_key=OPENAI_VIRTUAL_KEY,
-    trace_id="uuid-uuid-uuid-uuid"
+# Add the Portkey API Key from your account
+headers = Portkey.Config(
+    api_key = "<PORTKEY_API_KEY>",
+    trace_id = "fef659"
 )
 
-@tool
-def multiply(first_int: int, second_int: int) -> int:
-    """Multiply two integers together."""
-    return first_int * second_int
+llm = OpenAI(temperature=0, headers=headers)  
+tools = load_tools(["serpapi", "llm-math"], llm=llm)  
+agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)  
   
-  
-@tool  
-def exponentiate(base: int, exponent: int) -> int:  
-    "Exponentiate the base to the exponent power."  
-    return base**exponent  
-  
-  
-tools = [multiply, exponentiate]
-
-model = ChatOpenAI(api_key="X", base_url=PORTKEY_GATEWAY_URL, default_headers=portkey_headers, temperature=0)
-  
-# Construct the OpenAI Tools agent  
-agent = create_openai_tools_agent(model, tools, prompt)
-
-# Create an agent executor by passing in the agent and tools
-agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
-
-agent_executor.invoke({
-    "input": "Take 3 to the fifth power and multiply that by thirty six, then square the result"
-})
+# Let's test it out!  
+agent.run("What was the high temperature in SF yesterday in Fahrenheit? What is that number raised to the .023 power?")
 ```
 
 **You can see the requests' logs along with the trace id on Portkey dashboard:**
-![Langchain Agent Logs on Portkey](https://assets.portkey.ai/docs/agent_tracing.gif)
+
+<img src="/img/portkey-dashboard.gif" height="250"/>
+<img src="/img/portkey-tracing.png" height="250"/>
+
+## Advanced Features
+
+1. **Logging:** Log all your LLM requests automatically by sending them through Portkey. Each request log contains `timestamp`, `model name`, `total cost`, `request time`, `request json`, `response json`, and additional Portkey features.
+2. **Tracing:** Trace id can be passed along with each request and is visibe on the logs on Portkey dashboard. You can also set a **distinct trace id** for each request. You can [append user feedback](https://docs.portkey.ai/key-features/feedback-api) to a trace id as well.
+3. **Caching:** Respond to previously served customers queries from cache instead of sending them again to OpenAI. Match exact strings OR semantically similar strings. Cache can save costs and reduce latencies by 20x.
+4. **Retries:** Automatically reprocess any unsuccessful API requests **`upto 5`** times. Uses an **`exponential backoff`** strategy, which spaces out retry attempts to prevent network overload.
+5. **Tagging:** Track and audit each user interaction in high detail with predefined tags.
+
+| Feature | Config Key | Value (Type) | Required/Optional |
+| -- | -- | -- | -- |
+| API Key | `api_key` | API Key (`string`) | ✅ Required |
+| [Tracing Requests](https://docs.portkey.ai/key-features/request-tracing) | `trace_id` | Custom `string` | ❔ Optional |
+| [Automatic Retries](https://docs.portkey.ai/key-features/automatic-retries) | `retry_count` | `integer` [1,2,3,4,5] | ❔ Optional |
+| [Enabling Cache](https://docs.portkey.ai/key-features/request-caching) | `cache` | `simple` OR `semantic` | ❔ Optional |
+| Cache Force Refresh | `cache_force_refresh` | `True` | ❔ Optional |
+| Set Cache Expiry | `cache_age` | `integer` (in seconds) | ❔ Optional |
+| [Add User](https://docs.portkey.ai/key-features/custom-metadata) | `user` | `string` | ❔ Optional |
+| [Add Organisation](https://docs.portkey.ai/key-features/custom-metadata) | `organisation` | `string` | ❔ Optional |
+| [Add Environment](https://docs.portkey.ai/key-features/custom-metadata) | `environment` | `string` | ❔ Optional |
+| [Add Prompt (version/id/string)](https://docs.portkey.ai/key-features/custom-metadata) | `prompt` | `string` | ❔ Optional |
 
 
-Additional Docs are available here:
-- Observability - https://portkey.ai/docs/product/observability-modern-monitoring-for-llms
-- AI Gateway - https://portkey.ai/docs/product/ai-gateway-streamline-llm-integrations
-- Prompt Library - https://portkey.ai/docs/product/prompt-library
+## **Enabling all Portkey Features:**
 
-You can check out our popular Open Source AI Gateway here - https://github.com/portkey-ai/gateway
+```py
+headers = Portkey.Config(
+    
+    # Mandatory
+    api_key="<PORTKEY_API_KEY>",  
+	
+	# Cache Options
+    cache="semantic",                 
+    cache_force_refresh="True",             
+    cache_age=1729,  
 
-For detailed information on each feature and how to use it, [please refer to the Portkey docs](https://portkey.ai/docs). If you have any questions or need further assistance, [reach out to us on Twitter.](https://twitter.com/portkeyai) or our [support email](mailto:hello@portkey.ai).
+    # Advanced
+    retry_count=5,                                           
+    trace_id="langchain_agent",                          
+
+    # Metadata
+    environment="production",        
+    user="john",                      
+    organisation="acme",             
+    prompt="Frost"
+    
+)
+```
+
+
+For detailed information on each feature and how to use it, [please refer to the Portkey docs](https://docs.portkey.ai). If you have any questions or need further assistance, [reach out to us on Twitter.](https://twitter.com/portkeyai).

docs/docs/integrations/providers/portkey/logging_tracing_portkey.ipynb

@@ -6,7 +6,7 @@
    "source": [
     "# Log, Trace, and Monitor\n",
     "\n",
-    "When building apps or agents using Langchain, you end up making multiple API calls to fulfill a single user request. However, these requests are not chained when you want to analyse them. With [**Portkey**](/docs/integrations/providers/portkey/), all the embeddings, completions, and other requests from a single user request will get logged and traced to a common ID, enabling you to gain full visibility of user interactions.\n",
+    "When building apps or agents using Langchain, you end up making multiple API calls to fulfill a single user request. However, these requests are not chained when you want to analyse them. With [**Portkey**](/docs/integrations/providers/portkey), all the embeddings, completion, and other requests from a single user request will get logged and traced to a common ID, enabling you to gain full visibility of user interactions.\n",
     "\n",
     "This notebook serves as a step-by-step guide on how to log, trace, and monitor Langchain LLM calls using `Portkey` in your Langchain app."
    ]
@@ -20,15 +20,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import os\n",
     "\n",
-    "from langchain.agents import AgentExecutor, create_openai_tools_agent\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "from portkey_ai import PORTKEY_GATEWAY_URL, createHeaders"
+    "from langchain.agents import AgentType, initialize_agent, load_tools\n",
+    "from langchain_community.utilities import Portkey\n",
+    "from langchain_openai import OpenAI"
    ]
   },
   {
@@ -40,11 +40,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "os.environ[\"OPENAI_API_KEY\"] = \"...\""
+    "os.environ[\"OPENAI_API_KEY\"] = \"<OPENAI_API_KEY>\""
    ]
   },
   {
@@ -52,18 +52,18 @@
    "metadata": {},
    "source": [
     "## Get Portkey API Key\n",
-    "1. Sign up for [Portkey here](https://app.portkey.ai/signup)\n",
-    "2. On your [dashboard](https://app.portkey.ai/), click on the profile icon on the bottom left, then click on \"Copy API Key\"\n",
+    "1. Sign up for [Portkey here](https://app.portkey.ai/login)\n",
+    "2. On your [dashboard](https://app.portkey.ai/), click on the profile icon on the top left, then click on \"Copy API Key\"\n",
     "3. Paste it below"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "PORTKEY_API_KEY = \"...\"  # Paste your Portkey API Key here"
+    "PORTKEY_API_KEY = \"<PORTKEY_API_KEY>\"  # Paste your Portkey API Key here"
    ]
   },
   {
@@ -77,11 +77,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "TRACE_ID = \"uuid-trace-id\"  # Set trace id here"
+    "TRACE_ID = \"portkey_langchain_demo\"  # Set trace id here"
    ]
   },
   {
@@ -93,49 +93,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "portkey_headers = createHeaders(\n",
-    "    api_key=PORTKEY_API_KEY, provider=\"openai\", trace_id=TRACE_ID\n",
+    "headers = Portkey.Config(\n",
+    "    api_key=PORTKEY_API_KEY,\n",
+    "    trace_id=TRACE_ID,\n",
     ")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Define the prompts and the tools to use"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain import hub\n",
-    "from langchain_core.tools import tool\n",
-    "\n",
-    "prompt = hub.pull(\"hwchase17/openai-tools-agent\")\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def multiply(first_int: int, second_int: int) -> int:\n",
-    "    \"\"\"Multiply two integers together.\"\"\"\n",
-    "    return first_int * second_int\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def exponentiate(base: int, exponent: int) -> int:\n",
-    "    \"Exponentiate the base to the exponent power.\"\n",
-    "    return base**exponent\n",
-    "\n",
-    "\n",
-    "tools = [multiply, exponentiate]"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -145,60 +112,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `exponentiate` with `{'base': 3, 'exponent': 5}`\n",
-      "\n",
-      "\n",
-      "\u001b[0m\u001b[33;1m\u001b[1;3m243\u001b[0m\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `multiply` with `{'first_int': 243, 'second_int': 36}`\n",
-      "\n",
-      "\n",
-      "\u001b[0m\u001b[36;1m\u001b[1;3m8748\u001b[0m\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `exponentiate` with `{'base': 8748, 'exponent': 2}`\n",
-      "\n",
-      "\n",
-      "\u001b[0m\u001b[33;1m\u001b[1;3m76527504\u001b[0m\u001b[32;1m\u001b[1;3mThe result of taking 3 to the fifth power, multiplying it by 36, and then squaring the result is 76,527,504.\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'input': 'Take 3 to the fifth power and multiply that by thirty six, then square the result',\n",
-       " 'output': 'The result of taking 3 to the fifth power, multiplying it by 36, and then squaring the result is 76,527,504.'}"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "model = ChatOpenAI(\n",
-    "    base_url=PORTKEY_GATEWAY_URL, default_headers=portkey_headers, temperature=0\n",
+    "llm = OpenAI(temperature=0, headers=headers)\n",
+    "tools = load_tools([\"serpapi\", \"llm-math\"], llm=llm)\n",
+    "agent = initialize_agent(\n",
+    "    tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True\n",
     ")\n",
     "\n",
-    "# Construct the OpenAI Tools agent\n",
-    "agent = create_openai_tools_agent(model, tools, prompt)\n",
-    "\n",
-    "# Create an agent executor by passing in the agent and tools\n",
-    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)\n",
-    "\n",
-    "agent_executor.invoke(\n",
-    "    {\n",
-    "        \"input\": \"Take 3 to the fifth power and multiply that by thirty six, then square the result\"\n",
-    "    }\n",
+    "# Let's test it out!\n",
+    "agent.run(\n",
+    "    \"What was the high temperature in SF yesterday in Fahrenheit? What is that number raised to the .023 power?\"\n",
     ")"
    ]
   },
@@ -212,13 +138,10 @@
     "- Sending your request through Portkey ensures that all of the requests are logged by default\n",
     "- Each request log contains `timestamp`, `model name`, `total cost`, `request time`, `request json`, `response json`, and additional Portkey features\n",
     "\n",
-    "**[Tracing](https://portkey.ai/docs/product/observability-modern-monitoring-for-llms/traces)**\n",
-    "- Trace id is passed along with each request and is visible on the logs on Portkey dashboard\n",
+    "**Tracing**\n",
+    "- Trace id is passed along with each request and is visibe on the logs on Portkey dashboard\n",
     "- You can also set a **distinct trace id** for each request if you want\n",
-    "- You can append user feedback to a trace id as well. [More info on this here](https://portkey.ai/docs/product/observability-modern-monitoring-for-llms/feedback)\n",
-    "\n",
-    "For the above request, you will be able to view the entire log trace like this\n",
-    "![View Langchain traces on Portkey](https://assets.portkey.ai/docs/agent_tracing.gif)"
+    "- You can append user feedback to a trace id as well. [More info on this here](https://docs.portkey.ai/key-features/feedback-api)"
    ]
   },
   {
@@ -231,15 +154,62 @@
     "\n",
     "**Caching**\n",
     "\n",
-    "Respond to previously served customers queries from cache instead of sending them again to OpenAI. Match exact strings OR semantically similar strings. Cache can save costs and reduce latencies by 20x. [Docs](https://portkey.ai/docs/product/ai-gateway-streamline-llm-integrations/cache-simple-and-semantic)\n",
+    "Respond to previously served customers queries from cache instead of sending them again to OpenAI. Match exact strings OR semantically similar strings. Cache can save costs and reduce latencies by 20x.\n",
     "\n",
     "**Retries**\n",
     "\n",
-    "Automatically reprocess any unsuccessful API requests **`upto 5`** times. Uses an **`exponential backoff`** strategy, which spaces out retry attempts to prevent network overload.[Docs](https://portkey.ai/docs/product/ai-gateway-streamline-llm-integrations)\n",
+    "Automatically reprocess any unsuccessful API requests **`upto 5`** times. Uses an **`exponential backoff`** strategy, which spaces out retry attempts to prevent network overload.\n",
+    "\n",
+    "| Feature | Config Key | Value (Type) |\n",
+    "| -- | -- | -- |\n",
+    "| [🔁 Automatic Retries](https://docs.portkey.ai/key-features/automatic-retries) | `retry_count` | `integer` [1,2,3,4,5] |\n",
+    "| [🧠 Enabling Cache](https://docs.portkey.ai/key-features/request-caching) | `cache` | `simple` OR `semantic` |\n",
     "\n",
     "**Tagging**\n",
     "\n",
-    "Track and audit each user interaction in high detail with predefined tags. [Docs](https://portkey.ai/docs/product/observability-modern-monitoring-for-llms/metadata)"
+    "Track and audit ach user interaction in high detail with predefined tags.\n",
+    "\n",
+    "| Tag | Config Key | Value (Type) |\n",
+    "| -- | -- | -- |\n",
+    "| User Tag | `user` | `string` |\n",
+    "| Organisation Tag | `organisation` | `string` |\n",
+    "| Environment Tag | `environment` | `string` |\n",
+    "| Prompt Tag (version/id/string) | `prompt` | `string` |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Code Example With All Features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "headers = Portkey.Config(\n",
+    "    # Mandatory\n",
+    "    api_key=\"<PORTKEY_API_KEY>\",\n",
+    "    # Cache Options\n",
+    "    cache=\"semantic\",\n",
+    "    cache_force_refresh=\"True\",\n",
+    "    cache_age=1729,\n",
+    "    # Advanced\n",
+    "    retry_count=5,\n",
+    "    trace_id=\"langchain_agent\",\n",
+    "    # Metadata\n",
+    "    environment=\"production\",\n",
+    "    user=\"john\",\n",
+    "    organisation=\"acme\",\n",
+    "    prompt=\"Frost\",\n",
+    ")\n",
+    "\n",
+    "llm = OpenAI(temperature=0.9, headers=headers)\n",
+    "\n",
+    "print(llm(\"Two roads diverged in the yellow woods\"))"
    ]
   }
  ],
@@ -259,7 +229,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/providers/predibase.md

@@ -23,21 +23,6 @@ response = model("Can you recommend me a nice dry wine?")
 print(response)
 ```
 
-Predibase also supports Predibase-hosted and HuggingFace-hosted adapters that are fine-tuned on the base model given by the `model` argument:
-
-```python
-import os
-os.environ["PREDIBASE_API_TOKEN"] = "{PREDIBASE_API_TOKEN}"
-
-from langchain_community.llms import Predibase
-
-# The fine-tuned adapter is hosted at Predibase (adapter_version can be specified; omitting it is equivalent to the most recent version).
-model =  Predibase(model="mistral-7b"", adapter_id="e2e_nlg", adapter_version=1, predibase_api_key=os.environ.get("PREDIBASE_API_TOKEN"))
-
-response = model("Can you recommend me a nice dry wine?")
-print(response)
-```
-
 Predibase also supports adapters that are fine-tuned on the base model given by the `model` argument:
 
 ```python
@@ -46,7 +31,6 @@ os.environ["PREDIBASE_API_TOKEN"] = "{PREDIBASE_API_TOKEN}"
 
 from langchain_community.llms import Predibase
 
-# The fine-tuned adapter is hosted at HuggingFace (adapter_version does not apply and will be ignored).
 model =  Predibase(model="mistral-7b"", adapter_id="predibase/e2e_nlg", predibase_api_key=os.environ.get("PREDIBASE_API_TOKEN"))
 
 response = model("Can you recommend me a nice dry wine?")

docs/docs/integrations/providers/snowflake.mdx

@@ -1,32 +0,0 @@
-# Snowflake
-
-> [Snowflake](https://www.snowflake.com/) is a cloud-based data-warehousing platform 
-> that allows you to store and query large amounts of data.
-
-This page covers how to use the `Snowflake` ecosystem within `LangChain`.
-
-## Embedding models
-
-Snowflake offers their open weight `arctic` line of embedding models for free
-on [Hugging Face](https://huggingface.co/Snowflake/snowflake-arctic-embed-l). 
-You can use these models via the 
-[HuggingFaceEmbeddings](/docs/integrations/text_embedding/huggingfacehub) connector:
-
-```shell
-pip install langchain-community sentence-transformers
-```
-
-```python
-from langchain_community.text_embeddings import HuggingFaceEmbeddings
-
-model = HuggingFaceEmbeddings(model_name="snowflake/arctic-embed-l")
-```
-
-## Document loader
-
-You can use the [`SnowflakeLoader`](/docs/integrations/document_loaders/snowflake) 
-to load data from Snowflake:
-
-```python
-from langchain_community.document_loaders import SnowflakeLoader
-```

docs/docs/integrations/providers/upstage.ipynb

@@ -1,149 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Upstage\n",
-    "\n",
-    "[Upstage](https://upstage.ai) is a leading artificial intelligence (AI) company specializing in delivering above-human-grade performance LLM components. \n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Solar LLM\n",
-    "\n",
-    "**Solar Mini Chat** is a fast yet powerful advanced large language model focusing on English and Korean. It has been specifically fine-tuned for multi-turn chat purposes, showing enhanced performance across a wide range of natural language processing tasks, like multi-turn conversation or tasks that require an understanding of long contexts, such as RAG (Retrieval-Augmented Generation), compared to other models of a similar size. This fine-tuning equips it with the ability to handle longer conversations more effectively, making it particularly adept for interactive applications."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Installation and Setup\n",
-    "\n",
-    "Install `langchain-upstage` package:\n",
-    "\n",
-    "```bash\n",
-    "pip install -qU langchain-core langchain-upstage\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Get an [access token](https://console.upstage.ai) and set it as an environment variable (`UPSTAGE_API_KEY`)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Upstage LangChain integrations\n",
-    "\n",
-    "| API | Description | Import | Example usage |\n",
-    "| --- | --- | --- | --- |\n",
-    "| Chat | Build assistants using Solar Mini Chat | `from langchain_upstage import ChatUpstage` | [Go](../../chat/upstage) |\n",
-    "| Text Embedding | Embed strings to vectors | `from langchain_upstage import UpstageEmbeddings` | [Go](../../text_embedding/upstage) |\n",
-    "\n",
-    "See [documentations](https://developers.upstage.ai/) for more details about the features."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Quick Examples\n",
-    "\n",
-    "### Environment Setup"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"UPSTAGE_API_KEY\"] = \"YOUR_API_KEY\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "### Chat\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_upstage import ChatUpstage\n",
-    "\n",
-    "chat = ChatUpstage()\n",
-    "response = chat.invoke(\"Hello, how are you?\")\n",
-    "print(response)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n",
-    "### Text embedding\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_upstage import UpstageEmbeddings\n",
-    "\n",
-    "embeddings = UpstageEmbeddings()\n",
-    "doc_result = embeddings.embed_documents(\n",
-    "    [\"Sam is a teacher.\", \"This is another document\"]\n",
-    ")\n",
-    "print(doc_result)\n",
-    "\n",
-    "query_result = embeddings.embed_query(\"What does Sam do?\")\n",
-    "print(query_result)"
-   ]
-  }
- ],
- "metadata": {
-  "colab": {
-   "provenance": []
-  },
-  "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.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}

docs/docs/integrations/providers/uptrain.md

@@ -1,20 +0,0 @@
-# UpTrain
-
->[UpTrain](https://uptrain.ai/) is an open-source unified platform to evaluate and
->improve Generative AI applications. It provides grades for 20+ preconfigured evaluations 
->(covering language, code, embedding use cases), performs root cause analysis on failure 
->cases and gives insights on how to resolve them.
-
-## Installation and Setup
-
-```bash
-pip install uptrain
-```
-
-## Callbacks
-
-```python
-from langchain_community.callbacks.uptrain_callback import UpTrainCallbackHandler
-```
-
-See an [example](/docs/integrations/callbacks/uptrain).

docs/docs/integrations/providers/vlite.mdx

@@ -1,31 +0,0 @@
-# vlite
-
-This page covers how to use [vlite](https://github.com/sdan/vlite) within LangChain. vlite is a simple and fast vector database for storing and retrieving embeddings.
-
-## Installation and Setup
-
-To install vlite, run the following command:
-
-```bash
-pip install vlite
-```
-
-For PDF OCR support, install the `vlite[ocr]` extra:
-
-```bash
-pip install vlite[ocr]
-```
-
-## VectorStore
-
-vlite provides a wrapper around its vector database, allowing you to use it as a vectorstore for semantic search and example selection.
-
-To import the vlite vectorstore:
-
-```python
-from langchain_community.vectorstores import vlite
-```
-
-### Usage
-
-For a more detailed walkthrough of the vlite wrapper, see [this notebook](/docs/integrations/vectorstores/vlite).

docs/docs/integrations/retrievers/merger_retriever.ipynb

@@ -28,12 +28,12 @@
     "    DocumentCompressorPipeline,\n",
     "    MergerRetriever,\n",
     ")\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_transformers import (\n",
     "    EmbeddingsClusteringFilter,\n",
     "    EmbeddingsRedundantFilter,\n",
     ")\n",
     "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "# Get 3 diff embeddings.\n",

docs/docs/integrations/retrievers/re_phrase.ipynb

@@ -28,8 +28,8 @@
     "import logging\n",
     "\n",
     "from langchain.retrievers import RePhraseQueryRetriever\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import WebBaseLoader\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter"
    ]

docs/docs/integrations/retrievers/self_query/chroma_self_query.ipynb

@@ -20,7 +20,7 @@
     "## Creating a Chroma vector store\n",
     "First we'll want to create a Chroma vector store and seed it with some data. We've created a small demo set of documents that contain summaries of movies.\n",
     "\n",
-    "**Note:** The self-query retriever requires you to have `lark` installed (`pip install lark`). We also need the `langchain-chroma` package."
+    "**Note:** The self-query retriever requires you to have `lark` installed (`pip install lark`). We also need the `chromadb` package."
    ]
   },
   {
@@ -44,7 +44,7 @@
    },
    "outputs": [],
    "source": [
-    "%pip install --upgrade --quiet  langchain-chroma"
+    "%pip install --upgrade --quiet  chromadb"
    ]
   },
   {
@@ -87,7 +87,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain_chroma import Chroma\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_core.documents import Document\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",

docs/docs/integrations/retrievers/thirdai_neuraldb.ipynb

@@ -1,148 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# **NeuralDB**\n",
-    "NeuralDB is a CPU-friendly and fine-tunable retrieval engine developed by ThirdAI.\n",
-    "\n",
-    "### **Initialization**\n",
-    "There are two initialization methods:\n",
-    "- From Scratch: Basic model\n",
-    "- From Checkpoint: Load a model that was previously saved\n",
-    "\n",
-    "For all of the following initialization methods, the `thirdai_key` parameter can be ommitted if the `THIRDAI_KEY` environment variable is set.\n",
-    "\n",
-    "ThirdAI API keys can be obtained at https://www.thirdai.com/try-bolt/"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.retrievers import NeuralDBRetriever\n",
-    "\n",
-    "# From scratch\n",
-    "retriever = NeuralDBRetriever.from_scratch(thirdai_key=\"your-thirdai-key\")\n",
-    "\n",
-    "# From checkpoint\n",
-    "retriever = NeuralDBRetriever.from_checkpoint(\n",
-    "    # Path to a NeuralDB checkpoint. For example, if you call\n",
-    "    # retriever.save(\"/path/to/checkpoint.ndb\") in one script, then you can\n",
-    "    # call NeuralDBRetriever.from_checkpoint(\"/path/to/checkpoint.ndb\") in\n",
-    "    # another script to load the saved model.\n",
-    "    checkpoint=\"/path/to/checkpoint.ndb\",\n",
-    "    thirdai_key=\"your-thirdai-key\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### **Inserting document sources**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "retriever.insert(\n",
-    "    # If you have PDF, DOCX, or CSV files, you can directly pass the paths to the documents\n",
-    "    sources=[\"/path/to/doc.pdf\", \"/path/to/doc.docx\", \"/path/to/doc.csv\"],\n",
-    "    # When True this means that the underlying model in the NeuralDB will\n",
-    "    # undergo unsupervised pretraining on the inserted files. Defaults to True.\n",
-    "    train=True,\n",
-    "    # Much faster insertion with a slight drop in performance. Defaults to True.\n",
-    "    fast_mode=True,\n",
-    ")\n",
-    "\n",
-    "from thirdai import neural_db as ndb\n",
-    "\n",
-    "retriever.insert(\n",
-    "    # If you have files in other formats, or prefer to configure how\n",
-    "    # your files are parsed, then you can pass in NeuralDB document objects\n",
-    "    # like this.\n",
-    "    sources=[\n",
-    "        ndb.PDF(\n",
-    "            \"/path/to/doc.pdf\",\n",
-    "            version=\"v2\",\n",
-    "            chunk_size=100,\n",
-    "            metadata={\"published\": 2022},\n",
-    "        ),\n",
-    "        ndb.Unstructured(\"/path/to/deck.pptx\"),\n",
-    "    ]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### **Retrieving documents**\n",
-    "To query the retriever, you can use the standard LangChain retriever method `get_relevant_documents`, which returns a list of LangChain Document objects. Each document object represents a chunk of text from the indexed files. For example, it may contain a paragraph from one of the indexed PDF files. In addition to the text, the document's metadata field contains information such as the document's ID, the source of this document (which file it came from), and the score of the document."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This returns a list of LangChain Document objects\n",
-    "documents = retriever.get_relevant_documents(\"query\", top_k=10)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### **Fine tuning**\n",
-    "NeuralDBRetriever can be fine-tuned to user behavior and domain-specific knowledge. It can be fine-tuned in two ways:\n",
-    "1. Association: the retriever associates a source phrase with a target phrase. When the retriever sees the source phrase, it will also consider results that are relevant to the target phrase.\n",
-    "2. Upvoting: the retriever upweights the score of a document for a specific query. This is useful when you want to fine-tune the retriever to user behavior. For example, if a user searches \"how is a car manufactured\" and likes the returned document with id 52, then we can upvote the document with id 52 for the query \"how is a car manufactured\"."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "retriever.associate(source=\"source phrase\", target=\"target phrase\")\n",
-    "retriever.associate_batch(\n",
-    "    [\n",
-    "        (\"source phrase 1\", \"target phrase 1\"),\n",
-    "        (\"source phrase 2\", \"target phrase 2\"),\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "retriever.upvote(query=\"how is a car manufactured\", document_id=52)\n",
-    "retriever.upvote_batch(\n",
-    "    [\n",
-    "        (\"query 1\", 52),\n",
-    "        (\"query 2\", 20),\n",
-    "    ]\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "langchain",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.10.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/text_embedding/openvino.ipynb

@@ -41,10 +41,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "ff9be586",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, onnx, openvino\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/utils/import_utils.py:519: FutureWarning: `is_torch_tpu_available` is deprecated and will be removed in 4.41.0. Please use the `is_torch_xla_available` instead.\n",
+      "  warnings.warn(\n",
+      "Framework not specified. Using pt to export the model.\n",
+      "Using the export variant default. Available variants are:\n",
+      "    - default: The default ONNX variant.\n",
+      "Using framework PyTorch: 2.2.1+cu121\n",
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/modeling_utils.py:4225: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
+      "  warnings.warn(\n",
+      "Compiling the model to CPU ...\n"
+     ]
+    }
+   ],
    "source": [
     "model_name = \"sentence-transformers/all-mpnet-base-v2\"\n",
     "model_kwargs = {\"device\": \"CPU\"}\n",
@@ -100,7 +131,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "bb5e74c0",
    "metadata": {},
    "outputs": [],
@@ -119,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "a6544a65",
    "metadata": {},
    "outputs": [],
@@ -128,23 +159,24 @@
     "\n",
     "ov_model_dir = \"all-mpnet-base-v2-ov\"\n",
     "if not Path(ov_model_dir).exists():\n",
-    "    ov_embeddings.save_model(ov_model_dir)"
+    "    from optimum.intel.openvino import OVModelForFeatureExtraction\n",
+    "    from transformers import AutoTokenizer\n",
+    "\n",
+    "    ov_model = OVModelForFeatureExtraction.from_pretrained(\n",
+    "        model_name, compile=False, export=True\n",
+    "    )\n",
+    "    tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
+    "    ov_model.half()\n",
+    "    ov_model.save_pretrained(ov_model_dir)\n",
+    "    tokenizer.save_pretrained(ov_model_dir)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "162004c4",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Compiling the model to CPU ...\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "ov_embeddings = OpenVINOEmbeddings(\n",
     "    model_name_or_path=ov_model_dir,\n",
@@ -164,10 +196,43 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "66f5c6ba-1446-43e1-b012-800d17cef300",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, onnx, openvino\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/utils/import_utils.py:519: FutureWarning: `is_torch_tpu_available` is deprecated and will be removed in 4.41.0. Please use the `is_torch_xla_available` instead.\n",
+      "  warnings.warn(\n",
+      "Framework not specified. Using pt to export the model.\n",
+      "Using the export variant default. Available variants are:\n",
+      "    - default: The default ONNX variant.\n",
+      "Using framework PyTorch: 2.2.1+cu121\n",
+      "Overriding 1 configuration item(s)\n",
+      "\t- use_cache -> False\n",
+      "/home/ethan/intel/langchain_test/lib/python3.10/site-packages/transformers/modeling_utils.py:4225: FutureWarning: `_is_quantized_training_enabled` is going to be deprecated in transformers 4.39.0. Please use `model.hf_quantizer.is_trainable` instead\n",
+      "  warnings.warn(\n",
+      "Compiling the model to CPU ...\n"
+     ]
+    }
+   ],
    "source": [
     "from langchain_community.embeddings import OpenVINOBgeEmbeddings\n",
     "\n",

docs/docs/integrations/text_embedding/titan_takeoff.ipynb

@@ -1,112 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Titan Takeoff\n",
-    "\n",
-    "`TitanML` helps businesses build and deploy better, smaller, cheaper, and faster NLP models through our training, compression, and inference optimization platform.\n",
-    "\n",
-    "Our inference server, [Titan Takeoff](https://docs.titanml.co/docs/intro) enables deployment of LLMs locally on your hardware in a single command. Most embedding models are supported out of the box, if you experience trouble with a specific model, please let us know at hello@titanml.co."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Example usage\n",
-    "Here are some helpful examples to get started using Titan Takeoff Server. You need to make sure Takeoff Server has been started in the background before running these commands. For more information see [docs page for launching Takeoff](https://docs.titanml.co/docs/Docs/launching/)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import time\n",
-    "\n",
-    "from langchain_community.embeddings import TitanTakeoffEmbed"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Example 1\n",
-    "Basic use assuming Takeoff is running on your machine using its default ports (ie localhost:3000)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "embed = TitanTakeoffEmbed()\n",
-    "output = embed.embed_query(\n",
-    "    \"What is the weather in London in August?\", consumer_group=\"embed\"\n",
-    ")\n",
-    "print(output)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Example 2 \n",
-    "Starting readers using TitanTakeoffEmbed Python Wrapper. If you haven't created any readers with first launching Takeoff, or you want to add another you can do so when you initialize the TitanTakeoffEmbed object. Just pass a list of models you want to start as the `models` parameter.\n",
-    "\n",
-    "You can use `embed.query_documents` to embed multiple documents at once. The expected input is a list of strings, rather than just a string expected for the `embed_query` method."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Model config for the embedding model, where you can specify the following parameters:\n",
-    "#   model_name (str): The name of the model to use\n",
-    "#   device: (str): The device to use for inference, cuda or cpu\n",
-    "#   consumer_group (str): The consumer group to place the reader into\n",
-    "embedding_model = {\n",
-    "    \"model_name\": \"BAAI/bge-large-en-v1.5\",\n",
-    "    \"device\": \"cpu\",\n",
-    "    \"consumer_group\": \"embed\",\n",
-    "}\n",
-    "embed = TitanTakeoffEmbed(models=[embedding_model])\n",
-    "\n",
-    "# The model needs time to spin up, length of time need will depend on the size of model and your network connection speed\n",
-    "time.sleep(60)\n",
-    "\n",
-    "prompt = \"What is the capital of France?\"\n",
-    "# We specified \"embed\" consumer group so need to send request to the same consumer group so it hits our embedding model and not others\n",
-    "output = embed.embed_query(prompt, consumer_group=\"embed\")\n",
-    "print(output)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "langchain",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/text_embedding/upstage.ipynb

@@ -1,216 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "a1915c573ecefe5e",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "---\n",
-    "sidebar_label: Upstage\n",
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c07bf6cf93adec81",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "# UpstageEmbeddings\n",
-    "\n",
-    "This notebook covers how to get started with Upstage embedding models.\n",
-    "\n",
-    "## Installation\n",
-    "\n",
-    "Install `langchain-upstage` package.\n",
-    "\n",
-    "```bash\n",
-    "pip install -U langchain-upstage\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c2b1c8fd01d71683",
-   "metadata": {
-    "collapsed": false
-   },
-   "source": [
-    "## Environment Setup\n",
-    "\n",
-    "Make sure to set the following environment variables:\n",
-    "\n",
-    "- `UPSTAGE_API_KEY`: Your Upstage API key from [Upstage console](https://console.upstage.ai/)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a50c04f9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"UPSTAGE_API_KEY\"] = \"YOUR_API_KEY\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c02e30aa",
-   "metadata": {},
-   "source": [
-    "\n",
-    "## Usage\n",
-    "\n",
-    "Initialize `UpstageEmbeddings` class."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ea89ac9da2520b91",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "from langchain_upstage import UpstageEmbeddings\n",
-    "\n",
-    "embeddings = UpstageEmbeddings()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8be6eab1",
-   "metadata": {},
-   "source": [
-    "Use `embed_documents` to embed list of texts or documents. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "26aa179f7ad60cbe",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "doc_result = embeddings.embed_documents(\n",
-    "    [\"Sam is a teacher.\", \"This is another document\"]\n",
-    ")\n",
-    "print(doc_result)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0197135c",
-   "metadata": {},
-   "source": [
-    "Use `embed_query` to embed query string."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5a80d47413c27bbc",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "query_result = embeddings.embed_query(\"What does Sam do?\")\n",
-    "print(query_result)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6d5ff58e",
-   "metadata": {},
-   "source": [
-    "Use `aembed_documents` and `aembed_query` for async operations."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "af75139d0e1d9ba2",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# async embed query\n",
-    "await embeddings.aembed_query(\"My query to look up\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "17968d20c0dfb2f9",
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
-   "source": [
-    "# async embed documents\n",
-    "await embeddings.aembed_documents(\n",
-    "    [\"This is a content of the document\", \"This is another document\"]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6429f2f8",
-   "metadata": {},
-   "source": [
-    "## Using with vector store\n",
-    "\n",
-    "You can use `UpstageEmbeddings` with vector store component. The following demonstrates a simple example."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "09ac41d5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.vectorstores import DocArrayInMemorySearch\n",
-    "\n",
-    "vectorstore = DocArrayInMemorySearch.from_texts(\n",
-    "    [\"harrison worked at kensho\", \"bears like to eat honey\"],\n",
-    "    embedding=UpstageEmbeddings(),\n",
-    ")\n",
-    "retriever = vectorstore.as_retriever()\n",
-    "docs = retriever.get_relevant_documents(\"Where did Harrison work?\")\n",
-    "print(docs)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 2
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/tools/dataherald.ipynb

@@ -1,117 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "245a954a",
-   "metadata": {},
-   "source": [
-    "# Dataherald\n",
-    "\n",
-    "This notebook goes over how to use the dataherald component.\n",
-    "\n",
-    "First, you need to set up your Dataherald account and get your API KEY:\n",
-    "\n",
-    "1. Go to dataherald and sign up [here](https://www.dataherald.com/)\n",
-    "2. Once you are logged in your Admin Console, create an API KEY\n",
-    "3. pip install dataherald\n",
-    "\n",
-    "Then we will need to set some environment variables:\n",
-    "1. Save your API KEY into DATAHERALD_API_KEY env variable"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "961b3689",
-   "metadata": {
-    "vscode": {
-     "languageId": "shellscript"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "pip install dataherald"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "34bb5968",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"DATAHERALD_API_KEY\"] = \"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "ac4910f8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.utilities.dataherald import DataheraldAPIWrapper"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "84b8f773",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dataherald = DataheraldAPIWrapper(db_connection_id=\"65fb766367dd22c99ce1a12d\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "068991a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'select COUNT(*) from employees'"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "dataherald.run(\"How many employees are in the company?\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.7"
-  },
-  "vscode": {
-   "interpreter": {
-    "hash": "53f3bc57609c7a84333bb558594977aa5b4026b1d6070b93987956689e367341"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/tools/nuclia.ipynb

@@ -8,7 +8,7 @@
     "\n",
     ">[Nuclia](https://nuclia.com) automatically indexes your unstructured data from any internal and external source, providing optimized search results and generative answers. It can handle video and audio transcription, image content extraction, and document parsing.\n",
     "\n",
-    "The `Nuclia Understanding API` supports the processing of unstructured data, including text, web pages, documents, and audio/video contents. It extracts all texts wherever it is (using speech-to-text or OCR when needed), it identifies entities, it also extracts metadata, embedded files (like images in a PDF), and web links. It also provides a summary of the content.\n",
+    "The `Nuclia Understanding API` supports the processing of unstructured data, including text, web pages, documents, and audio/video contents. It extracts all texts wherever it is (using speech-to-text or OCR when needed), it identifies entities, it aslo extracts metadata, embedded files (like images in a PDF), and web links. It also provides a summary of the content.\n",
     "\n",
     "To use the `Nuclia Understanding API`, you need to have a `Nuclia` account. You can create one for free at [https://nuclia.cloud](https://nuclia.cloud), and then [create a NUA key](https://docs.nuclia.dev/docs/docs/using/understanding/intro)."
    ]

docs/docs/integrations/vectorstores/chroma.ipynb

@@ -13,7 +13,7 @@
     "Install Chroma with:\n",
     "\n",
     "```sh\n",
-    "pip install langchain-chroma\n",
+    "pip install chromadb\n",
     "```\n",
     "\n",
     "Chroma runs in various modes. See below for examples of each integrated with LangChain.\n",
@@ -65,11 +65,11 @@
    ],
    "source": [
     "# import\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import TextLoader\n",
     "from langchain_community.embeddings.sentence_transformer import (\n",
     "    SentenceTransformerEmbeddings,\n",
     ")\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "# load the document and split it into chunks\n",

docs/docs/integrations/vectorstores/google_cloud_sql_mysql.ipynb

@@ -1,585 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Google Cloud SQL for MySQL\n",
-        "\n",
-        "> [Cloud SQL](https://cloud.google.com/sql) is a fully managed relational database service that offers high performance, seamless integration, and impressive scalability. It offers PostgreSQL, MySQL, and SQL Server database engines. Extend your database application to build AI-powered experiences leveraging Cloud SQL's LangChain integrations.\n",
-        "\n",
-        "This notebook goes over how to use `Cloud SQL for MySQL` to store vector embeddings with the `MySQLVectorStore` class.\n",
-        "\n",
-        "Learn more about the package on [GitHub](https://github.com/googleapis/langchain-google-cloud-sql-mysql-python/).\n",
-        "\n",
-        "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/googleapis/langchain-google-cloud-sql-mysql-python/blob/main/docs/vector_store.ipynb)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Before you begin\n",
-        "\n",
-        "To run this notebook, you will need to do the following:\n",
-        "\n",
-        " * [Create a Google Cloud Project](https://developers.google.com/workspace/guides/create-project)\n",
-        " * [Enable the Cloud SQL Admin API.](https://console.cloud.google.com/flows/enableapi?apiid=sqladmin.googleapis.com)\n",
-        " * [Create a Cloud SQL instance.](https://cloud.google.com/sql/docs/mysql/connect-instance-auth-proxy#create-instance) (version must be >= **8.0.36** with **cloudsql_vector** database flag configured to \"On\")\n",
-        " * [Create a Cloud SQL database.](https://cloud.google.com/sql/docs/mysql/create-manage-databases)\n",
-        " * [Add a User to the database.](https://cloud.google.com/sql/docs/mysql/create-manage-users)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### 🦜🔗 Library Installation\n",
-        "Install the integration library, `langchain-google-cloud-sql-mysql`, and the library for the embedding service, `langchain-google-vertexai`."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "0ZITIDE160OD"
-      },
-      "outputs": [],
-      "source": [
-        "%pip install --upgrade --quiet langchain-google-cloud-sql-mysql langchain-google-vertexai"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "v40bB_GMcr9f"
-      },
-      "source": [
-        "**Colab only:** Uncomment the following cell to restart the kernel or use the button to restart the kernel. For Vertex AI Workbench you can restart the terminal using the button on top."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "v6jBDnYnNM08"
-      },
-      "outputs": [],
-      "source": [
-        "# # Automatically restart kernel after installs so that your environment can access the new packages\n",
-        "# import IPython\n",
-        "\n",
-        "# app = IPython.Application.instance()\n",
-        "# app.kernel.do_shutdown(True)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "yygMe6rPWxHS"
-      },
-      "source": [
-        "### 🔐 Authentication\n",
-        "Authenticate to Google Cloud as the IAM user logged into this notebook in order to access your Google Cloud Project.\n",
-        "\n",
-        "* If you are using Colab to run this notebook, use the cell below and continue.\n",
-        "* If you are using Vertex AI Workbench, check out the setup instructions [here](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/setup-env)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "PTXN1_DSXj2b"
-      },
-      "outputs": [],
-      "source": [
-        "from google.colab import auth\n",
-        "\n",
-        "auth.authenticate_user()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "NEvB9BoLEulY"
-      },
-      "source": [
-        "### ☁ Set Your Google Cloud Project\n",
-        "Set your Google Cloud project so that you can leverage Google Cloud resources within this notebook.\n",
-        "\n",
-        "If you don't know your project ID, try the following:\n",
-        "\n",
-        "* Run `gcloud config list`.\n",
-        "* Run `gcloud projects list`.\n",
-        "* See the support page: [Locate the project ID](https://support.google.com/googleapi/answer/7014113)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "cellView": "form",
-        "id": "gfkS3yVRE4_W"
-      },
-      "outputs": [],
-      "source": [
-        "# @markdown Please fill in the value below with your Google Cloud project ID and then run the cell.\n",
-        "\n",
-        "PROJECT_ID = \"my-project-id\"  # @param {type:\"string\"}\n",
-        "\n",
-        "# Set the project id\n",
-        "!gcloud config set project {PROJECT_ID}"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "f8f2830ee9ca1e01"
-      },
-      "source": [
-        "## Basic Usage"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "OMvzMWRrR6n7"
-      },
-      "source": [
-        "### Set Cloud SQL database values\n",
-        "Find your database values, in the [Cloud SQL Instances page](https://console.cloud.google.com/sql?_ga=2.223735448.2062268965.1707700487-2088871159.1707257687).\n",
-        "\n",
-        "**Note:** MySQL vector support is only available on MySQL instances with version **>= 8.0.36**.\n",
-        "\n",
-        "For existing instances, you may need to perform a [self-service maintenance update](https://cloud.google.com/sql/docs/mysql/self-service-maintenance) to update your maintenance version to **MYSQL_8_0_36.R20240401.03_00** or greater. Once updated, [configure your database flags](https://cloud.google.com/sql/docs/mysql/flags) to have the new **cloudsql_vector** flag to \"On\"."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# @title Set Your Values Here { display-mode: \"form\" }\n",
-        "REGION = \"us-central1\"  # @param {type: \"string\"}\n",
-        "INSTANCE = \"my-mysql-instance\"  # @param {type: \"string\"}\n",
-        "DATABASE = \"my-database\"  # @param {type: \"string\"}\n",
-        "TABLE_NAME = \"vector_store\"  # @param {type: \"string\"}"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "QuQigs4UoFQ2"
-      },
-      "source": [
-        "### MySQLEngine Connection Pool\n",
-        "\n",
-        "One of the requirements and arguments to establish Cloud SQL as a vector store is a `MySQLEngine` object. The `MySQLEngine` configures a connection pool to your Cloud SQL database, enabling successful connections from your application and following industry best practices.\n",
-        "\n",
-        "To create a `MySQLEngine` using `MySQLEngine.from_instance()` you need to provide only 4 things:\n",
-        "\n",
-        "1. `project_id` : Project ID of the Google Cloud Project where the Cloud SQL instance is located.\n",
-        "1. `region` : Region where the Cloud SQL instance is located.\n",
-        "1. `instance` : The name of the Cloud SQL instance.\n",
-        "1. `database` : The name of the database to connect to on the Cloud SQL instance.\n",
-        "\n",
-        "By default, [IAM database authentication](https://cloud.google.com/sql/docs/mysql/iam-authentication#iam-db-auth) will be used as the method of database authentication. This library uses the IAM principal belonging to the [Application Default Credentials (ADC)](https://cloud.google.com/docs/authentication/application-default-credentials) sourced from the envionment.\n",
-        "\n",
-        "For more informatin on IAM database authentication please see:\n",
-        "\n",
-        "* [Configure an instance for IAM database authentication](https://cloud.google.com/sql/docs/mysql/create-edit-iam-instances)\n",
-        "* [Manage users with IAM database authentication](https://cloud.google.com/sql/docs/mysql/add-manage-iam-users)\n",
-        "\n",
-        "Optionally, [built-in database authentication](https://cloud.google.com/sql/docs/mysql/built-in-authentication) using a username and password to access the Cloud SQL database can also be used. Just provide the optional `user` and `password` arguments to `MySQLEngine.from_instance()`:\n",
-        "\n",
-        "* `user` : Database user to use for built-in database authentication and login\n",
-        "* `password` : Database password to use for built-in database authentication and login.\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "guVURf1QLL53"
-      },
-      "outputs": [],
-      "source": [
-        "from langchain_google_cloud_sql_mysql import MySQLEngine\n",
-        "\n",
-        "engine = MySQLEngine.from_instance(\n",
-        "    project_id=PROJECT_ID, region=REGION, instance=INSTANCE, database=DATABASE\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Initialize a table\n",
-        "The `MySQLVectorStore` class requires a database table. The `MySQLEngine` class has a helper method `init_vectorstore_table()` that can be used to create a table with the proper schema for you."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "avlyHEMn6gzU"
-      },
-      "outputs": [],
-      "source": [
-        "engine.init_vectorstore_table(\n",
-        "    table_name=TABLE_NAME,\n",
-        "    vector_size=768,  # Vector size for VertexAI model(textembedding-gecko@latest)\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Create an embedding class instance\n",
-        "\n",
-        "You can use any [LangChain embeddings model](/docs/integrations/text_embedding/).\n",
-        "You may need to enable the Vertex AI API to use `VertexAIEmbeddings`.\n",
-        "\n",
-        "We recommend pinning the embedding model's version for production, learn more about the [Text embeddings models](https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/text-embeddings)."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "5utKIdq7KYi5"
-      },
-      "outputs": [],
-      "source": [
-        "# enable Vertex AI API\n",
-        "!gcloud services enable aiplatform.googleapis.com"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Vb2RJocV9_LQ"
-      },
-      "outputs": [],
-      "source": [
-        "from langchain_google_vertexai import VertexAIEmbeddings\n",
-        "\n",
-        "embedding = VertexAIEmbeddings(\n",
-        "    model_name=\"textembedding-gecko@latest\", project=PROJECT_ID\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "e1tl0aNx7SWy"
-      },
-      "source": [
-        "### Initialize a default MySQLVectorStore\n",
-        "\n",
-        "To initialize a `MySQLVectorStore` class you need to provide only 3 things:\n",
-        "\n",
-        "1. `engine` - An instance of a `MySQLEngine` engine.\n",
-        "1. `embedding_service` - An instance of a LangChain embedding model.\n",
-        "1. `table_name` : The name of the table within the Cloud SQL database to use as the vector store."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "z-AZyzAQ7bsf"
-      },
-      "outputs": [],
-      "source": [
-        "from langchain_google_cloud_sql_mysql import MySQLVectorStore\n",
-        "\n",
-        "store = MySQLVectorStore(\n",
-        "    engine=engine,\n",
-        "    embedding_service=embedding,\n",
-        "    table_name=TABLE_NAME,\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Add texts"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "nrDvGWIOLL54"
-      },
-      "outputs": [],
-      "source": [
-        "import uuid\n",
-        "\n",
-        "all_texts = [\"Apples and oranges\", \"Cars and airplanes\", \"Pineapple\", \"Train\", \"Banana\"]\n",
-        "metadatas = [{\"len\": len(t)} for t in all_texts]\n",
-        "ids = [str(uuid.uuid4()) for _ in all_texts]\n",
-        "\n",
-        "store.add_texts(all_texts, metadatas=metadatas, ids=ids)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Delete texts\n",
-        "\n",
-        "Delete vectors from the vector store by ID."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "store.delete([ids[1]])"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Search for documents"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 17,
-      "metadata": {
-        "id": "fpqeZgUeLL54",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "f674a3af-452c-4d58-bb62-cbf514a9e1e3"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Pineapple\n"
-          ]
-        }
-      ],
-      "source": [
-        "query = \"I'd like a fruit.\"\n",
-        "docs = store.similarity_search(query)\n",
-        "print(docs[0].page_content)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Search for documents by vector\n",
-        "\n",
-        "It is also possible to do a search for documents similar to a given embedding vector using `similarity_search_by_vector` which accepts an embedding vector as a parameter instead of a string."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "N-NC5jgGLL55",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "69a1f9de-a830-450d-8a5e-118b36815a46"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "[Document(page_content='Pineapple', metadata={'len': 9}), Document(page_content='Banana', metadata={'len': 6})]\n"
-          ]
-        }
-      ],
-      "source": [
-        "query_vector = embedding.embed_query(query)\n",
-        "docs = store.similarity_search_by_vector(query_vector, k=2)\n",
-        "print(docs)"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Add an index\n",
-        "Speed up vector search queries by applying a vector index. Learn more about [MySQL vector indexes](https://github.com/googleapis/langchain-google-cloud-sql-mysql-python/blob/main/src/langchain_google_cloud_sql_mysql/indexes.py).\n",
-        "\n",
-        "**Note:** For IAM database authentication (default usage), the IAM database user will need to be granted the following permissions by a privileged database user for full control of vector indexes.\n",
-        "\n",
-        "```\n",
-        "GRANT EXECUTE ON PROCEDURE mysql.create_vector_index TO '<IAM_DB_USER>'@'%';\n",
-        "GRANT EXECUTE ON PROCEDURE mysql.alter_vector_index TO '<IAM_DB_USER>'@'%';\n",
-        "GRANT EXECUTE ON PROCEDURE mysql.drop_vector_index TO '<IAM_DB_USER>'@'%';\n",
-        "GRANT SELECT ON mysql.vector_indexes TO '<IAM_DB_USER>'@'%';\n",
-        "```"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "from langchain_google_cloud_sql_mysql import VectorIndex\n",
-        "\n",
-        "store.apply_vector_index(VectorIndex())"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Remove an index"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "store.drop_vector_index()"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "source": [
-        "## Advanced Usage"
-      ],
-      "metadata": {}
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "### Create a MySQLVectorStore with custom metadata\n",
-        "\n",
-        "A vector store can take advantage of relational data to filter similarity searches.\n",
-        "\n",
-        "Create a table and `MySQLVectorStore` instance with custom metadata columns."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "eANG7_8qLL55"
-      },
-      "outputs": [],
-      "source": [
-        "from langchain_google_cloud_sql_mysql import Column\n",
-        "\n",
-        "# set table name\n",
-        "CUSTOM_TABLE_NAME = \"vector_store_custom\"\n",
-        "\n",
-        "engine.init_vectorstore_table(\n",
-        "    table_name=CUSTOM_TABLE_NAME,\n",
-        "    vector_size=768,  # VertexAI model: textembedding-gecko@latest\n",
-        "    metadata_columns=[Column(\"len\", \"INTEGER\")],\n",
-        ")\n",
-        "\n",
-        "\n",
-        "# initialize MySQLVectorStore with custom metadata columns\n",
-        "custom_store = MySQLVectorStore(\n",
-        "    engine=engine,\n",
-        "    embedding_service=embedding,\n",
-        "    table_name=CUSTOM_TABLE_NAME,\n",
-        "    metadata_columns=[\"len\"],\n",
-        "    # connect to an existing VectorStore by customizing the table schema:\n",
-        "    # id_column=\"uuid\",\n",
-        "    # content_column=\"documents\",\n",
-        "    # embedding_column=\"vectors\",\n",
-        ")"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "bj2d-c2sLL5-"
-      },
-      "source": [
-        "### Search for documents with metadata filter\n",
-        "\n",
-        "It can be helpful to narrow down the documents before working with them.\n",
-        "\n",
-        "For example, documents can be filtered on metadata using the `filter` argument."
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "Sqfgk6EOLL5-",
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "outputId": "a10c74e2-fe48-4cf9-ba2f-85aecb2490d0"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "[Document(page_content='Pineapple', metadata={'len': 9}), Document(page_content='Banana', metadata={'len': 6}), Document(page_content='Apples and oranges', metadata={'len': 18}), Document(page_content='Cars and airplanes', metadata={'len': 18})]\n"
-          ]
-        }
-      ],
-      "source": [
-        "import uuid\n",
-        "\n",
-        "# add texts to the vector store\n",
-        "all_texts = [\"Apples and oranges\", \"Cars and airplanes\", \"Pineapple\", \"Train\", \"Banana\"]\n",
-        "metadatas = [{\"len\": len(t)} for t in all_texts]\n",
-        "ids = [str(uuid.uuid4()) for _ in all_texts]\n",
-        "custom_store.add_texts(all_texts, metadatas=metadatas, ids=ids)\n",
-        "\n",
-        "# use filter on search\n",
-        "query_vector = embedding.embed_query(\"I'd like a fruit.\")\n",
-        "docs = custom_store.similarity_search_by_vector(query_vector, filter=\"len >= 6\")\n",
-        "\n",
-        "print(docs)"
-      ]
-    }
-  ],
-  "metadata": {
-    "colab": {
-      "provenance": [],
-      "toc_visible": true
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "name": "python3"
-    },
-    "language_info": {
-      "codemirror_mode": {
-        "name": "ipython",
-        "version": 3
-      },
-      "file_extension": ".py",
-      "mimetype": "text/x-python",
-      "name": "python",
-      "nbconvert_exporter": "python",
-      "pygments_lexer": "ipython3",
-      "version": "3.11.5"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}

docs/docs/integrations/vectorstores/google_firestore.ipynb

@@ -1,399 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "1957f5cb",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Firestore\n",
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ef1f0986",
-   "metadata": {},
-   "source": [
-    "# Google Firestore (Native Mode)\n",
-    "\n",
-    "> [Firestore](https://cloud.google.com/firestore) is a serverless document-oriented database that scales to meet any demand. Extend your database application to build AI-powered experiences leveraging Firestore's Langchain integrations.\n",
-    "\n",
-    "This notebook goes over how to use [Firestore](https://cloud.google.com/firestore) to to store vectors and query them using the `FirestoreVectorStore` class.\n",
-    "\n",
-    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/googleapis/langchain-google-firestore-python/blob/main/docs/vectorstores.ipynb)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "36fdc060",
-   "metadata": {},
-   "source": [
-    "## Before You Begin\n",
-    "\n",
-    "To run this notebook, you will need to do the following:\n",
-    "\n",
-    "* [Create a Google Cloud Project](https://developers.google.com/workspace/guides/create-project)\n",
-    "* [Enable the Firestore API](https://console.cloud.google.com/flows/enableapi?apiid=firestore.googleapis.com)\n",
-    "* [Create a Firestore database](https://cloud.google.com/firestore/docs/manage-databases)\n",
-    "\n",
-    "After confirmed access to database in the runtime environment of this notebook, filling the following values and run the cell before running example scripts."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "22e53b34",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# @markdown Please specify a source for demo purpose.\n",
-    "COLLECTION_NAME = \"test\"  # @param {type:\"CollectionReference\"|\"string\"}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e5d3d8e4",
-   "metadata": {},
-   "source": [
-    "### 🦜🔗 Library Installation\n",
-    "\n",
-    "The integration lives in its own `langchain-google-firestore` package, so we need to install it. For this notebook, we will also install `langchain-google-genai` to use Google Generative AI embeddings."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "75510ef7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install -upgrade --quiet langchain-google-firestore langchain-google-vertexai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2664ca45",
-   "metadata": {},
-   "source": [
-    "**Colab only**: Uncomment the following cell to restart the kernel or use the button to restart the kernel. For Vertex AI Workbench you can restart the terminal using the button on top."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ddfcd6b7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# # Automatically restart kernel after installs so that your environment can access the new packages\n",
-    "# import IPython\n",
-    "\n",
-    "# app = IPython.Application.instance()\n",
-    "# app.kernel.do_shutdown(True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4ab63daa",
-   "metadata": {},
-   "source": [
-    "### ☁ Set Your Google Cloud Project\n",
-    "Set your Google Cloud project so that you can leverage Google Cloud resources within this notebook.\n",
-    "\n",
-    "If you don't know your project ID, try the following:\n",
-    "\n",
-    "* Run `gcloud config list`.\n",
-    "* Run `gcloud projects list`.\n",
-    "* See the support page: [Locate the project ID](https://support.google.com/googleapi/answer/7014113)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "129f1f8d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# @markdown Please fill in the value below with your Google Cloud project ID and then run the cell.\n",
-    "\n",
-    "PROJECT_ID = \"extensions-testing\"  # @param {type:\"string\"}\n",
-    "\n",
-    "# Set the project id\n",
-    "!gcloud config set project {PROJECT_ID}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ccd32ce5",
-   "metadata": {},
-   "source": [
-    "### 🔐 Authentication\n",
-    "\n",
-    "Authenticate to Google Cloud as the IAM user logged into this notebook in order to access your Google Cloud Project.\n",
-    "\n",
-    "- If you are using Colab to run this notebook, use the cell below and continue.\n",
-    "- If you are using Vertex AI Workbench, check out the setup instructions [here](https://github.com/GoogleCloudPlatform/generative-ai/tree/main/setup-env)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4b5793e7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from google.colab import auth\n",
-    "\n",
-    "auth.authenticate_user()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2cade39f",
-   "metadata": {},
-   "source": [
-    "# Basic Usage"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "580e6f96",
-   "metadata": {},
-   "source": [
-    "### Initialize FirestoreVectorStore\n",
-    "\n",
-    "`FirestoreVectorStore` allows you to store new vectors in a Firestore database. You can use it to store embeddings from any model, including those from Google Generative AI."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dc37144c-208d-4ab3-9f3a-0407a69fe052",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain_google_firestore import FirestoreVectorStore\n",
-    "from langchain_google_vertexai import VertexAIEmbeddings\n",
-    "\n",
-    "embedding = VertexAIEmbeddings(\n",
-    "    model_name=\"textembedding-gecko@latest\",\n",
-    "    project=PROJECT_ID,\n",
-    ")\n",
-    "\n",
-    "# Sample data\n",
-    "ids = [\"apple\", \"banana\", \"orange\"]\n",
-    "fruits_texts = ['{\"name\": \"apple\"}', '{\"name\": \"banana\"}', '{\"name\": \"orange\"}']\n",
-    "\n",
-    "# Create a vector store\n",
-    "vector_store = FirestoreVectorStore(\n",
-    "    collection=\"fruits\",\n",
-    "    embedding=embedding,\n",
-    ")\n",
-    "\n",
-    "# Add the fruits to the vector store\n",
-    "vector_store.add_texts(fruits_texts, ids=ids)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f8a4d7f7",
-   "metadata": {},
-   "source": [
-    "As a shorthand, you can initilize and add vectors in a single step using the `from_texts` and `from_documents` method."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0bb6745e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vector_store = FirestoreVectorStore.from_texts(\n",
-    "    collection=\"fruits\",\n",
-    "    texts=fruits_texts,\n",
-    "    embedding=embedding,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f86024b9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.documents import Document\n",
-    "\n",
-    "fruits_docs = [Document(page_content=fruit) for fruit in fruits_texts]\n",
-    "\n",
-    "vector_store = FirestoreVectorStore.from_documents(\n",
-    "    collection=\"fruits\",\n",
-    "    documents=fruits_docs,\n",
-    "    embedding=embedding,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "942911a8",
-   "metadata": {},
-   "source": [
-    "### Delete Vectors"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ee1d8090",
-   "metadata": {},
-   "source": [
-    "You can delete documents with vectors from the database using the `delete` method. You'll need to provide the document ID of the vector you want to delete. This will remove the whole document from the database, including any other fields it may have."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "901f2ae7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vector_store.delete(ids)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "bc8e555f",
-   "metadata": {},
-   "source": [
-    "### Update Vectors"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "af734e8f",
-   "metadata": {},
-   "source": [
-    "Updating vectors is similar to adding them. You can use the `add` method to update the vector of a document by providing the document ID and the new vector."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cb2aadb7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fruit_to_update = ['{\"name\": \"apple\",\"price\": 12}']\n",
-    "apple_id = \"apple\"\n",
-    "\n",
-    "vector_store.add_texts(fruit_to_update, ids=[apple_id])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "16342b7a",
-   "metadata": {},
-   "source": [
-    "## Similarity Search\n",
-    "\n",
-    "You can use the `FirestoreVectorStore` to perform similarity searches on the vectors you have stored. This is useful for finding similar documents or text."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "44d1b94e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vector_store.similarity_search(\"I like fuji apples\", k=3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "acb2f640",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vector_store.max_marginal_relevance_search(\"fuji\", 5)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4ac1d391",
-   "metadata": {},
-   "source": [
-    "You can add a pre-filter to the search by using the `filters` parameter. This is useful for filtering by a specific field or value."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cd864d4f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from google.cloud.firestore_v1.base_query import FieldFilter\n",
-    "\n",
-    "vector_store.max_marginal_relevance_search(\n",
-    "    \"fuji\", 5, filters=FieldFilter(\"content\", \"==\", \"apple\")\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9988c71d",
-   "metadata": {},
-   "source": [
-    "### Customize Connection & Authentication"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6b9dfc65",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from google.api_core.client_options import ClientOptions\n",
-    "from google.cloud import firestore\n",
-    "from langchain_google_firestore import FirestoreVectorStore\n",
-    "\n",
-    "client_options = ClientOptions()\n",
-    "client = firestore.Client(client_options=client_options)\n",
-    "\n",
-    "# Create a vector store\n",
-    "vector_store = FirestoreVectorStore(\n",
-    "    collection=\"fruits\",\n",
-    "    embedding=embedding,\n",
-    "    client=client,\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/vectorstores/pgvector.ipynb

@@ -2,442 +2,597 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "7679dd7b-7ed4-4755-a499-824deadba708",
    "metadata": {},
    "source": [
     "# PGVector\n",
     "\n",
-    "> An implementation of LangChain vectorstore abstraction using `postgres` as the backend and utilizing the `pgvector` extension.\n",
+    ">[PGVector](https://github.com/pgvector/pgvector) is an open-source vector similarity search for `Postgres`\n",
     "\n",
-    "The code lives in an integration package called: [langchain_postgres](https://github.com/langchain-ai/langchain-postgres/).\n",
+    "It supports:\n",
+    "- exact and approximate nearest neighbor search\n",
+    "- L2 distance, inner product, and cosine distance\n",
     "\n",
-    "You can run the following command to spin up a a postgres container with the `pgvector` extension:\n",
-    "\n",
-    "```shell\n",
-    "docker run --name pgvector-container -e POSTGRES_USER=langchain -e POSTGRES_PASSWORD=langchain -e POSTGRES_DB=langchain -p 6024:5432 -d pgvector/pgvector:pg16\n",
-    "```\n",
-    "\n",
-    "## Status\n",
-    "\n",
-    "This code has been ported over from `langchain_community` into a dedicated package called `langchain-postgres`. The following changes have been made:\n",
-    "\n",
-    "* langchain_postgres works only with psycopg3. Please update your connnecion strings from `postgresql+psycopg2://...` to `postgresql+psycopg://langchain:langchain@...` (yes, it's the driver name is `psycopg` not `psycopg3`, but it'll use `psycopg3`.\n",
-    "* The schema of the embedding store and collection have been changed to make add_documents work correctly with user specified ids.\n",
-    "* One has to pass an explicit connection object now.\n",
-    "\n",
-    "\n",
-    "Currently, there is **no mechanism** that supports easy data migration on schema changes. So any schema changes in the vectorstore will require the user to recreate the tables and re-add the documents.\n",
-    "If this is a concern, please use a different vectorstore. If not, this implementation should be fine for your use case."
+    "This notebook shows how to use the Postgres vector database (`PGVector`)."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "342cd5e9-f349-42b4-9713-12e63779835b",
    "metadata": {},
    "source": [
-    "## Install dependencies\n",
-    "\n",
-    "Here, we're using `langchain_cohere` for embeddings, but you can use other embeddings providers."
+    "See the [installation instruction](https://github.com/pgvector/pgvector)."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "42d42297-11b8-44e3-bf21-7c3d1bce8277",
+   "execution_count": null,
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "!pip install --quiet -U langchain_cohere\n",
-    "!pip install --quiet -U langchain_postgres"
+    "# Pip install necessary package\n",
+    "%pip install --upgrade --quiet  pgvector\n",
+    "%pip install --upgrade --quiet  langchain-openai\n",
+    "%pip install --upgrade --quiet  psycopg2-binary\n",
+    "%pip install --upgrade --quiet  tiktoken"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "eee31ce1-2c28-484d-82be-d22d9f9a31fd",
    "metadata": {},
    "source": [
-    "## Initialize the vectorstore"
+    "We want to use `OpenAIEmbeddings` so we have to get the OpenAI API Key."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "979a65bd-742f-4b0d-be1e-c0baae245ec6",
    "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:02:16.802456Z",
+     "start_time": "2023-09-09T08:02:07.065604Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:02:19.742896Z",
+     "start_time": "2023-09-09T08:02:19.732527Z"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "False"
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "## Loading Environment Variables\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:02:23.144824Z",
+     "start_time": "2023-09-09T08:02:22.047801Z"
+    },
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain_cohere import CohereEmbeddings\n",
-    "from langchain_core.documents import Document\n",
-    "from langchain_postgres import PGVector\n",
-    "from langchain_postgres.vectorstores import PGVector\n",
-    "\n",
-    "# See docker command above to launch a postgres instance with pgvector enabled.\n",
-    "connection = \"postgresql+psycopg://langchain:langchain@localhost:6024/langchain\"  # Uses psycopg3!\n",
-    "collection_name = \"my_docs\"\n",
-    "embeddings = CohereEmbeddings()\n",
-    "\n",
-    "vectorstore = PGVector(\n",
-    "    embeddings=embeddings,\n",
-    "    collection_name=collection_name,\n",
-    "    connection=connection,\n",
-    "    use_jsonb=True,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0fc32168-5a82-4629-a78d-158fe2615086",
-   "metadata": {},
-   "source": [
-    "## Drop tables\n",
-    "\n",
-    "If you need to drop tables (e.g., updating the embedding to a different dimension or just updating the embedding provider): "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5de5ef98-7dbb-4892-853f-47c7dc87b70e",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "```python\n",
-    "vectorstore.drop_tables()\n",
-    "````"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "61a224a1-d70b-4daf-86ba-ab6e43c08b50",
-   "metadata": {},
-   "source": [
-    "## Add documents\n",
-    "\n",
-    "Add documents to the vectorstore"
+    "from langchain.docstore.document import Document\n",
+    "from langchain_community.document_loaders import TextLoader\n",
+    "from langchain_community.vectorstores.pgvector import PGVector\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "from langchain_text_splitters import CharacterTextSplitter"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "88a288cc-ffd4-4800-b011-750c72b9fd10",
    "metadata": {
-    "tags": []
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:02:25.452472Z",
+     "start_time": "2023-09-09T08:02:25.441563Z"
+    }
    },
    "outputs": [],
    "source": [
-    "docs = [\n",
-    "    Document(\n",
-    "        page_content=\"there are cats in the pond\",\n",
-    "        metadata={\"id\": 1, \"location\": \"pond\", \"topic\": \"animals\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"ducks are also found in the pond\",\n",
-    "        metadata={\"id\": 2, \"location\": \"pond\", \"topic\": \"animals\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"fresh apples are available at the market\",\n",
-    "        metadata={\"id\": 3, \"location\": \"market\", \"topic\": \"food\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the market also sells fresh oranges\",\n",
-    "        metadata={\"id\": 4, \"location\": \"market\", \"topic\": \"food\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the new art exhibit is fascinating\",\n",
-    "        metadata={\"id\": 5, \"location\": \"museum\", \"topic\": \"art\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"a sculpture exhibit is also at the museum\",\n",
-    "        metadata={\"id\": 6, \"location\": \"museum\", \"topic\": \"art\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"a new coffee shop opened on Main Street\",\n",
-    "        metadata={\"id\": 7, \"location\": \"Main Street\", \"topic\": \"food\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the book club meets at the library\",\n",
-    "        metadata={\"id\": 8, \"location\": \"library\", \"topic\": \"reading\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the library hosts a weekly story time for kids\",\n",
-    "        metadata={\"id\": 9, \"location\": \"library\", \"topic\": \"reading\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"a cooking class for beginners is offered at the community center\",\n",
-    "        metadata={\"id\": 10, \"location\": \"community center\", \"topic\": \"classes\"},\n",
-    "    ),\n",
-    "]"
+    "loader = TextLoader(\"../../modules/state_of_the_union.txt\")\n",
+    "documents = loader.load()\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
+    "docs = text_splitter.split_documents(documents)\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "73aa9124-9d49-4e10-8ed3-82255e7a4106",
    "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:02:28.174088Z",
+     "start_time": "2023-09-09T08:02:28.162698Z"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
-    "vectorstore.add_documents(docs, ids=[doc.metadata[\"id\"] for doc in docs])"
+    "# PGVector needs the connection string to the database.\n",
+    "CONNECTION_STRING = \"postgresql+psycopg2://harrisonchase@localhost:5432/test3\"\n",
+    "\n",
+    "# # Alternatively, you can create it from environment variables.\n",
+    "# import os\n",
+    "\n",
+    "# CONNECTION_STRING = PGVector.connection_string_from_db_params(\n",
+    "#     driver=os.environ.get(\"PGVECTOR_DRIVER\", \"psycopg2\"),\n",
+    "#     host=os.environ.get(\"PGVECTOR_HOST\", \"localhost\"),\n",
+    "#     port=int(os.environ.get(\"PGVECTOR_PORT\", \"5432\")),\n",
+    "#     database=os.environ.get(\"PGVECTOR_DATABASE\", \"postgres\"),\n",
+    "#     user=os.environ.get(\"PGVECTOR_USER\", \"postgres\"),\n",
+    "#     password=os.environ.get(\"PGVECTOR_PASSWORD\", \"postgres\"),\n",
+    "# )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": [
+    "## Similarity Search with Euclidean Distance (Default)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
-   "id": "a5b2b71f-49eb-407d-b03a-dea4c0a517d6",
    "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='there are cats in the pond', metadata={'id': 1, 'topic': 'animals', 'location': 'pond'}),\n",
-       " Document(page_content='the book club meets at the library', metadata={'id': 8, 'topic': 'reading', 'location': 'library'}),\n",
-       " Document(page_content='the library hosts a weekly story time for kids', metadata={'id': 9, 'topic': 'reading', 'location': 'library'}),\n",
-       " Document(page_content='the new art exhibit is fascinating', metadata={'id': 5, 'topic': 'art', 'location': 'museum'}),\n",
-       " Document(page_content='ducks are also found in the pond', metadata={'id': 2, 'topic': 'animals', 'location': 'pond'}),\n",
-       " Document(page_content='the market also sells fresh oranges', metadata={'id': 4, 'topic': 'food', 'location': 'market'}),\n",
-       " Document(page_content='a cooking class for beginners is offered at the community center', metadata={'id': 10, 'topic': 'classes', 'location': 'community center'}),\n",
-       " Document(page_content='fresh apples are available at the market', metadata={'id': 3, 'topic': 'food', 'location': 'market'}),\n",
-       " Document(page_content='a sculpture exhibit is also at the museum', metadata={'id': 6, 'topic': 'art', 'location': 'museum'}),\n",
-       " Document(page_content='a new coffee shop opened on Main Street', metadata={'id': 7, 'topic': 'food', 'location': 'Main Street'})]"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:04:16.696625Z",
+     "start_time": "2023-09-09T08:02:31.817790Z"
     }
-   ],
+   },
+   "outputs": [],
    "source": [
-    "vectorstore.similarity_search(\"kitty\", k=10)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1d87a413-015a-4b46-a64e-332f30806524",
-   "metadata": {},
-   "source": [
-    "Adding documents by ID will over-write any existing documents that match that ID."
+    "# The PGVector Module will try to create a table with the name of the collection.\n",
+    "# So, make sure that the collection name is unique and the user has the permission to create a table.\n",
+    "\n",
+    "COLLECTION_NAME = \"state_of_the_union_test\"\n",
+    "\n",
+    "db = PGVector.from_documents(\n",
+    "    embedding=embeddings,\n",
+    "    documents=docs,\n",
+    "    collection_name=COLLECTION_NAME,\n",
+    "    connection_string=CONNECTION_STRING,\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
-   "id": "13c69357-aaee-4de0-bcc2-7ab4419c920e",
    "metadata": {
-    "tags": []
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:05:11.104135Z",
+     "start_time": "2023-09-09T08:05:10.548998Z"
+    }
    },
    "outputs": [],
    "source": [
-    "docs = [\n",
-    "    Document(\n",
-    "        page_content=\"there are cats in the pond\",\n",
-    "        metadata={\"id\": 1, \"location\": \"pond\", \"topic\": \"animals\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"ducks are also found in the pond\",\n",
-    "        metadata={\"id\": 2, \"location\": \"pond\", \"topic\": \"animals\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"fresh apples are available at the market\",\n",
-    "        metadata={\"id\": 3, \"location\": \"market\", \"topic\": \"food\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the market also sells fresh oranges\",\n",
-    "        metadata={\"id\": 4, \"location\": \"market\", \"topic\": \"food\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the new art exhibit is fascinating\",\n",
-    "        metadata={\"id\": 5, \"location\": \"museum\", \"topic\": \"art\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"a sculpture exhibit is also at the museum\",\n",
-    "        metadata={\"id\": 6, \"location\": \"museum\", \"topic\": \"art\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"a new coffee shop opened on Main Street\",\n",
-    "        metadata={\"id\": 7, \"location\": \"Main Street\", \"topic\": \"food\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the book club meets at the library\",\n",
-    "        metadata={\"id\": 8, \"location\": \"library\", \"topic\": \"reading\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"the library hosts a weekly story time for kids\",\n",
-    "        metadata={\"id\": 9, \"location\": \"library\", \"topic\": \"reading\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"a cooking class for beginners is offered at the community center\",\n",
-    "        metadata={\"id\": 10, \"location\": \"community center\", \"topic\": \"classes\"},\n",
-    "    ),\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "59f82250-7903-4279-8300-062542c83416",
-   "metadata": {},
-   "source": [
-    "## Filtering Support\n",
-    "\n",
-    "The vectorstore supports a set of filters that can be applied against the metadata fields of the documents.\n",
-    "\n",
-    "| Operator | Meaning/Category        |\n",
-    "|----------|-------------------------|\n",
-    "| \\$eq      | Equality (==)           |\n",
-    "| \\$ne      | Inequality (!=)         |\n",
-    "| \\$lt      | Less than (<)           |\n",
-    "| \\$lte     | Less than or equal (<=) |\n",
-    "| \\$gt      | Greater than (>)        |\n",
-    "| \\$gte     | Greater than or equal (>=) |\n",
-    "| \\$in      | Special Cased (in)      |\n",
-    "| \\$nin     | Special Cased (not in)  |\n",
-    "| \\$between | Special Cased (between) |\n",
-    "| \\$like    | Text (like)             |\n",
-    "| \\$ilike   | Text (case-insensitive like) |\n",
-    "| \\$and     | Logical (and)           |\n",
-    "| \\$or      | Logical (or)            |"
+    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
+    "docs_with_score = db.similarity_search_with_score(query)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
-   "id": "f15a2359-6dc3-4099-8214-785f167a9ca4",
    "metadata": {
-    "tags": []
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:05:13.532334Z",
+     "start_time": "2023-09-09T08:05:13.523191Z"
+    }
    },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='there are cats in the pond', metadata={'id': 1, 'topic': 'animals', 'location': 'pond'}),\n",
-       " Document(page_content='the library hosts a weekly story time for kids', metadata={'id': 9, 'topic': 'reading', 'location': 'library'}),\n",
-       " Document(page_content='the new art exhibit is fascinating', metadata={'id': 5, 'topic': 'art', 'location': 'museum'}),\n",
-       " Document(page_content='ducks are also found in the pond', metadata={'id': 2, 'topic': 'animals', 'location': 'pond'})]"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.18456886638850434\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",
+      "--------------------------------------------------------------------------------\n",
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.21742627672631343\n",
+      "A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. \n",
+      "\n",
+      "And if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. \n",
+      "\n",
+      "We can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling.  \n",
+      "\n",
+      "We’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers.  \n",
+      "\n",
+      "We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. \n",
+      "\n",
+      "We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.\n",
+      "--------------------------------------------------------------------------------\n",
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.22641793174529334\n",
+      "And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. \n",
+      "\n",
+      "As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. \n",
+      "\n",
+      "While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. \n",
+      "\n",
+      "And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. \n",
+      "\n",
+      "So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together.  \n",
+      "\n",
+      "First, beat the opioid epidemic.\n",
+      "--------------------------------------------------------------------------------\n",
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.22670040608054465\n",
+      "Tonight, I’m announcing a crackdown on these companies overcharging American businesses and consumers. \n",
+      "\n",
+      "And as Wall Street firms take over more nursing homes, quality in those homes has gone down and costs have gone up.  \n",
+      "\n",
+      "That ends on my watch. \n",
+      "\n",
+      "Medicare is going to set higher standards for nursing homes and make sure your loved ones get the care they deserve and expect. \n",
+      "\n",
+      "We’ll also cut costs and keep the economy going strong by giving workers a fair shot, provide more training and apprenticeships, hire them based on their skills not degrees. \n",
+      "\n",
+      "Let’s pass the Paycheck Fairness Act and paid leave.  \n",
+      "\n",
+      "Raise the minimum wage to $15 an hour and extend the Child Tax Credit, so no one has to raise a family in poverty. \n",
+      "\n",
+      "Let’s increase Pell Grants and increase our historic support of HBCUs, and invest in what Jill—our First Lady who teaches full-time—calls America’s best-kept secret: community colleges.\n",
+      "--------------------------------------------------------------------------------\n"
+     ]
     }
    ],
    "source": [
-    "vectorstore.similarity_search(\"kitty\", k=10, filter={\"id\": {\"$in\": [1, 5, 2, 9]}})"
+    "for doc, score in docs_with_score:\n",
+    "    print(\"-\" * 80)\n",
+    "    print(\"Score: \", score)\n",
+    "    print(doc.page_content)\n",
+    "    print(\"-\" * 80)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d92ea049-1b1f-4ae9-9525-35750fe2e52e",
-   "metadata": {},
+   "metadata": {
+    "collapsed": false
+   },
    "source": [
-    "If you provide a dict with multiple fields, but no operators, the top level will be interpreted as a logical **AND** filter"
+    "## Maximal Marginal Relevance Search (MMR)\n",
+    "Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 10,
-   "id": "88f919e4-e4b0-4b5f-99b3-24c675c26d33",
    "metadata": {
-    "tags": []
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:05:23.276819Z",
+     "start_time": "2023-09-09T08:05:21.972256Z"
+    },
+    "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='ducks are also found in the pond', metadata={'id': 2, 'topic': 'animals', 'location': 'pond'}),\n",
-       " Document(page_content='there are cats in the pond', metadata={'id': 1, 'topic': 'animals', 'location': 'pond'})]"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "vectorstore.similarity_search(\n",
-    "    \"ducks\",\n",
-    "    k=10,\n",
-    "    filter={\"id\": {\"$in\": [1, 5, 2, 9]}, \"location\": {\"$in\": [\"pond\", \"market\"]}},\n",
-    ")"
+    "docs_with_score = db.max_marginal_relevance_search_with_score(query)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
-   "id": "88f423a4-6575-4fb8-9be2-a3da01106591",
    "metadata": {
-    "tags": []
+    "ExecuteTime": {
+     "end_time": "2023-09-09T08:05:27.478580Z",
+     "start_time": "2023-09-09T08:05:27.470138Z"
+    },
+    "collapsed": false
    },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.18453882564037527\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",
+      "--------------------------------------------------------------------------------\n",
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.23523731441720075\n",
+      "We can’t change how divided we’ve been. But we can change how we move forward—on COVID-19 and other issues we must face together. \n",
+      "\n",
+      "I recently visited the New York City Police Department days after the funerals of Officer Wilbert Mora and his partner, Officer Jason Rivera. \n",
+      "\n",
+      "They were responding to a 9-1-1 call when a man shot and killed them with a stolen gun. \n",
+      "\n",
+      "Officer Mora was 27 years old. \n",
+      "\n",
+      "Officer Rivera was 22. \n",
+      "\n",
+      "Both Dominican Americans who’d grown up on the same streets they later chose to patrol as police officers. \n",
+      "\n",
+      "I spoke with their families and told them that we are forever in debt for their sacrifice, and we will carry on their mission to restore the trust and safety every community deserves. \n",
+      "\n",
+      "I’ve worked on these issues a long time. \n",
+      "\n",
+      "I know what works: Investing in crime prevention and community police officers who’ll walk the beat, who’ll know the neighborhood, and who can restore trust and safety.\n",
+      "--------------------------------------------------------------------------------\n",
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.2448441215698569\n",
+      "One was stationed at bases and breathing in toxic smoke from “burn pits” that incinerated wastes of war—medical and hazard material, jet fuel, and more. \n",
+      "\n",
+      "When they came home, many of the world’s fittest and best trained warriors were never the same. \n",
+      "\n",
+      "Headaches. Numbness. Dizziness. \n",
+      "\n",
+      "A cancer that would put them in a flag-draped coffin. \n",
+      "\n",
+      "I know. \n",
+      "\n",
+      "One of those soldiers was my son Major Beau Biden. \n",
+      "\n",
+      "We don’t know for sure if a burn pit was the cause of his brain cancer, or the diseases of so many of our troops. \n",
+      "\n",
+      "But I’m committed to finding out everything we can. \n",
+      "\n",
+      "Committed to military families like Danielle Robinson from Ohio. \n",
+      "\n",
+      "The widow of Sergeant First Class Heath Robinson.  \n",
+      "\n",
+      "He was born a soldier. Army National Guard. Combat medic in Kosovo and Iraq. \n",
+      "\n",
+      "Stationed near Baghdad, just yards from burn pits the size of football fields. \n",
+      "\n",
+      "Heath’s widow Danielle is here with us tonight. They loved going to Ohio State football games. He loved building Legos with their daughter.\n",
+      "--------------------------------------------------------------------------------\n",
+      "--------------------------------------------------------------------------------\n",
+      "Score:  0.2513994424701056\n",
+      "And I’m taking robust action to make sure the pain of our sanctions  is targeted at Russia’s economy. And I will use every tool at our disposal to protect American businesses and consumers. \n",
+      "\n",
+      "Tonight, I can announce that the United States has worked with 30 other countries to release 60 Million barrels of oil from reserves around the world.  \n",
+      "\n",
+      "America will lead that effort, releasing 30 Million barrels from our own Strategic Petroleum Reserve. And we stand ready to do more if necessary, unified with our allies.  \n",
+      "\n",
+      "These steps will help blunt gas prices here at home. And I know the news about what’s happening can seem alarming. \n",
+      "\n",
+      "But I want you to know that we are going to be okay. \n",
+      "\n",
+      "When the history of this era is written Putin’s war on Ukraine will have left Russia weaker and the rest of the world stronger. \n",
+      "\n",
+      "While it shouldn’t have taken something so terrible for people around the world to see what’s at stake now everyone sees it clearly.\n",
+      "--------------------------------------------------------------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "for doc, score in docs_with_score:\n",
+    "    print(\"-\" * 80)\n",
+    "    print(\"Score: \", score)\n",
+    "    print(doc.page_content)\n",
+    "    print(\"-\" * 80)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Working with vectorstore\n",
+    "\n",
+    "Above, we created a vectorstore from scratch. However, often times we want to work with an existing vectorstore.\n",
+    "In order to do that, we can initialize it directly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "store = PGVector(\n",
+    "    collection_name=COLLECTION_NAME,\n",
+    "    connection_string=CONNECTION_STRING,\n",
+    "    embedding_function=embeddings,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Add documents\n",
+    "We can add documents to the existing vectorstore."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[Document(page_content='ducks are also found in the pond', metadata={'id': 2, 'topic': 'animals', 'location': 'pond'}),\n",
-       " Document(page_content='there are cats in the pond', metadata={'id': 1, 'topic': 'animals', 'location': 'pond'})]"
+       "['048c2e14-1cf3-11ee-8777-e65801318980']"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "vectorstore.similarity_search(\n",
-    "    \"ducks\",\n",
-    "    k=10,\n",
-    "    filter={\n",
-    "        \"$and\": [\n",
-    "            {\"id\": {\"$in\": [1, 5, 2, 9]}},\n",
-    "            {\"location\": {\"$in\": [\"pond\", \"market\"]}},\n",
-    "        ]\n",
-    "    },\n",
+    "store.add_documents([Document(page_content=\"foo\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs_with_score = db.similarity_search_with_score(\"foo\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(Document(page_content='foo', metadata={}), 3.3203430005457335e-09)"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs_with_score[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(Document(page_content='A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. \\n\\nAnd if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. \\n\\nWe can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling.  \\n\\nWe’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers.  \\n\\nWe’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. \\n\\nWe’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " 0.2404395365581814)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs_with_score[1]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Overriding a vectorstore\n",
+    "\n",
+    "If you have an existing collection, you override it by doing `from_documents` and setting `pre_delete_collection` = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db = PGVector.from_documents(\n",
+    "    documents=docs,\n",
+    "    embedding=embeddings,\n",
+    "    collection_name=COLLECTION_NAME,\n",
+    "    connection_string=CONNECTION_STRING,\n",
+    "    pre_delete_collection=True,\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "65133340-2acd-4957-849e-029b6b5d60f0",
-   "metadata": {
-    "tags": []
-   },
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "docs_with_score = db.similarity_search_with_score(\"foo\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[Document(page_content='the book club meets at the library', metadata={'id': 8, 'topic': 'reading', 'location': 'library'}),\n",
-       " Document(page_content='the new art exhibit is fascinating', metadata={'id': 5, 'topic': 'art', 'location': 'museum'}),\n",
-       " Document(page_content='the library hosts a weekly story time for kids', metadata={'id': 9, 'topic': 'reading', 'location': 'library'}),\n",
-       " Document(page_content='a sculpture exhibit is also at the museum', metadata={'id': 6, 'topic': 'art', 'location': 'museum'}),\n",
-       " Document(page_content='the market also sells fresh oranges', metadata={'id': 4, 'topic': 'food', 'location': 'market'}),\n",
-       " Document(page_content='a cooking class for beginners is offered at the community center', metadata={'id': 10, 'topic': 'classes', 'location': 'community center'}),\n",
-       " Document(page_content='a new coffee shop opened on Main Street', metadata={'id': 7, 'topic': 'food', 'location': 'Main Street'}),\n",
-       " Document(page_content='fresh apples are available at the market', metadata={'id': 3, 'topic': 'food', 'location': 'market'})]"
+       "(Document(page_content='A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. \\n\\nAnd if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. \\n\\nWe can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling.  \\n\\nWe’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers.  \\n\\nWe’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. \\n\\nWe’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.', metadata={'source': '../../../state_of_the_union.txt'}),\n",
+       " 0.2404115088144465)"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "vectorstore.similarity_search(\"bird\", k=10, filter={\"location\": {\"$ne\": \"pond\"}})"
+    "docs_with_score[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Using a VectorStore as a Retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "retriever = store.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tags=None metadata=None vectorstore=<langchain_community.vectorstores.pgvector.PGVector object at 0x29f94f880> search_type='similarity' search_kwargs={}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(retriever)"
    ]
   }
  ],
@@ -457,9 +612,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 5
+ "nbformat_minor": 4
 }

docs/docs/integrations/vectorstores/thirdai_neuraldb.ipynb

@@ -10,8 +10,9 @@
     "\n",
     "## Initialization\n",
     "\n",
-    "There are two initialization methods:\n",
+    "There are three initialization methods:\n",
     "- From Scratch: Basic model\n",
+    "- From Bazaar: Download a pretrained base model from our model bazaar for better performance\n",
     "- From Checkpoint: Load a model that was previously saved\n",
     "\n",
     "For all of the following initialization methods, the `thirdai_key` parameter can be omitted if the `THIRDAI_KEY` environment variable is set.\n",
@@ -30,6 +31,17 @@
     "# From scratch\n",
     "vectorstore = NeuralDBVectorStore.from_scratch(thirdai_key=\"your-thirdai-key\")\n",
     "\n",
+    "# From bazaar\n",
+    "vectorstore = NeuralDBVectorStore.from_bazaar(\n",
+    "    # Name of base model to be downloaded from model bazaar.\n",
+    "    # \"General QnA\" gives better performance on question-answering.\n",
+    "    base=\"General QnA\",\n",
+    "    # Path to a directory that caches models to prevent repeated downloading.\n",
+    "    # Defaults to {CWD}/model_bazaar\n",
+    "    bazaar_cache=\"/path/to/bazaar_cache\",\n",
+    "    thirdai_key=\"your-thirdai-key\",\n",
+    ")\n",
+    "\n",
     "# From checkpoint\n",
     "vectorstore = NeuralDBVectorStore.from_checkpoint(\n",
     "    # Path to a NeuralDB checkpoint. For example, if you call\n",

docs/docs/integrations/vectorstores/vlite.ipynb

@@ -1,186 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "# vlite\n",
-    "\n",
-    "VLite is a simple and blazing fast vector database that allows you to store and retrieve data semantically using embeddings. Made with numpy, vlite is a lightweight batteries-included database to implement RAG, similarity search, and embeddings into your projects.\n",
-    "\n",
-    "## Installation\n",
-    "\n",
-    "To use the VLite in LangChain, you need to install the `vlite` package:\n",
-    "\n",
-    "```bash\n",
-    "!pip install vlite\n",
-    "```\n",
-    "\n",
-    "## Importing VLite\n",
-    "\n",
-    "```python\n",
-    "from langchain.vectorstores import VLite\n",
-    "```\n",
-    "\n",
-    "## Basic Example\n",
-    "\n",
-    "In this basic example, we load a text document, and store them in the VLite vector database. Then, we perform a similarity search to retrieve relevant documents based on a query.\n",
-    "\n",
-    "VLite handles chunking and embedding of the text for you, and you can change these parameters by pre-chunking the text and/or embeddings those chunks into the VLite database.\n",
-    "\n",
-    "```python\n",
-    "from langchain.document_loaders import TextLoader\n",
-    "from langchain.text_splitter import CharacterTextSplitter\n",
-    "\n",
-    "# Load the document and split it into chunks\n",
-    "loader = TextLoader(\"path/to/document.txt\")\n",
-    "documents = loader.load()\n",
-    "\n",
-    "# Create a VLite instance\n",
-    "vlite = VLite(collection=\"my_collection\")\n",
-    "\n",
-    "# Add documents to the VLite vector database\n",
-    "vlite.add_documents(documents)\n",
-    "\n",
-    "# Perform a similarity search\n",
-    "query = \"What is the main topic of the document?\"\n",
-    "docs = vlite.similarity_search(query)\n",
-    "\n",
-    "# Print the most relevant document\n",
-    "print(docs[0].page_content)\n",
-    "```\n",
-    "\n",
-    "## Adding Texts and Documents\n",
-    "\n",
-    "You can add texts or documents to the VLite vector database using the `add_texts` and `add_documents` methods, respectively.\n",
-    "\n",
-    "```python\n",
-    "# Add texts to the VLite vector database\n",
-    "texts = [\"This is the first text.\", \"This is the second text.\"]\n",
-    "vlite.add_texts(texts)\n",
-    "\n",
-    "# Add documents to the VLite vector database\n",
-    "documents = [Document(page_content=\"This is a document.\", metadata={\"source\": \"example.txt\"})]\n",
-    "vlite.add_documents(documents)\n",
-    "```\n",
-    "\n",
-    "## Similarity Search\n",
-    "\n",
-    "VLite provides methods for performing similarity search on the stored documents.\n",
-    "\n",
-    "```python\n",
-    "# Perform a similarity search\n",
-    "query = \"What is the main topic of the document?\"\n",
-    "docs = vlite.similarity_search(query, k=3)\n",
-    "\n",
-    "# Perform a similarity search with scores\n",
-    "docs_with_scores = vlite.similarity_search_with_score(query, k=3)\n",
-    "```\n",
-    "\n",
-    "## Max Marginal Relevance Search\n",
-    "\n",
-    "VLite also supports Max Marginal Relevance (MMR) search, which optimizes for both similarity to the query and diversity among the retrieved documents.\n",
-    "\n",
-    "```python\n",
-    "# Perform an MMR search\n",
-    "docs = vlite.max_marginal_relevance_search(query, k=3)\n",
-    "```\n",
-    "\n",
-    "## Updating and Deleting Documents\n",
-    "\n",
-    "You can update or delete documents in the VLite vector database using the `update_document` and `delete` methods.\n",
-    "\n",
-    "```python\n",
-    "# Update a document\n",
-    "document_id = \"doc_id_1\"\n",
-    "updated_document = Document(page_content=\"Updated content\", metadata={\"source\": \"updated.txt\"})\n",
-    "vlite.update_document(document_id, updated_document)\n",
-    "\n",
-    "# Delete documents\n",
-    "document_ids = [\"doc_id_1\", \"doc_id_2\"]\n",
-    "vlite.delete(document_ids)\n",
-    "```\n",
-    "\n",
-    "## Retrieving Documents\n",
-    "\n",
-    "You can retrieve documents from the VLite vector database based on their IDs or metadata using the `get` method.\n",
-    "\n",
-    "```python\n",
-    "# Retrieve documents by IDs\n",
-    "document_ids = [\"doc_id_1\", \"doc_id_2\"]\n",
-    "docs = vlite.get(ids=document_ids)\n",
-    "\n",
-    "# Retrieve documents by metadata\n",
-    "metadata_filter = {\"source\": \"example.txt\"}\n",
-    "docs = vlite.get(where=metadata_filter)\n",
-    "```\n",
-    "\n",
-    "## Creating VLite Instances\n",
-    "\n",
-    "You can create VLite instances using various methods:\n",
-    "\n",
-    "```python\n",
-    "# Create a VLite instance from texts\n",
-    "vlite = VLite.from_texts(texts)\n",
-    "\n",
-    "# Create a VLite instance from documents\n",
-    "vlite = VLite.from_documents(documents)\n",
-    "\n",
-    "# Create a VLite instance from an existing index\n",
-    "vlite = VLite.from_existing_index(collection=\"existing_collection\")\n",
-    "```\n",
-    "\n",
-    "## Additional Features\n",
-    "\n",
-    "VLite provides additional features for managing the vector database:\n",
-    "\n",
-    "```python\n",
-    "from langchain.vectorstores import VLite\n",
-    "vlite = VLite(collection=\"my_collection\")\n",
-    "\n",
-    "# Get the number of items in the collection\n",
-    "count = vlite.count()\n",
-    "\n",
-    "# Save the collection\n",
-    "vlite.save()\n",
-    "\n",
-    "# Clear the collection\n",
-    "vlite.clear()\n",
-    "\n",
-    "# Get collection information\n",
-    "vlite.info()\n",
-    "\n",
-    "# Dump the collection data\n",
-    "data = vlite.dump()\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

docs/docs/modules/agents/agent_types/index.mdx

@@ -33,7 +33,7 @@ Our commentary on when you should consider using this agent type.
 
 | Agent Type | Intended Model Type | Supports Chat History | Supports Multi-Input Tools | Supports Parallel Function Calling | Required Model Params | When to Use | API |
 |--------------------------------------------|---------------------|-----------------------|----------------------------|-------------------------------------|----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|
-| [Tool Calling](/docs/modules/agents/agent_types/tool_calling)             | Chat                | ✅                    | ✅                         | ✅                                   | `tools`              | If you are using a tool-calling model | [Ref](https://api.python.langchain.com/en/latest/agents/langchain.agents.tool_calling_agent.base.create_tool_calling_agent.html) |
+| [Tool Calling](/docs/modules/agents/agent_types/tool_calling)             | Chat                | ✅                    | ✅                         | ✅                                   | `tools`              | If you are using a tool-calling model | TODO: Ref |
 | [OpenAI Tools](./openai_tools)             | Chat                | ✅                    | ✅                         | ✅                                   | `tools`              | [Legacy] If you are using a recent OpenAI model (`1106` onwards). Generic Tool Calling agent recommended instead. | [Ref](https://api.python.langchain.com/en/latest/agents/langchain.agents.openai_tools.base.create_openai_tools_agent.html) |
 | [OpenAI Functions](./openai_functions_agent)| Chat                | ✅                    | ✅                         |                                     | `functions`          | [Legacy] If you are using an OpenAI model, or an open-source model that has been finetuned for function calling and exposes the same `functions` parameters as OpenAI. Generic Tool Calling agent recommended instead | [Ref](https://api.python.langchain.com/en/latest/agents/langchain.agents.openai_functions_agent.base.create_openai_functions_agent.html) |
 | [XML](./xml_agent)                         | LLM                 | ✅                    |                            |                                     |                      | If you are using Anthropic models, or other models good at XML | [Ref](https://api.python.langchain.com/en/latest/agents/langchain.agents.xml.base.create_xml_agent.html)                                                                                               |

docs/docs/modules/agents/agent_types/tool_calling.ipynb

@@ -36,10 +36,7 @@
     "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs\n",
-    "  customVarName=\"llm\"\n",
-    "  hideCohere\n",
-    "/>\n",
+    "<ChatModelTabs customVarName=\"llm\" />\n",
     "```"
    ]
   },
@@ -49,9 +46,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# | output: false\n",
-    "# | echo: false\n",
-    "\n",
     "from langchain_anthropic import ChatAnthropic\n",
     "\n",
     "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\", temperature=0)"

docs/docs/modules/agents/how_to/agent_structured.ipynb

@@ -43,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install -qU langchain langchain-community langchain-openai langchain-chroma"
+    "%pip install -qU chromadb langchain langchain-community langchain-openai"
    ]
   },
   {
@@ -53,8 +53,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import TextLoader\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter"
    ]

docs/docs/modules/callbacks/filecallbackhandler.ipynb

@@ -5,11 +5,8 @@
    "id": "63b87b91",
    "metadata": {},
    "source": [
-    "# File logging\n",
-    "\n",
-    "LangChain provides the `FileCallbackHandler` to write logs to a file. The `FileCallbackHandler` is similar to the [`StdOutCallbackHandler`](/docs/modules/callbacks/), but instead of printing logs to standard output it writes logs to a file.\n",
-    "\n",
-    "We see how to use the `FileCallbackHandler` in this example. Additionally we use the `StdOutCallbackHandler` to print logs to the standard output. It also uses the `loguru` library to log other outputs that are not captured by the handler."
+    "# Logging to file\n",
+    "This example shows how to print logs to file. It shows how to use the `FileCallbackHandler`, which does the same thing as [`StdOutCallbackHandler`](/docs/modules/callbacks/#get-started), but instead writes the output to file. It also uses the `loguru` library to log other outputs that are not captured by the handler."
    ]
   },
   {
@@ -48,7 +45,8 @@
     }
    ],
    "source": [
-    "from langchain_core.callbacks import FileCallbackHandler, StdOutCallbackHandler\n",
+    "from langchain.callbacks import FileCallbackHandler\n",
+    "from langchain.chains import LLMChain\n",
     "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_openai import OpenAI\n",
     "from loguru import logger\n",
@@ -56,18 +54,16 @@
     "logfile = \"output.log\"\n",
     "\n",
     "logger.add(logfile, colorize=True, enqueue=True)\n",
-    "handler_1 = FileCallbackHandler(logfile)\n",
-    "handler_2 = StdOutCallbackHandler()\n",
+    "handler = FileCallbackHandler(logfile)\n",
     "\n",
+    "llm = OpenAI()\n",
     "prompt = PromptTemplate.from_template(\"1 + {number} = \")\n",
-    "model = OpenAI()\n",
     "\n",
     "# this chain will both print to stdout (because verbose=True) and write to 'output.log'\n",
     "# if verbose=False, the FileCallbackHandler will still write to 'output.log'\n",
-    "chain = prompt | model\n",
-    "\n",
-    "response = chain.invoke({\"number\": 2}, {\"callbacks\": [handler_1, handler_2]})\n",
-    "logger.info(response)"
+    "chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler], verbose=True)\n",
+    "answer = chain.run(number=2)\n",
+    "logger.info(answer)"
    ]
   },
   {
@@ -170,7 +166,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.6"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,

docs/docs/modules/data_connection/document_loaders/html.mdx

@@ -55,32 +55,6 @@ data
 
 </CodeOutputBlock>
 
-## Loading HTML with FireCrawlLoader
-
-[FireCrawl](https://firecrawl.dev/?ref=langchain) crawls and convert any website into markdown. It crawls all accessible subpages and give you clean markdown and metadata for each.
-
-FireCrawl handles complex tasks such as reverse proxies, caching, rate limits, and content blocked by JavaScript.
-
-### Prerequisite
-
-You need to have a FireCrawl API key to use this loader. You can get one by signing up at [FireCrawl](https://firecrawl.dev/?ref=langchainpy).
-
-```python
-%pip install --upgrade --quiet  langchain langchain-community firecrawl-py
-
-from langchain_community.document_loaders import FireCrawlLoader
-
-
-loader = FireCrawlLoader(
-    api_key="YOUR_API_KEY", url="https://firecrawl.dev", mode="crawl"
-)
-
-data = loader.load()
-```
-
-For more information on how to use FireCrawl, visit [FireCrawl](https://firecrawl.dev/?ref=langchainpy).
-
-
 ## Loading HTML with AzureAIDocumentIntelligenceLoader
 
 [Azure AI Document Intelligence](https://aka.ms/doc-intelligence) (formerly known as `Azure Form Recognizer`) is machine-learning 

docs/docs/modules/data_connection/retrievers/MultiQueryRetriever.ipynb

@@ -20,8 +20,8 @@
    "outputs": [],
    "source": [
     "# Build a sample vectorDB\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import WebBaseLoader\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "\n",

docs/docs/modules/data_connection/retrievers/custom_retriever.ipynb

@@ -1,309 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "b5fc1fc7-c4c5-418f-99da-006c604a7ea6",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "title: Custom Retriever\n",
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ff6f3c79-0848-4956-9115-54f6b2134587",
-   "metadata": {},
-   "source": [
-    "# Custom Retriever\n",
-    "\n",
-    "## Overview\n",
-    "\n",
-    "Many LLM applications involve retrieving information from external data sources using a `Retriever`. \n",
-    "\n",
-    "A retriever is responsible for retrieving a list of relevant `Documents` to a given user `query`.\n",
-    "\n",
-    "The retrieved documents are often formatted into prompts that are fed into an LLM, allowing the LLM to use the information in the to generate an appropriate response (e.g., answering a user question based on a knowledge base).\n",
-    "\n",
-    "## Interface\n",
-    "\n",
-    "To create your own retriever, you need to extend the `BaseRetriever` class and implement the following methods:\n",
-    "\n",
-    "| Method                         | Description                                      | Required/Optional |\n",
-    "|--------------------------------|--------------------------------------------------|-------------------|\n",
-    "| `_get_relevant_documents`      | Get documents relevant to a query.               | Required          |\n",
-    "| `_aget_relevant_documents`     | Implement to provide async native support.       | Optional          |\n",
-    "\n",
-    "\n",
-    "The logic inside of `_get_relevant_documents` can involve arbitrary calls to a database or to the web using requests.\n",
-    "\n",
-    ":::{.callout-tip}\n",
-    "By inherting from `BaseRetriever`, your retriever automatically becomes a LangChain [Runnable](/docs/expression_language/interface) and will gain the standard `Runnable` functionality out of the box!\n",
-    ":::\n",
-    "\n",
-    "\n",
-    ":::{.callout-info}\n",
-    "You can use a `RunnableLambda` or `RunnableGenerator` to implement a retriever.\n",
-    "\n",
-    "The main benefit of implementing a retriever as a `BaseRetriever` vs. a `RunnableLambda` (a custom [runnable function](/docs/expression_language/primitives/functions)) is that a `BaseRetriever` is a well\n",
-    "known LangChain entity so some tooling for monitoring may implement specialized behavior for retrievers. Another difference\n",
-    "is that a `BaseRetriever` will behave slightly differently from `RunnableLambda` in some APIs; e.g., the `start` event\n",
-    "in `astream_events` API will be `on_retriever_start` instead of `on_chain_start`.\n",
-    ":::\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2be9fe82-0757-41d1-a647-15bed11fd3bf",
-   "metadata": {},
-   "source": [
-    "## Example\n",
-    "\n",
-    "Let's implement a toy retriever that returns all documents whose text contains the text in the user query."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "bdf61902-2984-493b-a002-d4fced6df590",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from typing import List\n",
-    "\n",
-    "from langchain_core.callbacks import CallbackManagerForRetrieverRun\n",
-    "from langchain_core.documents import Document\n",
-    "from langchain_core.retrievers import BaseRetriever\n",
-    "\n",
-    "\n",
-    "class ToyRetriever(BaseRetriever):\n",
-    "    \"\"\"A toy retriever that contains the top k documents that contain the user query.\n",
-    "\n",
-    "    This retriever only implements the sync method _get_relevant_documents.\n",
-    "\n",
-    "    If the retriever were to involve file access or network access, it could benefit\n",
-    "    from a native async implementation of `_aget_relevant_documents`.\n",
-    "\n",
-    "    As usual, with Runnables, there's a default async implementation that's provided\n",
-    "    that delegates to the sync implementation running on another thread.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    documents: List[Document]\n",
-    "    \"\"\"List of documents to retrieve from.\"\"\"\n",
-    "    k: int\n",
-    "    \"\"\"Number of top results to return\"\"\"\n",
-    "\n",
-    "    def _get_relevant_documents(\n",
-    "        self, query: str, *, run_manager: CallbackManagerForRetrieverRun\n",
-    "    ) -> List[Document]:\n",
-    "        \"\"\"Sync implementations for retriever.\"\"\"\n",
-    "        matching_documents = []\n",
-    "        for document in documents:\n",
-    "            if len(matching_documents) > self.k:\n",
-    "                return matching_documents\n",
-    "\n",
-    "            if query.lower() in document.page_content.lower():\n",
-    "                matching_documents.append(document)\n",
-    "        return matching_documents\n",
-    "\n",
-    "    # Optional: Provide a more efficient native implementation by overriding\n",
-    "    # _aget_relevant_documents\n",
-    "    # async def _aget_relevant_documents(\n",
-    "    #     self, query: str, *, run_manager: AsyncCallbackManagerForRetrieverRun\n",
-    "    # ) -> List[Document]:\n",
-    "    #     \"\"\"Asynchronously get documents relevant to a query.\n",
-    "\n",
-    "    #     Args:\n",
-    "    #         query: String to find relevant documents for\n",
-    "    #         run_manager: The callbacks handler to use\n",
-    "\n",
-    "    #     Returns:\n",
-    "    #         List of relevant documents\n",
-    "    #     \"\"\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2eac1f28-29c1-4888-b3aa-b4fa70c73b4c",
-   "metadata": {},
-   "source": [
-    "## Test it 🧪"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "ea868db5-48cc-4ec2-9b0a-1ab94c32b302",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "documents = [\n",
-    "    Document(\n",
-    "        page_content=\"Dogs are great companions, known for their loyalty and friendliness.\",\n",
-    "        metadata={\"type\": \"dog\", \"trait\": \"loyalty\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"Cats are independent pets that often enjoy their own space.\",\n",
-    "        metadata={\"type\": \"cat\", \"trait\": \"independence\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"Goldfish are popular pets for beginners, requiring relatively simple care.\",\n",
-    "        metadata={\"type\": \"fish\", \"trait\": \"low maintenance\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"Parrots are intelligent birds capable of mimicking human speech.\",\n",
-    "        metadata={\"type\": \"bird\", \"trait\": \"intelligence\"},\n",
-    "    ),\n",
-    "    Document(\n",
-    "        page_content=\"Rabbits are social animals that need plenty of space to hop around.\",\n",
-    "        metadata={\"type\": \"rabbit\", \"trait\": \"social\"},\n",
-    "    ),\n",
-    "]\n",
-    "retriever = ToyRetriever(documents=documents, k=3)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "18be85e9-6ef0-4ee0-ae5d-a0810c38b254",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'}),\n",
-       " Document(page_content='Rabbits are social animals that need plenty of space to hop around.', metadata={'type': 'rabbit', 'trait': 'social'})]"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "retriever.invoke(\"that\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "13f76f6e-cf2b-4f67-859b-0ef8be98abbe",
-   "metadata": {},
-   "source": [
-    "It's a **runnable** so it'll benefit from the standard Runnable Interface! 🤩"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "3672e9fe-4365-4628-9d25-31924cfaf784",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'}),\n",
-       " Document(page_content='Rabbits are social animals that need plenty of space to hop around.', metadata={'type': 'rabbit', 'trait': 'social'})]"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "await retriever.ainvoke(\"that\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "e2c96eed-6813-421c-acf2-6554839840ee",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[[Document(page_content='Dogs are great companions, known for their loyalty and friendliness.', metadata={'type': 'dog', 'trait': 'loyalty'})],\n",
-       " [Document(page_content='Cats are independent pets that often enjoy their own space.', metadata={'type': 'cat', 'trait': 'independence'})]]"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "retriever.batch([\"dog\", \"cat\"])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "978b6636-bf36-42c2-969c-207718f084cf",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'event': 'on_retriever_start', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'name': 'ToyRetriever', 'tags': [], 'metadata': {}, 'data': {'input': 'bar'}}\n",
-      "{'event': 'on_retriever_stream', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'tags': [], 'metadata': {}, 'name': 'ToyRetriever', 'data': {'chunk': []}}\n",
-      "{'event': 'on_retriever_end', 'name': 'ToyRetriever', 'run_id': 'f96f268d-8383-4921-b175-ca583924d9ff', 'tags': [], 'metadata': {}, 'data': {'output': []}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "async for event in retriever.astream_events(\"bar\", version=\"v1\"):\n",
-    "    print(event)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7b45c404-37bf-4370-bb7c-26556777ff46",
-   "metadata": {},
-   "source": [
-    "## Contributing\n",
-    "\n",
-    "We appreciate contributions of interesting retrievers!\n",
-    "\n",
-    "Here's a checklist to help make sure your contribution gets added to LangChain:\n",
-    "\n",
-    "Documentation:\n",
-    "\n",
-    "* The retriever contains doc-strings for all initialization arguments, as these will be surfaced in the [API Reference](https://api.python.langchain.com/en/stable/langchain_api_reference.html).\n",
-    "* The class doc-string for the model contains a link to any relevant APIs used for the retriever (e.g., if the retriever is retrieving from wikipedia, it'll be good to link to the wikipedia API!)\n",
-    "\n",
-    "Tests:\n",
-    "\n",
-    "* [ ] Add unit or integration tests to verify that `invoke` and `ainvoke` work.\n",
-    "\n",
-    "Optimizations:\n",
-    "\n",
-    "If the retriever is connecting to external data sources (e.g., an API or a file), it'll almost certainly benefit from an async native optimization!\n",
-    " \n",
-    "* [ ] Provide a native async implementation of `_aget_relevant_documents` (used by `ainvoke`)"
-   ]
-  }
- ],
- "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.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/data_connection/retrievers/index.mdx

@@ -80,4 +80,23 @@ chain.invoke("What did the president say about technology?")
 
 ## Custom Retriever
 
-See the [documentation here](/docs/modules/data_connection/retrievers/custom_retriever) to implement a custom retriever.
+Since the retriever interface is so simple, it's pretty easy to write a custom one.
+
+```python
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from typing import List
+
+
+class CustomRetriever(BaseRetriever):
+    
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        return [Document(page_content=query)]
+
+retriever = CustomRetriever()
+
+retriever.get_relevant_documents("bar")
+```

docs/docs/modules/data_connection/retrievers/long_context_reorder.ipynb

@@ -21,7 +21,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install --upgrade --quiet  sentence-transformers langchain-chroma langchain langchain-openai > /dev/null"
+    "%pip install --upgrade --quiet  sentence-transformers > /dev/null"
    ]
   },
   {
@@ -53,11 +53,11 @@
    "source": [
     "from langchain.chains import LLMChain, StuffDocumentsChain\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_transformers import (\n",
     "    LongContextReorder,\n",
     ")\n",
     "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAI\n",
     "\n",
     "# Get embeddings.\n",

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

@@ -37,8 +37,8 @@
    "outputs": [],
    "source": [
     "from langchain.storage import InMemoryByteStore\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import TextLoader\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter"
    ]

docs/docs/modules/data_connection/retrievers/parent_document_retriever.ipynb

@@ -43,8 +43,8 @@
    "outputs": [],
    "source": [
     "from langchain.storage import InMemoryStore\n",
-    "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import TextLoader\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter"
    ]

docs/docs/modules/data_connection/retrievers/self_query.ipynb

@@ -30,7 +30,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install --upgrade --quiet  lark langchain-chroma"
+    "%pip install --upgrade --quiet  lark chromadb"
    ]
   },
   {
@@ -40,7 +40,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_chroma import Chroma\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_core.documents import Document\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",

docs/docs/modules/data_connection/vectorstores/index.mdx

@@ -30,7 +30,7 @@ There are many great vector store options, here are a few that are free, open-so
 This walkthrough uses the `chroma` vector database, which runs on your local machine as a library.
 
 ```bash
-pip install langchain-chroma
+pip install chromadb
 ```
 
 We want to use OpenAIEmbeddings so we have to get the OpenAI API Key.
@@ -47,7 +47,7 @@ os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:')
 from langchain_community.document_loaders import TextLoader
 from langchain_openai import OpenAIEmbeddings
 from langchain_text_splitters import CharacterTextSplitter
-from langchain_chroma import Chroma
+from langchain_community.vectorstores import Chroma
 
 # Load the document, split it into chunks, embed each chunk and load it into the vector store.
 raw_documents = TextLoader('../../../state_of_the_union.txt').load()

docs/docs/modules/memory/adding_memory_chain_multiple_inputs.ipynb

@@ -17,7 +17,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_chroma import Chroma\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "from langchain_text_splitters import CharacterTextSplitter"
    ]

docs/docs/modules/memory/agent_with_memory.ipynb

@@ -24,35 +24,23 @@
    "cell_type": "code",
    "execution_count": 1,
    "id": "8db95912",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:33:30.133001Z",
-     "start_time": "2024-04-17T15:33:29.307719Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
-    "\n",
-    "from langchain.agents import Tool\n",
-    "from langchain_community.utilities import GoogleSearchAPIWrapper"
+    "from langchain.agents import AgentExecutor, Tool, ZeroShotAgent\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.memory import ConversationBufferMemory\n",
+    "from langchain_community.utilities import GoogleSearchAPIWrapper\n",
+    "from langchain_openai import OpenAI"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 13,
    "id": "97ad8467",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:33:33.208064Z",
-     "start_time": "2024-04-17T15:33:33.181997Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "os.environ[\"GOOGLE_API_KEY\"] = \"GOOGLE_API_KEY\"\n",
-    "os.environ[\"GOOGLE_CSE_ID\"] = \"GOOGLE_CSE_ID\"\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"OPENAI_API_KEY\"\n",
     "search = GoogleSearchAPIWrapper()\n",
     "tools = [\n",
     "    Tool(\n",
@@ -75,55 +63,44 @@
    "cell_type": "code",
    "execution_count": 14,
    "id": "e3439cd6",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:34:31.336998Z",
-     "start_time": "2024-04-17T15:34:28.165959Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain import hub\n",
-    "from langchain.agents import AgentExecutor, create_react_agent\n",
-    "from langchain.memory import ChatMessageHistory\n",
+    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin!\"\n",
     "\n",
-    "prompt = hub.pull(\"hwchase17/react\")\n",
+    "{chat_history}\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
     "\n",
-    "memory = ChatMessageHistory(session_id=\"test-session\")"
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools,\n",
+    "    prefix=prefix,\n",
+    "    suffix=suffix,\n",
+    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"],\n",
+    ")\n",
+    "memory = ConversationBufferMemory(memory_key=\"chat_history\")"
    ]
   },
   {
    "cell_type": "markdown",
    "id": "0021675b",
    "metadata": {},
-   "source": []
+   "source": [
+    "We can now construct the `LLMChain`, with the Memory object, and then create the agent."
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "id": "c56a0e73",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:34:33.331368Z",
-     "start_time": "2024-04-17T15:34:33.077316Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
-    "from langchain_openai import OpenAI\n",
-    "\n",
-    "llm = OpenAI(temperature=0)\n",
-    "agent = create_react_agent(llm, tools, prompt)\n",
-    "agent_executor = AgentExecutor(agent=agent, tools=tools)\n",
-    "\n",
-    "agent_with_chat_history = RunnableWithMessageHistory(\n",
-    "    agent_executor,\n",
-    "    # This is needed because in most real world scenarios, a session id is needed\n",
-    "    # It isn't really used here because we are using a simple in memory ChatMessageHistory\n",
-    "    lambda session_id: memory,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
+    "agent_chain = AgentExecutor.from_agent_and_tools(\n",
+    "    agent=agent, tools=tools, verbose=True, memory=memory\n",
     ")"
    ]
   },
@@ -131,12 +108,7 @@
    "cell_type": "code",
    "execution_count": 16,
    "id": "ca4bc1fb",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:34:40.830858Z",
-     "start_time": "2024-04-17T15:34:35.831118Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -144,18 +116,21 @@
      "text": [
       "\n",
       "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m I should use the Search tool to find the most recent population data for Canada.\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
       "Action: Search\n",
-      "Action Input: \"population of Canada\"\u001B[0m\u001B[36;1m\u001B[1;3m{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}\u001B[0m\u001B[32;1m\u001B[1;3m38.93 million people live in Canada as of 2022.\n",
-      "Final Answer: 38.93 million\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
+      "Action Input: Population of Canada\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "text/plain": "{'input': 'How many people live in canada?',\n 'chat_history': [],\n 'output': '38.93 million'}"
+      "text/plain": [
+       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
+      ]
      },
      "execution_count": 16,
      "metadata": {},
@@ -163,10 +138,7 @@
     }
    ],
    "source": [
-    "agent_with_chat_history.invoke(\n",
-    "    {\"input\": \"How many people live in canada?\"},\n",
-    "    config={\"configurable\": {\"session_id\": \"<foo>\"}},\n",
-    ")"
+    "agent_chain.run(input=\"How many people live in canada?\")"
    ]
   },
   {
@@ -179,14 +151,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 17,
    "id": "eecc0462",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:35:38.358686Z",
-     "start_time": "2024-04-17T15:34:51.197752Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -194,29 +161,29 @@
      "text": [
       "\n",
       "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m I should search for the country's name and \"national anthem\"\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out what the national anthem of Canada is called.\n",
       "Action: Search\n",
-      "Action Input: \"country name\" national anthem\u001B[0m\u001B[36;1m\u001B[1;3m['\"Liberté\" (\"Freedom\") · \"Esta É a Nossa Pátria Bem Amada\" (\"This Is Our Beloved Country\") · \"Dear Land of Guyana, of Rivers and Plains\" · \"La Dessalinienne\" (\"Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndonesiaIndonesia, Indonesia Raya ( Great Indonesia ) ; IranIran, Soroud-e Melli-e Jomhouri-e Eslami-e Iran ( ...', '1. Afghanistan, \"Milli Surood\" (National Anthem) · 2. Armenia, \"Mer Hayrenik\" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', \"The countries with the ten newest anthem additions adopted them between 2006 to as recently as 2021. Let's take a look: ... Afghanistan's “Dā də bātorāno kor” (“ ...\"]\u001B[0m\u001B[32;1m\u001B[1;3mI now know the final answer\n",
-      "Final Answer: The national anthem of a country can be found by searching for the country's name and \"national anthem\".\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
+      "Action Input: National Anthem of Canada\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mJun 7, 2010 ... https://twitter.com/CanadaImmigrantCanadian National Anthem O Canada in HQ - complete with lyrics, captions, vocals & music.LYRICS:O Canada! Nov 23, 2022 ... After 100 years of tradition, O Canada was proclaimed Canada's national anthem in 1980. The music for O Canada was composed in 1880 by Calixa ... O Canada, national anthem of Canada. It was proclaimed the official national anthem on July 1, 1980. “God Save the Queen” remains the royal anthem of Canada ... O Canada! Our home and native land! True patriot love in all of us command. Car ton bras sait porter l'épée,. Il sait porter la croix! \"O Canada\" (French: Ô Canada) is the national anthem of Canada. The song was originally commissioned by Lieutenant Governor of Quebec Théodore Robitaille ... Feb 1, 2018 ... It was a simple tweak — just two words. But with that, Canada just voted to make its national anthem, “O Canada,” gender neutral, ... \"O Canada\" was proclaimed Canada's national anthem on July 1,. 1980, 100 years after it was first sung on June 24, 1880. The music. Patriotic music in Canada dates back over 200 years as a distinct category from British or French patriotism, preceding the first legal steps to ... Feb 4, 2022 ... English version: O Canada! Our home and native land! True patriot love in all of us command. With glowing hearts we ... Feb 1, 2018 ... Canada's Senate has passed a bill making the country's national anthem gender-neutral. If you're not familiar with the words to “O Canada,” ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: The national anthem of Canada is called \"O Canada\".\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "text/plain": "{'input': 'what is their national anthem called?',\n 'chat_history': [HumanMessage(content='How many people live in canada?'),\n  AIMessage(content='38.93 million')],\n 'output': 'The national anthem of a country can be found by searching for the country\\'s name and \"national anthem\".'}"
+      "text/plain": [
+       "'The national anthem of Canada is called \"O Canada\".'"
+      ]
      },
-     "execution_count": 18,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "agent_with_chat_history.invoke(\n",
-    "    {\"input\": \"what is their national anthem called?\"},\n",
-    "    config={\"configurable\": {\"session_id\": \"<foo>\"}},\n",
-    ")"
+    "agent_chain.run(input=\"what is their national anthem called?\")"
    ]
   },
   {
@@ -231,30 +198,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 18,
    "id": "3359d043",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:35:38.362341Z",
-     "start_time": "2024-04-17T15:35:38.357729Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "agent = create_react_agent(llm, tools, prompt)\n",
-    "agent_executor_without_memory = AgentExecutor(agent=agent, tools=tools)"
+    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin!\"\n",
+    "\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, prefix=prefix, suffix=suffix, input_variables=[\"input\", \"agent_scratchpad\"]\n",
+    ")\n",
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
+    "agent_without_memory = AgentExecutor.from_agent_and_tools(\n",
+    "    agent=agent, tools=tools, verbose=True\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 19,
    "id": "970d23df",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:38:14.599316Z",
-     "start_time": "2024-04-17T15:37:23.698759Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -262,40 +231,36 @@
      "text": [
       "\n",
       "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m I should use the Search tool to find the most recent population data for Canada.\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
       "Action: Search\n",
-      "Action Input: \"population of Canada\"\u001B[0m\u001B[36;1m\u001B[1;3m{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}\u001B[0m\u001B[32;1m\u001B[1;3mI should check the source of the data to ensure it is reliable.\n",
-      "Action: Search\n",
-      "Action Input: \"population of Canada source\"\u001B[0m\u001B[36;1m\u001B[1;3mThe 2021 Canadian census enumerated a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. It is estimated that Canada's population surpassed 40 million in 2023 and 41 million in 2024.\u001B[0m\u001B[32;1m\u001B[1;3m I now know the final answer.\n",
-      "Final Answer: The estimated population of Canada in 2022 is 38.93 million.\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
+      "Action Input: Population of Canada\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "text/plain": "{'input': 'How many people live in canada?',\n 'output': 'The estimated population of Canada in 2022 is 38.93 million.'}"
+      "text/plain": [
+       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
+      ]
      },
-     "execution_count": 23,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "agent_executor_without_memory.invoke({\"input\": \"How many people live in canada?\"})"
+    "agent_without_memory.run(\"How many people live in canada?\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 20,
    "id": "d9ea82f0",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:38:47.056686Z",
-     "start_time": "2024-04-17T15:38:22.811930Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -303,26 +268,29 @@
      "text": [
       "\n",
       "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m I should search for the country's name and \"national anthem\"\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I should look up the answer\n",
       "Action: Search\n",
-      "Action Input: \"country name\" national anthem\u001B[0m\u001B[36;1m\u001B[1;3m['\"Liberté\" (\"Freedom\") · \"Esta É a Nossa Pátria Bem Amada\" (\"This Is Our Beloved Country\") · \"Dear Land of Guyana, of Rivers and Plains\" · \"La Dessalinienne\" (\"Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndonesiaIndonesia, Indonesia Raya ( Great Indonesia ) ; IranIran, Soroud-e Melli-e Jomhouri-e Eslami-e Iran ( ...', '1. Afghanistan, \"Milli Surood\" (National Anthem) · 2. Armenia, \"Mer Hayrenik\" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', \"The countries with the ten newest anthem additions adopted them between 2006 to as recently as 2021. Let's take a look: ... Afghanistan's “Dā də bātorāno kor” (“ ...\"]\u001B[0m\u001B[32;1m\u001B[1;3mI now know the final answer\n",
-      "Final Answer: The national anthem of Afghanistan is called \"Milli Surood\".\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
+      "Action Input: national anthem of [country]\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mMost nation states have an anthem, defined as \"a song, as of praise, devotion, or patriotism\"; most anthems are either marches or hymns in style. List of all countries around the world with its national anthem. ... Title and lyrics in the language of the country and translated into English, Aug 1, 2021 ... 1. Afghanistan, \"Milli Surood\" (National Anthem) · 2. Armenia, \"Mer Hayrenik\" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ... A national anthem is a patriotic musical composition symbolizing and evoking eulogies of the history and traditions of a country or nation. National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”). You can find an anthem in the menu at the top alphabetically or you can use the search feature. This site is focussed on the scholarly study of national anthems ... Feb 13, 2022 ... The 38-year-old country music artist had the honor of singing the National Anthem during this year's big game, and she did not disappoint. Oldest of the World's National Anthems ; France, La Marseillaise (“The Marseillaise”), 1795 ; Argentina, Himno Nacional Argentino (“Argentine National Anthem”) ... Mar 3, 2022 ... Country music star Jessie James Decker gained the respect of music and hockey fans alike after a jaw-dropping rendition of \"The Star-Spangled ... This list shows the country on the left, the national anthem in the ... There are many countries over the world who have a national anthem of their own.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The national anthem of [country] is [name of anthem].\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "text/plain": "{'input': 'what is their national anthem called?',\n 'output': 'The national anthem of Afghanistan is called \"Milli Surood\".'}"
+      "text/plain": [
+       "'The national anthem of [country] is [name of anthem].'"
+      ]
      },
-     "execution_count": 24,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "agent_executor_without_memory.invoke({\"input\": \"what is their national anthem called?\"})"
+    "agent_without_memory.run(\"what is their national anthem called?\")"
    ]
   },
   {

docs/docs/modules/memory/agent_with_memory_in_db.ipynb

@@ -24,46 +24,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "8db95912",
    "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:19:07.167371Z",
-     "start_time": "2024-04-17T15:19:06.179726Z"
-    },
     "pycharm": {
      "is_executing": true
     }
    },
    "outputs": [],
    "source": [
-    "import os\n",
-    "\n",
-    "from langchain import hub\n",
-    "from langchain.agents import AgentExecutor, Tool\n",
+    "from langchain.agents import AgentExecutor, Tool, ZeroShotAgent\n",
+    "from langchain.chains import LLMChain\n",
+    "from langchain.memory import ConversationBufferMemory\n",
     "from langchain_community.chat_message_histories import RedisChatMessageHistory\n",
-    "from langchain_community.utilities import SerpAPIWrapper\n",
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+    "from langchain_community.utilities import GoogleSearchAPIWrapper\n",
     "from langchain_openai import OpenAI"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 13,
    "id": "97ad8467",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:19:08.240386Z",
-     "start_time": "2024-04-17T15:19:08.233094Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "os.environ[\"GOOGLE_API_KEY\"] = \"GOOGLE_API_KEY\"\n",
-    "os.environ[\"GOOGLE_CSE_ID\"] = \"GOOGLE_CSE_ID\"\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"OPENAI_API_KEY\"\n",
-    "\n",
-    "search = SerpAPIWrapper()\n",
+    "search = GoogleSearchAPIWrapper()\n",
     "tools = [\n",
     "    Tool(\n",
     "        name=\"Search\",\n",
@@ -83,17 +68,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 14,
    "id": "e3439cd6",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:19:21.515150Z",
-     "start_time": "2024-04-17T15:19:15.549110Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "prompt = hub.pull(\"hwchase17/react\")"
+    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin!\"\n",
+    "\n",
+    "{chat_history}\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools,\n",
+    "    prefix=prefix,\n",
+    "    suffix=suffix,\n",
+    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"],\n",
+    ")"
    ]
   },
   {
@@ -106,18 +98,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "17638dc7",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:19:26.689119Z",
-     "start_time": "2024-04-17T15:19:26.442469Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "message_history = RedisChatMessageHistory(\n",
-    "    url=\"redis://127.0.0.1:6379/0\", ttl=600, session_id=\"my-session\"\n",
+    "    url=\"redis://localhost:6379/0\", ttl=600, session_id=\"my-session\"\n",
+    ")\n",
+    "\n",
+    "memory = ConversationBufferMemory(\n",
+    "    memory_key=\"chat_history\", chat_memory=message_history\n",
     ")"
    ]
   },
@@ -131,33 +122,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 15,
    "id": "c56a0e73",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:19:29.158350Z",
-     "start_time": "2024-04-17T15:19:29.090646Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import create_react_agent\n",
-    "\n",
-    "model = OpenAI()\n",
-    "agent = create_react_agent(model, tools, prompt)\n",
-    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)"
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
+    "agent_chain = AgentExecutor.from_agent_and_tools(\n",
+    "    agent=agent, tools=tools, verbose=True, memory=memory\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 16,
    "id": "ca4bc1fb",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:20:27.186923Z",
-     "start_time": "2024-04-17T15:19:51.742185Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -165,38 +146,29 @@
      "text": [
       "\n",
       "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m I should use the Search tool to find the latest population data for Canada.\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
       "Action: Search\n",
-      "Action Input: \"population of canada\"\u001B[0m\u001B[36;1m\u001B[1;3m{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}\u001B[0m\u001B[32;1m\u001B[1;3mI now know the final answer\n",
-      "Final Answer: The final answer to the original input question is 38.93 million people live in Canada as of 2022.\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
+      "Action Input: Population of Canada\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "text/plain": "{'input': 'How many people live in canada?',\n 'chat_history': [],\n 'output': 'The final answer to the original input question is 38.93 million people live in Canada as of 2022.'}"
+      "text/plain": [
+       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
+      ]
      },
-     "execution_count": 12,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "agent_with_chat_history = RunnableWithMessageHistory(\n",
-    "    agent_executor,\n",
-    "    # This is needed because in most real world scenarios, a session id is needed\n",
-    "    # It isn't really used here because we are using a simple in memory ChatMessageHistory\n",
-    "    lambda session_id: message_history,\n",
-    "    input_messages_key=\"input\",\n",
-    "    history_messages_key=\"chat_history\",\n",
-    ")\n",
-    "\n",
-    "agent_with_chat_history.invoke(\n",
-    "    {\"input\": \"How many people live in canada?\"},\n",
-    "    config={\"configurable\": {\"session_id\": \"<foo>\"}},\n",
-    ")"
+    "agent_chain.run(input=\"How many people live in canada?\")"
    ]
   },
   {
@@ -209,14 +181,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 17,
    "id": "eecc0462",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:20:59.141583Z",
-     "start_time": "2024-04-17T15:20:47.717981Z"
-    }
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -224,29 +191,29 @@
      "text": [
       "\n",
       "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m There are many countries in the world with different national anthems, so I may need to specify which country's national anthem I am looking for.\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out what the national anthem of Canada is called.\n",
       "Action: Search\n",
-      "Action Input: \"national anthem\" + country name\u001B[0m\u001B[36;1m\u001B[1;3m['\"Liberté\" (\"Freedom\") · \"Esta É a Nossa Pátria Bem Amada\" (\"This Is Our Beloved Country\") · \"Dear Land of Guyana, of Rivers and Plains\" · \"La Dessalinienne\" (\"Song ...', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General information: Hatikvah (the Hope) is now firmly established as the Anthem of the State of Israel as well as the Jewish National Anthem. 1. While yet ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; DjiboutiDjibouti, Djibouti ; DominicaDominica, Isle of Beauty, Isle of Splendour ; Dominican RepublicDominican ...', \"Today, the total number is massive, with all 193 UN countries having a national anthem. Former and non-UN countries' anthems add to the list. Due to space ...\", '1. United States of America - The Star-Spangled Banner · 2. United Kingdom - God Save the Queen/King · 3. Canada - O Canada · 4. France - La ...', \"Pedro I wrote the song that was used as the national anthem of Brazil from 1822 to 1831. The song is now recognized as the country's official patriotic song. 7.\"]\u001B[0m\u001B[32;1m\u001B[1;3mI now know the final answer\n",
-      "Final Answer: The final answer cannot be determined without specifying which country's national anthem is being referred to.\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
+      "Action Input: National Anthem of Canada\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mJun 7, 2010 ... https://twitter.com/CanadaImmigrantCanadian National Anthem O Canada in HQ - complete with lyrics, captions, vocals & music.LYRICS:O Canada! Nov 23, 2022 ... After 100 years of tradition, O Canada was proclaimed Canada's national anthem in 1980. The music for O Canada was composed in 1880 by Calixa ... O Canada, national anthem of Canada. It was proclaimed the official national anthem on July 1, 1980. “God Save the Queen” remains the royal anthem of Canada ... O Canada! Our home and native land! True patriot love in all of us command. Car ton bras sait porter l'épée,. Il sait porter la croix! \"O Canada\" (French: Ô Canada) is the national anthem of Canada. The song was originally commissioned by Lieutenant Governor of Quebec Théodore Robitaille ... Feb 1, 2018 ... It was a simple tweak — just two words. But with that, Canada just voted to make its national anthem, “O Canada,” gender neutral, ... \"O Canada\" was proclaimed Canada's national anthem on July 1,. 1980, 100 years after it was first sung on June 24, 1880. The music. Patriotic music in Canada dates back over 200 years as a distinct category from British or French patriotism, preceding the first legal steps to ... Feb 4, 2022 ... English version: O Canada! Our home and native land! True patriot love in all of us command. With glowing hearts we ... Feb 1, 2018 ... Canada's Senate has passed a bill making the country's national anthem gender-neutral. If you're not familiar with the words to “O Canada,” ...\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: The national anthem of Canada is called \"O Canada\".\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
      ]
     },
     {
      "data": {
-      "text/plain": "{'input': 'what is their national anthem called?',\n 'chat_history': [HumanMessage(content='How many people live in canada?'),\n  AIMessage(content='The final answer to the original input question is 38.93 million people live in Canada as of 2022.')],\n 'output': \"The final answer cannot be determined without specifying which country's national anthem is being referred to.\"}"
+      "text/plain": [
+       "'The national anthem of Canada is called \"O Canada\".'"
+      ]
      },
-     "execution_count": 13,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "agent_with_chat_history.invoke(\n",
-    "    {\"input\": \"what is their national anthem called?\"},\n",
-    "    config={\"configurable\": {\"session_id\": \"<foo>\"}},\n",
-    ")"
+    "agent_chain.run(input=\"what is their national anthem called?\")"
    ]
   },
   {
@@ -261,100 +228,101 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 18,
    "id": "3359d043",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:21:12.756721Z",
-     "start_time": "2024-04-17T15:21:12.745830Z"
-    }
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
-    "agent = create_react_agent(model, tools, prompt)\n",
-    "agent_executor__without_memory = AgentExecutor(agent=agent, tools=tools, verbose=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "970d23df",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:23:37.774243Z",
-     "start_time": "2024-04-17T15:23:29.655034Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m To find the number of people living in Canada, I should use a search engine to look for a reliable source.\n",
-      "Action: Search\n",
-      "Action Input: \"Population of Canada\"\u001B[0m\u001B[36;1m\u001B[1;3m{'type': 'population_result', 'place': 'Canada', 'population': '38.93 million', 'year': '2022'}\u001B[0m\u001B[32;1m\u001B[1;3m38.93 million people live in Canada as of 2022.\n",
-      "Final Answer: 38.93 million people live in Canada.\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "{'input': 'How many people live in canada?',\n 'output': '38.93 million people live in Canada.'}"
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_executor__without_memory.invoke({\"input\": \"How many people live in canada?\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "d9ea82f0",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2024-04-17T15:25:53.364206Z",
-     "start_time": "2024-04-17T15:25:23.567528Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
-      "\u001B[32;1m\u001B[1;3m I should always think about what to do\n",
-      "Action: Search\n",
-      "Action Input: \"national anthem of [country name]\"\u001B[0m\u001B[36;1m\u001B[1;3m['Most nation states have an anthem, defined as \"a song, as of praise, devotion, or patriotism\"; most anthems are either marches or hymns in style.', 'National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”).', 'List of national anthems ; Albania · Hymni i Flamurit · Algeria ; The Bahamas · March On, Bahamaland · Bahrain ; Cambodia · Nokoreach · Cameroon ; Madagascar · Ry ...', 'General Information: First sung in 1844 with the title,. Sang till Norden (Song of the North). Its use as a. National Anthem dates from 1880-90. 1. Thou ancient ...', 'National anthem · Afghanistan · Akrotiri · Albania · Algeria · American Samoa · Andorra · Angola · Anguilla.', 'Background > National anthems: Countries Compared ; IndiaIndia, Jana Gana Mana ( Hail the ruler of all minds ) ; IndonesiaIndonesia, Indonesia Raya ( Great ...', '1. Afghanistan, \"Milli Surood\" (National Anthem) · 2. Armenia, \"Mer Hayrenik\" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ...', 'National Anthems of all the countries of the world ; Star Spangled Banner with Lyrics, Vocals, and Beautiful Photos. Musicplay ; Russia National ...', 'Himno Nacional del Perú, also known as Marcha Nacional del Perú or Somos libres, was selected as the national anthem of Peru in a public contest. Shortly after ...']\u001B[0m\u001B[32;1m\u001B[1;3mI now know the final answer\n",
-      "Final Answer: It depends on the country, but their national anthem can be found by searching \"national anthem of [country name]\".\u001B[0m\n",
-      "\n",
-      "\u001B[1m> Finished chain.\u001B[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": "{'input': 'what is their national anthem called?',\n 'output': 'It depends on the country, but their national anthem can be found by searching \"national anthem of [country name]\".'}"
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_executor__without_memory.invoke(\n",
-    "    {\"input\": \"what is their national anthem called?\"}\n",
+    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin!\"\n",
+    "\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, prefix=prefix, suffix=suffix, input_variables=[\"input\", \"agent_scratchpad\"]\n",
+    ")\n",
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
+    "agent_without_memory = AgentExecutor.from_agent_and_tools(\n",
+    "    agent=agent, tools=tools, verbose=True\n",
     ")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "970d23df",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
+      "Action: Search\n",
+      "Action Input: Population of Canada\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data. · Canada ... Additional information related to Canadian population trends can be found on Statistics Canada's Population and Demography Portal. Population of Canada (real- ... Index to the latest information from the Census of Population. This survey conducted by Statistics Canada provides a statistical portrait of Canada and its ... 14 records ... Estimated number of persons by quarter of a year and by year, Canada, provinces and territories. The 2021 Canadian census counted a total population of 36,991,981, an increase of around 5.2 percent over the 2016 figure. ... Between 1990 and 2008, the ... ( 2 ) Census reports and other statistical publications from national statistical offices, ( 3 ) Eurostat: Demographic Statistics, ( 4 ) United Nations ... Canada is a country in North America. Its ten provinces and three territories extend from ... Population. • Q4 2022 estimate. 39,292,355 (37th). Information is available for the total Indigenous population and each of the three ... The term 'Aboriginal' or 'Indigenous' used on the Statistics Canada ... Jun 14, 2022 ... Determinants of health are the broad range of personal, social, economic and environmental factors that determine individual and population ... COVID-19 vaccination coverage across Canada by demographics and key populations. Updated every Friday at 12:00 PM Eastern Time.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The current population of Canada is 38,566,192 as of Saturday, December 31, 2022, based on Worldometer elaboration of the latest United Nations data.'"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_without_memory.run(\"How many people live in canada?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "d9ea82f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I should look up the answer\n",
+      "Action: Search\n",
+      "Action Input: national anthem of [country]\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mMost nation states have an anthem, defined as \"a song, as of praise, devotion, or patriotism\"; most anthems are either marches or hymns in style. List of all countries around the world with its national anthem. ... Title and lyrics in the language of the country and translated into English, Aug 1, 2021 ... 1. Afghanistan, \"Milli Surood\" (National Anthem) · 2. Armenia, \"Mer Hayrenik\" (Our Fatherland) · 3. Azerbaijan (a transcontinental country with ... A national anthem is a patriotic musical composition symbolizing and evoking eulogies of the history and traditions of a country or nation. National Anthem of Every Country ; Fiji, “Meda Dau Doka” (“God Bless Fiji”) ; Finland, “Maamme”. (“Our Land”) ; France, “La Marseillaise” (“The Marseillaise”). You can find an anthem in the menu at the top alphabetically or you can use the search feature. This site is focussed on the scholarly study of national anthems ... Feb 13, 2022 ... The 38-year-old country music artist had the honor of singing the National Anthem during this year's big game, and she did not disappoint. Oldest of the World's National Anthems ; France, La Marseillaise (“The Marseillaise”), 1795 ; Argentina, Himno Nacional Argentino (“Argentine National Anthem”) ... Mar 3, 2022 ... Country music star Jessie James Decker gained the respect of music and hockey fans alike after a jaw-dropping rendition of \"The Star-Spangled ... This list shows the country on the left, the national anthem in the ... There are many countries over the world who have a national anthem of their own.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: The national anthem of [country] is [name of anthem].\u001b[0m\n",
+      "\u001b[1m> Finished AgentExecutor chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'The national anthem of [country] is [name of anthem].'"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_without_memory.run(\"what is their national anthem called?\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/chat/function_calling.ipynb

@@ -1,707 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "a413ade7-48f0-4d43-a1f3-d87f550a8018",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_position: 2\n",
-    "title: Tool/function calling\n",
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "50d59b14-c434-4359-be8e-4a21378e762f",
-   "metadata": {},
-   "source": [
-    "# Tool calling\n",
-    "\n",
-    "```{=mdx}\n",
-    ":::info\n",
-    "We use the term tool calling interchangeably with function calling. Although\n",
-    "function calling is sometimes meant to refer to invocations of a single function,\n",
-    "we treat all models as though they can return multiple tool or function calls in \n",
-    "each message.\n",
-    ":::\n",
-    "```\n",
-    "\n",
-    "Tool calling allows a model to respond to a given prompt by generating output that \n",
-    "matches a user-defined schema. While the name implies that the model is performing \n",
-    "some action, this is actually not the case! The model is coming up with the \n",
-    "arguments to a tool, and actually running the tool (or not) is up to the user - \n",
-    "for example, if you want to [extract output matching some schema](/docs/use_cases/extraction/) \n",
-    "from unstructured text, you could give the model an \"extraction\" tool that takes \n",
-    "parameters matching the desired schema, then treat the generated output as your final \n",
-    "result.\n",
-    "\n",
-    "A tool call includes a name, arguments dict, and an optional identifier. The \n",
-    "arguments dict is structured `{argument_name: argument_value}`.\n",
-    "\n",
-    "Many LLM providers, including [Anthropic](https://www.anthropic.com/), \n",
-    "[Cohere](https://cohere.com/), [Google](https://cloud.google.com/vertex-ai), \n",
-    "[Mistral](https://mistral.ai/), [OpenAI](https://openai.com/), and others, \n",
-    "support variants of a tool calling feature. These features typically allow requests \n",
-    "to the LLM to include available tools and their schemas, and for responses to include \n",
-    "calls to these tools. For instance, given a search engine tool, an LLM might handle a \n",
-    "query by first issuing a call to the search engine. The system calling the LLM can \n",
-    "receive the tool call, execute it, and return the output to the LLM to inform its \n",
-    "response. LangChain includes a suite of [built-in tools](/docs/integrations/tools/) \n",
-    "and supports several methods for defining your own [custom tools](/docs/modules/tools/custom_tools). \n",
-    "Tool-calling is extremely useful for building [tool-using chains and agents](/docs/use_cases/tool_use), \n",
-    "and for getting structured outputs from models more generally.\n",
-    "\n",
-    "Providers adopt different conventions for formatting tool schemas and tool calls. \n",
-    "For instance, Anthropic returns tool calls as parsed structures within a larger content block:\n",
-    "```python\n",
-    "[\n",
-    "  {\n",
-    "    \"text\": \"<thinking>\\nI should use a tool.\\n</thinking>\",\n",
-    "    \"type\": \"text\"\n",
-    "  },\n",
-    "  {\n",
-    "    \"id\": \"id_value\",\n",
-    "    \"input\": {\"arg_name\": \"arg_value\"},\n",
-    "    \"name\": \"tool_name\",\n",
-    "    \"type\": \"tool_use\"\n",
-    "  }\n",
-    "]\n",
-    "```\n",
-    "whereas OpenAI separates tool calls into a distinct parameter, with arguments as JSON strings:\n",
-    "```python\n",
-    "{\n",
-    "  \"tool_calls\": [\n",
-    "    {\n",
-    "      \"id\": \"id_value\",\n",
-    "      \"function\": {\n",
-    "        \"arguments\": '{\"arg_name\": \"arg_value\"}',\n",
-    "        \"name\": \"tool_name\"\n",
-    "      },\n",
-    "      \"type\": \"function\"\n",
-    "    }\n",
-    "  ]\n",
-    "}\n",
-    "```\n",
-    "LangChain implements standard interfaces for defining tools, passing them to LLMs, \n",
-    "and representing tool calls.\n",
-    "\n",
-    "## Passing tools to LLMs\n",
-    "\n",
-    "Chat models supporting tool calling features implement a `.bind_tools` method, which \n",
-    "receives a list of LangChain [tool objects](https://api.python.langchain.com/en/latest/tools/langchain_core.tools.BaseTool.html#langchain_core.tools.BaseTool) \n",
-    "and binds them to the chat model in its expected format. Subsequent invocations of the \n",
-    "chat model will include tool schemas in its calls to the LLM.\n",
-    "\n",
-    "For example, we can define the schema for custom tools using the `@tool` decorator \n",
-    "on Python functions:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "841dca72-1b57-4a42-8e22-da4835c4cfe0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.tools import tool\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def add(a: int, b: int) -> int:\n",
-    "    \"\"\"Adds a and b.\"\"\"\n",
-    "    return a + b\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def multiply(a: int, b: int) -> int:\n",
-    "    \"\"\"Multiplies a and b.\"\"\"\n",
-    "    return a * b\n",
-    "\n",
-    "\n",
-    "tools = [add, multiply]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "48058b7d-048d-48e6-a272-3931ad7ad146",
-   "metadata": {},
-   "source": [
-    "Or below, we define the schema using Pydantic:\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "fca56328-85e4-4839-97b7-b5dc55920602",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
-    "\n",
-    "\n",
-    "# Note that the docstrings here are crucial, as they will be passed along\n",
-    "# to the model along with the class name.\n",
-    "class Add(BaseModel):\n",
-    "    \"\"\"Add two integers together.\"\"\"\n",
-    "\n",
-    "    a: int = Field(..., description=\"First integer\")\n",
-    "    b: int = Field(..., description=\"Second integer\")\n",
-    "\n",
-    "\n",
-    "class Multiply(BaseModel):\n",
-    "    \"\"\"Multiply two integers together.\"\"\"\n",
-    "\n",
-    "    a: int = Field(..., description=\"First integer\")\n",
-    "    b: int = Field(..., description=\"Second integer\")\n",
-    "\n",
-    "\n",
-    "tools = [Add, Multiply]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ead9068d-11f6-42f3-a508-3c1830189947",
-   "metadata": {},
-   "source": [
-    "We can bind them to chat models as follows:\n",
-    "\n",
-    "```{=mdx}\n",
-    "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
-    "\n",
-    "<ChatModelTabs\n",
-    "  customVarName=\"llm\"\n",
-    "  fireworksParams={`model=\"accounts/fireworks/models/firefunction-v1\", temperature=0`}\n",
-    "/>\n",
-    "```\n",
-    "\n",
-    "We can use the `bind_tools()` method to handle converting\n",
-    "`Multiply` to a \"tool\" and binding it to the model (i.e.,\n",
-    "passing it in each time the model is invoked)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 67,
-   "id": "44eb8327-a03d-4c7c-945e-30f13f455346",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# | echo: false\n",
-    "# | output: false\n",
-    "\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 68,
-   "id": "af2a83ac-e43f-43ce-b107-9ed8376bfb75",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm_with_tools = llm.bind_tools(tools)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "16208230-f64f-4935-9aa1-280a91f34ba3",
-   "metadata": {},
-   "source": [
-    "## Tool calls\n",
-    "\n",
-    "If tool calls are included in a LLM response, they are attached to the corresponding \n",
-    "[message](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessage.html#langchain_core.messages.ai.AIMessage) \n",
-    "or [message chunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) \n",
-    "as a list of [tool call](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.ToolCall.html#langchain_core.messages.tool.ToolCall) \n",
-    "objects in the `.tool_calls` attribute. A `ToolCall` is a typed dict that includes a \n",
-    "tool name, dict of argument values, and (optionally) an identifier. Messages with no \n",
-    "tool calls default to an empty list for this attribute.\n",
-    "\n",
-    "Example:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "1640a4b4-c201-4b23-b257-738d854fb9fd",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'name': 'Multiply',\n",
-       "  'args': {'a': 3, 'b': 12},\n",
-       "  'id': 'call_1Tdp5wUXbYQzpkBoagGXqUTo'},\n",
-       " {'name': 'Add',\n",
-       "  'args': {'a': 11, 'b': 49},\n",
-       "  'id': 'call_k9v09vYioS3X0Qg35zESuUKI'}]"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "query = \"What is 3 * 12? Also, what is 11 + 49?\"\n",
-    "\n",
-    "llm_with_tools.invoke(query).tool_calls"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ac3ff0fe-5119-46b8-a578-530245bff23f",
-   "metadata": {},
-   "source": [
-    "The `.tool_calls` attribute should contain valid tool calls. Note that on occasion, \n",
-    "model providers may output malformed tool calls (e.g., arguments that are not \n",
-    "valid JSON). When parsing fails in these cases, instances \n",
-    "of [InvalidToolCall](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.InvalidToolCall.html#langchain_core.messages.tool.InvalidToolCall) \n",
-    "are populated in the `.invalid_tool_calls` attribute. An `InvalidToolCall` can have \n",
-    "a name, string arguments, identifier, and error message.\n",
-    "\n",
-    "If desired, [output parsers](/docs/modules/model_io/output_parsers) can further \n",
-    "process the output. For example, we can convert back to the original Pydantic class:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "ca15fcad-74fe-4109-a1b1-346c3eefe238",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Multiply(a=3, b=12), Add(a=11, b=49)]"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_core.output_parsers.openai_tools import PydanticToolsParser\n",
-    "\n",
-    "chain = llm_with_tools | PydanticToolsParser(tools=[Multiply, Add])\n",
-    "chain.invoke(query)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0ba3505d-f405-43ba-93c4-7fbd84f6464b",
-   "metadata": {},
-   "source": [
-    "### Streaming\n",
-    "\n",
-    "When tools are called in a streaming context, \n",
-    "[message chunks](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) \n",
-    "will be populated with [tool call chunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.ToolCallChunk.html#langchain_core.messages.tool.ToolCallChunk) \n",
-    "objects in a list via the `.tool_call_chunks` attribute. A `ToolCallChunk` includes \n",
-    "optional string fields for the tool `name`, `args`, and `id`, and includes an optional \n",
-    "integer field `index` that can be used to join chunks together. Fields are optional \n",
-    "because portions of a tool call may be streamed across different chunks (e.g., a chunk \n",
-    "that includes a substring of the arguments may have null values for the tool name and id).\n",
-    "\n",
-    "Because message chunks inherit from their parent message class, an \n",
-    "[AIMessageChunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) \n",
-    "with tool call chunks will also include `.tool_calls` and `.invalid_tool_calls` fields. \n",
-    "These fields are parsed best-effort from the message's tool call chunks.\n",
-    "\n",
-    "Note that not all providers currently support streaming for tool calls.\n",
-    "\n",
-    "Example:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "4f54a0de-74c7-4f2d-86c5-660aed23840d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[]\n",
-      "[{'name': 'Multiply', 'args': '', 'id': 'call_d39MsxKM5cmeGJOoYKdGBgzc', 'index': 0}]\n",
-      "[{'name': None, 'args': '{\"a\"', 'id': None, 'index': 0}]\n",
-      "[{'name': None, 'args': ': 3, ', 'id': None, 'index': 0}]\n",
-      "[{'name': None, 'args': '\"b\": 1', 'id': None, 'index': 0}]\n",
-      "[{'name': None, 'args': '2}', 'id': None, 'index': 0}]\n",
-      "[{'name': 'Add', 'args': '', 'id': 'call_QJpdxD9AehKbdXzMHxgDMMhs', 'index': 1}]\n",
-      "[{'name': None, 'args': '{\"a\"', 'id': None, 'index': 1}]\n",
-      "[{'name': None, 'args': ': 11,', 'id': None, 'index': 1}]\n",
-      "[{'name': None, 'args': ' \"b\": ', 'id': None, 'index': 1}]\n",
-      "[{'name': None, 'args': '49}', 'id': None, 'index': 1}]\n",
-      "[]\n"
-     ]
-    }
-   ],
-   "source": [
-    "async for chunk in llm_with_tools.astream(query):\n",
-    "    print(chunk.tool_call_chunks)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "55046320-3466-4ec1-a1f8-336234ba9019",
-   "metadata": {},
-   "source": [
-    "Note that adding message chunks will merge their corresponding tool call chunks. This is the principle by which LangChain's various [tool output parsers](/docs/modules/model_io/output_parsers/types/openai_tools/) support streaming.\n",
-    "\n",
-    "For example, below we accumulate tool call chunks:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "0a944af0-eedd-43c8-8ff3-f4301f129d9b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[]\n",
-      "[{'name': 'Multiply', 'args': '', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\"', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, ', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 1', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{\"a\"', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{\"a\": 11,', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{\"a\": 11, \"b\": ', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{\"a\": 11, \"b\": 49}', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}]\n",
-      "[{'name': 'Multiply', 'args': '{\"a\": 3, \"b\": 12}', 'id': 'call_erKtz8z3e681cmxYKbRof0NS', 'index': 0}, {'name': 'Add', 'args': '{\"a\": 11, \"b\": 49}', 'id': 'call_tYHYdEV2YBvzDcSCiFCExNvw', 'index': 1}]\n"
-     ]
-    }
-   ],
-   "source": [
-    "first = True\n",
-    "async for chunk in llm_with_tools.astream(query):\n",
-    "    if first:\n",
-    "        gathered = chunk\n",
-    "        first = False\n",
-    "    else:\n",
-    "        gathered = gathered + chunk\n",
-    "\n",
-    "    print(gathered.tool_call_chunks)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "db4e3e3a-3553-44dc-bd31-149c0981a06a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'str'>\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(type(gathered.tool_call_chunks[0][\"args\"]))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "95e92826-6e55-4684-9498-556f357f73ac",
-   "metadata": {},
-   "source": [
-    "And below we accumulate tool calls to demonstrate partial parsing:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "e9402bde-d4b5-4564-a99e-f88c9b46b28a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[]\n",
-      "[]\n",
-      "[{'name': 'Multiply', 'args': {}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 1}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}]\n",
-      "[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_BXqUtt6jYCwR1DguqpS2ehP0'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_UjSHJKROSAw2BDc8cp9cSv4i'}]\n"
-     ]
-    }
-   ],
-   "source": [
-    "first = True\n",
-    "async for chunk in llm_with_tools.astream(query):\n",
-    "    if first:\n",
-    "        gathered = chunk\n",
-    "        first = False\n",
-    "    else:\n",
-    "        gathered = gathered + chunk\n",
-    "\n",
-    "    print(gathered.tool_calls)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "8c2f21cc-0c6d-416a-871f-e854621c96e2",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<class 'dict'>\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(type(gathered.tool_calls[0][\"args\"]))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "97a0c977-0c3c-4011-b49b-db98c609d0ce",
-   "metadata": {},
-   "source": [
-    "## Passing tool outputs to model\n",
-    "\n",
-    "If we're using the model-generated tool invocations to actually call tools and want to pass the tool results back to the model, we can do so using `ToolMessage`s."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 117,
-   "id": "48049192-be28-42ab-9a44-d897924e67cd",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[HumanMessage(content='What is 3 * 12? Also, what is 11 + 49?'),\n",
-       " AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_K5DsWEmgt6D08EI9AFu9NaL1', 'function': {'arguments': '{\"a\": 3, \"b\": 12}', 'name': 'Multiply'}, 'type': 'function'}, {'id': 'call_qywVrsplg0ZMv7LHYYMjyG81', 'function': {'arguments': '{\"a\": 11, \"b\": 49}', 'name': 'Add'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 50, 'prompt_tokens': 105, 'total_tokens': 155}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-1a0b8cdd-9221-4d94-b2ed-5701f67ce9fe-0', tool_calls=[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_K5DsWEmgt6D08EI9AFu9NaL1'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_qywVrsplg0ZMv7LHYYMjyG81'}]),\n",
-       " ToolMessage(content='36', tool_call_id='call_K5DsWEmgt6D08EI9AFu9NaL1'),\n",
-       " ToolMessage(content='60', tool_call_id='call_qywVrsplg0ZMv7LHYYMjyG81')]"
-      ]
-     },
-     "execution_count": 117,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_core.messages import HumanMessage, ToolMessage\n",
-    "\n",
-    "messages = [HumanMessage(query)]\n",
-    "ai_msg = llm_with_tools.invoke(messages)\n",
-    "messages.append(ai_msg)\n",
-    "for tool_call in ai_msg.tool_calls:\n",
-    "    selected_tool = {\"add\": add, \"multiply\": multiply}[tool_call[\"name\"].lower()]\n",
-    "    tool_output = selected_tool.invoke(tool_call[\"args\"])\n",
-    "    messages.append(ToolMessage(tool_output, tool_call_id=tool_call[\"id\"]))\n",
-    "messages"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 118,
-   "id": "611e0f36-d736-48d1-bca1-1cec51d223f3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='3 * 12 is 36 and 11 + 49 is 60.', response_metadata={'token_usage': {'completion_tokens': 18, 'prompt_tokens': 171, 'total_tokens': 189}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-a6c8093c-b16a-4c92-8308-7c9ac998118c-0')"
-      ]
-     },
-     "execution_count": 118,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "llm_with_tools.invoke(messages)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a5937498-d6fe-400a-b192-ef35c314168e",
-   "metadata": {},
-   "source": [
-    "## Few-shot prompting\n",
-    "\n",
-    "For more complex tool use it's very useful to add few-shot examples to the prompt. We can do this by adding `AIMessage`s with `ToolCall`s and corresponding `ToolMessage`s to our prompt.\n",
-    "\n",
-    "For example, even with some special instructions our model can get tripped up by order of operations:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 112,
-   "id": "5ef2e7c3-0925-49da-ab8f-e42c4fa40f29",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'name': 'Multiply',\n",
-       "  'args': {'a': 119, 'b': 8},\n",
-       "  'id': 'call_Dl3FXRVkQCFW4sUNYOe4rFr7'},\n",
-       " {'name': 'Add',\n",
-       "  'args': {'a': 952, 'b': -20},\n",
-       "  'id': 'call_n03l4hmka7VZTCiP387Wud2C'}]"
-      ]
-     },
-     "execution_count": 112,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "llm_with_tools.invoke(\n",
-    "    \"Whats 119 times 8 minus 20. Don't do any math yourself, only use tools for math. Respect order of operations\"\n",
-    ").tool_calls"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a5249069-b5f8-40ac-ae74-30d67c4e9168",
-   "metadata": {},
-   "source": [
-    "The model shouldn't be trying to add anything yet, since it technically can't know the results of 119 * 8 yet.\n",
-    "\n",
-    "By adding a prompt with some examples we can correct this behavior:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 107,
-   "id": "7b2e8b19-270f-4e1a-8be7-7aad704c1cf4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'name': 'Multiply',\n",
-       "  'args': {'a': 119, 'b': 8},\n",
-       "  'id': 'call_MoSgwzIhPxhclfygkYaKIsGZ'}]"
-      ]
-     },
-     "execution_count": 107,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_core.messages import AIMessage\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_core.runnables import RunnablePassthrough\n",
-    "\n",
-    "examples = [\n",
-    "    HumanMessage(\n",
-    "        \"What's the product of 317253 and 128472 plus four\", name=\"example_user\"\n",
-    "    ),\n",
-    "    AIMessage(\n",
-    "        \"\",\n",
-    "        name=\"example_assistant\",\n",
-    "        tool_calls=[\n",
-    "            {\"name\": \"Multiply\", \"args\": {\"x\": 317253, \"y\": 128472}, \"id\": \"1\"}\n",
-    "        ],\n",
-    "    ),\n",
-    "    ToolMessage(\"16505054784\", tool_call_id=\"1\"),\n",
-    "    AIMessage(\n",
-    "        \"\",\n",
-    "        name=\"example_assistant\",\n",
-    "        tool_calls=[{\"name\": \"Add\", \"args\": {\"x\": 16505054784, \"y\": 4}, \"id\": \"2\"}],\n",
-    "    ),\n",
-    "    ToolMessage(\"16505054788\", tool_call_id=\"2\"),\n",
-    "    AIMessage(\n",
-    "        \"The product of 317253 and 128472 plus four is 16505054788\",\n",
-    "        name=\"example_assistant\",\n",
-    "    ),\n",
-    "]\n",
-    "\n",
-    "system = \"\"\"You are bad at math but are an expert at using a calculator. \n",
-    "\n",
-    "Use past tool usage as an example of how to correctly use the tools.\"\"\"\n",
-    "few_shot_prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\"system\", system),\n",
-    "        *examples,\n",
-    "        (\"human\", \"{query}\"),\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "chain = {\"query\": RunnablePassthrough()} | few_shot_prompt | llm_with_tools\n",
-    "chain.invoke(\"Whats 119 times 8 minus 20\").tool_calls"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "19160e3e-3eb5-4e9a-ae56-74a2dce0af32",
-   "metadata": {},
-   "source": [
-    "Seems like we get the correct output this time.\n",
-    "\n",
-    "Here's what the [LangSmith trace](https://smith.langchain.com/public/f70550a1-585f-4c9d-a643-13148ab1616f/r) looks like."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "020cfd3b-0838-49d0-96bb-7cd919921833",
-   "metadata": {},
-   "source": [
-    "## Next steps\n",
-    "\n",
-    "- **Output parsing**: See [OpenAI Tools output\n",
-    "    parsers](/docs/modules/model_io/output_parsers/types/openai_tools/)\n",
-    "    and [OpenAI Functions output\n",
-    "    parsers](/docs/modules/model_io/output_parsers/types/openai_functions/)\n",
-    "    to learn about extracting the function calling API responses into\n",
-    "    various formats.\n",
-    "- **Structured output chains**: [Some models have constructors](/docs/modules/model_io/chat/structured_output/) that\n",
-    "    handle creating a structured output chain for you.\n",
-    "- **Tool use**: See how to construct chains and agents that\n",
-    "    call the invoked tools in [these\n",
-    "    guides](/docs/use_cases/tool_use/)."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "poetry-venv-2",
-   "language": "python",
-   "name": "poetry-venv-2"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/model_io/chat/function_calling.mdx

@@ -0,0 +1,326 @@
+---
+sidebar_position: 2
+title: Tool/function calling
+---
+
+# Tool calling
+
+:::info
+We use the term tool calling interchangeably with function calling. Although
+function calling is sometimes meant to refer to invocations of a single function,
+we treat all models as though they can return multiple tool or function calls in 
+each message.
+:::
+
+# Calling Tools
+
+Tool calling allows a model to respond to a given prompt by generating output that 
+matches a user-defined schema. While the name implies that the model is performing 
+some action, this is actually not the case! The model is coming up with the 
+arguments to a tool, and actually running the tool (or not) is up to the user - 
+for example, if you want to [extract output matching some schema](/docs/use_cases/extraction/) 
+from unstructured text, you could give the model an "extraction" tool that takes 
+parameters matching the desired schema, then treat the generated output as your final 
+result.
+
+A tool call includes a name, arguments dict, and an optional identifier. The 
+arguments dict is structured `{argument_name: argument_value}`.
+
+Many LLM providers, including [Anthropic](https://www.anthropic.com/), 
+[Cohere](https://cohere.com/), [Google](https://cloud.google.com/vertex-ai), 
+[Mistral](https://mistral.ai/), [OpenAI](https://openai.com/), and others, 
+support variants of a tool calling feature. These features typically allow requests 
+to the LLM to include available tools and their schemas, and for responses to include 
+calls to these tools. For instance, given a search engine tool, an LLM might handle a 
+query by first issuing a call to the search engine. The system calling the LLM can 
+receive the tool call, execute it, and return the output to the LLM to inform its 
+response. LangChain includes a suite of [built-in tools](/docs/integrations/tools/) 
+and supports several methods for defining your own [custom tools](/docs/modules/tools/custom_tools). 
+Tool-calling is extremely useful for building [tool-using chains and agents](/docs/use_cases/tool_use), 
+and for getting structured outputs from models more generally.
+
+Providers adopt different conventions for formatting tool schemas and tool calls. 
+For instance, Anthropic returns tool calls as parsed structures within a larger content block:
+```
+[
+  {
+    "text": "<thinking>\nI should use a tool.\n</thinking>",
+    "type": "text"
+  },
+  {
+    "id": "id_value",
+    "input": {"arg_name": "arg_value"},
+    "name": "tool_name",
+    "type": "tool_use"
+  }
+]
+```
+whereas OpenAI separates tool calls into a distinct parameter, with arguments as JSON strings:
+```
+{
+  "tool_calls": [
+    {
+      "id": "id_value",
+      "function": {
+        "arguments": '{"arg_name": "arg_value"}',
+        "name": "tool_name"
+      },
+      "type": "function"
+    }
+  ]
+}
+```
+LangChain implements standard interfaces for defining tools, passing them to LLMs, 
+and representing tool calls.
+
+## Passing tools to LLMs
+
+Chat models supporting tool calling features implement a `.bind_tools` method, which 
+receives a list of LangChain [tool objects](https://api.python.langchain.com/en/latest/tools/langchain_core.tools.BaseTool.html#langchain_core.tools.BaseTool) 
+and binds them to the chat model in its expected format. Subsequent invocations of the 
+chat model will include tool schemas in its calls to the LLM.
+
+For example, we can define the schema for custom tools using the `@tool` decorator 
+on Python functions:
+
+```python
+from langchain.tools import tool
+
+
+@tool
+def add(a: int, b: int) -> int:
+    """Adds a and b."""
+    return a + b
+
+
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiplies a and b."""
+    return a * b
+
+
+tools = [add, multiply]
+```
+
+Or below, we define the schema using Pydantic:
+```python
+from langchain_core.pydantic_v1 import BaseModel, Field
+
+
+# Note that the docstrings here are crucial, as they will be passed along
+# to the model along with the class name.
+class Add(BaseModel):
+    """Add two integers together."""
+
+    a: int = Field(..., description="First integer")
+    b: int = Field(..., description="Second integer")
+
+
+class Multiply(BaseModel):
+    """Multiply two integers together."""
+
+    a: int = Field(..., description="First integer")
+    b: int = Field(..., description="Second integer")
+
+
+tools = [Add, Multiply]
+```
+
+We can bind them to chat models as follows:
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+import ChatModelTabs from "@theme/ChatModelTabs";
+
+<ChatModelTabs
+  customVarName="llm"
+  fireworksParams={`model="accounts/fireworks/models/firefunction-v1", temperature=0`}
+  hideGoogle={true}
+  hideAnthropic={false}
+/>
+
+We can use the `bind_tools()` method to handle converting
+`Multiply` to a "tool" and binding it to the model (i.e.,
+passing it in each time the model is invoked).
+
+```python
+llm_with_tools = llm.bind_tools(tools)
+```
+
+## Tool calls
+
+If tool calls are included in a LLM response, they are attached to the corresponding 
+[message](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessage.html#langchain_core.messages.ai.AIMessage) 
+or [message chunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) 
+as a list of [tool call](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.ToolCall.html#langchain_core.messages.tool.ToolCall) 
+objects in the `.tool_calls` attribute. A `ToolCall` is a typed dict that includes a 
+tool name, dict of argument values, and (optionally) an identifier. Messages with no 
+tool calls default to an empty list for this attribute.
+
+Example:
+
+```python
+query = "What is 3 * 12? Also, what is 11 + 49?"
+
+llm_with_tools.invoke(query).tool_calls
+```
+```text
+[{'name': 'Multiply',
+  'args': {'a': 3, 'b': 12},
+  'id': 'call_viACG45wBz9jYzljHIwHamXw'},
+ {'name': 'Add',
+  'args': {'a': 11, 'b': 49},
+  'id': 'call_JMFUqoi5L27rGeMuII4MJMWo'}]
+```
+
+The `.tool_calls` attribute should contain valid tool calls. Note that on occasion, 
+model providers may output malformed tool calls (e.g., arguments that are not 
+valid JSON). When parsing fails in these cases, instances 
+of [InvalidToolCall](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.InvalidToolCall.html#langchain_core.messages.tool.InvalidToolCall) 
+are populated in the `.invalid_tool_calls` attribute. An `InvalidToolCall` can have 
+a name, string arguments, identifier, and error message.
+
+If desired, [output parsers](/docs/modules/model_io/output_parsers) can further 
+process the output. For example, we can convert back to the original Pydantic class:
+
+```python
+from langchain_core.output_parsers.openai_tools import PydanticToolsParser
+
+chain = llm_with_tools | PydanticToolsParser(tools=[Multiply, Add])
+chain.invoke(query)
+```
+```text
+[Multiply(a=3, b=12), Add(a=11, b=49)]
+```
+
+### Streaming
+
+When tools are called in a streaming context, 
+[message chunks](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) 
+will be populated with [tool call chunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.ToolCallChunk.html#langchain_core.messages.tool.ToolCallChunk) 
+objects in a list via the `.tool_call_chunks` attribute. A `ToolCallChunk` includes 
+optional string fields for the tool `name`, `args`, and `id`, and includes an optional 
+integer field `index` that can be used to join chunks together. Fields are optional 
+because portions of a tool call may be streamed across different chunks (e.g., a chunk 
+that includes a substring of the arguments may have null values for the tool name and id).
+
+Because message chunks inherit from their parent message class, an 
+[AIMessageChunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html#langchain_core.messages.ai.AIMessageChunk) 
+with tool call chunks will also include `.tool_calls` and `.invalid_tool_calls` fields. 
+These fields are parsed best-effort from the message's tool call chunks.
+
+Note that not all providers currently support streaming for tool calls.
+
+Example:
+
+```python
+async for chunk in llm_with_tools.astream(query):
+    print(chunk.tool_call_chunks)
+```
+
+```text
+[]
+[{'name': 'Multiply', 'args': '', 'id': 'call_Al2xpR4uFPXQUDzGTSawMOah', 'index': 0}]
+[{'name': None, 'args': '{"a"', 'id': None, 'index': 0}]
+[{'name': None, 'args': ': 3, ', 'id': None, 'index': 0}]
+[{'name': None, 'args': '"b": 1', 'id': None, 'index': 0}]
+[{'name': None, 'args': '2}', 'id': None, 'index': 0}]
+[{'name': 'Add', 'args': '', 'id': 'call_VV6ck8JSQ6joKtk2xGtNKgXf', 'index': 1}]
+[{'name': None, 'args': '{"a"', 'id': None, 'index': 1}]
+[{'name': None, 'args': ': 11,', 'id': None, 'index': 1}]
+[{'name': None, 'args': ' "b": ', 'id': None, 'index': 1}]
+[{'name': None, 'args': '49}', 'id': None, 'index': 1}]
+[]
+```
+
+Note that adding message chunks will merge their corresponding tool call chunks. This is the principle by which LangChain's various [tool output parsers](/docs/modules/model_io/output_parsers/types/openai_tools/) support streaming.
+
+For example, below we accumulate tool call chunks:
+
+```python
+first = True
+async for chunk in llm_with_tools.astream(query):
+    if first:
+        gathered = chunk
+        first = False
+    else:
+        gathered = gathered + chunk
+
+    print(gathered.tool_call_chunks)
+```
+
+```text
+[]
+[{'name': 'Multiply', 'args': '', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}]
+[{'name': 'Multiply', 'args': '{"a"', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}]
+[{'name': 'Multiply', 'args': '{"a": 3, ', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 1', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}, {'name': 'Add', 'args': '', 'id': 'call_uGot9MOHDcz67Bj0h13c7QA5', 'index': 1}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}, {'name': 'Add', 'args': '{"a"', 'id': 'call_uGot9MOHDcz67Bj0h13c7QA5', 'index': 1}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}, {'name': 'Add', 'args': '{"a": 11,', 'id': 'call_uGot9MOHDcz67Bj0h13c7QA5', 'index': 1}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": ', 'id': 'call_uGot9MOHDcz67Bj0h13c7QA5', 'index': 1}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": 49}', 'id': 'call_uGot9MOHDcz67Bj0h13c7QA5', 'index': 1}]
+[{'name': 'Multiply', 'args': '{"a": 3, "b": 12}', 'id': 'call_2MG1IGft6WmgMooqZgJ07JX6', 'index': 0}, {'name': 'Add', 'args': '{"a": 11, "b": 49}', 'id': 'call_uGot9MOHDcz67Bj0h13c7QA5', 'index': 1}]
+```
+
+```python
+print(type(gathered.tool_call_chunks[0]["args"]))
+```
+
+```text
+<class 'str'>
+```
+
+And below we accumulate tool calls to demonstrate partial parsing:
+
+```python
+first = True
+async for chunk in llm_with_tools.astream(query):
+    if first:
+        gathered = chunk
+        first = False
+    else:
+        gathered = gathered + chunk
+
+    print(gathered.tool_calls)
+```
+
+```text
+[]
+[]
+[{'name': 'Multiply', 'args': {}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}]
+[{'name': 'Multiply', 'args': {'a': 3}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 1}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}, {'name': 'Add', 'args': {}, 'id': 'call_zPAyMWr8hN1q083GWGX2dSiB'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_zPAyMWr8hN1q083GWGX2dSiB'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}, {'name': 'Add', 'args': {'a': 11}, 'id': 'call_zPAyMWr8hN1q083GWGX2dSiB'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_zPAyMWr8hN1q083GWGX2dSiB'}]
+[{'name': 'Multiply', 'args': {'a': 3, 'b': 12}, 'id': 'call_z3B4o82SQDY5NCnmrXIcVQo4'}, {'name': 'Add', 'args': {'a': 11, 'b': 49}, 'id': 'call_zPAyMWr8hN1q083GWGX2dSiB'}]
+```
+
+```python
+print(type(gathered.tool_calls[0]["args"]))
+```
+
+```text
+<class 'dict'>
+```
+
+
+## Next steps
+
+- **Output parsing**: See [OpenAI Tools output
+    parsers](/docs/modules/model_io/output_parsers/types/openai_tools/)
+    and [OpenAI Functions output
+    parsers](/docs/modules/model_io/output_parsers/types/openai_functions/)
+    to learn about extracting the function calling API responses into
+    various formats.
+- **Structured output chains**: [Some models have constructors](/docs/modules/model_io/chat/structured_output/) that
+    handle creating a structured output chain for you.
+- **Tool use**: See how to construct chains and agents that actually
+    call the invoked tools in [these
+    guides](/docs/use_cases/tool_use/).

docs/docs/modules/model_io/chat/index.mdx

@@ -30,4 +30,4 @@ This includes:
 - [How to use ChatModels that support function calling](./function_calling)
 - [How to stream responses from a ChatModel](./streaming)
 - [How to track token usage in a ChatModel call](./token_usage_tracking)
-- [How to create a custom ChatModel](./custom_chat_model)
+- [How to creat a custom ChatModel](./custom_chat_model)

docs/docs/modules/model_io/chat/quick_start.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "---\n",
     "sidebar_position: 0\n",
-    "title: Quickstart\n",
+    "title: Quick Start\n",
     "---"
    ]
   },
@@ -16,7 +16,7 @@
    "id": "a1a454a9-f963-417b-8be0-e60317cd328c",
    "metadata": {},
    "source": [
-    "# Quickstart\n",
+    "# Quick Start\n",
     "\n",
     "Chat models are a variation on language models.\n",
     "While chat models use language models under the hood, the interface they use is a bit different.\n",

docs/docs/modules/model_io/chat/response_metadata.ipynb

@@ -1,354 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "6bd1219b-f31c-41b0-95e6-3204ad894ac7",
-   "metadata": {},
-   "source": [
-    "# Response metadata\n",
-    "\n",
-    "Many model providers include some metadata in their chat generation responses. This metadata can be accessed via the `AIMessage.response_metadata: Dict` attribute. Depending on the model provider and model configuration, this can contain information like [token counts](/docs/modules/model_io/chat/token_usage_tracking/), [logprobs](/docs/modules/model_io/chat/logprobs/), and more.\n",
-    "\n",
-    "Here's what the response metadata looks like for a few different providers:\n",
-    "\n",
-    "## OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "161f5898-9976-4a75-943d-03eda1a40a60",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'token_usage': {'completion_tokens': 164,\n",
-       "  'prompt_tokens': 17,\n",
-       "  'total_tokens': 181},\n",
-       " 'model_name': 'gpt-4-turbo',\n",
-       " 'system_fingerprint': 'fp_76f018034d',\n",
-       " 'finish_reason': 'stop',\n",
-       " 'logprobs': None}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "llm = ChatOpenAI(model=\"gpt-4-turbo\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "98eab683-df03-44a1-a034-ebbe7c6851b6",
-   "metadata": {},
-   "source": [
-    "## Anthropic"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "61c43496-83b5-4d71-bd60-3e6d46c62a5e",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'id': 'msg_01CzQyD7BX8nkhDNfT1QqvEp',\n",
-       " 'model': 'claude-3-sonnet-20240229',\n",
-       " 'stop_reason': 'end_turn',\n",
-       " 'stop_sequence': None,\n",
-       " 'usage': {'input_tokens': 17, 'output_tokens': 296}}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_anthropic import ChatAnthropic\n",
-    "\n",
-    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c1f24f69-18f6-43c1-8b26-3f88ec515259",
-   "metadata": {},
-   "source": [
-    "## Google VertexAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "39549336-25f5-4839-9846-f687cd77e59b",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'is_blocked': False,\n",
-       " 'safety_ratings': [{'category': 'HARM_CATEGORY_HATE_SPEECH',\n",
-       "   'probability_label': 'NEGLIGIBLE',\n",
-       "   'blocked': False},\n",
-       "  {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT',\n",
-       "   'probability_label': 'NEGLIGIBLE',\n",
-       "   'blocked': False},\n",
-       "  {'category': 'HARM_CATEGORY_HARASSMENT',\n",
-       "   'probability_label': 'NEGLIGIBLE',\n",
-       "   'blocked': False},\n",
-       "  {'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT',\n",
-       "   'probability_label': 'NEGLIGIBLE',\n",
-       "   'blocked': False}],\n",
-       " 'citation_metadata': None,\n",
-       " 'usage_metadata': {'prompt_token_count': 10,\n",
-       "  'candidates_token_count': 30,\n",
-       "  'total_token_count': 40}}"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_google_vertexai import ChatVertexAI\n",
-    "\n",
-    "llm = ChatVertexAI(model=\"gemini-pro\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "bc4ef8bb-eee3-4266-b530-0af9b3b79fe9",
-   "metadata": {},
-   "source": [
-    "## Bedrock (Anthropic)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "1e4ac668-4c6a-48ad-9a6f-7b291477b45d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'model_id': 'anthropic.claude-v2',\n",
-       " 'usage': {'prompt_tokens': 19, 'completion_tokens': 371, 'total_tokens': 390}}"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_aws import ChatBedrock\n",
-    "\n",
-    "llm = ChatBedrock(model_id=\"anthropic.claude-v2\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ee040d15-5575-4309-a9e9-aed5a09c78e3",
-   "metadata": {},
-   "source": [
-    "## MistralAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "deb41321-52d0-4795-a40c-4a811a13d7b0",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'token_usage': {'prompt_tokens': 19,\n",
-       "  'total_tokens': 141,\n",
-       "  'completion_tokens': 122},\n",
-       " 'model': 'mistral-small',\n",
-       " 'finish_reason': 'stop'}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_mistralai import ChatMistralAI\n",
-    "\n",
-    "llm = ChatMistralAI()\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "297c7be4-9505-48ac-96c0-4dc2047cfe7f",
-   "metadata": {},
-   "source": [
-    "## Groq"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "744e14ec-ff50-4642-9893-ff7bdf8927ff",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'token_usage': {'completion_time': 0.243,\n",
-       "  'completion_tokens': 132,\n",
-       "  'prompt_time': 0.022,\n",
-       "  'prompt_tokens': 22,\n",
-       "  'queue_time': None,\n",
-       "  'total_time': 0.265,\n",
-       "  'total_tokens': 154},\n",
-       " 'model_name': 'mixtral-8x7b-32768',\n",
-       " 'system_fingerprint': 'fp_7b44c65f25',\n",
-       " 'finish_reason': 'stop',\n",
-       " 'logprobs': None}"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_groq import ChatGroq\n",
-    "\n",
-    "llm = ChatGroq()\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7cdeec00-8a8f-422a-8819-47c646578b65",
-   "metadata": {},
-   "source": [
-    "## TogetherAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "a984118e-a731-4864-bcea-7dc6c6b3d139",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'token_usage': {'completion_tokens': 208,\n",
-       "  'prompt_tokens': 20,\n",
-       "  'total_tokens': 228},\n",
-       " 'model_name': 'mistralai/Mixtral-8x7B-Instruct-v0.1',\n",
-       " 'system_fingerprint': None,\n",
-       " 'finish_reason': 'eos',\n",
-       " 'logprobs': None}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "import os\n",
-    "\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "llm = ChatOpenAI(\n",
-    "    base_url=\"https://api.together.xyz/v1\",\n",
-    "    api_key=os.environ[\"TOGETHER_API_KEY\"],\n",
-    "    model=\"mistralai/Mixtral-8x7B-Instruct-v0.1\",\n",
-    ")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3d5e0614-8dc2-4948-a0b5-dc76c7837a5a",
-   "metadata": {},
-   "source": [
-    "## FireworksAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "6ae32a93-26db-41bb-95c2-38ddd5085fbe",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'token_usage': {'prompt_tokens': 19,\n",
-       "  'total_tokens': 219,\n",
-       "  'completion_tokens': 200},\n",
-       " 'model_name': 'accounts/fireworks/models/mixtral-8x7b-instruct',\n",
-       " 'system_fingerprint': '',\n",
-       " 'finish_reason': 'length',\n",
-       " 'logprobs': None}"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_fireworks import ChatFireworks\n",
-    "\n",
-    "llm = ChatFireworks(model=\"accounts/fireworks/models/mixtral-8x7b-instruct\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "poetry-venv-2",
-   "language": "python",
-   "name": "poetry-venv-2"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/modules/model_io/chat/streaming.ipynb

@@ -1,15 +1,5 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "e9437c8a-d8b7-4bf6-8ff4-54068a5a266c",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_position: 1.5\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "d0df7646-b1e1-4014-a841-6dae9b3c50d9",
@@ -76,9 +66,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "poetry-venv",
    "language": "python",
-   "name": "python3"
+   "name": "poetry-venv"
   },
   "language_info": {
    "codemirror_mode": {

docs/docs/modules/model_io/chat/structured_output.ipynb

@@ -86,7 +86,7 @@
    "id": "deddb6d3",
    "metadata": {},
    "source": [
-    "#### Tool/function Calling\n",
+    "### Function Calling\n",
     "\n",
     "By default, we will use `function_calling`"
    ]
@@ -128,7 +128,7 @@
    "id": "39d7a555",
    "metadata": {},
    "source": [
-    "#### JSON Mode\n",
+    "### JSON Mode\n",
     "\n",
     "We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in."
    ]
@@ -193,7 +193,7 @@
    "id": "36270ed5",
    "metadata": {},
    "source": [
-    "#### Tool/function Calling\n",
+    "### Function Calling\n",
     "\n",
     "By default, we will use `function_calling`"
    ]
@@ -235,7 +235,7 @@
    "id": "ddb6b3ba",
    "metadata": {},
    "source": [
-    "#### JSON Mode\n",
+    "### JSON Mode\n",
     "\n",
     "We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in."
    ]
@@ -401,7 +401,7 @@
    "id": "6b7e97a6",
    "metadata": {},
    "source": [
-    "#### Tool/function Calling\n",
+    "### Function Calling\n",
     "\n",
     "By default, we will use `function_calling`"
    ]
@@ -452,7 +452,7 @@
    "id": "a82c2f55",
    "metadata": {},
    "source": [
-    "#### JSON Mode\n",
+    "### JSON Mode\n",
     "\n",
     "We also support JSON mode. Note that we need to specify in the prompt the format that it should respond in."
    ]
@@ -532,7 +532,7 @@
    "id": "6c797e2d-3115-4ca2-9c2f-e853bdc7956d",
    "metadata": {},
    "source": [
-    "## Google Vertex AI\n",
+    "# Vertex AI\n",
     "\n",
     "Google's Gemini models support [function-calling](https://ai.google.dev/docs/function_calling), which we can access via Vertex AI and use for structuring outputs.\n",
     "\n",

docs/docs/modules/model_io/chat/token_usage_tracking.ipynb

@@ -7,130 +7,35 @@
    "source": [
     "# Tracking token usage\n",
     "\n",
-    "This notebook goes over how to track your token usage for specific calls."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1a55e87a-3291-4e7f-8e8e-4c69b0854384",
-   "metadata": {},
-   "source": [
-    "## Using AIMessage.response_metadata\n",
-    "\n",
-    "A number of model providers return token usage information as part of the chat generation response. When available, this is included in the [AIMessage.response_metadata](/docs/modules/model_io/chat/response_metadata/). Here's an example with OpenAI:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "467ccdeb-6b62-45e5-816e-167cd24d2586",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'token_usage': {'completion_tokens': 225,\n",
-       "  'prompt_tokens': 17,\n",
-       "  'total_tokens': 242},\n",
-       " 'model_name': 'gpt-4-turbo',\n",
-       " 'system_fingerprint': 'fp_76f018034d',\n",
-       " 'finish_reason': 'stop',\n",
-       " 'logprobs': None}"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# !pip install -qU langchain-openai\n",
-    "\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "llm = ChatOpenAI(model=\"gpt-4-turbo\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9d5026e9-3ad4-41e6-9946-9f1a26f4a21f",
-   "metadata": {},
-   "source": [
-    "And here's an example with Anthropic:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "145404f1-e088-4824-b468-236c486a9903",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'id': 'msg_01P61rdHbapEo6h3fjpfpCQT',\n",
-       " 'model': 'claude-3-sonnet-20240229',\n",
-       " 'stop_reason': 'end_turn',\n",
-       " 'stop_sequence': None,\n",
-       " 'usage': {'input_tokens': 17, 'output_tokens': 306}}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# !pip install -qU langchain-anthropic\n",
-    "\n",
-    "from langchain_anthropic import ChatAnthropic\n",
-    "\n",
-    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d6845407-af25-4eed-bc3e-50925c6661e0",
-   "metadata": {},
-   "source": [
-    "## Using callbacks\n",
-    "\n",
-    "There are also some API-specific callback context managers that allow you to track token usage across multiple calls. It is currently only implemented for the OpenAI API and Bedrock Anthropic API.\n",
-    "\n",
-    "### OpenAI\n",
+    "This notebook goes over how to track your token usage for specific calls. It is currently only implemented for the OpenAI API.\n",
     "\n",
     "Let's first look at an extremely simple example of tracking token usage for a single Chat model call."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "id": "9455db35",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# !pip install -qU langchain-community wikipedia\n",
-    "\n",
-    "from langchain_community.callbacks.manager import get_openai_callback"
+    "from langchain_community.callbacks import get_openai_callback\n",
+    "from langchain_openai import ChatOpenAI"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 8,
    "id": "d1c55cc9",
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm = ChatOpenAI(model=\"gpt-4-turbo\", temperature=0)"
+    "llm = ChatOpenAI(model=\"gpt-4\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "id": "31667d54",
    "metadata": {},
    "outputs": [
@@ -138,11 +43,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Tokens Used: 26\n",
+      "Tokens Used: 24\n",
       "\tPrompt Tokens: 11\n",
-      "\tCompletion Tokens: 15\n",
+      "\tCompletion Tokens: 13\n",
       "Successful Requests: 1\n",
-      "Total Cost (USD): $0.00056\n"
+      "Total Cost (USD): $0.0011099999999999999\n"
      ]
     }
    ],
@@ -162,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 10,
    "id": "e09420f4",
    "metadata": {},
    "outputs": [
@@ -170,7 +75,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "52\n"
+      "48\n"
      ]
     }
    ],
@@ -191,43 +96,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 11,
    "id": "5d1125c6",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import AgentExecutor, create_tool_calling_agent, load_tools\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain.agents import AgentType, initialize_agent, load_tools\n",
+    "from langchain_openai import OpenAI\n",
     "\n",
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\"system\", \"You're a helpful assistant\"),\n",
-    "        (\"human\", \"{input}\"),\n",
-    "        (\"placeholder\", \"{agent_scratchpad}\"),\n",
-    "    ]\n",
-    ")\n",
-    "tools = load_tools([\"wikipedia\"])\n",
-    "agent = create_tool_calling_agent(llm, tools, prompt)\n",
-    "agent_executor = AgentExecutor(\n",
-    "    agent=agent, tools=tools, verbose=True, stream_runnable=False\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9c1ae74d-8300-4041-9ff4-66093ee592b1",
-   "metadata": {},
-   "source": [
-    "```{=mdx}\n",
-    ":::note\n",
-    "We have to set `stream_runnable=False` for token counting to work. By default the AgentExecutor will stream the underlying agent so that you can get the most granular results when streaming events via AgentExecutor.stream_events. However, OpenAI does not return token counts when streaming model responses, so we need to turn off the underlying streaming.\n",
-    ":::\n",
-    "```"
+    "tools = load_tools([\"serpapi\", \"llm-math\"], llm=llm)\n",
+    "agent = initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 12,
    "id": "2f98c536",
    "metadata": {},
    "outputs": [
@@ -239,115 +122,42 @@
       "\n",
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
       "\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `wikipedia` with `Hummingbird`\n",
+      "Invoking: `Search` with `Olivia Wilde's current boyfriend`\n",
       "\n",
       "\n",
-      "\u001b[0m\u001b[36;1m\u001b[1;3mPage: Hummingbird\n",
-      "Summary: Hummingbirds are birds native to the Americas and comprise the biological family Trochilidae. With approximately 366 species and 113 genera, they occur from Alaska to Tierra del Fuego, but most species are found in Central and South America. As of 2024, 21 hummingbird species are listed as endangered or critically endangered, with numerous species declining in population.Hummingbirds have varied specialized characteristics to enable rapid, maneuverable flight: exceptional metabolic capacity, adaptations to high altitude, sensitive visual and communication abilities, and long-distance migration in some species. Among all birds, male hummingbirds have the widest diversity of plumage color, particularly in blues, greens, and purples. Hummingbirds are the smallest mature birds, measuring 7.5–13 cm (3–5 in) in length. The smallest is the 5 cm (2.0 in) bee hummingbird, which weighs less than 2.0 g (0.07 oz), and the largest is the 23 cm (9 in) giant hummingbird, weighing 18–24 grams (0.63–0.85 oz). Noted for long beaks, hummingbirds are specialized for feeding on flower nectar, but all species also consume small insects.\n",
-      "They are known as hummingbirds because of the humming sound created by their beating wings, which flap at high frequencies audible to other birds and humans. They hover at rapid wing-flapping rates, which vary from around 12 beats per second in the largest species to 80 per second in small hummingbirds.\n",
-      "Hummingbirds have the highest mass-specific metabolic rate of any homeothermic animal. To conserve energy when food is scarce and at night when not foraging, they can enter torpor, a state similar to hibernation, and slow their metabolic rate to 1⁄15 of its normal rate. While most hummingbirds do not migrate, the rufous hummingbird has one of the longest migrations among birds, traveling twice per year between Alaska and Mexico, a distance of about 3,900 miles (6,300 km).\n",
-      "Hummingbirds split from their sister group, the swifts and treeswifts, around 42 million years ago. The oldest known fossil hummingbird is Eurotrochilus, from the Rupelian Stage of Early Oligocene Europe.\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3m['Things are looking golden for Olivia Wilde, as the actress has jumped back into the dating pool following her split from Harry Styles — read ...', \"“I did not want service to take place at the home of Olivia's current partner because Otis and Daisy might be present,” Sudeikis wrote in his ...\", \"February 2021: Olivia Wilde praises Harry Styles' modesty. One month after the duo made headlines with their budding romance, Wilde gave her new beau major ...\", 'An insider revealed to People that the new couple had been dating for some time. \"They were in Montecito, California this weekend for a wedding, ...', 'A source told People last year that Wilde and Styles were still friends despite deciding to take a break. \"He\\'s still touring and is now going ...', \"... love life. “He's your typical average Joe.” The source adds, “She's not giving too much away right now and wants to keep the relationship ...\", \"Multiple sources said the two were “taking a break” from dating because of distance and different priorities. “He's still touring and is now ...\", 'Comments. Filed under. celebrity couples · celebrity dating · harry styles · jason sudeikis · olivia wilde ... Now Holds A Darker MeaningNYPost.', '... dating during filming. The 39-year-old did however look very cosy with the comedian, although his relationship status is unknown. Olivia ...']\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `Search` with `Harry Styles current age`\n",
+      "responded: Olivia Wilde's current boyfriend is Harry Styles. Let me find out his age for you.\n",
+      "\n",
+      "\u001b[0m\u001b[36;1m\u001b[1;3m29 years\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "Invoking: `Calculator` with `29 ^ 0.23`\n",
       "\n",
       "\n",
-      "\n",
-      "Page: Bee hummingbird\n",
-      "Summary: The bee hummingbird, zunzuncito or Helena hummingbird (Mellisuga helenae) is a species of hummingbird, native to the island of Cuba in the Caribbean. It is the smallest known bird. The bee hummingbird feeds on nectar of flowers and bugs found in Cuba.\n",
-      "\n",
-      "Page: Hummingbird cake\n",
-      "Summary: Hummingbird cake is a banana-pineapple spice cake originating in Jamaica and a popular dessert in the southern United States since the 1970s. Ingredients include flour, sugar, salt, vegetable oil, ripe banana, pineapple, cinnamon, pecans, vanilla extract, eggs, and leavening agent. It is often served with cream cheese frosting.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `wikipedia` with `Fastest bird`\n",
-      "\n",
-      "\n",
-      "\u001b[0m\u001b[36;1m\u001b[1;3mPage: Fastest animals\n",
-      "Summary: This is a list of the fastest animals in the world, by types of animal.\n",
-      "\n",
-      "\n",
-      "\n",
-      "Page: List of birds by flight speed\n",
-      "Summary: This is a list of the fastest flying birds in the world. A bird's velocity is necessarily variable; a hunting bird will reach much greater speeds while diving to catch prey than when flying horizontally. The bird that can achieve the greatest airspeed is the peregrine falcon, able to exceed 320 km/h (200 mph) in its dives. A close relative of the common swift, the white-throated needletail (Hirundapus caudacutus), is commonly reported as the fastest bird in level flight with a reported top speed of 169 km/h (105 mph). This record remains unconfirmed as the measurement methods have never been published or verified. The record for the fastest confirmed level flight by a bird is 111.5 km/h (69.3 mph) held by the common swift.\n",
-      "\n",
-      "Page: Ostrich\n",
-      "Summary: Ostriches are large flightless birds. They are the heaviest and largest living birds, with adult common ostriches weighing anywhere between 63.5 and 145 kilograms and laying the largest eggs of any living land animal. With the ability to run at 70 km/h (43.5 mph), they are the fastest birds on land. They are farmed worldwide, with significant industries in the Philippines and in Namibia. Ostrich leather is a lucrative commodity, and the large feathers are used as plumes for the decoration of ceremonial headgear. Ostrich eggs have been used by humans for millennia.\n",
-      "Ostriches are of the genus Struthio in the order Struthioniformes, part of the infra-class Palaeognathae, a diverse group of flightless birds also known as ratites that includes the emus, rheas, cassowaries, kiwis and the extinct elephant birds and moas. There are two living species of ostrich: the common ostrich, native to large areas of sub-Saharan Africa, and the Somali ostrich, native to the Horn of Africa.  The common ostrich was historically native to the Arabian Peninsula, and ostriches were present across Asia as far east as China and Mongolia during the Late Pleistocene and possibly into the Holocene.\u001b[0m\u001b[32;1m\u001b[1;3m### Hummingbird's Scientific Name\n",
-      "The scientific name for the bee hummingbird, which is the smallest known bird and a species of hummingbird, is **Mellisuga helenae**. It is native to Cuba.\n",
-      "\n",
-      "### Fastest Bird Species\n",
-      "The fastest bird in terms of airspeed is the **peregrine falcon**, which can exceed speeds of 320 km/h (200 mph) during its diving flight. In level flight, the fastest confirmed speed is held by the **common swift**, which can fly at 111.5 km/h (69.3 mph).\u001b[0m\n",
+      "\u001b[0m\u001b[33;1m\u001b[1;3mAnswer: 2.169459462491557\u001b[0m\u001b[32;1m\u001b[1;3mHarry Styles' current age (29 years) raised to the 0.23 power is approximately 2.17.\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n",
-      "Total Tokens: 1583\n",
-      "Prompt Tokens: 1412\n",
-      "Completion Tokens: 171\n",
-      "Total Cost (USD): $0.019250000000000003\n"
+      "Total Tokens: 1929\n",
+      "Prompt Tokens: 1799\n",
+      "Completion Tokens: 130\n",
+      "Total Cost (USD): $0.06176999999999999\n"
      ]
     }
    ],
    "source": [
     "with get_openai_callback() as cb:\n",
-    "    response = agent_executor.invoke(\n",
-    "        {\n",
-    "            \"input\": \"What's a hummingbird's scientific name and what's the fastest bird species?\"\n",
-    "        }\n",
+    "    response = agent.run(\n",
+    "        \"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\"\n",
     "    )\n",
     "    print(f\"Total Tokens: {cb.total_tokens}\")\n",
     "    print(f\"Prompt Tokens: {cb.prompt_tokens}\")\n",
     "    print(f\"Completion Tokens: {cb.completion_tokens}\")\n",
     "    print(f\"Total Cost (USD): ${cb.total_cost}\")"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ebc9122b-050b-4006-b763-264b0b26d9df",
-   "metadata": {},
-   "source": [
-    "### Bedrock Anthropic\n",
-    "\n",
-    "The `get_bedrock_anthropic_callback` works very similarly:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "4a3eced5-2ff7-49a7-a48b-768af8658323",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Tokens Used: 0\n",
-      "\tPrompt Tokens: 0\n",
-      "\tCompletion Tokens: 0\n",
-      "Successful Requests: 2\n",
-      "Total Cost (USD): $0.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "# !pip install langchain-aws\n",
-    "from langchain_aws import ChatBedrock\n",
-    "from langchain_community.callbacks.manager import get_bedrock_anthropic_callback\n",
-    "\n",
-    "llm = ChatBedrock(model_id=\"anthropic.claude-v2\")\n",
-    "\n",
-    "with get_bedrock_anthropic_callback() as cb:\n",
-    "    result = llm.invoke(\"Tell me a joke\")\n",
-    "    result2 = llm.invoke(\"Tell me a joke\")\n",
-    "    print(cb)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bb40375d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -361,7 +171,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/modules/model_io/output_parsers/types/csv.ipynb

@@ -83,14 +83,6 @@
     "    print(s)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "af204787",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [CommaSeparatedListOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.list.CommaSeparatedListOutputParser.html#langchain_core.output_parsers.list.CommaSeparatedListOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/datetime.ipynb

@@ -100,14 +100,6 @@
     "print(output)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "8a12b77a",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [DatetimeOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.datetime.DatetimeOutputParser.html#langchain.output_parsers.datetime.DatetimeOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/enum.ipynb

@@ -87,14 +87,6 @@
     "chain.invoke({\"person\": \"Frank Sinatra\"})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "b1adc71f",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [EnumOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.enum.EnumOutputParser.html#langchain.output_parsers.enum.EnumOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/json.ipynb

@@ -10,7 +10,7 @@
     "\n",
     "Keep in mind that large language models are leaky abstractions! You'll have to use an LLM with sufficient capacity to generate well-formed JSON. In the OpenAI family, DaVinci can do reliably but Curie's ability already drops off dramatically. \n",
     "\n",
-    "You can optionally use Pydantic to declare your data model. \n"
+    "You can optionally use Pydantic to declare your data model."
    ]
   },
   {
@@ -172,14 +172,6 @@
     "chain.invoke({\"query\": joke_query})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "6d9b8f6c",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [JsonOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.json.JsonOutputParser.html#langchain_core.output_parsers.json.JsonOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/output_fixing.ipynb

@@ -126,14 +126,6 @@
     "new_parser.parse(misformatted)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "84498e02",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [OutputFixingParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.fix.OutputFixingParser.html#langchain.output_parsers.fix.OutputFixingParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

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

@@ -203,13 +203,6 @@
     "parser_output = chain.invoke({\"query\": df_query})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [PandasDataFrameOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.pandas_dataframe.PandasDataFrameOutputParser.html#langchain.output_parsers.pandas_dataframe.PandasDataFrameOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/pydantic.ipynb

@@ -125,14 +125,6 @@
     "chain.invoke({\"query\": actor_query})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "e227d9a0",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [PydanticOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.pydantic.PydanticOutputParser.html#langchain_core.output_parsers.pydantic.PydanticOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/retry.ipynb

@@ -243,14 +243,6 @@
     "main_chain.invoke({\"query\": \"who is leo di caprios gf?\"})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "e3a2513a",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [RetryOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.retry.RetryOutputParser.html#langchain.output_parsers.retry.RetryOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/structured.ipynb

@@ -115,14 +115,6 @@
     "    print(s)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "1f97aa07",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [StructuredOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.structured.StructuredOutputParser.html#langchain.output_parsers.structured.StructuredOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/xml.ipynb

@@ -178,14 +178,6 @@
     "    print(s)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "09c711fb",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [XMLOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain_core.output_parsers.xml.XMLOutputParser.html#langchain_core.output_parsers.xml.XMLOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/output_parsers/types/yaml.ipynb

@@ -86,14 +86,6 @@
     "chain.invoke({\"query\": joke_query})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "f859ace0",
-   "metadata": {},
-   "source": [
-    "Find out api documentation for [YamlOutputParser](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.yaml.YamlOutputParser.html#langchain.output_parsers.yaml.YamlOutputParser)."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/modules/model_io/prompts/example_selectors/similarity.ipynb

@@ -19,7 +19,7 @@
    "source": [
     "from langchain.prompts import FewShotPromptTemplate, PromptTemplate\n",
     "from langchain.prompts.example_selector import SemanticSimilarityExampleSelector\n",
-    "from langchain_chroma import Chroma\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "example_prompt = PromptTemplate(\n",

docs/docs/modules/model_io/prompts/few_shot_examples.ipynb

@@ -254,7 +254,7 @@
    ],
    "source": [
     "from langchain.prompts.example_selector import SemanticSimilarityExampleSelector\n",
-    "from langchain_chroma import Chroma\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "example_selector = SemanticSimilarityExampleSelector.from_examples(\n",

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

@@ -202,7 +202,7 @@
    "outputs": [],
    "source": [
     "from langchain.prompts import SemanticSimilarityExampleSelector\n",
-    "from langchain_chroma import Chroma\n",
+    "from langchain_community.vectorstores import Chroma\n",
     "from langchain_openai import OpenAIEmbeddings"
    ]
   },