wip

.devcontainer/README.md

@@ -10,7 +10,7 @@ You can use the dev container configuration in this folder to build and run the
 You may use the button above, or follow these steps to open this repo in a Codespace:
 1. Click the **Code** drop-down menu at the top of https://github.com/langchain-ai/langchain.
 1. Click on the **Codespaces** tab.
-1. Click **Create codespace on master**.
+1. Click **Create codespace on master** .
 
 For more info, check out the [GitHub documentation](https://docs.github.com/en/free-pro-team@latest/github/developing-online-with-codespaces/creating-a-codespace#creating-a-codespace).
   

.github/workflows/.codespell-exclude

@@ -1,7 +0,0 @@
-libs/community/langchain_community/llms/yuan2.py
-"NotIn": "not in",
-- `/checkin`: Check-in
-docs/docs/integrations/providers/trulens.mdx
-self.assertIn(
-from trulens_eval import Tru
-tru = Tru()

.github/workflows/_release.yml

@@ -72,67 +72,10 @@ jobs:
         run: |
           echo pkg-name="$(poetry version | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
           echo version="$(poetry version --short)" >> $GITHUB_OUTPUT
-  release-notes:
-    needs:
-      - build
-    runs-on: ubuntu-latest
-    outputs:
-      release-body: ${{ steps.generate-release-body.outputs.release-body }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          repository: langchain-ai/langchain
-          path: langchain
-          sparse-checkout: | # this only grabs files for relevant dir
-            ${{ inputs.working-directory }}
-          ref: master # this scopes to just master branch
-          fetch-depth: 0 # this fetches entire commit history
-      - name: Check Tags
-        id: check-tags
-        shell: bash
-        working-directory: langchain/${{ inputs.working-directory }}
-        env:
-          PKG_NAME: ${{ needs.build.outputs.pkg-name }}
-          VERSION: ${{ needs.build.outputs.version }}
-        run: |
-          REGEX="^$PKG_NAME==\\d+\\.\\d+\\.\\d+\$"
-          echo $REGEX
-          PREV_TAG=$(git tag --sort=-creatordate | grep -P $REGEX || true | head -1)
-          TAG="${PKG_NAME}==${VERSION}"
-          if [ "$TAG" == "$PREV_TAG" ]; then
-            echo "No new version to release"
-            exit 1
-          fi
-          echo tag="$TAG" >> $GITHUB_OUTPUT
-          echo prev-tag="$PREV_TAG" >> $GITHUB_OUTPUT
-      - name: Generate release body
-        id: generate-release-body
-        working-directory: langchain
-        env:
-          WORKING_DIR: ${{ inputs.working-directory }}
-          PKG_NAME: ${{ needs.build.outputs.pkg-name }}
-          TAG: ${{ steps.check-tags.outputs.tag }}
-          PREV_TAG: ${{ steps.check-tags.outputs.prev-tag }}
-        run: |
-          PREAMBLE="Changes since $PREV_TAG"
-          # if PREV_TAG is empty, then we are releasing the first version
-          if [ -z "$PREV_TAG" ]; then
-            PREAMBLE="Initial release"
-            PREV_TAG=$(git rev-list --max-parents=0 HEAD)
-          fi
-          {
-            echo 'release-body<<EOF'
-            echo "# Release $TAG"
-            echo $PREAMBLE
-            echo
-            git log --format="%s" "$PREV_TAG"..HEAD -- $WORKING_DIR
-            echo EOF
-          } >> "$GITHUB_OUTPUT"
 
   test-pypi-publish:
     needs:
       - build
-      - release-notes
     uses:
       ./.github/workflows/_test_release.yml
     with:
@@ -143,7 +86,6 @@ jobs:
   pre-release-checks:
     needs:
       - build
-      - release-notes
       - test-pypi-publish
     runs-on: ubuntu-latest
     steps:
@@ -287,7 +229,6 @@ jobs:
   publish:
     needs:
       - build
-      - release-notes
       - test-pypi-publish
       - pre-release-checks
     runs-on: ubuntu-latest
@@ -329,7 +270,6 @@ jobs:
   mark-release:
     needs:
       - build
-      - release-notes
       - test-pypi-publish
       - pre-release-checks
       - publish
@@ -366,6 +306,6 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           generateReleaseNotes: false
           tag: ${{needs.build.outputs.pkg-name}}==${{ needs.build.outputs.version }}
-          body: ${{ needs.release-notes.outputs.release-body }}
+          body: "# Release ${{needs.build.outputs.pkg-name}}==${{ needs.build.outputs.version }}\n\nPackage-specific release note generation coming soon."
           commit: ${{ github.sha }}
           makeLatest: ${{ needs.build.outputs.pkg-name == 'langchain-core'}}

.github/workflows/check-broken-links.yml

@@ -7,7 +7,6 @@ on:
 
 jobs:
   check-links:
-    if: github.repository_owner == 'langchain-ai'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/check_diffs.yml

@@ -123,9 +123,7 @@ jobs:
         shell: bash
         run: |
           echo "Running extended tests, installing dependencies with poetry..."
-          poetry install --with test
-          poetry run pip install uv
-          poetry run uv pip install -r extended_testing_deps.txt
+          poetry install -E extended_testing --with test
 
       - name: Run extended tests
         run: make extended_tests

.github/workflows/check_new_docs.yml

@@ -1,31 +0,0 @@
----
-name: Integration docs lint
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-
-# If another push to the same PR or branch happens while this workflow is still running,
-# cancel the earlier run in favor of the next run.
-#
-# There's no point in testing an outdated version of the code. GitHub only allows
-# a limited number of job runners to be active at the same time, so it's better to cancel
-# pointless jobs early so that more useful jobs can run sooner.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.10'
-      - id: files
-        uses: Ana06/get-changed-files@v2.2.0
-      - name: Check new docs
-        run: |
-          python docs/scripts/check_templates.py ${{ steps.files.outputs.added }}

.github/workflows/codespell.yml

@@ -29,9 +29,9 @@ jobs:
           python .github/workflows/extract_ignored_words_list.py
         id: extract_ignore_words
 
-#      - name: Codespell
-#        uses: codespell-project/actions-codespell@v2
-#        with:
-#          skip: guide_imports.json,*.ambr,./cookbook/data/imdb_top_1000.csv,*.lock
-#          ignore_words_list: ${{ steps.extract_ignore_words.outputs.ignore_words_list }}
-#          exclude_file: ./.github/workflows/codespell-exclude
+      - name: Codespell
+        uses: codespell-project/actions-codespell@v2
+        with:
+          skip: guide_imports.json,*.ambr,./cookbook/data/imdb_top_1000.csv,*.lock
+          ignore_words_list: ${{ steps.extract_ignore_words.outputs.ignore_words_list }}
+          exclude_file: libs/community/langchain_community/llms/yuan2.py

.github/workflows/scheduled_test.yml

@@ -10,8 +10,6 @@ env:
 
 jobs:
   build:
-    if: github.repository_owner == 'langchain-ai'
-    name: Python ${{ matrix.python-version }} - ${{ matrix.working-directory }}
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -27,52 +25,16 @@ jobs:
           - "libs/partners/groq"
           - "libs/partners/mistralai"
           - "libs/partners/together"
-          - "libs/partners/cohere"
-          - "libs/partners/google-vertexai"
-          - "libs/partners/google-genai"
-          - "libs/partners/aws"
-          - "libs/partners/nvidia-ai-endpoints"
-
+    name: Python ${{ matrix.python-version }} - ${{ matrix.working-directory }}
     steps:
       - uses: actions/checkout@v4
-        with:
-          path: langchain
-      - uses: actions/checkout@v4
-        with:
-          repository: langchain-ai/langchain-google
-          path: langchain-google
-      - uses: actions/checkout@v4
-        with:
-          repository: langchain-ai/langchain-nvidia
-          path: langchain-nvidia
-      - uses: actions/checkout@v4
-        with:
-          repository: langchain-ai/langchain-cohere
-          path: langchain-cohere
-      - uses: actions/checkout@v4
-        with:
-          repository: langchain-ai/langchain-aws
-          path: langchain-aws
-
-      - name: Move libs
-        run: |
-          rm -rf \
-            langchain/libs/partners/google-genai \
-            langchain/libs/partners/google-vertexai \
-            langchain/libs/partners/nvidia-ai-endpoints \
-            langchain/libs/partners/cohere
-          mv langchain-google/libs/genai langchain/libs/partners/google-genai
-          mv langchain-google/libs/vertexai langchain/libs/partners/google-vertexai
-          mv langchain-nvidia/libs/ai-endpoints langchain/libs/partners/nvidia-ai-endpoints
-          mv langchain-cohere/libs/cohere langchain/libs/partners/cohere
-          mv langchain-aws/libs/aws langchain/libs/partners/aws
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: "./langchain/.github/actions/poetry_setup"
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: langchain/${{ matrix.working-directory }}
+          working-directory: ${{ matrix.working-directory }}
           cache-key: scheduled
 
       - name: 'Authenticate to Google Cloud'
@@ -81,20 +43,16 @@ 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: ${{ secrets.AWS_REGION }}
-
       - name: Install dependencies
+        working-directory: ${{ matrix.working-directory }}
+        shell: bash
         run: |
           echo "Running scheduled tests, installing dependencies with poetry..."
-          cd langchain/${{ matrix.working-directory }}
           poetry install --with=test_integration,test
 
       - name: Run integration tests
+        working-directory: ${{ matrix.working-directory }}
+        shell: bash
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -109,26 +67,12 @@ jobs:
           GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
           MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
           TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
-          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
-          NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
-          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
-          GOOGLE_SEARCH_API_KEY: ${{ secrets.GOOGLE_SEARCH_API_KEY }}
-          GOOGLE_CSE_ID: ${{ secrets.GOOGLE_CSE_ID }}
         run: |
-          cd langchain/${{ matrix.working-directory }}
-          make integration_tests
-
-      - name: Remove external libraries
-        run: | 
-          rm -rf \
-            langchain/libs/partners/google-genai \
-            langchain/libs/partners/google-vertexai \
-            langchain/libs/partners/nvidia-ai-endpoints \
-            langchain/libs/partners/cohere \
-            langchain/libs/partners/aws
+          make integration_test
 
       - name: Ensure the tests did not create any additional files
-        working-directory: langchain
+        working-directory: ${{ matrix.working-directory }}
+        shell: bash
         run: |
           set -eu
 

.gitignore

@@ -133,7 +133,6 @@ env.bak/
 
 # mypy
 .mypy_cache/
-.mypy_cache_test/
 .dmypy.json
 dmypy.json
 

Makefile

@@ -32,13 +32,10 @@ api_docs_build:
 	poetry run python docs/api_reference/create_api_rst.py
 	cd docs/api_reference && poetry run make html
 
-API_PKG ?= text-splitters
-
 api_docs_quick_preview:
-	poetry run pip install "pydantic<2"
-	poetry run python docs/api_reference/create_api_rst.py $(API_PKG)
+	poetry run python docs/api_reference/create_api_rst.py text-splitters
 	cd docs/api_reference && poetry run make html
-	open docs/api_reference/_build/html/$(shell echo $(API_PKG) | sed 's/-/_/g')_api_reference.html
+	open docs/api_reference/_build/html/text_splitters_api_reference.html
 
 ## api_docs_clean: Clean the API Reference documentation build artifacts.
 api_docs_clean:

README.md

@@ -2,17 +2,17 @@
 
 ⚡ Build context-aware reasoning applications ⚡
 
-[![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain?style=flat-square)](https://github.com/langchain-ai/langchain/releases)
+[![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/releases)
 [![CI](https://github.com/langchain-ai/langchain/actions/workflows/check_diffs.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/check_diffs.yml)
-[![PyPI - License](https://img.shields.io/pypi/l/langchain-core?style=flat-square)](https://opensource.org/licenses/MIT)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/langchain-core?style=flat-square)](https://pypistats.org/packages/langchain-core)
-[![GitHub star chart](https://img.shields.io/github/stars/langchain-ai/langchain?style=flat-square)](https://star-history.com/#langchain-ai/langchain)
-[![Dependency Status](https://img.shields.io/librariesio/github/langchain-ai/langchain?style=flat-square)](https://libraries.io/github/langchain-ai/langchain)
-[![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langchain?style=flat-square)](https://github.com/langchain-ai/langchain/issues)
-[![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode&style=flat-square)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchain)
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/langchain-ai/langchain)
-[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+[![Downloads](https://static.pepy.tech/badge/langchain-core/month)](https://pepy.tech/project/langchain-core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
+[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+[![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchain)
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/langchain-ai/langchain)
+[![GitHub star chart](https://img.shields.io/github/stars/langchain-ai/langchain?style=social)](https://star-history.com/#langchain-ai/langchain)
+[![Dependency Status](https://img.shields.io/librariesio/github/langchain-ai/langchain)](https://libraries.io/github/langchain-ai/langchain)
+[![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/issues)
 
 Looking for the JS/TS library? Check out [LangChain.js](https://github.com/langchain-ai/langchainjs).
 
@@ -38,22 +38,22 @@ conda install langchain -c conda-forge
 
 For these applications, LangChain simplifies the entire application lifecycle:
 
-- **Open-source libraries**: Build your applications using LangChain's [modular building blocks](https://python.langchain.com/v0.2/docs/concepts/#langchain-expression-language-lcel) and [components](https://python.langchain.com/v0.2/docs/concepts/#components). Integrate with hundreds of [third-party providers](https://python.langchain.com/v0.2/docs/integrations/platforms/).
-- **Productionization**: Inspect, monitor, and evaluate your apps with [LangSmith](https://docs.smith.langchain.com/) so that you can constantly optimize and deploy with confidence.
-- **Deployment**: Turn any chain into a REST API with [LangServe](https://python.langchain.com/v0.2/docs/langserve/).
+- **Open-source libraries**: Build your applications using LangChain's [modular building blocks](https://python.langchain.com/docs/expression_language/) and [components](https://python.langchain.com/docs/modules/). Integrate with hundreds of [third-party providers](https://python.langchain.com/docs/integrations/platforms/).
+- **Productionization**: Inspect, monitor, and evaluate your apps with [LangSmith](https://python.langchain.com/docs/langsmith/) so that you can constantly optimize and deploy with confidence.
+- **Deployment**: Turn any chain into a REST API with [LangServe](https://python.langchain.com/docs/langserve).
 
 ### Open-source libraries
 - **`langchain-core`**: Base abstractions and LangChain Expression Language.
 - **`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://langchain-ai.github.io/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://docs.smith.langchain.com/)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
+- **[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.
 
 ### Deployment:
-- **[LangServe](https://python.langchain.com/v0.2/docs/langserve/)**: A library for deploying LangChain chains as REST APIs.
+- **[LangServe](https://python.langchain.com/docs/langserve)**: A library for deploying LangChain chains as REST APIs.
 
 ![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](docs/static/svg/langchain_stack.svg "LangChain Architecture Overview")
 
@@ -61,20 +61,20 @@ For these applications, LangChain simplifies the entire application lifecycle:
 
 **❓ Question answering with RAG**
 
-- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/rag/)
+- [Documentation](https://python.langchain.com/docs/use_cases/question_answering/)
 - End-to-end Example: [Chat LangChain](https://chat.langchain.com) and [repo](https://github.com/langchain-ai/chat-langchain)
 
 **🧱 Extracting structured output**
 
-- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/extraction/)
+- [Documentation](https://python.langchain.com/docs/use_cases/extraction/)
 - End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain-extract/)
 
 **🤖 Chatbots**
 
-- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/chatbot/)
+- [Documentation](https://python.langchain.com/docs/use_cases/chatbots)
 - End-to-end Example: [Web LangChain (web researcher chatbot)](https://weblangchain.vercel.app) and [repo](https://github.com/langchain-ai/weblangchain)
 
-And much more! Head to the [Tutorials](https://python.langchain.com/v0.2/docs/tutorials/) section of the docs for more.
+And much more! Head to the [Use cases](https://python.langchain.com/docs/use_cases/) section of the docs for more.
 
 ## 🚀 How does LangChain help?
 The main value props of the LangChain libraries are:
@@ -87,50 +87,49 @@ Off-the-shelf chains make it easy to get started. Components make it easy to cus
 
 LCEL is the foundation of many of LangChain's components, and is a declarative way to compose chains. LCEL was designed from day 1 to support putting prototypes in production, with no code changes, from the simplest “prompt + LLM” chain to the most complex chains.
 
-- **[Overview](https://python.langchain.com/v0.2/docs/concepts/#langchain-expression-language-lcel)**: LCEL and its benefits
-- **[Interface](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface)**: The standard Runnable interface for LCEL objects
-- **[Primitives](https://python.langchain.com/v0.2/docs/how_to/#langchain-expression-language-lcel)**: More on the primitives LCEL includes
-- **[Cheatsheet](https://python.langchain.com/v0.2/docs/how_to/lcel_cheatsheet/)**: Quick overview of the most common usage patterns
+- **[Overview](https://python.langchain.com/docs/expression_language/)**: LCEL and its benefits
+- **[Interface](https://python.langchain.com/docs/expression_language/interface)**: The standard interface for LCEL objects
+- **[Primitives](https://python.langchain.com/docs/expression_language/primitives)**: More on the primitives LCEL includes
 
 ## Components
 
 Components fall into the following **modules**:
 
-**📃 Model I/O**
+**📃 Model I/O:**
 
-This includes [prompt management](https://python.langchain.com/v0.2/docs/concepts/#prompt-templates), [prompt optimization](https://python.langchain.com/v0.2/docs/concepts/#example-selectors), a generic interface for [chat models](https://python.langchain.com/v0.2/docs/concepts/#chat-models) and [LLMs](https://python.langchain.com/v0.2/docs/concepts/#llms), and common utilities for working with [model outputs](https://python.langchain.com/v0.2/docs/concepts/#output-parsers).
+This includes [prompt management](https://python.langchain.com/docs/modules/model_io/prompts/), [prompt optimization](https://python.langchain.com/docs/modules/model_io/prompts/example_selectors/), a generic interface for [chat models](https://python.langchain.com/docs/modules/model_io/chat/) and [LLMs](https://python.langchain.com/docs/modules/model_io/llms/), and common utilities for working with [model outputs](https://python.langchain.com/docs/modules/model_io/output_parsers/).
 
-**📚 Retrieval**
+**📚 Retrieval:**
 
-Retrieval Augmented Generation involves [loading data](https://python.langchain.com/v0.2/docs/concepts/#document-loaders) from a variety of sources, [preparing it](https://python.langchain.com/v0.2/docs/concepts/#text-splitters), then [searching over (a.k.a. retrieving from)](https://python.langchain.com/v0.2/docs/concepts/#retrievers) it for use in the generation step.
+Retrieval Augmented Generation involves [loading data](https://python.langchain.com/docs/modules/data_connection/document_loaders/) from a variety of sources, [preparing it](https://python.langchain.com/docs/modules/data_connection/document_loaders/), [then retrieving it](https://python.langchain.com/docs/modules/data_connection/retrievers/) for use in the generation step.
 
-**🤖 Agents**
+**🤖 Agents:**
 
-Agents allow an LLM autonomy over how a task is accomplished. Agents make decisions about which Actions to take, then take that Action, observe the result, and repeat until the task is complete. LangChain provides a [standard interface for agents](https://python.langchain.com/v0.2/docs/concepts/#agents) along with the [LangGraph](https://github.com/langchain-ai/langgraph) extension for building custom agents.
+Agents allow an LLM autonomy over how a task is accomplished. Agents make decisions about which Actions to take, then take that Action, observe the result, and repeat until the task is complete done. LangChain provides a [standard interface for agents](https://python.langchain.com/docs/modules/agents/), a [selection of agents](https://python.langchain.com/docs/modules/agents/agent_types/) to choose from, and examples of end-to-end agents.
 
 ## 📖 Documentation
 
 Please see [here](https://python.langchain.com) for full documentation, which includes:
 
-- [Introduction](https://python.langchain.com/v0.2/docs/introduction/): Overview of the framework and the structure of the docs.
-- [Tutorials](https://python.langchain.com/docs/use_cases/): If you're looking to build something specific or are more of a hands-on learner, check out our tutorials. This is the best place to get started.
-- [How-to guides](https://python.langchain.com/v0.2/docs/how_to/): Answers to “How do I….?” type questions. These guides are goal-oriented and concrete; they're meant to help you complete a specific task.
-- [Conceptual guide](https://python.langchain.com/v0.2/docs/concepts/): Conceptual explanations of the key parts of the framework.
-- [API Reference](https://api.python.langchain.com): Thorough documentation of every class and method.
+- [Getting started](https://python.langchain.com/docs/get_started/introduction): installation, setting up the environment, simple examples
+- [Use case](https://python.langchain.com/docs/use_cases/) walkthroughs and best practice [guides](https://python.langchain.com/docs/guides/)
+- Overviews of the [interfaces](https://python.langchain.com/docs/expression_language/), [components](https://python.langchain.com/docs/modules/), and [integrations](https://python.langchain.com/docs/integrations/providers)
+
+You can also check out the full [API Reference docs](https://api.python.langchain.com).
 
 ## 🌐 Ecosystem
 
-- [🦜🛠️ LangSmith](https://docs.smith.langchain.com/): Tracing and evaluating your language model applications and intelligent agents to help you move from prototype to production.
-- [🦜🕸️ LangGraph](https://langchain-ai.github.io/langgraph/): Creating stateful, multi-actor applications with LLMs, built on top of (and intended to be used with) LangChain primitives.
+- [🦜🛠️ LangSmith](https://python.langchain.com/docs/langsmith/): Tracing and evaluating your language model applications and intelligent agents to help you move from prototype to production.
+- [🦜🕸️ LangGraph](https://python.langchain.com/docs/langgraph): Creating stateful, multi-actor applications with LLMs, built on top of (and intended to be used with) LangChain primitives.
 - [🦜🏓 LangServe](https://python.langchain.com/docs/langserve): Deploying LangChain runnables and chains as REST APIs.
-  - [LangChain Templates](https://python.langchain.com/v0.2/docs/templates/): Example applications hosted with LangServe.
+  - [LangChain Templates](https://python.langchain.com/docs/templates/): Example applications hosted with LangServe.
 
 
 ## 💁 Contributing
 
 As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
 
-For detailed information on how to contribute, see [here](https://python.langchain.com/v0.2/docs/contributing/).
+For detailed information on how to contribute, see [here](https://python.langchain.com/docs/contributing/).
 
 ## 🌟 Contributors
 

cookbook/autogpt/marathon_times.ipynb

@@ -46,7 +46,7 @@
     "from langchain_experimental.autonomous_agents import AutoGPT\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
-    "# Needed since jupyter runs an async eventloop\n",
+    "# Needed synce jupyter runs an async eventloop\n",
     "nest_asyncio.apply()"
    ]
   },

cookbook/azure_container_apps_dynamic_sessions_data_analyst.ipynb

@@ -273,7 +273,7 @@
    "source": [
     "# Tool schema for querying SQL db\n",
     "class create_df_from_sql(BaseModel):\n",
-    "    \"\"\"Execute a PostgreSQL SELECT statement and use the results to create a DataFrame with the given column names.\"\"\"\n",
+    "    \"\"\"Execute a PostgreSQL SELECT statement and use the results to create a DataFrame with the given colum names.\"\"\"\n",
     "\n",
     "    select_query: str = Field(..., description=\"A PostgreSQL SELECT statement.\")\n",
     "    # We're going to convert the results to a Pandas DataFrame that we pass\n",

cookbook/nomic_multimodal_rag.ipynb

@@ -1,497 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "9fc3897d-176f-4729-8fd1-cfb4add53abd",
-   "metadata": {},
-   "source": [
-    "## Nomic multi-modal RAG\n",
-    "\n",
-    "Many documents contain a mixture of content types, including text and images. \n",
-    "\n",
-    "Yet, information captured in images is lost in most RAG applications.\n",
-    "\n",
-    "With the emergence of multimodal LLMs, like [GPT-4V](https://openai.com/research/gpt-4v-system-card), it is worth considering how to utilize images in RAG:\n",
-    "\n",
-    "In this demo we\n",
-    "\n",
-    "* Use multimodal embeddings from Nomic Embed [Vision](https://huggingface.co/nomic-ai/nomic-embed-vision-v1.5) and [Text](https://huggingface.co/nomic-ai/nomic-embed-text-v1.5) to embed images and text\n",
-    "* Retrieve both using similarity search\n",
-    "* Pass raw images and text chunks to a multimodal LLM for answer synthesis \n",
-    "\n",
-    "## Signup\n",
-    "\n",
-    "Get your API token, then run:\n",
-    "```\n",
-    "! nomic login\n",
-    "```\n",
-    "\n",
-    "Then run with your generated API token \n",
-    "```\n",
-    "! nomic login < token > \n",
-    "```\n",
-    "\n",
-    "## Packages\n",
-    "\n",
-    "For `unstructured`, you will also need `poppler` ([installation instructions](https://pdf2image.readthedocs.io/en/latest/installation.html)) and `tesseract` ([installation instructions](https://tesseract-ocr.github.io/tessdoc/Installation.html)) in your system."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "54926b9b-75c2-4cd4-8f14-b3882a0d370b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! nomic login token"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "febbc459-ebba-4c1a-a52b-fed7731593f8",
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "! pip install -U langchain-nomic langchain_community tiktoken langchain-openai chromadb langchain # (newest versions required for multi-modal)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "acbdc603-39e2-4a5f-836c-2bbaecd46b0b",
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "# lock to 0.10.19 due to a persistent bug in more recent versions\n",
-    "! pip install \"unstructured[all-docs]==0.10.19\" pillow pydantic lxml pillow matplotlib tiktoken"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1e94b3fb-8e3e-4736-be0a-ad881626c7bd",
-   "metadata": {},
-   "source": [
-    "## Data Loading\n",
-    "\n",
-    "### Partition PDF text and images\n",
-    "  \n",
-    "Let's look at an example pdfs containing interesting images.\n",
-    "\n",
-    "1/ Art from the J Paul Getty museum:\n",
-    "\n",
-    " * Here is a [zip file](https://drive.google.com/file/d/18kRKbq2dqAhhJ3DfZRnYcTBEUfYxe1YR/view?usp=sharing) with the PDF and the already extracted images. \n",
-    "* https://www.getty.edu/publications/resources/virtuallibrary/0892360224.pdf\n",
-    "\n",
-    "2/ Famous photographs from library of congress:\n",
-    "\n",
-    "* https://www.loc.gov/lcm/pdf/LCM_2020_1112.pdf\n",
-    "* We'll use this as an example below\n",
-    "\n",
-    "We can use `partition_pdf` below from [Unstructured](https://unstructured-io.github.io/unstructured/introduction.html#key-concepts) to extract text and images.\n",
-    "\n",
-    "To supply this to extract the images:\n",
-    "```\n",
-    "extract_images_in_pdf=True\n",
-    "```\n",
-    "\n",
-    "\n",
-    "\n",
-    "If using this zip file, then you can simply process the text only with:\n",
-    "```\n",
-    "extract_images_in_pdf=False\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9646b524-71a7-4b2a-bdc8-0b81f77e968f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Folder with pdf and extracted images\n",
-    "from pathlib import Path\n",
-    "\n",
-    "# replace with actual path to images\n",
-    "path = Path(\"../art\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "77f096ab-a933-41d0-8f4e-1efc83998fc3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "path.resolve()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bc4839c0-8773-4a07-ba59-5364501269b2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Extract images, tables, and chunk text\n",
-    "from unstructured.partition.pdf import partition_pdf\n",
-    "\n",
-    "raw_pdf_elements = partition_pdf(\n",
-    "    filename=str(path.resolve()) + \"/getty.pdf\",\n",
-    "    extract_images_in_pdf=False,\n",
-    "    infer_table_structure=True,\n",
-    "    chunking_strategy=\"by_title\",\n",
-    "    max_characters=4000,\n",
-    "    new_after_n_chars=3800,\n",
-    "    combine_text_under_n_chars=2000,\n",
-    "    image_output_dir_path=path,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "969545ad",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Categorize text elements by type\n",
-    "tables = []\n",
-    "texts = []\n",
-    "for element in raw_pdf_elements:\n",
-    "    if \"unstructured.documents.elements.Table\" in str(type(element)):\n",
-    "        tables.append(str(element))\n",
-    "    elif \"unstructured.documents.elements.CompositeElement\" in str(type(element)):\n",
-    "        texts.append(str(element))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5d8e6349-1547-4cbf-9c6f-491d8610ec10",
-   "metadata": {},
-   "source": [
-    "## Multi-modal embeddings with our document\n",
-    "\n",
-    "We will use [nomic-embed-vision-v1.5](https://huggingface.co/nomic-ai/nomic-embed-vision-v1.5) embeddings. This model is aligned \n",
-    "to [nomic-embed-text-v1.5](https://huggingface.co/nomic-ai/nomic-embed-text-v1.5) allowing for multimodal semantic search and Multimodal RAG!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4bc15842-cb95-4f84-9eb5-656b0282a800",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import uuid\n",
-    "\n",
-    "import chromadb\n",
-    "import numpy as np\n",
-    "from langchain_community.vectorstores import Chroma\n",
-    "from langchain_nomic import NomicEmbeddings\n",
-    "from PIL import Image as _PILImage\n",
-    "\n",
-    "# Create chroma\n",
-    "text_vectorstore = Chroma(\n",
-    "    collection_name=\"mm_rag_clip_photos_text\",\n",
-    "    embedding_function=NomicEmbeddings(\n",
-    "        vision_model=\"nomic-embed-vision-v1.5\", model=\"nomic-embed-text-v1.5\"\n",
-    "    ),\n",
-    ")\n",
-    "image_vectorstore = Chroma(\n",
-    "    collection_name=\"mm_rag_clip_photos_image\",\n",
-    "    embedding_function=NomicEmbeddings(\n",
-    "        vision_model=\"nomic-embed-vision-v1.5\", model=\"nomic-embed-text-v1.5\"\n",
-    "    ),\n",
-    ")\n",
-    "\n",
-    "# Get image URIs with .jpg extension only\n",
-    "image_uris = sorted(\n",
-    "    [\n",
-    "        os.path.join(path, image_name)\n",
-    "        for image_name in os.listdir(path)\n",
-    "        if image_name.endswith(\".jpg\")\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "# Add images\n",
-    "image_vectorstore.add_images(uris=image_uris)\n",
-    "\n",
-    "# Add documents\n",
-    "text_vectorstore.add_texts(texts=texts)\n",
-    "\n",
-    "# Make retriever\n",
-    "image_retriever = image_vectorstore.as_retriever()\n",
-    "text_retriever = text_vectorstore.as_retriever()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "02a186d0-27e0-4820-8092-63b5349dd25d",
-   "metadata": {},
-   "source": [
-    "## RAG\n",
-    "\n",
-    "`vectorstore.add_images` will store / retrieve images as base64 encoded strings.\n",
-    "\n",
-    "These can be passed to [GPT-4V](https://platform.openai.com/docs/guides/vision)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "344f56a8-0dc3-433e-851c-3f7600c7a72b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import base64\n",
-    "import io\n",
-    "from io import BytesIO\n",
-    "\n",
-    "import numpy as np\n",
-    "from PIL import Image\n",
-    "\n",
-    "\n",
-    "def resize_base64_image(base64_string, size=(128, 128)):\n",
-    "    \"\"\"\n",
-    "    Resize an image encoded as a Base64 string.\n",
-    "\n",
-    "    Args:\n",
-    "    base64_string (str): Base64 string of the original image.\n",
-    "    size (tuple): Desired size of the image as (width, height).\n",
-    "\n",
-    "    Returns:\n",
-    "    str: Base64 string of the resized image.\n",
-    "    \"\"\"\n",
-    "    # Decode the Base64 string\n",
-    "    img_data = base64.b64decode(base64_string)\n",
-    "    img = Image.open(io.BytesIO(img_data))\n",
-    "\n",
-    "    # Resize the image\n",
-    "    resized_img = img.resize(size, Image.LANCZOS)\n",
-    "\n",
-    "    # Save the resized image to a bytes buffer\n",
-    "    buffered = io.BytesIO()\n",
-    "    resized_img.save(buffered, format=img.format)\n",
-    "\n",
-    "    # Encode the resized image to Base64\n",
-    "    return base64.b64encode(buffered.getvalue()).decode(\"utf-8\")\n",
-    "\n",
-    "\n",
-    "def is_base64(s):\n",
-    "    \"\"\"Check if a string is Base64 encoded\"\"\"\n",
-    "    try:\n",
-    "        return base64.b64encode(base64.b64decode(s)) == s.encode()\n",
-    "    except Exception:\n",
-    "        return False\n",
-    "\n",
-    "\n",
-    "def split_image_text_types(docs):\n",
-    "    \"\"\"Split numpy array images and texts\"\"\"\n",
-    "    images = []\n",
-    "    text = []\n",
-    "    for doc in docs:\n",
-    "        doc = doc.page_content  # Extract Document contents\n",
-    "        if is_base64(doc):\n",
-    "            # Resize image to avoid OAI server error\n",
-    "            images.append(\n",
-    "                resize_base64_image(doc, size=(250, 250))\n",
-    "            )  # base64 encoded str\n",
-    "        else:\n",
-    "            text.append(doc)\n",
-    "    return {\"images\": images, \"texts\": text}"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "23a2c1d8-fea6-4152-b184-3172dd46c735",
-   "metadata": {},
-   "source": [
-    "Currently, we format the inputs using a `RunnableLambda` while we add image support to `ChatPromptTemplates`.\n",
-    "\n",
-    "Our runnable follows the classic RAG flow - \n",
-    "\n",
-    "* We first compute the context (both \"texts\" and \"images\" in this case) and the question (just a RunnablePassthrough here) \n",
-    "* Then we pass this into our prompt template, which is a custom function that formats the message for the gpt-4-vision-preview model. \n",
-    "* And finally we parse the output as a string."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5d8919dc-c238-4746-86ba-45d940a7d260",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4c93fab3-74c4-4f1d-958a-0bc4cdd0797e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from operator import itemgetter\n",
-    "\n",
-    "from langchain_core.messages import HumanMessage, SystemMessage\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "\n",
-    "def prompt_func(data_dict):\n",
-    "    # Joining the context texts into a single string\n",
-    "    formatted_texts = \"\\n\".join(data_dict[\"text_context\"][\"texts\"])\n",
-    "    messages = []\n",
-    "\n",
-    "    # Adding image(s) to the messages if present\n",
-    "    if data_dict[\"image_context\"][\"images\"]:\n",
-    "        image_message = {\n",
-    "            \"type\": \"image_url\",\n",
-    "            \"image_url\": {\n",
-    "                \"url\": f\"data:image/jpeg;base64,{data_dict['image_context']['images'][0]}\"\n",
-    "            },\n",
-    "        }\n",
-    "        messages.append(image_message)\n",
-    "\n",
-    "    # Adding the text message for analysis\n",
-    "    text_message = {\n",
-    "        \"type\": \"text\",\n",
-    "        \"text\": (\n",
-    "            \"As an expert art critic and historian, your task is to analyze and interpret images, \"\n",
-    "            \"considering their historical and cultural significance. Alongside the images, you will be \"\n",
-    "            \"provided with related text to offer context. Both will be retrieved from a vectorstore based \"\n",
-    "            \"on user-input keywords. Please use your extensive knowledge and analytical skills to provide a \"\n",
-    "            \"comprehensive summary that includes:\\n\"\n",
-    "            \"- A detailed description of the visual elements in the image.\\n\"\n",
-    "            \"- The historical and cultural context of the image.\\n\"\n",
-    "            \"- An interpretation of the image's symbolism and meaning.\\n\"\n",
-    "            \"- Connections between the image and the related text.\\n\\n\"\n",
-    "            f\"User-provided keywords: {data_dict['question']}\\n\\n\"\n",
-    "            \"Text and / or tables:\\n\"\n",
-    "            f\"{formatted_texts}\"\n",
-    "        ),\n",
-    "    }\n",
-    "    messages.append(text_message)\n",
-    "\n",
-    "    return [HumanMessage(content=messages)]\n",
-    "\n",
-    "\n",
-    "model = ChatOpenAI(temperature=0, model=\"gpt-4-vision-preview\", max_tokens=1024)\n",
-    "\n",
-    "# RAG pipeline\n",
-    "chain = (\n",
-    "    {\n",
-    "        \"text_context\": text_retriever | RunnableLambda(split_image_text_types),\n",
-    "        \"image_context\": image_retriever | RunnableLambda(split_image_text_types),\n",
-    "        \"question\": RunnablePassthrough(),\n",
-    "    }\n",
-    "    | RunnableLambda(prompt_func)\n",
-    "    | model\n",
-    "    | StrOutputParser()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1566096d-97c2-4ddc-ba4a-6ef88c525e4e",
-   "metadata": {},
-   "source": [
-    "## Test retrieval and run RAG"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "90121e56-674b-473b-871d-6e4753fd0c45",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from IPython.display import HTML, display\n",
-    "\n",
-    "\n",
-    "def plt_img_base64(img_base64):\n",
-    "    # Create an HTML img tag with the base64 string as the source\n",
-    "    image_html = f'<img src=\"data:image/jpeg;base64,{img_base64}\" />'\n",
-    "\n",
-    "    # Display the image by rendering the HTML\n",
-    "    display(HTML(image_html))\n",
-    "\n",
-    "\n",
-    "docs = text_retriever.invoke(\"Women with children\", k=5)\n",
-    "for doc in docs:\n",
-    "    if is_base64(doc.page_content):\n",
-    "        plt_img_base64(doc.page_content)\n",
-    "    else:\n",
-    "        print(doc.page_content)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "44eaa532-f035-4c04-b578-02339d42554c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "docs = image_retriever.invoke(\"Women with children\", k=5)\n",
-    "for doc in docs:\n",
-    "    if is_base64(doc.page_content):\n",
-    "        plt_img_base64(doc.page_content)\n",
-    "    else:\n",
-    "        print(doc.page_content)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "69fb15fd-76fc-49b4-806d-c4db2990027d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain.invoke(\"Women with children\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "227f08b8-e732-4089-b65c-6eb6f9e48f15",
-   "metadata": {},
-   "source": [
-    "We can see the images retrieved in the LangSmith trace:\n",
-    "\n",
-    "LangSmith [trace](https://smith.langchain.com/public/69c558a5-49dc-4c60-a49b-3adbb70f74c5/r/e872c2c8-528c-468f-aefd-8b5cd730a673)."
-   ]
-  }
- ],
- "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.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

cookbook/oracleai_demo.ipynb

@@ -86,7 +86,8 @@
     "\n",
     "import oracledb\n",
     "\n",
-    "# Update with your username, password, hostname, and service_name\n",
+    "# please update with your username, password, hostname and service_name\n",
+    "# please make sure this user has sufficient privileges to perform all below\n",
     "username = \"\"\n",
     "password = \"\"\n",
     "dsn = \"\"\n",
@@ -96,45 +97,40 @@
     "    print(\"Connection successful!\")\n",
     "\n",
     "    cursor = conn.cursor()\n",
-    "    try:\n",
-    "        cursor.execute(\n",
-    "            \"\"\"\n",
-    "            begin\n",
-    "                -- Drop user\n",
-    "                begin\n",
-    "                    execute immediate 'drop user testuser cascade';\n",
-    "                exception\n",
-    "                    when others then\n",
-    "                        dbms_output.put_line('Error dropping user: ' || SQLERRM);\n",
-    "                end;\n",
-    "                \n",
-    "                -- Create user and grant privileges\n",
-    "                execute immediate 'create user testuser identified by testuser';\n",
-    "                execute immediate 'grant connect, unlimited tablespace, create credential, create procedure, create any index to testuser';\n",
-    "                execute immediate 'create or replace directory DEMO_PY_DIR as ''/scratch/hroy/view_storage/hroy_devstorage/demo/orachain''';\n",
-    "                execute immediate 'grant read, write on directory DEMO_PY_DIR to public';\n",
-    "                execute immediate 'grant create mining model to testuser';\n",
-    "                \n",
-    "                -- Network access\n",
-    "                begin\n",
-    "                    DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(\n",
-    "                        host => '*',\n",
-    "                        ace => xs$ace_type(privilege_list => xs$name_list('connect'),\n",
-    "                                           principal_name => 'testuser',\n",
-    "                                           principal_type => xs_acl.ptype_db)\n",
-    "                    );\n",
-    "                end;\n",
-    "            end;\n",
-    "            \"\"\"\n",
-    "        )\n",
-    "        print(\"User setup done!\")\n",
-    "    except Exception as e:\n",
-    "        print(f\"User setup failed with error: {e}\")\n",
-    "    finally:\n",
-    "        cursor.close()\n",
+    "    cursor.execute(\n",
+    "        \"\"\"\n",
+    "    begin\n",
+    "        -- drop user\n",
+    "        begin\n",
+    "            execute immediate 'drop user testuser cascade';\n",
+    "        exception\n",
+    "            when others then\n",
+    "                dbms_output.put_line('Error setting up user.');\n",
+    "        end;\n",
+    "        execute immediate 'create user testuser identified by testuser';\n",
+    "        execute immediate 'grant connect, unlimited tablespace, create credential, create procedure, create any index to testuser';\n",
+    "        execute immediate 'create or replace directory DEMO_PY_DIR as ''/scratch/hroy/view_storage/hroy_devstorage/demo/orachain''';\n",
+    "        execute immediate 'grant read, write on directory DEMO_PY_DIR to public';\n",
+    "        execute immediate 'grant create mining model to testuser';\n",
+    "\n",
+    "        -- network access\n",
+    "        begin\n",
+    "            DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(\n",
+    "                host => '*',\n",
+    "                ace => xs$ace_type(privilege_list => xs$name_list('connect'),\n",
+    "                                principal_name => 'testuser',\n",
+    "                                principal_type => xs_acl.ptype_db));\n",
+    "        end;\n",
+    "    end;\n",
+    "    \"\"\"\n",
+    "    )\n",
+    "    print(\"User setup done!\")\n",
+    "    cursor.close()\n",
     "    conn.close()\n",
     "except Exception as e:\n",
-    "    print(f\"Connection failed with error: {e}\")\n",
+    "    print(\"User setup failed!\")\n",
+    "    cursor.close()\n",
+    "    conn.close()\n",
     "    sys.exit(1)"
    ]
   },
@@ -530,6 +526,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "***Note:*** Currently, OracleEmbeddings processes each embedding generation request individually, without batching, by calling REST endpoints separately for each request. This method could potentially lead to exceeding the maximum request per minute quota set by some providers. However, we are actively working to enhance this process by implementing request batching, which will allow multiple embedding requests to be combined into fewer API calls, thereby optimizing our use of provider resources and adhering to their request limits. This update is expected to be rolled out soon, eliminating the current limitation.\n",
+    "\n",
     "***Note:*** Users may need to configure a proxy to utilize third-party embedding generation providers, excluding the 'database' provider that utilizes an ONNX model."
    ]
   },

docs/Makefile

@@ -35,6 +35,8 @@ generate-files:
 	mkdir -p $(INTERMEDIATE_DIR)
 	cp -r $(SOURCE_DIR)/* $(INTERMEDIATE_DIR)
 	mkdir -p $(INTERMEDIATE_DIR)/templates
+	cp ../templates/docs/INDEX.md $(INTERMEDIATE_DIR)/templates/index.md
+	cp ../cookbook/README.md $(INTERMEDIATE_DIR)/cookbook.mdx
 
 	$(PYTHON) scripts/model_feat_table.py $(INTERMEDIATE_DIR)
 

docs/api_reference/create_api_rst.py

@@ -128,11 +128,11 @@ def _load_package_modules(
     of the modules/packages are part of the package vs. 3rd party or built-in.
 
     Parameters:
-        package_directory (Union[str, Path]): Path to the package directory.
-        submodule (Optional[str]): Optional name of submodule to load.
+        package_directory: Path to the package directory.
+        submodule: Optional name of submodule to load.
 
     Returns:
-        Dict[str, ModuleMembers]: A dictionary where keys are module names and values are ModuleMembers objects.
+        list: A list of loaded module objects.
     """
     package_path = (
         Path(package_directory)

docs/docs/additional_resources/arxiv_references.mdx

@@ -2,153 +2,32 @@
             
 LangChain implements the latest research in the field of Natural Language Processing.
 This page contains `arXiv` papers referenced in the LangChain Documentation, API Reference,
- Templates, and Cookbooks.
-
-From the opposite direction, scientists use LangChain in research and reference LangChain in the research papers. 
-Here you find [such papers](https://arxiv.org/search/?query=langchain&searchtype=all&source=header).
+and Templates.
 
 ## Summary
 
 | arXiv id / Title | Authors | Published date 🔻 | LangChain Documentation|
 |------------------|---------|-------------------|------------------------|
-| `2402.03620v1` [Self-Discover: Large Language Models Self-Compose Reasoning Structures](http://arxiv.org/abs/2402.03620v1) | Pei Zhou, Jay Pujara, Xiang Ren,  et al. | 2024-02-06 | `Cookbook:` [self-discover](https://github.com/langchain-ai/langchain/blob/master/cookbook/self-discover.ipynb)
-| `2401.18059v1` [RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval](http://arxiv.org/abs/2401.18059v1) | Parth Sarthi, Salman Abdullah, Aditi Tuli,  et al. | 2024-01-31 | `Cookbook:` [RAPTOR](https://github.com/langchain-ai/langchain/blob/master/cookbook/RAPTOR.ipynb)
-| `2401.15884v2` [Corrective Retrieval Augmented Generation](http://arxiv.org/abs/2401.15884v2) | Shi-Qi Yan, Jia-Chen Gu, Yun Zhu,  et al. | 2024-01-29 | `Cookbook:` [langgraph_crag](https://github.com/langchain-ai/langchain/blob/master/cookbook/langgraph_crag.ipynb)
-| `2401.04088v1` [Mixtral of Experts](http://arxiv.org/abs/2401.04088v1) | Albert Q. Jiang, Alexandre Sablayrolles, Antoine Roux,  et al. | 2024-01-08 | `Cookbook:` [together_ai](https://github.com/langchain-ai/langchain/blob/master/cookbook/together_ai.ipynb)
 | `2312.06648v2` [Dense X Retrieval: What Retrieval Granularity Should We Use?](http://arxiv.org/abs/2312.06648v2) | Tong Chen, Hongwei Wang, Sihao Chen,  et al. | 2023-12-11 | `Template:` [propositional-retrieval](https://python.langchain.com/docs/templates/propositional-retrieval)
 | `2311.09210v1` [Chain-of-Note: Enhancing Robustness in Retrieval-Augmented Language Models](http://arxiv.org/abs/2311.09210v1) | Wenhao Yu, Hongming Zhang, Xiaoman Pan,  et al. | 2023-11-15 | `Template:` [chain-of-note-wiki](https://python.langchain.com/docs/templates/chain-of-note-wiki)
-| `2310.11511v1` [Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection](http://arxiv.org/abs/2310.11511v1) | Akari Asai, Zeqiu Wu, Yizhong Wang,  et al. | 2023-10-17 | `Cookbook:` [langgraph_self_rag](https://github.com/langchain-ai/langchain/blob/master/cookbook/langgraph_self_rag.ipynb)
-| `2310.06117v2` [Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models](http://arxiv.org/abs/2310.06117v2) | Huaixiu Steven Zheng, Swaroop Mishra, Xinyun Chen,  et al. | 2023-10-09 | `Template:` [stepback-qa-prompting](https://python.langchain.com/docs/templates/stepback-qa-prompting), `Cookbook:` [stepback-qa](https://github.com/langchain-ai/langchain/blob/master/cookbook/stepback-qa.ipynb)
-| `2307.09288v2` [Llama 2: Open Foundation and Fine-Tuned Chat Models](http://arxiv.org/abs/2307.09288v2) | Hugo Touvron, Louis Martin, Kevin Stone,  et al. | 2023-07-18 | `Cookbook:` [Semi_Structured_RAG](https://github.com/langchain-ai/langchain/blob/master/cookbook/Semi_Structured_RAG.ipynb)
-| `2305.14283v3` [Query Rewriting for Retrieval-Augmented Large Language Models](http://arxiv.org/abs/2305.14283v3) | Xinbei Ma, Yeyun Gong, Pengcheng He,  et al. | 2023-05-23 | `Template:` [rewrite-retrieve-read](https://python.langchain.com/docs/templates/rewrite-retrieve-read), `Cookbook:` [rewrite](https://github.com/langchain-ai/langchain/blob/master/cookbook/rewrite.ipynb)
-| `2305.08291v1` [Large Language Model Guided Tree-of-Thought](http://arxiv.org/abs/2305.08291v1) | Jieyi Long | 2023-05-15 | `API:` [langchain_experimental.tot](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.tot), `Cookbook:` [tree_of_thought](https://github.com/langchain-ai/langchain/blob/master/cookbook/tree_of_thought.ipynb)
-| `2305.04091v3` [Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models](http://arxiv.org/abs/2305.04091v3) | Lei Wang, Wanyu Xu, Yihuai Lan,  et al. | 2023-05-06 | `Cookbook:` [plan_and_execute_agent](https://github.com/langchain-ai/langchain/blob/master/cookbook/plan_and_execute_agent.ipynb)
-| `2304.08485v2` [Visual Instruction Tuning](http://arxiv.org/abs/2304.08485v2) | Haotian Liu, Chunyuan Li, Qingyang Wu,  et al. | 2023-04-17 | `Cookbook:` [Semi_structured_and_multi_modal_RAG](https://github.com/langchain-ai/langchain/blob/master/cookbook/Semi_structured_and_multi_modal_RAG.ipynb), [Semi_structured_multi_modal_RAG_LLaMA2](https://github.com/langchain-ai/langchain/blob/master/cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb)
-| `2304.03442v2` [Generative Agents: Interactive Simulacra of Human Behavior](http://arxiv.org/abs/2304.03442v2) | Joon Sung Park, Joseph C. O'Brien, Carrie J. Cai,  et al. | 2023-04-07 | `Cookbook:` [generative_agents_interactive_simulacra_of_human_behavior](https://github.com/langchain-ai/langchain/blob/master/cookbook/generative_agents_interactive_simulacra_of_human_behavior.ipynb), [multiagent_bidding](https://github.com/langchain-ai/langchain/blob/master/cookbook/multiagent_bidding.ipynb)
-| `2303.17760v2` [CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society](http://arxiv.org/abs/2303.17760v2) | Guohao Li, Hasan Abed Al Kader Hammoud, Hani Itani,  et al. | 2023-03-31 | `Cookbook:` [camel_role_playing](https://github.com/langchain-ai/langchain/blob/master/cookbook/camel_role_playing.ipynb)
-| `2303.17580v4` [HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face](http://arxiv.org/abs/2303.17580v4) | Yongliang Shen, Kaitao Song, Xu Tan,  et al. | 2023-03-30 | `API:` [langchain_experimental.autonomous_agents](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.autonomous_agents), `Cookbook:` [hugginggpt](https://github.com/langchain-ai/langchain/blob/master/cookbook/hugginggpt.ipynb)
+| `2310.06117v2` [Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models](http://arxiv.org/abs/2310.06117v2) | Huaixiu Steven Zheng, Swaroop Mishra, Xinyun Chen,  et al. | 2023-10-09 | `Template:` [stepback-qa-prompting](https://python.langchain.com/docs/templates/stepback-qa-prompting)
+| `2305.14283v3` [Query Rewriting for Retrieval-Augmented Large Language Models](http://arxiv.org/abs/2305.14283v3) | Xinbei Ma, Yeyun Gong, Pengcheng He,  et al. | 2023-05-23 | `Template:` [rewrite-retrieve-read](https://python.langchain.com/docs/templates/rewrite-retrieve-read)
+| `2305.08291v1` [Large Language Model Guided Tree-of-Thought](http://arxiv.org/abs/2305.08291v1) | Jieyi Long | 2023-05-15 | `API:` [langchain_experimental.tot](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.tot)
+| `2303.17580v4` [HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face](http://arxiv.org/abs/2303.17580v4) | Yongliang Shen, Kaitao Song, Xu Tan,  et al. | 2023-03-30 | `API:` [langchain_experimental.autonomous_agents](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.autonomous_agents)
 | `2303.08774v6` [GPT-4 Technical Report](http://arxiv.org/abs/2303.08774v6) | OpenAI, Josh Achiam, Steven Adler,  et al. | 2023-03-15 | `Docs:` [docs/integrations/vectorstores/mongodb_atlas](https://python.langchain.com/docs/integrations/vectorstores/mongodb_atlas)
-| `2301.10226v4` [A Watermark for Large Language Models](http://arxiv.org/abs/2301.10226v4) | John Kirchenbauer, Jonas Geiping, Yuxin Wen,  et al. | 2023-01-24 | `API:` [langchain_community...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community...OCIModelDeploymentTGI](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI.html#langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI), [langchain_community...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint), [langchain_huggingface...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint)
-| `2212.10496v1` [Precise Zero-Shot Dense Retrieval without Relevance Labels](http://arxiv.org/abs/2212.10496v1) | Luyu Gao, Xueguang Ma, Jimmy Lin,  et al. | 2022-12-20 | `API:` [langchain...HypotheticalDocumentEmbedder](https://api.python.langchain.com/en/latest/chains/langchain.chains.hyde.base.HypotheticalDocumentEmbedder.html#langchain.chains.hyde.base.HypotheticalDocumentEmbedder), `Template:` [hyde](https://python.langchain.com/docs/templates/hyde), `Cookbook:` [hypothetical_document_embeddings](https://github.com/langchain-ai/langchain/blob/master/cookbook/hypothetical_document_embeddings.ipynb)
+| `2301.10226v4` [A Watermark for Large Language Models](http://arxiv.org/abs/2301.10226v4) | John Kirchenbauer, Jonas Geiping, Yuxin Wen,  et al. | 2023-01-24 | `API:` [langchain_community.llms...OCIModelDeploymentTGI](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI.html#langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI), [langchain_community.llms...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community.llms...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint)
+| `2212.10496v1` [Precise Zero-Shot Dense Retrieval without Relevance Labels](http://arxiv.org/abs/2212.10496v1) | Luyu Gao, Xueguang Ma, Jimmy Lin,  et al. | 2022-12-20 | `API:` [langchain.chains...HypotheticalDocumentEmbedder](https://api.python.langchain.com/en/latest/chains/langchain.chains.hyde.base.HypotheticalDocumentEmbedder.html#langchain.chains.hyde.base.HypotheticalDocumentEmbedder), `Template:` [hyde](https://python.langchain.com/docs/templates/hyde)
 | `2212.07425v3` [Robust and Explainable Identification of Logical Fallacies in Natural Language Arguments](http://arxiv.org/abs/2212.07425v3) | Zhivar Sourati, Vishnu Priya Prasanna Venkatesh, Darshan Deshpande,  et al. | 2022-12-12 | `API:` [langchain_experimental.fallacy_removal](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.fallacy_removal)
-| `2211.13892v2` [Complementary Explanations for Effective In-Context Learning](http://arxiv.org/abs/2211.13892v2) | Xi Ye, Srinivasan Iyer, Asli Celikyilmaz,  et al. | 2022-11-25 | `API:` [langchain_core...MaxMarginalRelevanceExampleSelector](https://api.python.langchain.com/en/latest/example_selectors/langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector.html#langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector)
-| `2211.10435v2` [PAL: Program-aided Language Models](http://arxiv.org/abs/2211.10435v2) | Luyu Gao, Aman Madaan, Shuyan Zhou,  et al. | 2022-11-18 | `API:` [langchain_experimental...PALChain](https://api.python.langchain.com/en/latest/pal_chain/langchain_experimental.pal_chain.base.PALChain.html#langchain_experimental.pal_chain.base.PALChain), [langchain_experimental.pal_chain](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.pal_chain), `Cookbook:` [program_aided_language_model](https://github.com/langchain-ai/langchain/blob/master/cookbook/program_aided_language_model.ipynb)
+| `2211.13892v2` [Complementary Explanations for Effective In-Context Learning](http://arxiv.org/abs/2211.13892v2) | Xi Ye, Srinivasan Iyer, Asli Celikyilmaz,  et al. | 2022-11-25 | `API:` [langchain_core.example_selectors...MaxMarginalRelevanceExampleSelector](https://api.python.langchain.com/en/latest/example_selectors/langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector.html#langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector)
+| `2211.10435v2` [PAL: Program-aided Language Models](http://arxiv.org/abs/2211.10435v2) | Luyu Gao, Aman Madaan, Shuyan Zhou,  et al. | 2022-11-18 | `API:` [langchain_experimental.pal_chain...PALChain](https://api.python.langchain.com/en/latest/pal_chain/langchain_experimental.pal_chain.base.PALChain.html#langchain_experimental.pal_chain.base.PALChain), [langchain_experimental.pal_chain](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.pal_chain)
 | `2209.10785v2` [Deep Lake: a Lakehouse for Deep Learning](http://arxiv.org/abs/2209.10785v2) | Sasun Hambardzumyan, Abhinav Tuli, Levon Ghukasyan,  et al. | 2022-09-22 | `Docs:` [docs/integrations/providers/activeloop_deeplake](https://python.langchain.com/docs/integrations/providers/activeloop_deeplake)
-| `2205.12654v1` [Bitext Mining Using Distilled Sentence Representations for Low-Resource Languages](http://arxiv.org/abs/2205.12654v1) | Kevin Heffernan, Onur Çelebi, Holger Schwenk | 2022-05-25 | `API:` [langchain_community...LaserEmbeddings](https://api.python.langchain.com/en/latest/embeddings/langchain_community.embeddings.laser.LaserEmbeddings.html#langchain_community.embeddings.laser.LaserEmbeddings)
-| `2204.00498v1` [Evaluating the Text-to-SQL Capabilities of Large Language Models](http://arxiv.org/abs/2204.00498v1) | Nitarshan Rajkumar, Raymond Li, Dzmitry Bahdanau | 2022-03-15 | `API:` [langchain_community...SparkSQL](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.spark_sql.SparkSQL.html#langchain_community.utilities.spark_sql.SparkSQL), [langchain_community...SQLDatabase](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.sql_database.SQLDatabase.html#langchain_community.utilities.sql_database.SQLDatabase)
-| `2202.00666v5` [Locally Typical Sampling](http://arxiv.org/abs/2202.00666v5) | Clara Meister, Tiago Pimentel, Gian Wiher,  et al. | 2022-02-01 | `API:` [langchain_community...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint), [langchain_huggingface...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint)
+| `2205.12654v1` [Bitext Mining Using Distilled Sentence Representations for Low-Resource Languages](http://arxiv.org/abs/2205.12654v1) | Kevin Heffernan, Onur Çelebi, Holger Schwenk | 2022-05-25 | `API:` [langchain_community.embeddings...LaserEmbeddings](https://api.python.langchain.com/en/latest/embeddings/langchain_community.embeddings.laser.LaserEmbeddings.html#langchain_community.embeddings.laser.LaserEmbeddings)
+| `2204.00498v1` [Evaluating the Text-to-SQL Capabilities of Large Language Models](http://arxiv.org/abs/2204.00498v1) | Nitarshan Rajkumar, Raymond Li, Dzmitry Bahdanau | 2022-03-15 | `API:` [langchain_community.utilities...SQLDatabase](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.sql_database.SQLDatabase.html#langchain_community.utilities.sql_database.SQLDatabase), [langchain_community.utilities...SparkSQL](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.spark_sql.SparkSQL.html#langchain_community.utilities.spark_sql.SparkSQL)
+| `2202.00666v5` [Locally Typical Sampling](http://arxiv.org/abs/2202.00666v5) | Clara Meister, Tiago Pimentel, Gian Wiher,  et al. | 2022-02-01 | `API:` [langchain_community.llms...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community.llms...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint)
 | `2103.00020v1` [Learning Transferable Visual Models From Natural Language Supervision](http://arxiv.org/abs/2103.00020v1) | Alec Radford, Jong Wook Kim, Chris Hallacy,  et al. | 2021-02-26 | `API:` [langchain_experimental.open_clip](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.open_clip)
-| `1909.05858v2` [CTRL: A Conditional Transformer Language Model for Controllable Generation](http://arxiv.org/abs/1909.05858v2) | Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney,  et al. | 2019-09-11 | `API:` [langchain_community...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint), [langchain_huggingface...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint)
+| `1909.05858v2` [CTRL: A Conditional Transformer Language Model for Controllable Generation](http://arxiv.org/abs/1909.05858v2) | Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney,  et al. | 2019-09-11 | `API:` [langchain_community.llms...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community.llms...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint)
 | `1908.10084v1` [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](http://arxiv.org/abs/1908.10084v1) | Nils Reimers, Iryna Gurevych | 2019-08-27 | `Docs:` [docs/integrations/text_embedding/sentence_transformers](https://python.langchain.com/docs/integrations/text_embedding/sentence_transformers)
 
-## Self-Discover: Large Language Models Self-Compose Reasoning Structures
-
-- **arXiv id:** 2402.03620v1
-- **Title:** Self-Discover: Large Language Models Self-Compose Reasoning Structures
-- **Authors:** Pei Zhou, Jay Pujara, Xiang Ren,  et al.
-- **Published Date:** 2024-02-06
-- **URL:** http://arxiv.org/abs/2402.03620v1
-- **LangChain:**
-
-   - **Cookbook:** [self-discover](https://github.com/langchain-ai/langchain/blob/master/cookbook/self-discover.ipynb)
-
-**Abstract:** We introduce SELF-DISCOVER, a general framework for LLMs to self-discover the
-task-intrinsic reasoning structures to tackle complex reasoning problems that
-are challenging for typical prompting methods. Core to the framework is a
-self-discovery process where LLMs select multiple atomic reasoning modules such
-as critical thinking and step-by-step thinking, and compose them into an
-explicit reasoning structure for LLMs to follow during decoding. SELF-DISCOVER
-substantially improves GPT-4 and PaLM 2's performance on challenging reasoning
-benchmarks such as BigBench-Hard, grounded agent reasoning, and MATH, by as
-much as 32% compared to Chain of Thought (CoT). Furthermore, SELF-DISCOVER
-outperforms inference-intensive methods such as CoT-Self-Consistency by more
-than 20%, while requiring 10-40x fewer inference compute. Finally, we show that
-the self-discovered reasoning structures are universally applicable across
-model families: from PaLM 2-L to GPT-4, and from GPT-4 to Llama2, and share
-commonalities with human reasoning patterns.
-                
-## RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval
-
-- **arXiv id:** 2401.18059v1
-- **Title:** RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval
-- **Authors:** Parth Sarthi, Salman Abdullah, Aditi Tuli,  et al.
-- **Published Date:** 2024-01-31
-- **URL:** http://arxiv.org/abs/2401.18059v1
-- **LangChain:**
-
-   - **Cookbook:** [RAPTOR](https://github.com/langchain-ai/langchain/blob/master/cookbook/RAPTOR.ipynb)
-
-**Abstract:** Retrieval-augmented language models can better adapt to changes in world
-state and incorporate long-tail knowledge. However, most existing methods
-retrieve only short contiguous chunks from a retrieval corpus, limiting
-holistic understanding of the overall document context. We introduce the novel
-approach of recursively embedding, clustering, and summarizing chunks of text,
-constructing a tree with differing levels of summarization from the bottom up.
-At inference time, our RAPTOR model retrieves from this tree, integrating
-information across lengthy documents at different levels of abstraction.
-Controlled experiments show that retrieval with recursive summaries offers
-significant improvements over traditional retrieval-augmented LMs on several
-tasks. On question-answering tasks that involve complex, multi-step reasoning,
-we show state-of-the-art results; for example, by coupling RAPTOR retrieval
-with the use of GPT-4, we can improve the best performance on the QuALITY
-benchmark by 20% in absolute accuracy.
-                
-## Corrective Retrieval Augmented Generation
-
-- **arXiv id:** 2401.15884v2
-- **Title:** Corrective Retrieval Augmented Generation
-- **Authors:** Shi-Qi Yan, Jia-Chen Gu, Yun Zhu,  et al.
-- **Published Date:** 2024-01-29
-- **URL:** http://arxiv.org/abs/2401.15884v2
-- **LangChain:**
-
-   - **Cookbook:** [langgraph_crag](https://github.com/langchain-ai/langchain/blob/master/cookbook/langgraph_crag.ipynb)
-
-**Abstract:** Large language models (LLMs) inevitably exhibit hallucinations since the
-accuracy of generated texts cannot be secured solely by the parametric
-knowledge they encapsulate. Although retrieval-augmented generation (RAG) is a
-practicable complement to LLMs, it relies heavily on the relevance of retrieved
-documents, raising concerns about how the model behaves if retrieval goes
-wrong. To this end, we propose the Corrective Retrieval Augmented Generation
-(CRAG) to improve the robustness of generation. Specifically, a lightweight
-retrieval evaluator is designed to assess the overall quality of retrieved
-documents for a query, returning a confidence degree based on which different
-knowledge retrieval actions can be triggered. Since retrieval from static and
-limited corpora can only return sub-optimal documents, large-scale web searches
-are utilized as an extension for augmenting the retrieval results. Besides, a
-decompose-then-recompose algorithm is designed for retrieved documents to
-selectively focus on key information and filter out irrelevant information in
-them. CRAG is plug-and-play and can be seamlessly coupled with various
-RAG-based approaches. Experiments on four datasets covering short- and
-long-form generation tasks show that CRAG can significantly improve the
-performance of RAG-based approaches.
-                
-## Mixtral of Experts
-
-- **arXiv id:** 2401.04088v1
-- **Title:** Mixtral of Experts
-- **Authors:** Albert Q. Jiang, Alexandre Sablayrolles, Antoine Roux,  et al.
-- **Published Date:** 2024-01-08
-- **URL:** http://arxiv.org/abs/2401.04088v1
-- **LangChain:**
-
-   - **Cookbook:** [together_ai](https://github.com/langchain-ai/langchain/blob/master/cookbook/together_ai.ipynb)
-
-**Abstract:** We introduce Mixtral 8x7B, a Sparse Mixture of Experts (SMoE) language model.
-Mixtral has the same architecture as Mistral 7B, with the difference that each
-layer is composed of 8 feedforward blocks (i.e. experts). For every token, at
-each layer, a router network selects two experts to process the current state
-and combine their outputs. Even though each token only sees two experts, the
-selected experts can be different at each timestep. As a result, each token has
-access to 47B parameters, but only uses 13B active parameters during inference.
-Mixtral was trained with a context size of 32k tokens and it outperforms or
-matches Llama 2 70B and GPT-3.5 across all evaluated benchmarks. In particular,
-Mixtral vastly outperforms Llama 2 70B on mathematics, code generation, and
-multilingual benchmarks. We also provide a model fine-tuned to follow
-instructions, Mixtral 8x7B - Instruct, that surpasses GPT-3.5 Turbo,
-Claude-2.1, Gemini Pro, and Llama 2 70B - chat model on human benchmarks. Both
-the base and instruct models are released under the Apache 2.0 license.
-                
 ## Dense X Retrieval: What Retrieval Granularity Should We Use?
 
 - **arXiv id:** 2312.06648v2
@@ -212,39 +91,6 @@ average improvement of +7.9 in EM score given entirely noisy retrieved
 documents and +10.5 in rejection rates for real-time questions that fall
 outside the pre-training knowledge scope.
                 
-## Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection
-
-- **arXiv id:** 2310.11511v1
-- **Title:** Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection
-- **Authors:** Akari Asai, Zeqiu Wu, Yizhong Wang,  et al.
-- **Published Date:** 2023-10-17
-- **URL:** http://arxiv.org/abs/2310.11511v1
-- **LangChain:**
-
-   - **Cookbook:** [langgraph_self_rag](https://github.com/langchain-ai/langchain/blob/master/cookbook/langgraph_self_rag.ipynb)
-
-**Abstract:** Despite their remarkable capabilities, large language models (LLMs) often
-produce responses containing factual inaccuracies due to their sole reliance on
-the parametric knowledge they encapsulate. Retrieval-Augmented Generation
-(RAG), an ad hoc approach that augments LMs with retrieval of relevant
-knowledge, decreases such issues. However, indiscriminately retrieving and
-incorporating a fixed number of retrieved passages, regardless of whether
-retrieval is necessary, or passages are relevant, diminishes LM versatility or
-can lead to unhelpful response generation. We introduce a new framework called
-Self-Reflective Retrieval-Augmented Generation (Self-RAG) that enhances an LM's
-quality and factuality through retrieval and self-reflection. Our framework
-trains a single arbitrary LM that adaptively retrieves passages on-demand, and
-generates and reflects on retrieved passages and its own generations using
-special tokens, called reflection tokens. Generating reflection tokens makes
-the LM controllable during the inference phase, enabling it to tailor its
-behavior to diverse task requirements. Experiments show that Self-RAG (7B and
-13B parameters) significantly outperforms state-of-the-art LLMs and
-retrieval-augmented models on a diverse set of tasks. Specifically, Self-RAG
-outperforms ChatGPT and retrieval-augmented Llama2-chat on Open-domain QA,
-reasoning and fact verification tasks, and it shows significant gains in
-improving factuality and citation accuracy for long-form generations relative
-to these models.
-                
 ## Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models
 
 - **arXiv id:** 2310.06117v2
@@ -255,7 +101,6 @@ to these models.
 - **LangChain:**
 
    - **Template:** [stepback-qa-prompting](https://python.langchain.com/docs/templates/stepback-qa-prompting)
-   - **Cookbook:** [stepback-qa](https://github.com/langchain-ai/langchain/blob/master/cookbook/stepback-qa.ipynb)
 
 **Abstract:** We present Step-Back Prompting, a simple prompting technique that enables
 LLMs to do abstractions to derive high-level concepts and first principles from
@@ -268,27 +113,6 @@ including STEM, Knowledge QA, and Multi-Hop Reasoning. For instance, Step-Back
 Prompting improves PaLM-2L performance on MMLU (Physics and Chemistry) by 7%
 and 11% respectively, TimeQA by 27%, and MuSiQue by 7%.
                 
-## Llama 2: Open Foundation and Fine-Tuned Chat Models
-
-- **arXiv id:** 2307.09288v2
-- **Title:** Llama 2: Open Foundation and Fine-Tuned Chat Models
-- **Authors:** Hugo Touvron, Louis Martin, Kevin Stone,  et al.
-- **Published Date:** 2023-07-18
-- **URL:** http://arxiv.org/abs/2307.09288v2
-- **LangChain:**
-
-   - **Cookbook:** [Semi_Structured_RAG](https://github.com/langchain-ai/langchain/blob/master/cookbook/Semi_Structured_RAG.ipynb)
-
-**Abstract:** In this work, we develop and release Llama 2, a collection of pretrained and
-fine-tuned large language models (LLMs) ranging in scale from 7 billion to 70
-billion parameters. Our fine-tuned LLMs, called Llama 2-Chat, are optimized for
-dialogue use cases. Our models outperform open-source chat models on most
-benchmarks we tested, and based on our human evaluations for helpfulness and
-safety, may be a suitable substitute for closed-source models. We provide a
-detailed description of our approach to fine-tuning and safety improvements of
-Llama 2-Chat in order to enable the community to build on our work and
-contribute to the responsible development of LLMs.
-                
 ## Query Rewriting for Retrieval-Augmented Large Language Models
 
 - **arXiv id:** 2305.14283v3
@@ -299,7 +123,6 @@ contribute to the responsible development of LLMs.
 - **LangChain:**
 
    - **Template:** [rewrite-retrieve-read](https://python.langchain.com/docs/templates/rewrite-retrieve-read)
-   - **Cookbook:** [rewrite](https://github.com/langchain-ai/langchain/blob/master/cookbook/rewrite.ipynb)
 
 **Abstract:** Large Language Models (LLMs) play powerful, black-box readers in the
 retrieve-then-read pipeline, making remarkable progress in knowledge-intensive
@@ -329,7 +152,6 @@ for retrieval-augmented LLM.
 - **LangChain:**
 
    - **API Reference:** [langchain_experimental.tot](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.tot)
-   - **Cookbook:** [tree_of_thought](https://github.com/langchain-ai/langchain/blob/master/cookbook/tree_of_thought.ipynb)
 
 **Abstract:** In this paper, we introduce the Tree-of-Thought (ToT) framework, a novel
 approach aimed at improving the problem-solving capabilities of auto-regressive
@@ -349,132 +171,6 @@ significantly increase the success rate of Sudoku puzzle solving. Our
 implementation of the ToT-based Sudoku solver is available on GitHub:
 \url{https://github.com/jieyilong/tree-of-thought-puzzle-solver}.
                 
-## Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models
-
-- **arXiv id:** 2305.04091v3
-- **Title:** Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models
-- **Authors:** Lei Wang, Wanyu Xu, Yihuai Lan,  et al.
-- **Published Date:** 2023-05-06
-- **URL:** http://arxiv.org/abs/2305.04091v3
-- **LangChain:**
-
-   - **Cookbook:** [plan_and_execute_agent](https://github.com/langchain-ai/langchain/blob/master/cookbook/plan_and_execute_agent.ipynb)
-
-**Abstract:** Large language models (LLMs) have recently been shown to deliver impressive
-performance in various NLP tasks. To tackle multi-step reasoning tasks,
-few-shot chain-of-thought (CoT) prompting includes a few manually crafted
-step-by-step reasoning demonstrations which enable LLMs to explicitly generate
-reasoning steps and improve their reasoning task accuracy. To eliminate the
-manual effort, Zero-shot-CoT concatenates the target problem statement with
-"Let's think step by step" as an input prompt to LLMs. Despite the success of
-Zero-shot-CoT, it still suffers from three pitfalls: calculation errors,
-missing-step errors, and semantic misunderstanding errors. To address the
-missing-step errors, we propose Plan-and-Solve (PS) Prompting. It consists of
-two components: first, devising a plan to divide the entire task into smaller
-subtasks, and then carrying out the subtasks according to the plan. To address
-the calculation errors and improve the quality of generated reasoning steps, we
-extend PS prompting with more detailed instructions and derive PS+ prompting.
-We evaluate our proposed prompting strategy on ten datasets across three
-reasoning problems. The experimental results over GPT-3 show that our proposed
-zero-shot prompting consistently outperforms Zero-shot-CoT across all datasets
-by a large margin, is comparable to or exceeds Zero-shot-Program-of-Thought
-Prompting, and has comparable performance with 8-shot CoT prompting on the math
-reasoning problem. The code can be found at
-https://github.com/AGI-Edgerunners/Plan-and-Solve-Prompting.
-                
-## Visual Instruction Tuning
-
-- **arXiv id:** 2304.08485v2
-- **Title:** Visual Instruction Tuning
-- **Authors:** Haotian Liu, Chunyuan Li, Qingyang Wu,  et al.
-- **Published Date:** 2023-04-17
-- **URL:** http://arxiv.org/abs/2304.08485v2
-- **LangChain:**
-
-   - **Cookbook:** [Semi_structured_and_multi_modal_RAG](https://github.com/langchain-ai/langchain/blob/master/cookbook/Semi_structured_and_multi_modal_RAG.ipynb), [Semi_structured_multi_modal_RAG_LLaMA2](https://github.com/langchain-ai/langchain/blob/master/cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb)
-
-**Abstract:** Instruction tuning large language models (LLMs) using machine-generated
-instruction-following data has improved zero-shot capabilities on new tasks,
-but the idea is less explored in the multimodal field. In this paper, we
-present the first attempt to use language-only GPT-4 to generate multimodal
-language-image instruction-following data. By instruction tuning on such
-generated data, we introduce LLaVA: Large Language and Vision Assistant, an
-end-to-end trained large multimodal model that connects a vision encoder and
-LLM for general-purpose visual and language understanding.Our early experiments
-show that LLaVA demonstrates impressive multimodel chat abilities, sometimes
-exhibiting the behaviors of multimodal GPT-4 on unseen images/instructions, and
-yields a 85.1% relative score compared with GPT-4 on a synthetic multimodal
-instruction-following dataset. When fine-tuned on Science QA, the synergy of
-LLaVA and GPT-4 achieves a new state-of-the-art accuracy of 92.53%. We make
-GPT-4 generated visual instruction tuning data, our model and code base
-publicly available.
-                
-## Generative Agents: Interactive Simulacra of Human Behavior
-
-- **arXiv id:** 2304.03442v2
-- **Title:** Generative Agents: Interactive Simulacra of Human Behavior
-- **Authors:** Joon Sung Park, Joseph C. O'Brien, Carrie J. Cai,  et al.
-- **Published Date:** 2023-04-07
-- **URL:** http://arxiv.org/abs/2304.03442v2
-- **LangChain:**
-
-   - **Cookbook:** [generative_agents_interactive_simulacra_of_human_behavior](https://github.com/langchain-ai/langchain/blob/master/cookbook/generative_agents_interactive_simulacra_of_human_behavior.ipynb), [multiagent_bidding](https://github.com/langchain-ai/langchain/blob/master/cookbook/multiagent_bidding.ipynb)
-
-**Abstract:** Believable proxies of human behavior can empower interactive applications
-ranging from immersive environments to rehearsal spaces for interpersonal
-communication to prototyping tools. In this paper, we introduce generative
-agents--computational software agents that simulate believable human behavior.
-Generative agents wake up, cook breakfast, and head to work; artists paint,
-while authors write; they form opinions, notice each other, and initiate
-conversations; they remember and reflect on days past as they plan the next
-day. To enable generative agents, we describe an architecture that extends a
-large language model to store a complete record of the agent's experiences
-using natural language, synthesize those memories over time into higher-level
-reflections, and retrieve them dynamically to plan behavior. We instantiate
-generative agents to populate an interactive sandbox environment inspired by
-The Sims, where end users can interact with a small town of twenty five agents
-using natural language. In an evaluation, these generative agents produce
-believable individual and emergent social behaviors: for example, starting with
-only a single user-specified notion that one agent wants to throw a Valentine's
-Day party, the agents autonomously spread invitations to the party over the
-next two days, make new acquaintances, ask each other out on dates to the
-party, and coordinate to show up for the party together at the right time. We
-demonstrate through ablation that the components of our agent
-architecture--observation, planning, and reflection--each contribute critically
-to the believability of agent behavior. By fusing large language models with
-computational, interactive agents, this work introduces architectural and
-interaction patterns for enabling believable simulations of human behavior.
-                
-## CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society
-
-- **arXiv id:** 2303.17760v2
-- **Title:** CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society
-- **Authors:** Guohao Li, Hasan Abed Al Kader Hammoud, Hani Itani,  et al.
-- **Published Date:** 2023-03-31
-- **URL:** http://arxiv.org/abs/2303.17760v2
-- **LangChain:**
-
-   - **Cookbook:** [camel_role_playing](https://github.com/langchain-ai/langchain/blob/master/cookbook/camel_role_playing.ipynb)
-
-**Abstract:** The rapid advancement of chat-based language models has led to remarkable
-progress in complex task-solving. However, their success heavily relies on
-human input to guide the conversation, which can be challenging and
-time-consuming. This paper explores the potential of building scalable
-techniques to facilitate autonomous cooperation among communicative agents, and
-provides insight into their "cognitive" processes. To address the challenges of
-achieving autonomous cooperation, we propose a novel communicative agent
-framework named role-playing. Our approach involves using inception prompting
-to guide chat agents toward task completion while maintaining consistency with
-human intentions. We showcase how role-playing can be used to generate
-conversational data for studying the behaviors and capabilities of a society of
-agents, providing a valuable resource for investigating conversational language
-models. In particular, we conduct comprehensive studies on
-instruction-following cooperation in multi-agent settings. Our contributions
-include introducing a novel communicative agent framework, offering a scalable
-approach for studying the cooperative behaviors and capabilities of multi-agent
-systems, and open-sourcing our library to support research on communicative
-agents and beyond: https://github.com/camel-ai/camel.
-                
 ## HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face
 
 - **arXiv id:** 2303.17580v4
@@ -485,7 +181,6 @@ agents and beyond: https://github.com/camel-ai/camel.
 - **LangChain:**
 
    - **API Reference:** [langchain_experimental.autonomous_agents](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.autonomous_agents)
-   - **Cookbook:** [hugginggpt](https://github.com/langchain-ai/langchain/blob/master/cookbook/hugginggpt.ipynb)
 
 **Abstract:** Solving complicated AI tasks with different domains and modalities is a key
 step toward artificial general intelligence. While there are numerous AI models
@@ -540,7 +235,7 @@ more than 1/1,000th the compute of GPT-4.
 - **URL:** http://arxiv.org/abs/2301.10226v4
 - **LangChain:**
 
-   - **API Reference:** [langchain_community...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community...OCIModelDeploymentTGI](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI.html#langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI), [langchain_community...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint), [langchain_huggingface...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint)
+   - **API Reference:** [langchain_community.llms...OCIModelDeploymentTGI](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI.html#langchain_community.llms.oci_data_science_model_deployment_endpoint.OCIModelDeploymentTGI), [langchain_community.llms...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community.llms...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint)
 
 **Abstract:** Potential harms of large language models can be mitigated by watermarking
 model output, i.e., embedding signals into generated text that are invisible to
@@ -565,9 +260,8 @@ family, and discuss robustness and security.
 - **URL:** http://arxiv.org/abs/2212.10496v1
 - **LangChain:**
 
-   - **API Reference:** [langchain...HypotheticalDocumentEmbedder](https://api.python.langchain.com/en/latest/chains/langchain.chains.hyde.base.HypotheticalDocumentEmbedder.html#langchain.chains.hyde.base.HypotheticalDocumentEmbedder)
+   - **API Reference:** [langchain.chains...HypotheticalDocumentEmbedder](https://api.python.langchain.com/en/latest/chains/langchain.chains.hyde.base.HypotheticalDocumentEmbedder.html#langchain.chains.hyde.base.HypotheticalDocumentEmbedder)
    - **Template:** [hyde](https://python.langchain.com/docs/templates/hyde)
-   - **Cookbook:** [hypothetical_document_embeddings](https://github.com/langchain-ai/langchain/blob/master/cookbook/hypothetical_document_embeddings.ipynb)
 
 **Abstract:** While dense retrieval has been shown effective and efficient across tasks and
 languages, it remains difficult to create effective fully zero-shot dense
@@ -629,7 +323,7 @@ further work on logical fallacy identification.
 - **URL:** http://arxiv.org/abs/2211.13892v2
 - **LangChain:**
 
-   - **API Reference:** [langchain_core...MaxMarginalRelevanceExampleSelector](https://api.python.langchain.com/en/latest/example_selectors/langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector.html#langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector)
+   - **API Reference:** [langchain_core.example_selectors...MaxMarginalRelevanceExampleSelector](https://api.python.langchain.com/en/latest/example_selectors/langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector.html#langchain_core.example_selectors.semantic_similarity.MaxMarginalRelevanceExampleSelector)
 
 **Abstract:** Large language models (LLMs) have exhibited remarkable capabilities in
 learning from explanations in prompts, but there has been limited understanding
@@ -657,8 +351,7 @@ performance across three real-world tasks on multiple LLMs.
 - **URL:** http://arxiv.org/abs/2211.10435v2
 - **LangChain:**
 
-   - **API Reference:** [langchain_experimental...PALChain](https://api.python.langchain.com/en/latest/pal_chain/langchain_experimental.pal_chain.base.PALChain.html#langchain_experimental.pal_chain.base.PALChain), [langchain_experimental.pal_chain](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.pal_chain)
-   - **Cookbook:** [program_aided_language_model](https://github.com/langchain-ai/langchain/blob/master/cookbook/program_aided_language_model.ipynb)
+   - **API Reference:** [langchain_experimental.pal_chain...PALChain](https://api.python.langchain.com/en/latest/pal_chain/langchain_experimental.pal_chain.base.PALChain.html#langchain_experimental.pal_chain.base.PALChain), [langchain_experimental.pal_chain](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.pal_chain)
 
 **Abstract:** Large language models (LLMs) have recently demonstrated an impressive ability
 to perform arithmetic and symbolic reasoning tasks, when provided with a few
@@ -720,7 +413,7 @@ TensorFlow, JAX, and integrate with numerous MLOps tools.
 - **URL:** http://arxiv.org/abs/2205.12654v1
 - **LangChain:**
 
-   - **API Reference:** [langchain_community...LaserEmbeddings](https://api.python.langchain.com/en/latest/embeddings/langchain_community.embeddings.laser.LaserEmbeddings.html#langchain_community.embeddings.laser.LaserEmbeddings)
+   - **API Reference:** [langchain_community.embeddings...LaserEmbeddings](https://api.python.langchain.com/en/latest/embeddings/langchain_community.embeddings.laser.LaserEmbeddings.html#langchain_community.embeddings.laser.LaserEmbeddings)
 
 **Abstract:** Scaling multilingual representation learning beyond the hundred most frequent
 languages is challenging, in particular to cover the long tail of low-resource
@@ -749,7 +442,7 @@ encoders, mine bitexts, and validate the bitexts by training NMT systems.
 - **URL:** http://arxiv.org/abs/2204.00498v1
 - **LangChain:**
 
-   - **API Reference:** [langchain_community...SparkSQL](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.spark_sql.SparkSQL.html#langchain_community.utilities.spark_sql.SparkSQL), [langchain_community...SQLDatabase](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.sql_database.SQLDatabase.html#langchain_community.utilities.sql_database.SQLDatabase)
+   - **API Reference:** [langchain_community.utilities...SQLDatabase](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.sql_database.SQLDatabase.html#langchain_community.utilities.sql_database.SQLDatabase), [langchain_community.utilities...SparkSQL](https://api.python.langchain.com/en/latest/utilities/langchain_community.utilities.spark_sql.SparkSQL.html#langchain_community.utilities.spark_sql.SparkSQL)
 
 **Abstract:** We perform an empirical evaluation of Text-to-SQL capabilities of the Codex
 language model. We find that, without any finetuning, Codex is a strong
@@ -768,7 +461,7 @@ few-shot examples.
 - **URL:** http://arxiv.org/abs/2202.00666v5
 - **LangChain:**
 
-   - **API Reference:** [langchain_community...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint), [langchain_huggingface...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint)
+   - **API Reference:** [langchain_community.llms...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community.llms...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint)
 
 **Abstract:** Today's probabilistic language generators fall short when it comes to
 producing coherent and fluent text despite the fact that the underlying models
@@ -832,7 +525,7 @@ https://github.com/OpenAI/CLIP.
 - **URL:** http://arxiv.org/abs/1909.05858v2
 - **LangChain:**
 
-   - **API Reference:** [langchain_community...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint), [langchain_huggingface...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_huggingface.llms.huggingface_endpoint.HuggingFaceEndpoint)
+   - **API Reference:** [langchain_community.llms...HuggingFaceTextGenInference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference.html#langchain_community.llms.huggingface_text_gen_inference.HuggingFaceTextGenInference), [langchain_community.llms...HuggingFaceEndpoint](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint.html#langchain_community.llms.huggingface_endpoint.HuggingFaceEndpoint)
 
 **Abstract:** Large-scale language models show promising text generation capabilities, but
 users cannot easily control particular aspects of the generated text. We

docs/docs/concepts.mdx

@@ -38,7 +38,7 @@ All dependencies in this package are optional to keep the package as lightweight
 `langgraph` is an extension of `langchain` aimed at
 building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
 
-LangGraph exposes high level interfaces for creating common types of agents, as well as a low-level API for composing custom flows.
+LangGraph exposes high level interfaces for creating common types of agents, as well as a low-level API for constructing more contr
 
 ### [`langserve`](/docs/langserve)
 
@@ -58,7 +58,6 @@ A developer platform that lets you debug, test, evaluate, and monitor LLM applic
 />
 
 ## LangChain Expression Language (LCEL)
-<span data-heading-keywords="lcel"></span>
 
 LangChain Expression Language, or LCEL, is a declarative way to chain LangChain components.
 LCEL was designed from day 1 to **support putting prototypes in production, with no code changes**, from the simplest “prompt + LLM” chain to the most complex chains (we’ve seen folks successfully run LCEL chains with 100s of steps in production). To highlight a few of the reasons you might want to use LCEL:
@@ -89,16 +88,15 @@ With LCEL, **all** steps are automatically logged to [LangSmith](https://docs.sm
 Any chain created with LCEL can be easily deployed using [LangServe](/docs/langserve).
 
 ### Runnable interface
-<span data-heading-keywords="invoke"></span>
 
 To make it as easy as possible to create custom chains, we've implemented a ["Runnable"](https://api.python.langchain.com/en/stable/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable) protocol. Many LangChain components implement the `Runnable` protocol, including chat models, LLMs, output parsers, retrievers, prompt templates, and more. There are also several useful primitives for working with runnables, which you can read about below.
 
 This is a standard interface, which makes it easy to define custom chains as well as invoke them in a standard way.
 The standard interface includes:
 
-- `stream`: stream back chunks of the response
-- `invoke`: call the chain on an input
-- `batch`: call the chain on a list of inputs
+- [`stream`](#stream): stream back chunks of the response
+- [`invoke`](#invoke): call the chain on an input
+- [`batch`](#batch): call the chain on a list of inputs
 
 These also have corresponding async methods that should be used with [asyncio](https://docs.python.org/3/library/asyncio.html) `await` syntax for concurrency:
 
@@ -130,7 +128,6 @@ LangChain provides standard, extendable interfaces and external integrations for
 Some components LangChain implements, some components we rely on third-party integrations for, and others are a mix.
 
 ### Chat models
-<span data-heading-keywords="chat model,chat models"></span>
 
 Language models that use a sequence of messages as inputs and return chat messages as outputs (as opposed to using plain text).
 These are traditionally newer models (older models are generally `LLMs`, see above).
@@ -140,7 +137,7 @@ Although the underlying models are messages in, message out, the LangChain wrapp
 
 When a string is passed in as input, it is converted to a HumanMessage and then passed to the underlying model.
 
-LangChain does not host any Chat Models, rather we rely on third party integrations.
+LangChain does not provide any ChatModels, rather we rely on third party integrations.
 
 We have some standardized parameters when constructing ChatModels:
 - `model`: the name of the model
@@ -153,22 +150,17 @@ Generally, such models are better at tool calling than non-fine-tuned models, an
 Please see the [tool calling section](/docs/concepts/#functiontool-calling) for more information.
 :::
 
-For specifics on how to use chat models, see the [relevant how-to guides here](/docs/how_to/#chat-models).
-
 ### LLMs
-<span data-heading-keywords="llm,llms"></span>
 
 Language models that takes a string as input and returns a string.
-These are traditionally older models (newer models generally are [Chat Models](/docs/concepts/#chat-models), see below).
+These are traditionally older models (newer models generally are `ChatModels`, see below).
 
 Although the underlying models are string in, string out, the LangChain wrappers also allow these models to take messages as input.
-This gives them the same interface as [Chat Models](/docs/concepts/#chat-models).
+This makes them interchangeable with ChatModels.
 When messages are passed in as input, they will be formatted into a string under the hood before being passed to the underlying model.
 
 LangChain does not provide any LLMs, rather we rely on third party integrations.
 
-For specifics on how to use LLMs, see the [relevant how-to guides here](/docs/how_to/#llms).
-
 ### Messages
 
 Some language models take a list of messages as input and return a message.
@@ -222,8 +214,6 @@ This represents the result of a tool call. This is distinct from a FunctionMessa
 
 
 ### Prompt templates
-<span data-heading-keywords="prompt,prompttemplate,chatprompttemplate"></span>
-
 Prompt templates help to translate user input and parameters into instructions for a language model.
 This can be used to guide a model's response, helping it understand the context and generate relevant and coherent language-based output.
 
@@ -232,7 +222,7 @@ Prompt Templates take as input a dictionary, where each key represents a variabl
 Prompt Templates output a PromptValue. This PromptValue can be passed to an LLM or a ChatModel, and can also be cast to a string or a list of messages.
 The reason this PromptValue exists is to make it easy to switch between strings and messages.
 
-There are a few different types of prompt templates:
+There are a few different types of prompt templates
 
 #### String PromptTemplates
 
@@ -268,7 +258,6 @@ The first is a system message, that has no variables to format.
 The second is a HumanMessage, and will be formatted by the `topic` variable the user passes in.
 
 #### MessagesPlaceholder
-<span data-heading-keywords="messagesplaceholder"></span>
 
 This prompt template is responsible for adding a list of messages in a particular place.
 In the above ChatPromptTemplate, we saw how we could format two messages, each one a string.
@@ -300,18 +289,14 @@ prompt_template = ChatPromptTemplate.from_messages([
 ])
 ```
 
-For specifics on how to use prompt templates, see the [relevant how-to guides here](/docs/how_to/#prompt-templates).
-
 ### Example selectors
 One common prompting technique for achieving better performance is to include examples as part of the prompt.
 This gives the language model concrete examples of how it should behave.
 Sometimes these examples are hardcoded into the prompt, but for more advanced situations it may be nice to dynamically select them.
 Example Selectors are classes responsible for selecting and then formatting examples into prompts.
 
-For specifics on how to use example selectors, see the [relevant how-to guides here](/docs/how_to/#example-selectors).
 
 ### Output parsers
-<span data-heading-keywords="output parser"></span>
 
 :::note
 
@@ -355,19 +340,16 @@ LangChain has lots of different types of output parsers. This is a list of outpu
 | [Datetime](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.datetime.DatetimeOutputParser.html#langchain.output_parsers.datetime.DatetimeOutputParser)        |                    | ✅                             |           | `str` \| `Message`                 | `datetime.datetime`  | Parses response into a datetime string.                                                                                                                                                                                                                  |
 | [Structured](https://api.python.langchain.com/en/latest/output_parsers/langchain.output_parsers.structured.StructuredOutputParser.html#langchain.output_parsers.structured.StructuredOutputParser)      |                    | ✅                             |           | `str` \| `Message`                 | `Dict[str, str]`     | An output parser that returns structured information. It is less powerful than other output parsers since it only allows for fields to be strings. This can be useful when you are working with smaller LLMs.                                            |
 
-For specifics on how to use output parsers, see the [relevant how-to guides here](/docs/how_to/#output-parsers).
-
 ### Chat history
 Most LLM applications have a conversational interface.
 An essential component of a conversation is being able to refer to information introduced earlier in the conversation.
 At bare minimum, a conversational system should be able to access some window of past messages directly.
 
 The concept of `ChatHistory` refers to a class in LangChain which can be used to wrap an arbitrary chain.
-This `ChatHistory` will keep track of inputs and outputs of the underlying chain, and append them as messages to a message database.
+This `ChatHistory` will keep track of inputs and outputs of the underlying chain, and append them as messages to a message database
 Future interactions will then load those messages and pass them into the chain as part of the input.
 
 ### Documents
-<span data-heading-keywords="document,documents"></span>
 
 A Document object in LangChain contains information about some data. It has two attributes:
 
@@ -375,7 +357,6 @@ A Document object in LangChain contains information about some data. It has two
 - `metadata: dict`: Arbitrary metadata associated with this document. Can track the document id, file name, etc.
 
 ### Document loaders
-<span data-heading-keywords="document loader,document loaders"></span>
 
 These classes load Document objects. LangChain has hundreds of integrations with various data sources to load data from: Slack, Notion, Google Drive, etc.
 
@@ -391,8 +372,6 @@ loader = CSVLoader(
 data = loader.load()
 ```
 
-For specifics on how to use document loaders, see the [relevant how-to guides here](/docs/how_to/#document-loaders).
-
 ### Text splitters
 
 Once you've loaded documents, you'll often want to transform them to better suit your application. The simplest example is you may want to split a long document into smaller chunks that can fit into your model's context window. LangChain has a number of built-in document transformers that make it easy to split, combine, filter, and otherwise manipulate documents.
@@ -410,22 +389,14 @@ That means there are two different axes along which you can customize your text
 1. How the text is split
 2. How the chunk size is measured
 
-For specifics on how to use text splitters, see the [relevant how-to guides here](/docs/how_to/#text-splitters).
-
 ### Embedding models
-<span data-heading-keywords="embedding,embeddings"></span>
-
 The Embeddings class is a class designed for interfacing with text embedding models. There are lots of embedding model providers (OpenAI, Cohere, Hugging Face, etc) - this class is designed to provide a standard interface for all of them.
 
 Embeddings create a vector representation of a piece of text. This is useful because it means we can think about text in the vector space, and do things like semantic search where we look for pieces of text that are most similar in the vector space.
 
 The base Embeddings class in LangChain provides two methods: one for embedding documents and one for embedding a query. The former takes as input multiple texts, while the latter takes a single text. The reason for having these as two separate methods is that some embedding providers have different embedding methods for documents (to be searched over) vs queries (the search query itself).
 
-For specifics on how to use embedding models, see the [relevant how-to guides here](/docs/how_to/#embedding-models).
-
 ### Vector stores
-<span data-heading-keywords="vector,vectorstore,vectorstores,vector store,vector stores"></span>
-
 One of the most common ways to store and search over unstructured data is to embed it and store the resulting embedding vectors,
 and then at query time to embed the unstructured query and retrieve the embedding vectors that are 'most similar' to the embedded query.
 A vector store takes care of storing embedded data and performing vector search for you.
@@ -437,11 +408,7 @@ vectorstore = MyVectorStore()
 retriever = vectorstore.as_retriever()
 ```
 
-For specifics on how to use vector stores, see the [relevant how-to guides here](/docs/how_to/#vector-stores).
-
 ### Retrievers
-<span data-heading-keywords="retriever,retrievers"></span>
-
 A retriever is an interface that returns documents given an unstructured query.
 It is more general than a vector store.
 A retriever does not need to be able to store documents, only to return (or retrieve) them.
@@ -449,10 +416,7 @@ Retrievers can be created from vectorstores, but are also broad enough to includ
 
 Retrievers accept a string query as input and return a list of Document's as output.
 
-For specifics on how to use retrievers, see the [relevant how-to guides here](/docs/how_to/#retrievers).
-
 ### Tools
-<span data-heading-keywords="tool,tools"></span>
 
 Tools are interfaces that an agent, a chain, or a chat model / LLM can use to interact with the world.
 
@@ -478,8 +442,6 @@ Generally, when designing tools to be used by a chat model or LLM, it is importa
 - Models will perform better if the tools have well-chosen names, descriptions, and JSON schemas.
 - Simpler tools are generally easier for models to use than more complex tools.
 
-For specifics on how to use tools, see the [relevant how-to guides here](/docs/how_to/#tools).
-
 ### Toolkits
 
 Toolkits are collections of tools that are designed to be used together for specific tasks. They have convenient loading methods.
@@ -499,7 +461,7 @@ tools = toolkit.get_tools()
 
 By themselves, language models can't take actions - they just output text.
 A big use case for LangChain is creating **agents**.
-Agents are systems that use an LLM as a reasoning engine to determine which actions to take and what the inputs to those actions should be.
+Agents are systems that use an LLM as a reasoning enginer to determine which actions to take and what the inputs to those actions should be.
 The results of those actions can then be fed back into the agent and it determine whether more actions are needed, or whether it is okay to finish.
 
 [LangGraph](https://github.com/langchain-ai/langgraph) is an extension of LangChain specifically aimed at creating highly controllable and customizable agents.
@@ -512,7 +474,7 @@ In order to solve that we built LangGraph to be this flexible, highly-controllab
 
 If you are still using AgentExecutor, do not fear: we still have a guide on [how to use AgentExecutor](/docs/how_to/agent_executor).
 It is recommended, however, that you start to transition to LangGraph.
-In order to assist in this we have put together a [transition guide on how to do so](/docs/how_to/migrate_agent).
+In order to assist in this we have put together a [transition guide on how to do so](/docs/how_to/migrate_agent)
 
 ### Multimodal
 
@@ -520,8 +482,6 @@ Some models are multimodal, accepting images, audio and even video as inputs. Th
 
 In LangChain, most chat models that support multimodal inputs also accept those values in OpenAI's content blocks format. So far this is restricted to image inputs. For models like Gemini which support video and other bytes input, the APIs also support the native, model-specific representations.
 
-For specifics on how to use multimodal models, see the [relevant how-to guides here](/docs/how_to/#multimodal).
-
 ### Callbacks
 
 LangChain provides a callbacks system that allows you to hook into the various stages of your LLM application. This is useful for logging, monitoring, streaming, and other tasks.
@@ -592,122 +552,8 @@ This is a common reason why you may fail to see events being emitted from custom
 runnables or tools.
 :::
 
-For specifics on how to use callbacks, see the [relevant how-to guides here](/docs/how_to/#callbacks).
-
 ## Techniques
 
-### Streaming
-
-Individual LLM calls often run for much longer than traditional resource requests.
-This compounds when you build more complex chains or agents that require multiple reasoning steps.
-
-Fortunately, LLMs generate output iteratively, which means it's possible to show sensible intermediate results
-before the final response is ready. Consuming output as soon as it becomes available has therefore become a vital part of the UX
-around building apps with LLMs to help alleviate latency issues, and LangChain aims to have first-class support for streaming.
-
-Below, we'll discuss some concepts and considerations around streaming in LangChain.
-
-#### Tokens
-
-The unit that most model providers use to measure input and output is via a unit called a **token**.
-Tokens are the basic units that language models read and generate when processing or producing text.
-The exact definition of a token can vary depending on the specific way the model was trained -
-for instance, in English, a token could be a single word like "apple", or a part of a word like "app".
-The below example shows how OpenAI models tokenize `LangChain is cool!`:
-
-![](/img/tokenization.png)
-
-You can see that it gets split into 5 different tokens, and that the boundaries between tokens are not exactly the same as word boundaries.
-
-The reason language models use tokens rather than something more immediately intuitive like "characters"
-has to do with how they process and understand text. At a high-level, language models iteratively predict their next generated output based on
-the initial input and their previous generations. Training the model using tokens language models to handle linguistic
-units (like words or subwords) that carry meaning, rather than individual characters, which makes it easier for the model
-to learn and understand the structure of the language, including grammar and context.
-Furthermore, using tokens can also improve efficiency, since the model processes fewer units of text compared to character-level processing.
-
-When you send a model a prompt, the words and characters in the prompt are encoded into tokens using a **tokenizer**.
-The model then streams back generated output tokens, which the tokenizer decodes into human-readable text.
-
-#### Callbacks
-
-The lowest level way to stream outputs from LLMs in LangChain is via the [callbacks](/docs/concepts/#callbacks) system. You can pass a
-callback handler that handles the [`on_llm_new_token`](https://api.python.langchain.com/en/latest/callbacks/langchain.callbacks.streaming_aiter.AsyncIteratorCallbackHandler.html#langchain.callbacks.streaming_aiter.AsyncIteratorCallbackHandler.on_llm_new_token) event into LangChain components. When that component is invoked, any
-[LLM](/docs/concepts/#llms) or [chat model](/docs/concepts/#chat-models) contained in the component calls
-the callback with the generated token. Within the callback, you could pipe the tokens into some other destination, e.g. a HTTP response.
-You can also handle the [`on_llm_end`](https://api.python.langchain.com/en/latest/callbacks/langchain.callbacks.streaming_aiter.AsyncIteratorCallbackHandler.html#langchain.callbacks.streaming_aiter.AsyncIteratorCallbackHandler.on_llm_end) event to perform any necessary cleanup.
-
-You can see [this how-to section](/docs/how_to/#callbacks) for more specifics on using callbacks.
-
-Callbacks were the first technique for streaming introduced in LangChain. While powerful and generalizable,
-they can be unwieldy for developers. For example:
-
-- You need to explicitly initialize and manage some aggregator or other stream to collect results.
-- The execution order isn't explicitly guaranteed, and you could theoretically have a callback run after the `.invoke()` method finishes.
-- Providers would often make you pass an additional parameter to stream outputs instead of returning them all at once.
-- You would often ignore the result of the actual model call in favor of callback results.
-
-#### `.stream()`
-
-LangChain also includes the `.stream()` method as a more ergonomic streaming interface.
-`.stream()` returns an iterator, which you can consume with a simple `for` loop. Here's an example with a chat model:
-
-```python
-from langchain_anthropic import ChatAnthropic
-
-model = ChatAnthropic(model="claude-3-sonnet-20240229")
-
-for chunk in model.stream("what color is the sky?"):
-    print(chunk.content, end="|", flush=True)
-```
-
-For models (or other components) that don't support streaming natively, this iterator would just yield a single chunk, but
-you could still use the same general pattern. Using `.stream()` will also automatically call the model in streaming mode
-without the need to provide additional config.
-
-The type of each outputted chunk depends on the type of component - for example, chat models yield [`AIMessageChunks`](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html).
-Because this method is part of [LangChain Expression Language](/docs/concepts/#langchain-expression-language-lcel),
-you can handle formatting differences from different outputs using an [output parser](/docs/concepts/#output-parsers) to transform
-each yielded chunk.
-
-You can check out [this guide](/docs/how_to/streaming/#using-stream) for more detail on how to use `.stream()`.
-
-#### `.astream_events()`
-
-While the `.stream()` method is easier to use than callbacks, it only returns one type of value. This is fine for single LLM calls,
-but as you build more complex chains of several LLM calls together, you may want to use the intermediate values of
-the chain alongside the final output - for example, returning sources alongside the final generation when building a chat
-over documents app.
-
-There are ways to do this using the aforementioned callbacks, or by constructing your chain in such a way that it passes intermediate
-values to the end with something like [`.assign()`](/docs/how_to/passthrough/), but LangChain also includes an
-`.astream_events()` method that combines the flexibility of callbacks with the ergonomics of `.stream()`. When called, it returns an iterator
-which yields [various types of events](/docs/how_to/streaming/#event-reference) that you can filter and process according
-to the needs of your project.
-
-Here's one small example that prints just events containing streamed chat model output:
-
-```python
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_anthropic import ChatAnthropic
-
-model = ChatAnthropic(model="claude-3-sonnet-20240229")
-
-prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
-parser = StrOutputParser()
-chain = prompt | model | parser
-
-async for event in chain.astream_events({"topic": "parrot"}, version="v2"):
-    kind = event["event"]
-    if kind == "on_chat_model_stream":
-        print(event, end="|", flush=True)
-```
-
-You can roughly think of it as an iterator over callback events (though the format differs) - and you can use it on almost all LangChain components!
-
-See [this guide](/docs/how_to/streaming/#using-stream-events) for more detailed information on how to use `.astream_events()`.
-
 ### Function/tool calling
 
 :::info
@@ -777,7 +623,6 @@ LangChain provides several advanced retrieval types. A full list is below, along
 | [Multi-Query Retriever](/docs/how_to/MultiQueryRetriever/)     | Any                          | Yes                       | If users are asking questions that are complex and require multiple pieces of distinct information to respond                                 | This uses an LLM to generate multiple queries from the original one. This is useful when the original query needs pieces of information about multiple topics to be properly answered. By generating multiple queries, we can then fetch documents for each of them.                             |
 | [Ensemble](/docs/how_to/ensemble_retriever/)                  | Any                          | No                        | If you have multiple retrieval methods and want to try combining them.                                                                        | This fetches documents from multiple retrievers and then combines them.                                                                                                                                                                                                                          |
 
-For a high-level guide on retrieval, see this [tutorial on RAG](/docs/tutorials/rag/).
 
 ### Text splitting
 

docs/docs/contributing/code.mdx

@@ -206,7 +206,9 @@ ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogy
 
 `langchain-core` and partner packages **do not use** optional dependencies in this way.
 
-You'll notice that `pyproject.toml` and `poetry.lock` are **not** touched when you add optional dependencies below.
+You only need to add a new dependency if a **unit test** relies on the package.
+If your package is only required for **integration tests**, then you can skip these
+steps and leave all pyproject.toml and poetry.lock files alone.
 
 If you're adding a new dependency to Langchain, assume that it will be an optional dependency, and
 that most users won't have it installed.
@@ -214,12 +216,20 @@ that most users won't have it installed.
 Users who do not have the dependency installed should be able to **import** your code without
 any side effects (no warnings, no errors, no exceptions).
 
-To introduce the dependency to a library, please do the following:
+To introduce the dependency to the pyproject.toml file correctly, please do the following:
 
-1. Open extended_testing_deps.txt and add the dependency
-2. Add a unit test that the very least attempts to import the new code. Ideally, the unit
+1. Add the dependency to the main group as an optional dependency
+  ```bash
+  poetry add --optional [package_name]
+  ```
+2. Open pyproject.toml and add the dependency to the `extended_testing` extra
+3. Relock the poetry file to update the extra.
+  ```bash
+  poetry lock --no-update
+  ```
+4. Add a unit test that the very least attempts to import the new code. Ideally, the unit
 test makes use of lightweight fixtures to test the logic of the code.
-3. Please use the `@pytest.mark.requires(package_name)` decorator for any unit tests that require the dependency.
+5. Please use the `@pytest.mark.requires(package_name)` decorator for any tests that require the dependency.
 
 ## Adding a Jupyter Notebook
 

docs/docs/contributing/documentation/style_guide.mdx

@@ -55,7 +55,7 @@ The below sections are listed roughly in order of increasing level of abstractio
 
 ### Expression Language
 
-[LangChain Expression Language (LCEL)](/docs/concepts#langchain-expression-language-lcel) is the fundamental way that most LangChain components fit together, and this section is designed to teach
+[LangChain Expression Language (LCEL)](/docs/concepts#langchain-expression-language) is the fundamental way that most LangChain components fit together, and this section is designed to teach
 developers how to use it to build with LangChain's primitives effectively.
 
 This section should contains **Tutorials** that teach how to stream and use LCEL primitives for more abstract tasks, **Explanations** of specific behaviors,

docs/docs/how_to/agent_executor.ipynb

@@ -15,18 +15,18 @@
    "id": "f4c03f40-1328-412d-8a48-1db0cd481b77",
    "metadata": {},
    "source": [
-    "# Build an Agent with AgentExecutor (Legacy)\n",
-    "\n",
-    ":::{.callout-important}\n",
-    "This section will cover building with the legacy LangChain AgentExecutor. These are fine for getting started, but past a certain point, you will likely want flexibility and control that they do not offer. For working with more advanced agents, we'd recommend checking out [LangGraph Agents](/docs/concepts/#langgraph) or the [migration guide](/docs/how_to/migrate_agent/)\n",
-    ":::\n",
+    "# Build an Agent\n",
     "\n",
     "By themselves, language models can't take actions - they just output text.\n",
     "A big use case for LangChain is creating **agents**.\n",
-    "Agents are systems that use an LLM as a reasoning engine to determine which actions to take and what the inputs to those actions should be.\n",
-    "The results of those actions can then be fed back into the agent and it determines whether more actions are needed, or whether it is okay to finish.\n",
+    "Agents are systems that use an LLM as a reasoning enginer to determine which actions to take and what the inputs to those actions should be.\n",
+    "The results of those actions can then be fed back into the agent and it determine whether more actions are needed, or whether it is okay to finish.\n",
     "\n",
-    "In this tutorial, we will build an agent that can interact with multiple different tools: one being a local database, the other being a search engine. You will be able to ask this agent questions, watch it call tools, and have conversations with it.\n",
+    "In this tutorial we will build an agent that can interact with multiple different tools: one being a local database, the other being a search engine. You will be able to ask this agent questions, watch it call tools, and have conversations with it.\n",
+    "\n",
+    ":::{.callout-important}\n",
+    "This section will cover building with LangChain Agents. LangChain Agents are fine for getting started, but past a certain point you will likely want flexibility and control that they do not offer. For working with more advanced agents, we'd reccommend checking out [LangGraph](/docs/concepts/#langgraph)\n",
+    ":::\n",
     "\n",
     "## Concepts\n",
     "\n",
@@ -34,7 +34,7 @@
     "- Using [language models](/docs/concepts/#chat-models), in particular their tool calling ability\n",
     "- Creating a [Retriever](/docs/concepts/#retrievers) to expose specific information to our agent\n",
     "- Using a Search [Tool](/docs/concepts/#tools) to look up things online\n",
-    "- [`Chat History`](/docs/concepts/#chat-history), which allows a chatbot to \"remember\" past interactions and take them into account when responding to follow-up questions. \n",
+    "- [`Chat History`](/docs/concepts/#chat-history), which allows a chatbot to \"remember\" past interactions and take them into account when responding to followup questions. \n",
     "- Debugging and tracing your application using [LangSmith](/docs/concepts/#langsmith)\n",
     "\n",
     "## Setup\n",

docs/docs/how_to/character_text_splitter.ipynb

@@ -1,19 +1,5 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "f781411d",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
-   "source": [
-    "---\n",
-    "keywords: [charactertextsplitter]\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "c3ee8d00",

docs/docs/how_to/chat_models_universal_init.ipynb

@@ -1,157 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "cfdf4f09-8125-4ed1-8063-6feed57da8a3",
-   "metadata": {},
-   "source": [
-    "# How to let your end users choose their model\n",
-    "\n",
-    "Many LLM applications let end users specify what model provider and model they want the application to be powered by. This requires writing some logic to initialize different ChatModels based on some user configuration. The `init_chat_model()` helper method makes it easy to initialize a number of different model integrations without having to worry about import paths and class names.\n",
-    "\n",
-    ":::tip Supported models\n",
-    "\n",
-    "See the [init_chat_model()](https://api.python.langchain.com/en/latest/chat_models/langchain.chat_models.base.init_chat_model.html) API reference for a full list of supported integrations.\n",
-    "\n",
-    "Make sure you have the integration packages installed for any model providers you want to support. E.g. you should have `langchain-openai` installed to init an OpenAI model.\n",
-    "\n",
-    ":::"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "165b0de6-9ae3-4e3d-aa98-4fc8a97c4a06",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install -qU langchain langchain-openai langchain-anthropic langchain-google-vertexai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ea2c9f57-a796-45f8-b6f4-3efd3f361a9b",
-   "metadata": {},
-   "source": [
-    "## Basic usage"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "79e14913-803c-4382-9009-5c6af3d75d35",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "GPT-4o: I'm an AI created by OpenAI, and I don't have a personal name. You can call me Assistant! How can I help you today?\n",
-      "\n",
-      "Claude Opus: My name is Claude. It's nice to meet you!\n",
-      "\n",
-      "Gemini 1.5: I am a large language model, trained by Google. I do not have a name. \n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain.chat_models import init_chat_model\n",
-    "\n",
-    "# Returns a langchain_openai.ChatOpenAI instance.\n",
-    "gpt_4o = init_chat_model(\"gpt-4o\", model_provider=\"openai\", temperature=0)\n",
-    "# Returns a langchain_anthropic.ChatAnthropic instance.\n",
-    "claude_opus = init_chat_model(\n",
-    "    \"claude-3-opus-20240229\", model_provider=\"anthropic\", temperature=0\n",
-    ")\n",
-    "# Returns a langchain_google_vertexai.ChatVertexAI instance.\n",
-    "gemini_15 = init_chat_model(\n",
-    "    \"gemini-1.5-pro\", model_provider=\"google_vertexai\", temperature=0\n",
-    ")\n",
-    "\n",
-    "# Since all model integrations implement the ChatModel interface, you can use them in the same way.\n",
-    "print(\"GPT-4o: \" + gpt_4o.invoke(\"what's your name\").content + \"\\n\")\n",
-    "print(\"Claude Opus: \" + claude_opus.invoke(\"what's your name\").content + \"\\n\")\n",
-    "print(\"Gemini 1.5: \" + gemini_15.invoke(\"what's your name\").content + \"\\n\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fff9a4c8-b6ee-4a1a-8d3d-0ecaa312d4ed",
-   "metadata": {},
-   "source": [
-    "## Simple config example"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "75c25d39-bf47-4b51-a6c6-64d9c572bfd6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "user_config = {\n",
-    "    \"model\": \"...user-specified...\",\n",
-    "    \"model_provider\": \"...user-specified...\",\n",
-    "    \"temperature\": 0,\n",
-    "    \"max_tokens\": 1000,\n",
-    "}\n",
-    "\n",
-    "llm = init_chat_model(**user_config)\n",
-    "llm.invoke(\"what's your name\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f811f219-5e78-4b62-b495-915d52a22532",
-   "metadata": {},
-   "source": [
-    "## Inferring model provider\n",
-    "\n",
-    "For common and distinct model names `init_chat_model()` will attempt to infer the model provider. See the [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain.chat_models.base.init_chat_model.html) for a full list of inference behavior. E.g. any model that starts with `gpt-3...` or `gpt-4...` will be inferred as using model provider `openai`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "0378ccc6-95bc-4d50-be50-fccc193f0a71",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "gpt_4o = init_chat_model(\"gpt-4o\", temperature=0)\n",
-    "claude_opus = init_chat_model(\"claude-3-opus-20240229\", temperature=0)\n",
-    "gemini_15 = init_chat_model(\"gemini-1.5-pro\", temperature=0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "da07b5c0-d2e6-42e4-bfcd-2efcfaae6221",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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/how_to/chat_token_usage_tracking.ipynb

@@ -14,51 +14,35 @@
     "\n",
     ":::\n",
     "\n",
-    "Tracking token usage to calculate cost is an important part of putting your app in production. This guide goes over how to obtain this information from your LangChain model calls.\n",
-    "\n",
-    "This guide requires `langchain-openai >= 0.1.8`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9c7d1338-dd1b-4d06-b33d-d5cffc49fd6a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet langchain langchain-openai"
+    "Tracking token usage to calculate cost is an important part of putting your app in production. This guide goes over how to obtain this information from your LangChain model calls."
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "598ae1e2-a52d-4459-81fd-cdc68b06742a",
+   "id": "1a55e87a-3291-4e7f-8e8e-4c69b0854384",
    "metadata": {},
    "source": [
-    "## Using LangSmith\n",
+    "## Using AIMessage.response_metadata\n",
     "\n",
-    "You can use [LangSmith](https://www.langchain.com/langsmith) to help track token usage in your LLM application. See the [LangSmith quick start guide](https://docs.smith.langchain.com/).\n",
-    "\n",
-    "## Using AIMessage.usage_metadata\n",
-    "\n",
-    "A number of model providers return token usage information as part of the chat generation response. When available, this information will be included on the `AIMessage` objects produced by the corresponding model.\n",
-    "\n",
-    "LangChain `AIMessage` objects include a [usage_metadata](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessage.html#langchain_core.messages.ai.AIMessage.usage_metadata) attribute. When populated, this attribute will be a [UsageMetadata](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.UsageMetadata.html) dictionary with standard keys (e.g., `\"input_tokens\"` and `\"output_tokens\"`).\n",
-    "\n",
-    "Examples:\n",
-    "\n",
-    "**OpenAI**:"
+    "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/how_to/response_metadata) field. Here's an example with OpenAI:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "b39bf807-4125-4db4-bbf7-28a46afff6b4",
+   "id": "467ccdeb-6b62-45e5-816e-167cd24d2586",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'input_tokens': 8, 'output_tokens': 9, 'total_tokens': 17}"
+       "{'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,
@@ -67,33 +51,37 @@
     }
    ],
    "source": [
-    "# # !pip install -qU langchain-openai\n",
+    "# !pip install -qU langchain-openai\n",
     "\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\")\n",
-    "openai_response = llm.invoke(\"hello\")\n",
-    "openai_response.usage_metadata"
+    "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": "2299c44a-2fe6-4d52-a6a2-99ff6d231c73",
+   "id": "9d5026e9-3ad4-41e6-9946-9f1a26f4a21f",
    "metadata": {},
    "source": [
-    "**Anthropic**:"
+    "And here's an example with Anthropic:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "9c82ff80-ec4e-4049-b019-5f0bbd7df82a",
+   "id": "145404f1-e088-4824-b468-236c486a9903",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'input_tokens': 8, 'output_tokens': 12, 'total_tokens': 20}"
+       "{'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,
@@ -106,222 +94,9 @@
     "\n",
     "from langchain_anthropic import ChatAnthropic\n",
     "\n",
-    "llm = ChatAnthropic(model=\"claude-3-haiku-20240307\")\n",
-    "anthropic_response = llm.invoke(\"hello\")\n",
-    "anthropic_response.usage_metadata"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6d4efc15-ba9f-4b3d-9278-8e01f99f263f",
-   "metadata": {},
-   "source": [
-    "### Using AIMessage.response_metadata\n",
-    "\n",
-    "Metadata from the model response is also included in the AIMessage [response_metadata](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessage.html#langchain_core.messages.ai.AIMessage.response_metadata) attribute. These data are typically not standardized. Note that different providers adopt different conventions for representing token counts:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f156f9da-21f2-4c81-a714-54cbf9ad393e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "OpenAI: {'completion_tokens': 9, 'prompt_tokens': 8, 'total_tokens': 17}\n",
-      "\n",
-      "Anthropic: {'input_tokens': 8, 'output_tokens': 12}\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(f'OpenAI: {openai_response.response_metadata[\"token_usage\"]}\\n')\n",
-    "print(f'Anthropic: {anthropic_response.response_metadata[\"usage\"]}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b4ef2c43-0ff6-49eb-9782-e4070c9da8d7",
-   "metadata": {},
-   "source": [
-    "### Streaming\n",
-    "\n",
-    "Some providers support token count metadata in a streaming context.\n",
-    "\n",
-    "#### OpenAI\n",
-    "\n",
-    "For example, OpenAI will return a message [chunk](https://api.python.langchain.com/en/latest/messages/langchain_core.messages.ai.AIMessageChunk.html) at the end of a stream with token usage information. This behavior is supported by `langchain-openai >= 0.1.8` and can be enabled by setting `stream_options={\"include_usage\": True}`.\n",
-    "\n",
-    "```{=mdx}\n",
-    ":::note\n",
-    "By default, the last message chunk in a stream will include a `\"finish_reason\"` in the message's `response_metadata` attribute. If we include token usage in streaming mode, an additional chunk containing usage metadata will be added to the end of the stream, such that `\"finish_reason\"` appears on the second to last message chunk.\n",
-    ":::\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "07f0c872-6b6c-4fed-a129-9b5a858505be",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "content='' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content='Hello' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content='!' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content=' How' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content=' can' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content=' I' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content=' assist' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content=' you' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content=' today' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content='?' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content='' response_metadata={'finish_reason': 'stop'} id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf'\n",
-      "content='' id='run-b40e502e-d30e-4617-94ad-95b4dfee14bf' usage_metadata={'input_tokens': 8, 'output_tokens': 9, 'total_tokens': 17}\n"
-     ]
-    }
-   ],
-   "source": [
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\")\n",
-    "\n",
-    "aggregate = None\n",
-    "for chunk in llm.stream(\"hello\", stream_options={\"include_usage\": True}):\n",
-    "    print(chunk)\n",
-    "    aggregate = chunk if aggregate is None else aggregate + chunk"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dd809ded-8b13-4d5f-be5e-277b79d51802",
-   "metadata": {},
-   "source": [
-    "Note that the usage metadata will be included in the sum of the individual message chunks:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "3db7bc03-a7d4-4704-92ab-f8ba92ef59ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hello! How can I assist you today?\n",
-      "{'input_tokens': 8, 'output_tokens': 9, 'total_tokens': 17}\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(aggregate.content)\n",
-    "print(aggregate.usage_metadata)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7dba63e8-0ed7-4533-8f0f-78e19c38a25c",
-   "metadata": {},
-   "source": [
-    "To disable streaming token counts for OpenAI, set `\"include_usage\"` to False in `stream_options`, or omit it from the parameters:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "67117f2b-ce68-4c1e-9556-2d3849f90e1b",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "content='' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content='Hello' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content='!' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content=' How' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content=' can' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content=' I' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content=' assist' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content=' you' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content=' today' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content='?' id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n",
-      "content='' response_metadata={'finish_reason': 'stop'} id='run-0085d64c-13d2-431b-a0fa-399be8cd3c52'\n"
-     ]
-    }
-   ],
-   "source": [
-    "aggregate = None\n",
-    "for chunk in llm.stream(\"hello\"):\n",
-    "    print(chunk)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6a5d9617-be3a-419a-9276-de9c29fa50ae",
-   "metadata": {},
-   "source": [
-    "You can also enable streaming token usage by setting `model_kwargs` when instantiating the chat model. This can be useful when incorporating chat models into LangChain [chains](/docs/concepts#langchain-expression-language-lcel): usage metadata can be monitored when [streaming intermediate steps](/docs/how_to/streaming#using-stream-events) or using tracing software such as [LangSmith](https://docs.smith.langchain.com/).\n",
-    "\n",
-    "See the below example, where we return output structured to a desired schema, but can still observe token usage streamed from intermediate steps."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "57dec1fb-bd9c-4c98-8798-8fbbe67f6b2c",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Token usage: {'input_tokens': 79, 'output_tokens': 23, 'total_tokens': 102}\n",
-      "\n",
-      "setup='Why was the math book sad?' punchline='Because it had too many problems.'\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
-    "\n",
-    "\n",
-    "class Joke(BaseModel):\n",
-    "    \"\"\"Joke to tell user.\"\"\"\n",
-    "\n",
-    "    setup: str = Field(description=\"question to set up a joke\")\n",
-    "    punchline: str = Field(description=\"answer to resolve the joke\")\n",
-    "\n",
-    "\n",
-    "llm = ChatOpenAI(\n",
-    "    model=\"gpt-3.5-turbo-0125\",\n",
-    "    model_kwargs={\"stream_options\": {\"include_usage\": True}},\n",
-    ")\n",
-    "# Under the hood, .with_structured_output binds tools to the\n",
-    "# chat model and appends a parser.\n",
-    "structured_llm = llm.with_structured_output(Joke)\n",
-    "\n",
-    "async for event in structured_llm.astream_events(\"Tell me a joke\", version=\"v2\"):\n",
-    "    if event[\"event\"] == \"on_chat_model_end\":\n",
-    "        print(f'Token usage: {event[\"data\"][\"output\"].usage_metadata}\\n')\n",
-    "    elif event[\"event\"] == \"on_chain_end\":\n",
-    "        print(event[\"data\"][\"output\"])\n",
-    "    else:\n",
-    "        pass"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2bc8d313-4bef-463e-89a5-236d8bb6ab2f",
-   "metadata": {},
-   "source": [
-    "Token usage is also visible in the corresponding [LangSmith trace](https://smith.langchain.com/public/fe6513d5-7212-4045-82e0-fefa28bc7656/r) in the payload from the chat model."
+    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\")\n",
+    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
+    "msg.response_metadata"
    ]
   },
   {
@@ -340,7 +115,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "id": "31667d54",
    "metadata": {},
    "outputs": [
@@ -348,11 +123,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Tokens Used: 27\n",
+      "Tokens Used: 26\n",
       "\tPrompt Tokens: 11\n",
-      "\tCompletion Tokens: 16\n",
+      "\tCompletion Tokens: 15\n",
       "Successful Requests: 1\n",
-      "Total Cost (USD): $2.95e-05\n"
+      "Total Cost (USD): $0.00056\n"
      ]
     }
    ],
@@ -361,7 +136,7 @@
     "\n",
     "from langchain_community.callbacks.manager import get_openai_callback\n",
     "\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4-turbo\", temperature=0)\n",
     "\n",
     "with get_openai_callback() as cb:\n",
     "    result = llm.invoke(\"Tell me a joke\")\n",
@@ -378,7 +153,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 6,
    "id": "e09420f4",
    "metadata": {},
    "outputs": [
@@ -386,7 +161,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "55\n"
+      "52\n"
      ]
     }
    ],
@@ -397,39 +172,6 @@
     "    print(cb.total_tokens)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "9ac51188-c8f4-4230-90fd-3cd78cdd955d",
-   "metadata": {},
-   "source": [
-    "```{=mdx}\n",
-    ":::note\n",
-    "Cost information is currently not available in streaming mode. This is because model names are currently not propagated through chunks in streaming mode, and the model name is used to look up the correct pricing. Token counts however are available:\n",
-    ":::\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "b241069a-265d-4497-af34-b0a5f95ae67f",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "28\n"
-     ]
-    }
-   ],
-   "source": [
-    "with get_openai_callback() as cb:\n",
-    "    for chunk in llm.stream(\"Tell me a joke\", stream_options={\"include_usage\": True}):\n",
-    "        pass\n",
-    "    print(cb.total_tokens)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "d8186e7b",
@@ -440,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 17,
    "id": "5d1125c6",
    "metadata": {},
    "outputs": [],
@@ -469,15 +211,15 @@
    "source": [
     "```{=mdx}\n",
     ":::note\n",
-    "We have to set `stream_runnable=False` for cost information, as described above. 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.\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",
     "```"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "3950d88b-8bfb-4294-b75b-e6fd421e633c",
+   "execution_count": 18,
+   "id": "2f98c536",
    "metadata": {},
    "outputs": [
     {
@@ -488,51 +230,46 @@
       "\n",
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
       "\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `wikipedia` with `{'query': 'hummingbird scientific name'}`\n",
+      "Invoking: `wikipedia` with `Hummingbird`\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.\n",
-      "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",
+      "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",
       "\n",
-      "Page: Rufous hummingbird\n",
-      "Summary: The rufous hummingbird (Selasphorus rufus) is a small hummingbird, about 8 cm (3.1 in) long with a long, straight and slender bill. These birds are known for their extraordinary flight skills, flying 2,000 mi (3,200 km) during their migratory transits. It is one of nine species in the genus Selasphorus.\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: Anna's hummingbird\n",
-      "Summary: Anna's hummingbird (Calypte anna) is a North American species of hummingbird. It was named after Anna Masséna, Duchess of Rivoli.\n",
-      "It is native to western coastal regions of North America. In the early 20th century, Anna's hummingbirds bred only in northern Baja California and Southern California. The transplanting of exotic ornamental plants in residential areas throughout the Pacific coast and inland deserts provided expanded nectar and nesting sites, allowing the species to expand its breeding range. Year-round residence of Anna's hummingbirds in the Pacific Northwest is an example of ecological release dependent on acclimation to colder winter temperatures, introduced plants, and human provision of nectar feeders during winter.\n",
-      "These birds feed on nectar from flowers using a long extendable tongue. They also consume small insects and other arthropods caught in flight or gleaned from vegetation.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `wikipedia` with `{'query': 'fastest bird species'}`\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: 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 (Falco peregrinus), 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",
-      "\n",
-      "\n",
-      "Page: Fastest animals\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: Falcon\n",
-      "Summary: Falcons () are birds of prey in the genus Falco, which includes about 40 species. Falcons are widely distributed on all continents of the world except Antarctica, though closely related raptors did occur there in the Eocene.\n",
-      "Adult falcons have thin, tapered wings, which enable them to fly at high speed and change direction rapidly. Fledgling falcons, in their first year of flying, have longer flight feathers, which make their configuration more like that of a general-purpose bird such as a broad wing. This makes flying easier while learning the exceptional skills required to be effective hunters as adults.\n",
-      "The falcons are the largest genus in the Falconinae subfamily of Falconidae, which itself also includes another subfamily comprising caracaras and a few other species. All these birds kill with their beaks, using a tomial \"tooth\" on the side of their beaks—unlike the hawks, eagles, and other birds of prey in the Accipitridae, which use their feet.\n",
-      "The largest falcon is the gyrfalcon at up to 65 cm in length.  The smallest falcon species is the pygmy falcon, which measures just 20 cm.  As with hawks and owls, falcons exhibit sexual dimorphism, with the females typically larger than the males, thus allowing a wider range of prey species.\n",
-      "Some small falcons with long, narrow wings are called \"hobbies\" and some which hover while hunting are called \"kestrels\".\n",
-      "As is the case with many birds of prey, falcons have exceptional powers of vision; the visual acuity of one species has been measured at 2.6 times that of a normal human. Peregrine falcons have been recorded diving at speeds of 320 km/h (200 mph), making them the fastest-moving creatures on Earth; the fastest recorded dive attained a vertical speed of 390 km/h (240 mph).\u001b[0m\u001b[32;1m\u001b[1;3mThe scientific name for a hummingbird is Trochilidae. The fastest bird species is the peregrine falcon (Falco peregrinus), which can exceed speeds of 320 km/h (200 mph) in its dives.\u001b[0m\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",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n",
-      "Total Tokens: 1787\n",
-      "Prompt Tokens: 1687\n",
-      "Completion Tokens: 100\n",
-      "Total Cost (USD): $0.0009935\n"
+      "Total Tokens: 1583\n",
+      "Prompt Tokens: 1412\n",
+      "Completion Tokens: 171\n",
+      "Total Cost (USD): $0.019250000000000003\n"
      ]
     }
    ],
@@ -561,19 +298,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "1837c807-136a-49d8-9c33-060e58dc16d2",
+   "execution_count": 1,
+   "id": "4a3eced5-2ff7-49a7-a48b-768af8658323",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Tokens Used: 96\n",
-      "\tPrompt Tokens: 26\n",
-      "\tCompletion Tokens: 70\n",
+      "Tokens Used: 0\n",
+      "\tPrompt Tokens: 0\n",
+      "\tCompletion Tokens: 0\n",
       "Successful Requests: 2\n",
-      "Total Cost (USD): $0.001888\n"
+      "Total Cost (USD): $0.0\n"
      ]
     }
    ],
@@ -627,7 +364,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/dynamic_chain.ipynb

@@ -1,5 +1,15 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "77bf57fb-e990-45f2-8b5f-c76388b05966",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "keywords: [LCEL]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "50d57bf2-7104-4570-b3e5-90fd71e1bea1",

docs/docs/how_to/embed_text.mdx

@@ -75,31 +75,6 @@ Otherwise you can initialize without any params:
 from langchain_cohere import CohereEmbeddings
 
 embeddings_model = CohereEmbeddings()
-```
-
-  </TabItem>
-  <TabItem value="huggingface" label="Hugging Face">
-
-To start we'll need to install the Hugging Face partner package:
-
-```bash
-pip install langchain-huggingface
-```
-
-You can then load any [Sentence Transformers model](https://huggingface.co/models?library=sentence-transformers) from the Hugging Face Hub.
-
-```python
-from langchain_huggingface import HuggingFaceEmbeddings
-
-embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
-```
-
-You can also leave the `model_name` blank to use the default [sentence-transformers/all-mpnet-base-v2](https://huggingface.co/sentence-transformers/all-mpnet-base-v2) model.
-
-```python
-from langchain_huggingface import HuggingFaceEmbeddings
-
-embeddings_model = HuggingFaceEmbeddings()
 ```
 
   </TabItem>

docs/docs/how_to/ensemble_retriever.ipynb

@@ -4,17 +4,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# How to combine results from multiple retrievers\n",
+    "# How to create an Ensemble Retriever\n",
     "\n",
-    "The [EnsembleRetriever](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.ensemble.EnsembleRetriever.html) supports ensembling of results from multiple retrievers. It is initialized with a list of [BaseRetriever](https://api.python.langchain.com/en/latest/retrievers/langchain_core.retrievers.BaseRetriever.html) objects. EnsembleRetrievers rerank the results of the constituent retrievers based on the [Reciprocal Rank Fusion](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf) algorithm.\n",
+    "The `EnsembleRetriever` takes a list of retrievers as input and ensemble the results of their `get_relevant_documents()` methods and rerank the results based on the [Reciprocal Rank Fusion](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf) algorithm.\n",
     "\n",
     "By leveraging the strengths of different algorithms, the `EnsembleRetriever` can achieve better performance than any single algorithm. \n",
     "\n",
-    "The most common pattern is to combine a sparse retriever (like BM25) with a dense retriever (like embedding similarity), because their strengths are complementary. It is also known as \"hybrid search\". The sparse retriever is good at finding relevant documents based on keywords, while the dense retriever is good at finding relevant documents based on semantic similarity.\n",
-    "\n",
-    "## Basic usage\n",
-    "\n",
-    "Below we demonstrate ensembling of a [BM25Retriever](https://api.python.langchain.com/en/latest/retrievers/langchain_community.retrievers.bm25.BM25Retriever.html) with a retriever derived from the [FAISS vector store](https://api.python.langchain.com/en/latest/vectorstores/langchain_community.vectorstores.faiss.FAISS.html)."
+    "The most common pattern is to combine a sparse retriever (like BM25) with a dense retriever (like embedding similarity), because their strengths are complementary. It is also known as \"hybrid search\". The sparse retriever is good at finding relevant documents based on keywords, while the dense retriever is good at finding relevant documents based on semantic similarity."
    ]
   },
   {
@@ -28,15 +24,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain.retrievers import EnsembleRetriever\n",
     "from langchain_community.retrievers import BM25Retriever\n",
     "from langchain_community.vectorstores import FAISS\n",
-    "from langchain_openai import OpenAIEmbeddings\n",
-    "\n",
+    "from langchain_openai import OpenAIEmbeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "doc_list_1 = [\n",
     "    \"I like apples\",\n",
     "    \"I like oranges\",\n",
@@ -68,19 +71,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[Document(page_content='I like apples', metadata={'source': 1}),\n",
-       " Document(page_content='You like apples', metadata={'source': 2}),\n",
-       " Document(page_content='Apples and oranges are fruits', metadata={'source': 1}),\n",
-       " Document(page_content='You like oranges', metadata={'source': 2})]"
+       "[Document(page_content='You like apples', metadata={'source': 2}),\n",
+       " Document(page_content='I like apples', metadata={'source': 1}),\n",
+       " Document(page_content='You like oranges', metadata={'source': 2}),\n",
+       " Document(page_content='Apples and oranges are fruits', metadata={'source': 1})]"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -96,17 +99,24 @@
    "source": [
     "## Runtime Configuration\n",
     "\n",
-    "We can also configure the individual retrievers at runtime using [configurable fields](/docs/how_to/configure). Below we update the \"top-k\" parameter for the FAISS retriever specifically:"
+    "We can also configure the retrievers at runtime. In order to do this, we need to mark the fields as configurable"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.runnables import ConfigurableField"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_core.runnables import ConfigurableField\n",
-    "\n",
     "faiss_retriever = faiss_vectorstore.as_retriever(\n",
     "    search_kwargs={\"k\": 2}\n",
     ").configurable_fields(\n",
@@ -115,8 +125,15 @@
     "        name=\"Search Kwargs\",\n",
     "        description=\"The search kwargs to use\",\n",
     "    )\n",
-    ")\n",
-    "\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "ensemble_retriever = EnsembleRetriever(\n",
     "    retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5]\n",
     ")"
@@ -124,22 +141,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Document(page_content='I like apples', metadata={'source': 1}),\n",
-       " Document(page_content='You like apples', metadata={'source': 2}),\n",
-       " Document(page_content='Apples and oranges are fruits', metadata={'source': 1})]"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "config = {\"configurable\": {\"search_kwargs_faiss\": {\"k\": 1}}}\n",
     "docs = ensemble_retriever.invoke(\"apples\", config=config)\n",
@@ -177,7 +181,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/example_selectors.ipynb

@@ -60,7 +60,7 @@
    "source": [
     "examples = [\n",
     "    {\"input\": \"hi\", \"output\": \"ciao\"},\n",
-    "    {\"input\": \"bye\", \"output\": \"arrivederci\"},\n",
+    "    {\"input\": \"bye\", \"output\": \"arrivaderci\"},\n",
     "    {\"input\": \"soccer\", \"output\": \"calcio\"},\n",
     "]"
    ]
@@ -133,7 +133,7 @@
     {
      "data": {
       "text/plain": [
-       "[{'input': 'bye', 'output': 'arrivederci'}]"
+       "[{'input': 'bye', 'output': 'arrivaderci'}]"
       ]
      },
      "execution_count": 39,
@@ -209,7 +209,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Translate the following words from English to Italian:\n",
+      "Translate the following words from English to Italain:\n",
       "\n",
       "Input: hand -> Output: mano\n",
       "\n",
@@ -222,7 +222,7 @@
     "    example_selector=example_selector,\n",
     "    example_prompt=example_prompt,\n",
     "    suffix=\"Input: {input} -> Output:\",\n",
-    "    prefix=\"Translate the following words from English to Italian:\",\n",
+    "    prefix=\"Translate the following words from English to Italain:\",\n",
     "    input_variables=[\"input\"],\n",
     ")\n",
     "\n",

docs/docs/how_to/extraction_examples.ipynb

@@ -128,7 +128,7 @@
     "    # Having a good description can help improve extraction results.\n",
     "    name: Optional[str] = Field(..., description=\"The name of the person\")\n",
     "    hair_color: Optional[str] = Field(\n",
-    "        ..., description=\"The color of the person's hair if known\"\n",
+    "        ..., description=\"The color of the peron's eyes if known\"\n",
     "    )\n",
     "    height_in_meters: Optional[str] = Field(..., description=\"Height in METERs\")\n",
     "\n",

docs/docs/how_to/index.mdx

@@ -49,7 +49,7 @@ These are the core building blocks you can use when building applications.
 
 ### Prompt templates
 
-[Prompt Templates](/docs/concepts/#prompt-templates) are responsible for formatting user input into a format that can be passed to a language model.
+Prompt Templates are responsible for formatting user input into a format that can be passed to a language model.
 
 - [How to: use few shot examples](/docs/how_to/few_shot_examples)
 - [How to: use few shot examples in chat models](/docs/how_to/few_shot_examples_chat/)
@@ -58,7 +58,7 @@ These are the core building blocks you can use when building applications.
 
 ### Example selectors
 
-[Example Selectors](/docs/concepts/#example-selectors) are responsible for selecting the correct few shot examples to pass to the prompt.
+Example Selectors are responsible for selecting the correct few shot examples to pass to the prompt.
 
 - [How to: use example selectors](/docs/how_to/example_selectors)
 - [How to: select examples by length](/docs/how_to/example_selectors_length_based)
@@ -68,7 +68,7 @@ These are the core building blocks you can use when building applications.
 
 ### Chat models
 
-[Chat Models](/docs/concepts/#chat-models) are newer forms of language models that take messages in and output a message.
+Chat Models are newer forms of language models that take messages in and output a message.
 
 - [How to: do function/tool calling](/docs/how_to/tool_calling)
 - [How to: get models to return structured output](/docs/how_to/structured_output)
@@ -78,11 +78,10 @@ These are the core building blocks you can use when building applications.
 - [How to: stream a response back](/docs/how_to/chat_streaming)
 - [How to: track token usage](/docs/how_to/chat_token_usage_tracking)
 - [How to: track response metadata across providers](/docs/how_to/response_metadata)
-- [How to: let your end users choose their model](/docs/how_to/chat_models_universal_init/)
 
 ### LLMs
 
-What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language models that take a string in and output a string.
+What LangChain calls LLMs are older forms of language models that take a string in and output a string.
 
 - [How to: cache model responses](/docs/how_to/llm_caching)
 - [How to: create a custom LLM class](/docs/how_to/custom_llm)
@@ -92,7 +91,7 @@ What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language mo
 
 ### Output parsers
 
-[Output Parsers](/docs/concepts/#output-parsers) are responsible for taking the output of an LLM and parsing into more structured format.
+Output Parsers are responsible for taking the output of an LLM and parsing into more structured format.
 
 - [How to: use output parsers to parse an LLM response into structured format](/docs/how_to/output_parser_structured)
 - [How to: parse JSON output](/docs/how_to/output_parser_json)
@@ -104,7 +103,7 @@ What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language mo
 
 ### Document loaders
 
-[Document Loaders](/docs/concepts/#document-loaders) are responsible for loading documents from a variety of sources.
+Document Loaders are responsible for loading documents from a variety of sources.
 
 - [How to: load CSV data](/docs/how_to/document_loader_csv)
 - [How to: load data from a directory](/docs/how_to/document_loader_directory)
@@ -117,7 +116,7 @@ What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language mo
 
 ### Text splitters
 
-[Text Splitters](/docs/concepts/#text-splitters) take a document and split into chunks that can be used for retrieval.
+Text Splitters take a document and split into chunks that can be used for retrieval.
 
 - [How to: recursively split text](/docs/how_to/recursive_text_splitter)
 - [How to: split by HTML headers](/docs/how_to/HTML_header_metadata_splitter)
@@ -131,20 +130,20 @@ What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language mo
 
 ### Embedding models
 
-[Embedding Models](/docs/concepts/#embedding-models) take a piece of text and create a numerical representation of it.
+Embedding Models take a piece of text and create a numerical representation of it.
 
 - [How to: embed text data](/docs/how_to/embed_text)
 - [How to: cache embedding results](/docs/how_to/caching_embeddings)
 
 ### Vector stores
 
-[Vector stores](/docs/concepts/#vector-stores) are databases that can efficiently store and retrieve embeddings.
+Vector stores are databases that can efficiently store and retrieve embeddings.
 
 - [How to: use a vector store to retrieve data](/docs/how_to/vectorstores)
 
 ### Retrievers
 
-[Retrievers](/docs/concepts/#retrievers) are responsible for taking a query and returning relevant documents.
+Retrievers are responsible for taking a query and returning relevant documents.
 
 - [How to: use a vector store to retrieve data](/docs/how_to/vectorstore_retriever)
 - [How to: generate multiple queries to retrieve data for](/docs/how_to/MultiQueryRetriever)
@@ -152,7 +151,7 @@ What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language mo
 - [How to: write a custom retriever class](/docs/how_to/custom_retriever)
 - [How to: add similarity scores to retriever results](/docs/how_to/add_scores_retriever)
 - [How to: combine the results from multiple retrievers](/docs/how_to/ensemble_retriever)
-- [How to: reorder retrieved results to mitigate the "lost in the middle" effect](/docs/how_to/long_context_reorder)
+- [How to: reorder retrieved results to put most relevant documents not in the middle](/docs/how_to/long_context_reorder)
 - [How to: generate multiple embeddings per document](/docs/how_to/multi_vector)
 - [How to: retrieve the whole document for a chunk](/docs/how_to/parent_document_retriever)
 - [How to: generate metadata filters](/docs/how_to/self_query)
@@ -167,13 +166,12 @@ Indexing is the process of keeping your vectorstore in-sync with the underlying
 
 ### Tools
 
-LangChain [Tools](/docs/concepts/#tools) contain a description of the tool (to pass to the language model) as well as the implementation of the function to call).
+LangChain Tools contain a description of the tool (to pass to the language model) as well as the implementation of the function to call).
 
 - [How to: create custom tools](/docs/how_to/custom_tools)
 - [How to: use built-in tools and built-in toolkits](/docs/how_to/tools_builtin)
 - [How to: use a chat model to call tools](/docs/how_to/tool_calling/)
 - [How to: add ad-hoc tool calling capability to LLMs and chat models](/docs/how_to/tools_prompting)
-- [How to: pass run time values to tools](/docs/how_to/tool_runtime)
 - [How to: add a human in the loop to tool usage](/docs/how_to/tools_human)
 - [How to: handle errors when calling tools](/docs/how_to/tools_error)
 
@@ -196,8 +194,6 @@ For in depth how-to guides for agents, please check out [LangGraph](https://gith
 
 ### Callbacks
 
-[Callbacks](/docs/concepts/#callbacks) allow you to hook into the various stages of your LLM application's execution.
-
 - [How to: pass in callbacks at runtime](/docs/how_to/callbacks_runtime)
 - [How to: attach callbacks to a module](/docs/how_to/callbacks_attach)
 - [How to: pass callbacks into a module constructor](/docs/how_to/callbacks_constructor)
@@ -224,7 +220,6 @@ These guides cover use-case specific details.
 ### Q&A with RAG
 
 Retrieval Augmented Generation (RAG) is a way to connect LLMs to external sources of data.
-For a high-level tutorial on RAG, check out [this guide](/docs/tutorials/rag/).
 
 - [How to: add chat history](/docs/how_to/qa_chat_history_how_to/)
 - [How to: stream](/docs/how_to/qa_streaming/)
@@ -236,7 +231,6 @@ For a high-level tutorial on RAG, check out [this guide](/docs/tutorials/rag/).
 ### Extraction
 
 Extraction is when you use LLMs to extract structured information from unstructured text.
-For a high level tutorial on extraction, check out [this guide](/docs/tutorials/extraction/).
 
 - [How to: use reference examples](/docs/how_to/extraction_examples/)
 - [How to: handle long text](/docs/how_to/extraction_long_text/)
@@ -245,7 +239,6 @@ For a high level tutorial on extraction, check out [this guide](/docs/tutorials/
 ### Chatbots
 
 Chatbots involve using an LLM to have a conversation.
-For a high-level tutorial on building chatbots, check out [this guide](/docs/tutorials/chatbot/).
 
 - [How to: manage memory](/docs/how_to/chatbots_memory)
 - [How to: do retrieval](/docs/how_to/chatbots_retrieval)
@@ -254,7 +247,6 @@ For a high-level tutorial on building chatbots, check out [this guide](/docs/tut
 ### Query analysis
 
 Query Analysis is the task of using an LLM to generate a query to send to a retriever.
-For a high-level tutorial on query analysis, check out [this guide](/docs/tutorials/query_analysis/).
 
 - [How to: add examples to the prompt](/docs/how_to/query_few_shot)
 - [How to: handle cases where no queries are generated](/docs/how_to/query_no_queries)
@@ -266,7 +258,6 @@ For a high-level tutorial on query analysis, check out [this guide](/docs/tutori
 ### Q&A over SQL + CSV
 
 You can use LLMs to do question answering over tabular data.
-For a high-level tutorial, check out [this guide](/docs/tutorials/sql_qa/).
 
 - [How to: use prompting to improve results](/docs/how_to/sql_prompting)
 - [How to: do query validation](/docs/how_to/sql_query_checking)
@@ -276,25 +267,8 @@ For a high-level tutorial, check out [this guide](/docs/tutorials/sql_qa/).
 ### Q&A over graph databases
 
 You can use an LLM to do question answering over graph databases.
-For a high-level tutorial, check out [this guide](/docs/tutorials/graph/).
 
 - [How to: map values to a database](/docs/how_to/graph_mapping)
 - [How to: add a semantic layer over the database](/docs/how_to/graph_semantic)
 - [How to: improve results with prompting](/docs/how_to/graph_prompting)
 - [How to: construct knowledge graphs](/docs/how_to/graph_constructing)
-
-## [LangGraph](https://langchain-ai.github.io/langgraph)
-
-LangGraph is an extension of LangChain aimed at
-building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
-
-LangGraph documentation is currently hosted on a separate site.
-You can peruse [LangGraph how-to guides here](https://langchain-ai.github.io/langgraph/how-tos/).
-
-## [LangSmith](https://docs.smith.langchain.com/)
-
-LangSmith allows you to closely trace, monitor and evaluate your LLM application.
-It seamlessly integrates with LangChain, and you can use it to inspect and debug individual steps of your chains as you build.
-
-LangSmith documentation is hosted on a separate site.
-You can peruse [LangSmith how-to guides here](https://docs.smith.langchain.com/how_to_guides/).

docs/docs/how_to/indexing.ipynb

@@ -60,7 +60,7 @@
     "   * document addition by id (`add_documents` method with `ids` argument)\n",
     "   * delete by id (`delete` method with `ids` argument)\n",
     "\n",
-    "Compatible Vectorstores: `Aerospike`, `AnalyticDB`, `AstraDB`, `AwaDB`, `AzureCosmosDBNoSqlVectorSearch`, `AzureCosmosDBVectorSearch`, `Bagel`, `Cassandra`, `Chroma`, `CouchbaseVectorStore`, `DashVector`, `DatabricksVectorSearch`, `DeepLake`, `Dingo`, `ElasticVectorSearch`, `ElasticsearchStore`, `FAISS`, `HanaDB`, `Milvus`, `MyScale`, `OpenSearchVectorSearch`, `PGVector`, `Pinecone`, `Qdrant`, `Redis`, `Rockset`, `ScaNN`, `SupabaseVectorStore`, `SurrealDBStore`, `TimescaleVector`, `Vald`, `VDMS`, `Vearch`, `VespaStore`, `Weaviate`, `Yellowbrick`, `ZepVectorStore`, `TencentVectorDB`, `OpenSearchVectorSearch`.\n",
+    "Compatible Vectorstores: `Aerospike`, `AnalyticDB`, `AstraDB`, `AwaDB`, `Bagel`, `Cassandra`, `Chroma`, `CouchbaseVectorStore`, `DashVector`, `DatabricksVectorSearch`, `DeepLake`, `Dingo`, `ElasticVectorSearch`, `ElasticsearchStore`, `FAISS`, `HanaDB`, `Milvus`, `MyScale`, `OpenSearchVectorSearch`, `PGVector`, `Pinecone`, `Qdrant`, `Redis`, `Rockset`, `ScaNN`, `SupabaseVectorStore`, `SurrealDBStore`, `TimescaleVector`, `Vald`, `VDMS`, `Vearch`, `VespaStore`, `Weaviate`, `ZepVectorStore`, `TencentVectorDB`, `OpenSearchVectorSearch`.\n",
     "  \n",
     "## Caution\n",
     "\n",

docs/docs/how_to/llm_token_usage_tracking.ipynb

@@ -2,105 +2,119 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "90dff237-bc28-4185-a2c0-d5203bbdeacd",
+   "id": "e5715368",
    "metadata": {},
    "source": [
     "# How to track token usage for LLMs\n",
     "\n",
-    "Tracking token usage to calculate cost is an important part of putting your app in production. This guide goes over how to obtain this information from your LangChain model calls.\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",
-    ":::info Prerequisites\n",
-    "\n",
-    "This guide assumes familiarity with the following concepts:\n",
-    "\n",
-    "- [LLMs](/docs/concepts/#llms)\n",
-    ":::\n",
-    "\n",
-    "## Using LangSmith\n",
-    "\n",
-    "You can use [LangSmith](https://www.langchain.com/langsmith) to help track token usage in your LLM application. See the [LangSmith quick start guide](https://docs.smith.langchain.com/).\n",
-    "\n",
-    "## Using callbacks\n",
-    "\n",
-    "There are some API-specific callback context managers that allow you to track token usage across multiple calls. You'll need to check whether such an integration is available for your particular model.\n",
-    "\n",
-    "If such an integration is not available for your model, you can create a custom callback manager by adapting the implementation of the [OpenAI callback manager](https://api.python.langchain.com/en/latest/_modules/langchain_community/callbacks/openai_info.html#OpenAICallbackHandler).\n",
-    "\n",
-    "### OpenAI\n",
-    "\n",
-    "Let's first look at an extremely simple example of tracking token usage for a single Chat model call.\n",
-    "\n",
-    ":::{.callout-danger}\n",
-    "\n",
-    "The callback handler does not currently support streaming token counts for legacy language models (e.g., `langchain_openai.OpenAI`). For support in a streaming context, refer to the corresponding guide for chat models [here](/docs/how_to/chat_token_usage_tracking).\n",
-    "\n",
-    ":::"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f790edd9-823e-4bc5-befa-e9529c7237a0",
-   "metadata": {},
-   "source": [
-    "### Single call"
+    "Let's first look at an extremely simple example of tracking token usage for a single LLM call."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "2eebbee2-6ca1-4fa8-a3aa-0376888ceefb",
+   "id": "9455db35",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "Why don't scientists trust atoms?\n",
-      "\n",
-      "Because they make up everything.\n",
-      "---\n",
-      "\n",
-      "Total Tokens: 18\n",
-      "Prompt Tokens: 4\n",
-      "Completion Tokens: 14\n",
-      "Total Cost (USD): $3.4e-05\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from langchain_community.callbacks import get_openai_callback\n",
-    "from langchain_openai import OpenAI\n",
-    "\n",
-    "llm = OpenAI(model_name=\"gpt-3.5-turbo-instruct\")\n",
-    "\n",
-    "with get_openai_callback() as cb:\n",
-    "    result = llm.invoke(\"Tell me a joke\")\n",
-    "    print(result)\n",
-    "    print(\"---\")\n",
-    "print()\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": "7df3be35-dd97-4e3a-bd51-52434ab2249d",
-   "metadata": {},
-   "source": [
-    "### Multiple calls\n",
-    "\n",
-    "Anything inside the context manager will get tracked. Here's an example of using it to track multiple calls in sequence to a chain. This will also work for an agent which may use multiple steps."
+    "from langchain_openai import OpenAI"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "3ec10419-294c-44bf-af85-86aabf457cb6",
+   "id": "d1c55cc9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = OpenAI(model_name=\"gpt-3.5-turbo-instruct\", n=2, best_of=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "31667d54",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tokens Used: 37\n",
+      "\tPrompt Tokens: 4\n",
+      "\tCompletion Tokens: 33\n",
+      "Successful Requests: 1\n",
+      "Total Cost (USD): $7.2e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "with get_openai_callback() as cb:\n",
+    "    result = llm.invoke(\"Tell me a joke\")\n",
+    "    print(cb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c0ab6d27",
+   "metadata": {},
+   "source": [
+    "Anything inside the context manager will get tracked. Here's an example of using it to track multiple calls in sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e09420f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "72\n"
+     ]
+    }
+   ],
+   "source": [
+    "with get_openai_callback() as cb:\n",
+    "    result = llm.invoke(\"Tell me a joke\")\n",
+    "    result2 = llm.invoke(\"Tell me a joke\")\n",
+    "    print(cb.total_tokens)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8186e7b",
+   "metadata": {},
+   "source": [
+    "If a chain or agent with multiple steps in it is used, it will track all those steps."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5d1125c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import AgentType, initialize_agent, load_tools\n",
+    "from langchain_openai import OpenAI\n",
+    "\n",
+    "llm = OpenAI(temperature=0)\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",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2f98c536",
    "metadata": {},
    "outputs": [
     {
@@ -109,119 +123,48 @@
      "text": [
       "\n",
       "\n",
-      "Why did the chicken go to the seance?\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m I need to find out who Olivia Wilde's boyfriend is and then calculate his age raised to the 0.23 power.\n",
+      "Action: Search\n",
+      "Action Input: \"Olivia Wilde boyfriend\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3m[\"Olivia Wilde and Harry Styles took fans by surprise with their whirlwind romance, which began when they met on the set of Don't Worry Darling.\", 'Olivia Wilde started dating Harry Styles after ending her years-long engagement to Jason Sudeikis — see their relationship timeline.', 'Olivia Wilde and Harry Styles were spotted early on in their relationship walking around London. (. Image ...', \"Looks like Olivia Wilde and Jason Sudeikis are starting 2023 on good terms. Amid their highly publicized custody battle – and the actress' ...\", 'The two started dating after Wilde split up with actor Jason Sudeikisin 2020. However, their relationship came to an end last November.', \"Olivia Wilde and Harry Styles started dating during the filming of Don't Worry Darling. While the movie got a lot of backlash because of the ...\", \"Here's what we know so far about Harry Styles and Olivia Wilde's relationship.\", 'Olivia and the Grammy winner kept their romance out of the spotlight as their relationship began just two months after her split from ex-fiancé ...', \"Harry Styles and Olivia Wilde first met on the set of Don't Worry Darling and stepped out as a couple in January 2021. Relive all their biggest relationship ...\"]\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m Harry Styles is Olivia Wilde's boyfriend.\n",
+      "Action: Search\n",
+      "Action Input: \"Harry Styles age\"\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3m29 years\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I need to calculate 29 raised to the 0.23 power.\n",
+      "Action: Calculator\n",
+      "Action Input: 29^0.23\u001b[0m\n",
+      "Observation: \u001b[33;1m\u001b[1;3mAnswer: 2.169459462491557\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: Harry Styles is Olivia Wilde's boyfriend and his current age raised to the 0.23 power is 2.169459462491557.\u001b[0m\n",
       "\n",
-      "To talk to the other side of the road!\n",
-      "--\n",
-      "\n",
-      "\n",
-      "Why did the fish need a lawyer?\n",
-      "\n",
-      "Because it got caught in a net!\n",
-      "\n",
-      "---\n",
-      "Total Tokens: 50\n",
-      "Prompt Tokens: 12\n",
-      "Completion Tokens: 38\n",
-      "Total Cost (USD): $9.400000000000001e-05\n"
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "Total Tokens: 2205\n",
+      "Prompt Tokens: 2053\n",
+      "Completion Tokens: 152\n",
+      "Total Cost (USD): $0.0441\n"
      ]
     }
    ],
    "source": [
-    "from langchain_community.callbacks import get_openai_callback\n",
-    "from langchain_core.prompts import PromptTemplate\n",
-    "from langchain_openai import OpenAI\n",
-    "\n",
-    "llm = OpenAI(model_name=\"gpt-3.5-turbo-instruct\")\n",
-    "\n",
-    "template = PromptTemplate.from_template(\"Tell me a joke about {topic}\")\n",
-    "chain = template | llm\n",
-    "\n",
     "with get_openai_callback() as cb:\n",
-    "    response = chain.invoke({\"topic\": \"birds\"})\n",
-    "    print(response)\n",
-    "    response = chain.invoke({\"topic\": \"fish\"})\n",
-    "    print(\"--\")\n",
-    "    print(response)\n",
-    "\n",
-    "\n",
-    "print()\n",
-    "print(\"---\")\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": "ad7a3fba-9fac-4222-8f87-d1d276d27d6e",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "## Streaming\n",
-    "\n",
-    ":::{.callout-danger}\n",
-    "\n",
-    "`get_openai_callback` does not currently support streaming token counts for legacy language models (e.g., `langchain_openai.OpenAI`). If you want to count tokens correctly in a streaming context, there are a number of options:\n",
-    "\n",
-    "- Use chat models as described in [this guide](/docs/how_to/chat_token_usage_tracking);\n",
-    "- Implement a [custom callback handler](/docs/how_to/custom_callbacks/) that uses appropriate tokenizers to count the tokens;\n",
-    "- Use a monitoring platform such as [LangSmith](https://www.langchain.com/langsmith).\n",
-    ":::\n",
-    "\n",
-    "Note that when using legacy language models in a streaming context, token counts are not updated:"
+    "    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": "code",
-   "execution_count": 3,
-   "id": "cd61ed79-7858-49bb-afb5-d41291f597ba",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "Why don't scientists trust atoms?\n",
-      "\n",
-      "Because they make up everything!\n",
-      "\n",
-      "Why don't scientists trust atoms?\n",
-      "\n",
-      "Because they make up everything.\n",
-      "---\n",
-      "\n",
-      "Total Tokens: 0\n",
-      "Prompt Tokens: 0\n",
-      "Completion Tokens: 0\n",
-      "Total Cost (USD): $0.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain_community.callbacks import get_openai_callback\n",
-    "from langchain_openai import OpenAI\n",
-    "\n",
-    "llm = OpenAI(model_name=\"gpt-3.5-turbo-instruct\")\n",
-    "\n",
-    "with get_openai_callback() as cb:\n",
-    "    for chunk in llm.stream(\"Tell me a joke\"):\n",
-    "        print(chunk, end=\"\", flush=True)\n",
-    "    print(result)\n",
-    "    print(\"---\")\n",
-    "print()\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}\")"
-   ]
+   "execution_count": null,
+   "id": "80ca77a3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -240,7 +183,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/long_context_reorder.ipynb

@@ -5,38 +5,28 @@
    "id": "fc0db1bc",
    "metadata": {},
    "source": [
-    "# How to reorder retrieved results to mitigate the \"lost in the middle\" effect\n",
+    "# How to reorder retrieved results to put most relevant documents not in the middle\n",
     "\n",
-    "Substantial performance degradations in [RAG](/docs/tutorials/rag) applications have been [documented](https://arxiv.org/abs/2307.03172) as the number of retrieved documents grows (e.g., beyond ten). In brief: models are liable to miss relevant information in the middle of long contexts.\n",
+    "No matter the architecture of your model, there is a substantial performance degradation when you include 10+ retrieved documents.\n",
+    "In brief: When models must access relevant information in the middle of long contexts, they tend to ignore the provided documents.\n",
+    "See: https://arxiv.org/abs/2307.03172\n",
     "\n",
-    "By contrast, queries against vector stores will typically return documents in descending order of relevance (e.g., as measured by cosine similarity of [embeddings](/docs/concepts/#embedding-models)).\n",
-    "\n",
-    "To mitigate the [\"lost in the middle\"](https://arxiv.org/abs/2307.03172) effect, you can re-order documents after retrieval such that the most relevant documents are positioned at extrema (e.g., the first and last pieces of context), and the least relevant documents are positioned in the middle. In some cases this can help surface the most relevant information to LLMs.\n",
-    "\n",
-    "The [LongContextReorder](https://api.python.langchain.com/en/latest/document_transformers/langchain_community.document_transformers.long_context_reorder.LongContextReorder.html) document transformer implements this re-ordering procedure. Below we demonstrate an example."
+    "To avoid this issue you can re-order documents after retrieval to avoid performance degradation."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "2074fdaa-edff-468a-970f-6f5f26e93d4a",
+   "id": "74d1ebe8",
    "metadata": {},
    "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  sentence-transformers langchain-chroma langchain langchain-openai langchain-huggingface > /dev/null"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "c97eaaf2-34b7-4770-9949-e1abc4ca5226",
-   "metadata": {},
-   "source": [
-    "First we embed some artificial documents and index them in an (in-memory) [Chroma](/docs/integrations/providers/chroma/) vector store. We will use [Hugging Face](/docs/integrations/text_embedding/huggingfacehub/) embeddings, but any LangChain vector store or embeddings model will suffice."
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "49cbcd8e",
    "metadata": {},
    "outputs": [
@@ -55,14 +45,20 @@
        " Document(page_content='This is just a random text.')]"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "from langchain.chains import LLMChain, StuffDocumentsChain\n",
     "from langchain_chroma import Chroma\n",
+    "from langchain_community.document_transformers import (\n",
+    "    LongContextReorder,\n",
+    ")\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_huggingface import HuggingFaceEmbeddings\n",
+    "from langchain_openai import OpenAI\n",
     "\n",
     "# Get embeddings.\n",
     "embeddings = HuggingFaceEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
@@ -87,22 +83,14 @@
     "query = \"What can you tell me about the Celtics?\"\n",
     "\n",
     "# Get relevant documents ordered by relevance score\n",
-    "docs = retriever.invoke(query)\n",
+    "docs = retriever.get_relevant_documents(query)\n",
     "docs"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "175d031a-43fa-42f4-93c4-2ba52c3c3ee5",
-   "metadata": {},
-   "source": [
-    "Note that documents are returned in descending order of relevance to the query. The `LongContextReorder` document transformer will implement the re-ordering described above:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "9a1181f2-a3dc-4614-9233-2196ab65939e",
+   "execution_count": 4,
+   "id": "34fb9d6e",
    "metadata": {},
    "outputs": [
     {
@@ -120,14 +108,12 @@
        " Document(page_content='This is a document about the Boston Celtics')]"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "from langchain_community.document_transformers import LongContextReorder\n",
-    "\n",
     "# Reorder the documents:\n",
     "# Less relevant document will be at the middle of the list and more\n",
     "# relevant elements at beginning / end.\n",
@@ -138,55 +124,59 @@
     "reordered_docs"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "a8d2ef0c-c397-4d8d-8118-3f7acf86d241",
-   "metadata": {},
-   "source": [
-    "Below, we show how to incorporate the re-ordered documents into a simple question-answering chain:"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "8bbea705-d5b9-4ed5-9957-e12547283622",
+   "id": "ceccab87",
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "The Celtics are a professional basketball team and one of the most iconic franchises in the NBA. They are highly regarded and have a large fan base. The team has had many successful seasons and is often considered one of the top teams in the league. They have a strong history and have produced many great players, such as Larry Bird and L. Kornet. The team is based in Boston and is often referred to as the Boston Celtics.\n"
-     ]
+     "data": {
+      "text/plain": [
+       "'\\n\\nThe Celtics are referenced in four of the nine text extracts. They are mentioned as the favorite team of the author, the winner of a basketball game, a team with one of the best players, and a team with a specific player. Additionally, the last extract states that the document is about the Boston Celtics. This suggests that the Celtics are a basketball team, possibly from Boston, that is well-known and has had successful players and games in the past. '"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "from langchain.chains.combine_documents import create_stuff_documents_chain\n",
-    "from langchain_core.prompts import PromptTemplate\n",
-    "from langchain_openai import OpenAI\n",
+    "# We prepare and run a custom Stuff chain with reordered docs as context.\n",
     "\n",
+    "# Override prompts\n",
+    "document_prompt = PromptTemplate(\n",
+    "    input_variables=[\"page_content\"], template=\"{page_content}\"\n",
+    ")\n",
+    "document_variable_name = \"context\"\n",
     "llm = OpenAI()\n",
-    "\n",
-    "prompt_template = \"\"\"\n",
-    "Given these texts:\n",
+    "stuff_prompt_override = \"\"\"Given this text extracts:\n",
     "-----\n",
     "{context}\n",
     "-----\n",
     "Please answer the following question:\n",
-    "{query}\n",
-    "\"\"\"\n",
-    "\n",
+    "{query}\"\"\"\n",
     "prompt = PromptTemplate(\n",
-    "    template=prompt_template,\n",
-    "    input_variables=[\"context\", \"query\"],\n",
+    "    template=stuff_prompt_override, input_variables=[\"context\", \"query\"]\n",
     ")\n",
     "\n",
-    "# Create and invoke the chain:\n",
-    "chain = create_stuff_documents_chain(llm, prompt)\n",
-    "response = chain.invoke({\"context\": reordered_docs, \"query\": query})\n",
-    "print(response)"
+    "# Instantiate the chain\n",
+    "llm_chain = LLMChain(llm=llm, prompt=prompt)\n",
+    "chain = StuffDocumentsChain(\n",
+    "    llm_chain=llm_chain,\n",
+    "    document_prompt=document_prompt,\n",
+    "    document_variable_name=document_variable_name,\n",
+    ")\n",
+    "chain.run(input_documents=reordered_docs, query=query)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4696a97",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -205,7 +195,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/multi_vector.ipynb

@@ -5,36 +5,33 @@
    "id": "d9172545",
    "metadata": {},
    "source": [
-    "# How to retrieve using multiple vectors per document\n",
+    "# How to use the MultiVector Retriever\n",
     "\n",
-    "It can often be useful to store multiple vectors per document. There are multiple use cases where this is beneficial. For example, we can embed multiple chunks of a document and associate those embeddings with the parent document, allowing retriever hits on the chunks to return the larger document.\n",
-    "\n",
-    "LangChain implements a base [MultiVectorRetriever](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.multi_vector.MultiVectorRetriever.html), which simplifies this process. Much of the complexity lies in how to create the multiple vectors per document. This notebook covers some of the common ways to create those vectors and use the `MultiVectorRetriever`.\n",
+    "It can often be beneficial to store multiple vectors per document. There are multiple use cases where this is beneficial. LangChain has a base `MultiVectorRetriever` which makes querying this type of setup easy. A lot of the complexity lies in how to create the multiple vectors per document. This notebook covers some of the common ways to create those vectors and use the `MultiVectorRetriever`.\n",
     "\n",
     "The methods to create multiple vectors per document include:\n",
     "\n",
-    "- Smaller chunks: split a document into smaller chunks, and embed those (this is [ParentDocumentRetriever](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.parent_document_retriever.ParentDocumentRetriever.html)).\n",
+    "- Smaller chunks: split a document into smaller chunks, and embed those (this is ParentDocumentRetriever).\n",
     "- Summary: create a summary for each document, embed that along with (or instead of) the document.\n",
     "- Hypothetical questions: create hypothetical questions that each document would be appropriate to answer, embed those along with (or instead of) the document.\n",
     "\n",
-    "Note that this also enables another method of adding embeddings - manually. This is useful because you can explicitly add questions or queries that should lead to a document being recovered, giving you more control.\n",
     "\n",
-    "Below we walk through an example. First we instantiate some documents. We will index them in an (in-memory) [Chroma](/docs/integrations/providers/chroma/) vector store using [OpenAI](https://python.langchain.com/v0.2/docs/integrations/text_embedding/openai/) embeddings, but any LangChain vector store or embeddings model will suffice."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "09cecd95-3499-465a-895a-944627ffb77f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain-chroma langchain langchain-openai > /dev/null"
+    "Note that this also enables another method of adding embeddings - manually. This is great because you can explicitly add questions or queries that should lead to a document being recovered, giving you more control."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
+   "id": "eed469be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.retrievers.multi_vector import MultiVectorRetriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
    "id": "18c1421a",
    "metadata": {},
    "outputs": [],
@@ -43,22 +40,25 @@
     "from langchain_chroma import Chroma\n",
     "from langchain_community.document_loaders import TextLoader\n",
     "from langchain_openai import OpenAIEmbeddings\n",
-    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
-    "\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6d869496",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "loaders = [\n",
-    "    TextLoader(\"paul_graham_essay.txt\"),\n",
+    "    TextLoader(\"../../paul_graham_essay.txt\"),\n",
     "    TextLoader(\"state_of_the_union.txt\"),\n",
     "]\n",
     "docs = []\n",
     "for loader in loaders:\n",
     "    docs.extend(loader.load())\n",
     "text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000)\n",
-    "docs = text_splitter.split_documents(docs)\n",
-    "\n",
-    "# The vectorstore to use to index the child chunks\n",
-    "vectorstore = Chroma(\n",
-    "    collection_name=\"full_documents\", embedding_function=OpenAIEmbeddings()\n",
-    ")"
+    "docs = text_splitter.split_documents(docs)"
    ]
   },
   {
@@ -68,54 +68,52 @@
    "source": [
     "## Smaller chunks\n",
     "\n",
-    "Often times it can be useful to retrieve larger chunks of information, but embed smaller chunks. This allows for embeddings to capture the semantic meaning as closely as possible, but for as much context as possible to be passed downstream. Note that this is what the [ParentDocumentRetriever](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.parent_document_retriever.ParentDocumentRetriever.html) does. Here we show what is going on under the hood.\n",
-    "\n",
-    "We will make a distinction between the vector store, which indexes embeddings of the (sub) documents, and the document store, which houses the \"parent\" documents and associates them with an identifier."
+    "Often times it can be useful to retrieve larger chunks of information, but embed smaller chunks. This allows for embeddings to capture the semantic meaning as closely as possible, but for as much context as possible to be passed downstream. Note that this is what the `ParentDocumentRetriever` does. Here we show what is going on under the hood."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "id": "0e7b6b45",
    "metadata": {},
    "outputs": [],
    "source": [
-    "import uuid\n",
-    "\n",
-    "from langchain.retrievers.multi_vector import MultiVectorRetriever\n",
-    "\n",
+    "# The vectorstore to use to index the child chunks\n",
+    "vectorstore = Chroma(\n",
+    "    collection_name=\"full_documents\", embedding_function=OpenAIEmbeddings()\n",
+    ")\n",
     "# The storage layer for the parent documents\n",
     "store = InMemoryByteStore()\n",
     "id_key = \"doc_id\"\n",
-    "\n",
     "# The retriever (empty to start)\n",
     "retriever = MultiVectorRetriever(\n",
     "    vectorstore=vectorstore,\n",
     "    byte_store=store,\n",
     "    id_key=id_key,\n",
     ")\n",
+    "import uuid\n",
     "\n",
     "doc_ids = [str(uuid.uuid4()) for _ in docs]"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "d4feded4-856a-4282-91c3-53aabc62e6ff",
-   "metadata": {},
-   "source": [
-    "We next generate the \"sub\" documents by splitting the original documents. Note that we store the document identifier in the `metadata` of the corresponding [Document](https://api.python.langchain.com/en/latest/documents/langchain_core.documents.base.Document.html) object."
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "5d23247d",
+   "execution_count": 5,
+   "id": "72a36491",
    "metadata": {},
    "outputs": [],
    "source": [
     "# The splitter to use to create smaller chunks\n",
-    "child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)\n",
-    "\n",
+    "child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5d23247d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "sub_docs = []\n",
     "for i, doc in enumerate(docs):\n",
     "    _id = doc_ids[i]\n",
@@ -125,17 +123,9 @@
     "    sub_docs.extend(_sub_docs)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "8e0634f8-90d5-4250-981a-5257c8a6d455",
-   "metadata": {},
-   "source": [
-    "Finally, we index the documents in our vector store and document store:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "id": "92ed5861",
    "metadata": {},
    "outputs": [],
@@ -144,46 +134,31 @@
     "retriever.docstore.mset(list(zip(doc_ids, docs)))"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "14c48c6d-850c-4317-9b6e-1ade92f2f710",
-   "metadata": {},
-   "source": [
-    "The vector store alone will retrieve small chunks:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 8,
    "id": "8afed60c",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Document(page_content='Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.', metadata={'doc_id': '064eca46-a4c4-4789-8e3b-583f9597e54f', 'source': 'state_of_the_union.txt'})"
+       "Document(page_content='Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \\n\\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.', metadata={'doc_id': '2fd77862-9ed5-4fad-bf76-e487b747b333', 'source': 'state_of_the_union.txt'})"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "# Vectorstore alone retrieves the small chunks\n",
     "retriever.vectorstore.similarity_search(\"justice breyer\")[0]"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "717097c7-61d9-4306-8625-ef8f1940c127",
-   "metadata": {},
-   "source": [
-    "Whereas the retriever will return the larger parent document:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "id": "3c9017f1",
    "metadata": {},
    "outputs": [
@@ -193,13 +168,14 @@
        "9875"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "len(retriever.invoke(\"justice breyer\")[0].page_content)"
+    "# Retriever returns larger chunks\n",
+    "len(retriever.get_relevant_documents(\"justice breyer\")[0].page_content)"
    ]
   },
   {
@@ -207,12 +183,12 @@
    "id": "cdef8339-f9fa-4b3b-955f-ad9dbdf2734f",
    "metadata": {},
    "source": [
-    "The default search type the retriever performs on the vector database is a similarity search. LangChain vector stores also support searching via [Max Marginal Relevance](https://api.python.langchain.com/en/latest/vectorstores/langchain_core.vectorstores.VectorStore.html#langchain_core.vectorstores.VectorStore.max_marginal_relevance_search). This can be controlled via the `search_type` parameter of the retriever:"
+    "The default search type the retriever performs on the vector database is a similarity search. LangChain Vector Stores also support searching via [Max Marginal Relevance](https://api.python.langchain.com/en/latest/vectorstores/langchain_core.vectorstores.VectorStore.html#langchain_core.vectorstores.VectorStore.max_marginal_relevance_search) so if you want this instead you can just set the `search_type` property as follows:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
    "id": "36739460-a737-4a8e-b70f-50bf8c8eaae7",
    "metadata": {},
    "outputs": [
@@ -222,7 +198,7 @@
        "9875"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -232,7 +208,7 @@
     "\n",
     "retriever.search_type = SearchType.mmr\n",
     "\n",
-    "len(retriever.invoke(\"justice breyer\")[0].page_content)"
+    "len(retriever.get_relevant_documents(\"justice breyer\")[0].page_content)"
    ]
   },
   {
@@ -240,37 +216,14 @@
    "id": "d6a7ae0d",
    "metadata": {},
    "source": [
-    "## Associating summaries with a document for retrieval\n",
+    "## Summary\n",
     "\n",
-    "A summary may be able to distill more accurately what a chunk is about, leading to better retrieval. Here we show how to create summaries, and then embed those.\n",
-    "\n",
-    "We construct a simple [chain](/docs/how_to/sequence) that will receive an input [Document](https://api.python.langchain.com/en/latest/documents/langchain_core.documents.base.Document.html) object and generate a summary using a LLM.\n",
-    "\n",
-    "```{=mdx}\n",
-    "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
-    "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "Oftentimes a summary may be able to distill more accurately what a chunk is about, leading to better retrieval. Here we show how to create summaries, and then embed those."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "6589291f-55bb-4e9a-b4ff-08f2506ed641",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# | output: false\n",
-    "# | echo: false\n",
-    "\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "llm = ChatOpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 11,
    "id": "1433dff4",
    "metadata": {},
    "outputs": [],
@@ -280,26 +233,27 @@
     "from langchain_core.documents import Document\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
-    "\n",
+    "from langchain_openai import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "35b30390",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "chain = (\n",
     "    {\"doc\": lambda x: x.page_content}\n",
     "    | ChatPromptTemplate.from_template(\"Summarize the following document:\\n\\n{doc}\")\n",
-    "    | llm\n",
+    "    | ChatOpenAI(max_retries=0)\n",
     "    | StrOutputParser()\n",
     ")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "3faa9fde-1b09-4849-a815-8b2e89c30a02",
-   "metadata": {},
-   "source": [
-    "Note that we can [batch](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable) the chain accross documents:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 13,
    "id": "41a2a738",
    "metadata": {},
    "outputs": [],
@@ -307,17 +261,9 @@
     "summaries = chain.batch(docs, {\"max_concurrency\": 5})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "73ef599e-140b-4905-8b62-6c52cdde1852",
-   "metadata": {},
-   "source": [
-    "We can then initialize a `MultiVectorRetriever` as before, indexing the summaries in our vector store, and retaining the original documents in our document store:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 14,
    "id": "7ac5e4b1",
    "metadata": {},
    "outputs": [],
@@ -333,13 +279,29 @@
     "    byte_store=store,\n",
     "    id_key=id_key,\n",
     ")\n",
-    "doc_ids = [str(uuid.uuid4()) for _ in docs]\n",
-    "\n",
+    "doc_ids = [str(uuid.uuid4()) for _ in docs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "0d93309f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "summary_docs = [\n",
     "    Document(page_content=s, metadata={id_key: doc_ids[i]})\n",
     "    for i, s in enumerate(summaries)\n",
-    "]\n",
-    "\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "6d5edf0d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "retriever.vectorstore.add_documents(summary_docs)\n",
     "retriever.docstore.mset(list(zip(doc_ids, docs)))"
    ]
@@ -358,48 +320,50 @@
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "f0274892-29c1-4616-9040-d23f9d537526",
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "299232d6",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "Querying the vector store will return summaries:"
+    "sub_docs = vectorstore.similarity_search(\"justice breyer\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "299232d6",
+   "execution_count": 19,
+   "id": "10e404c0",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Document(page_content=\"President Biden recently nominated Judge Ketanji Brown Jackson to serve on the United States Supreme Court, emphasizing her qualifications and broad support. The President also outlined a plan to secure the border, fix the immigration system, protect women's rights, support LGBTQ+ Americans, and advance mental health services. He highlighted the importance of bipartisan unity in passing legislation, such as the Violence Against Women Act. The President also addressed supporting veterans, particularly those impacted by exposure to burn pits, and announced plans to expand benefits for veterans with respiratory cancers. Additionally, he proposed a plan to end cancer as we know it through the Cancer Moonshot initiative. President Biden expressed optimism about the future of America and emphasized the strength of the American people in overcoming challenges.\", metadata={'doc_id': '84015b1b-980e-400a-94d8-cf95d7e079bd'})"
+       "Document(page_content=\"The document is a speech given by President Biden addressing various issues and outlining his agenda for the nation. He highlights the importance of nominating a Supreme Court justice and introduces his nominee, Judge Ketanji Brown Jackson. He emphasizes the need to secure the border and reform the immigration system, including providing a pathway to citizenship for Dreamers and essential workers. The President also discusses the protection of women's rights, including access to healthcare and the right to choose. He calls for the passage of the Equality Act to protect LGBTQ+ rights. Additionally, President Biden discusses the need to address the opioid epidemic, improve mental health services, support veterans, and fight against cancer. He expresses optimism for the future of America and the strength of the American people.\", metadata={'doc_id': '56345bff-3ead-418c-a4ff-dff203f77474'})"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "sub_docs = retriever.vectorstore.similarity_search(\"justice breyer\")\n",
-    "\n",
     "sub_docs[0]"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "e4f77ac5-2926-4f60-aad5-b2067900dff9",
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "e4cce5c2",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "Whereas the retriever will return the larger source document:"
+    "retrieved_docs = retriever.get_relevant_documents(\"justice breyer\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "e4cce5c2",
+   "execution_count": 21,
+   "id": "c8570dbb",
    "metadata": {},
    "outputs": [
     {
@@ -408,14 +372,12 @@
        "9194"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "retrieved_docs = retriever.invoke(\"justice breyer\")\n",
-    "\n",
     "len(retrieved_docs[0].page_content)"
    ]
   },
@@ -426,28 +388,42 @@
    "source": [
     "## Hypothetical Queries\n",
     "\n",
-    "An LLM can also be used to generate a list of hypothetical questions that could be asked of a particular document, which might bear close semantic similarity to relevant queries in a [RAG](/docs/tutorials/rag) application. These questions can then be embedded and associated with the documents to improve retrieval.\n",
-    "\n",
-    "Below, we use the [with_structured_output](/docs/how_to/structured_output/) method to structure the LLM output into a list of strings."
+    "An LLM can also be used to generate a list of hypothetical questions that could be asked of a particular document. These questions can then be embedded"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "id": "03d85234-c33a-4a43-861d-47328e1ec2ea",
+   "execution_count": 22,
+   "id": "5219b085",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from typing import List\n",
-    "\n",
-    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
-    "\n",
-    "\n",
-    "class HypotheticalQuestions(BaseModel):\n",
-    "    \"\"\"Generate hypothetical questions.\"\"\"\n",
-    "\n",
-    "    questions: List[str] = Field(..., description=\"List of questions\")\n",
-    "\n",
+    "functions = [\n",
+    "    {\n",
+    "        \"name\": \"hypothetical_questions\",\n",
+    "        \"description\": \"Generate hypothetical questions\",\n",
+    "        \"parameters\": {\n",
+    "            \"type\": \"object\",\n",
+    "            \"properties\": {\n",
+    "                \"questions\": {\n",
+    "                    \"type\": \"array\",\n",
+    "                    \"items\": {\"type\": \"string\"},\n",
+    "                },\n",
+    "            },\n",
+    "            \"required\": [\"questions\"],\n",
+    "        },\n",
+    "    }\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "523deb92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers.openai_functions import JsonKeyOutputFunctionsParser\n",
     "\n",
     "chain = (\n",
     "    {\"doc\": lambda x: x.page_content}\n",
@@ -455,36 +431,28 @@
     "    | ChatPromptTemplate.from_template(\n",
     "        \"Generate a list of exactly 3 hypothetical questions that the below document could be used to answer:\\n\\n{doc}\"\n",
     "    )\n",
-    "    | ChatOpenAI(max_retries=0, model=\"gpt-4o\").with_structured_output(\n",
-    "        HypotheticalQuestions\n",
+    "    | ChatOpenAI(max_retries=0, model=\"gpt-4\").bind(\n",
+    "        functions=functions, function_call={\"name\": \"hypothetical_questions\"}\n",
     "    )\n",
-    "    | (lambda x: x.questions)\n",
+    "    | JsonKeyOutputFunctionsParser(key_name=\"questions\")\n",
     ")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "6dddc40f-62af-413c-b944-f94a5e1f2f4e",
-   "metadata": {},
-   "source": [
-    "Invoking the chain on a single document demonstrates that it outputs a list of questions:"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 24,
    "id": "11d30554",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[\"What impact did the IBM 1401 have on the author's early programming experiences?\",\n",
-       " \"How did the transition from using the IBM 1401 to microcomputers influence the author's programming journey?\",\n",
-       " \"What role did Lisp play in shaping the author's understanding and approach to AI?\"]"
+       "[\"What was the author's first experience with programming like?\",\n",
+       " 'Why did the author switch their focus from AI to Lisp during their graduate studies?',\n",
+       " 'What led the author to contemplate a career in art instead of computer science?']"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -494,24 +462,22 @@
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "dcffc572-7b20-4b77-857a-90ec360a8f7e",
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "3eb2e48c",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "We can batch then batch the chain over all documents and assemble our vector store and document store as before:"
+    "hypothetical_questions = chain.batch(docs, {\"max_concurrency\": 5})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 26,
    "id": "b2cd6e75",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Batch chain over documents to generate hypothetical questions\n",
-    "hypothetical_questions = chain.batch(docs, {\"max_concurrency\": 5})\n",
-    "\n",
-    "\n",
     "# The vectorstore to use to index the child chunks\n",
     "vectorstore = Chroma(\n",
     "    collection_name=\"hypo-questions\", embedding_function=OpenAIEmbeddings()\n",
@@ -525,67 +491,82 @@
     "    byte_store=store,\n",
     "    id_key=id_key,\n",
     ")\n",
-    "doc_ids = [str(uuid.uuid4()) for _ in docs]\n",
-    "\n",
-    "\n",
-    "# Generate Document objects from hypothetical questions\n",
+    "doc_ids = [str(uuid.uuid4()) for _ in docs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "18831b3b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "question_docs = []\n",
     "for i, question_list in enumerate(hypothetical_questions):\n",
     "    question_docs.extend(\n",
     "        [Document(page_content=s, metadata={id_key: doc_ids[i]}) for s in question_list]\n",
-    "    )\n",
-    "\n",
-    "\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "224b24c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "retriever.vectorstore.add_documents(question_docs)\n",
     "retriever.docstore.mset(list(zip(doc_ids, docs)))"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "75cba8ab-a06f-4545-85fc-cf49d0204b5e",
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "7b442b90",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "Note that querying the underlying vector store will retrieve hypothetical questions that are semantically similar to the input query:"
+    "sub_docs = vectorstore.similarity_search(\"justice breyer\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "id": "7b442b90",
+   "execution_count": 30,
+   "id": "089b5ad0",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[Document(page_content='What might be the potential benefits of nominating Circuit Court of Appeals Judge Ketanji Brown Jackson to the United States Supreme Court?', metadata={'doc_id': '43292b74-d1b8-4200-8a8b-ea0cb57fbcdb'}),\n",
-       " Document(page_content='How might the Bipartisan Infrastructure Law impact the economic competition between the U.S. and China?', metadata={'doc_id': '66174780-d00c-4166-9791-f0069846e734'}),\n",
-       " Document(page_content='What factors led to the creation of Y Combinator?', metadata={'doc_id': '72003c4e-4cc9-4f09-a787-0b541a65b38c'}),\n",
-       " Document(page_content='How did the ability to publish essays online change the landscape for writers and thinkers?', metadata={'doc_id': 'e8d2c648-f245-4bcc-b8d3-14e64a164b64'})]"
+       "[Document(page_content='Who has been nominated to serve on the United States Supreme Court?', metadata={'doc_id': '0b3a349e-c936-4e77-9c40-0a39fc3e07f0'}),\n",
+       " Document(page_content=\"What was the context and content of Robert Morris' advice to the document's author in 2010?\", metadata={'doc_id': 'b2b2cdca-988a-4af1-ba47-46170770bc8c'}),\n",
+       " Document(page_content='How did personal circumstances influence the decision to pass on the leadership of Y Combinator?', metadata={'doc_id': 'b2b2cdca-988a-4af1-ba47-46170770bc8c'}),\n",
+       " Document(page_content='What were the reasons for the author leaving Yahoo in the summer of 1999?', metadata={'doc_id': 'ce4f4981-ca60-4f56-86f0-89466de62325'})]"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "sub_docs = retriever.vectorstore.similarity_search(\"justice breyer\")\n",
-    "\n",
     "sub_docs"
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "63c32e43-5f4a-463b-a0c2-2101986f70e6",
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "7594b24e",
    "metadata": {},
+   "outputs": [],
    "source": [
-    "And invoking the retriever will return the corresponding document:"
+    "retrieved_docs = retriever.get_relevant_documents(\"justice breyer\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "id": "7594b24e",
+   "execution_count": 32,
+   "id": "4c120c65",
    "metadata": {},
    "outputs": [
     {
@@ -594,15 +575,22 @@
        "9194"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 32,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "retrieved_docs = retriever.invoke(\"justice breyer\")\n",
     "len(retrieved_docs[0].page_content)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "005072b8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -621,7 +609,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.4"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/multimodal_inputs.ipynb

@@ -220,7 +220,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/output_parser_structured.ipynb

@@ -94,7 +94,7 @@
    "source": [
     "## LCEL\n",
     "\n",
-    "Output parsers implement the [Runnable interface](/docs/concepts#interface), the basic building block of the [LangChain Expression Language (LCEL)](/docs/concepts#langchain-expression-language-lcel). This means they support `invoke`, `ainvoke`, `stream`, `astream`, `batch`, `abatch`, `astream_log` calls.\n",
+    "Output parsers implement the [Runnable interface](/docs/concepts#interface), the basic building block of the [LangChain Expression Language (LCEL)](/docs/concepts#langchain-expression-language). This means they support `invoke`, `ainvoke`, `stream`, `astream`, `batch`, `abatch`, `astream_log` calls.\n",
     "\n",
     "Output parsers accept a string or `BaseMessage` as input and can return an arbitrary type."
    ]

docs/docs/how_to/qa_chat_history_how_to.ipynb

@@ -36,13 +36,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "ede7fdc0-ef31-483d-bd67-32e4b5c5d527",
    "metadata": {},
    "outputs": [],
    "source": [
-    "%%capture --no-stderr\n",
-    "%pip install --upgrade --quiet  langchain langchain-community langchain-chroma bs4"
+    "%pip install --upgrade --quiet  langchain langchain-community langchainhub langchain-chroma bs4"
    ]
   },
   {
@@ -55,7 +54,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "143787ca-d8e6-4dc9-8281-4374f4d71720",
    "metadata": {},
    "outputs": [],
@@ -63,8 +62,7 @@
     "import getpass\n",
     "import os\n",
     "\n",
-    "if not os.environ.get(\"OPENAI_API_KEY\"):\n",
-    "    os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()\n",
+    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()\n",
     "\n",
     "# import dotenv\n",
     "\n",
@@ -85,14 +83,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "07411adb-3722-4f65-ab7f-8f6f57663d11",
    "metadata": {},
    "outputs": [],
    "source": [
     "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
-    "if not os.environ.get(\"LANGCHAIN_API_KEY\"):\n",
-    "    os.environ[\"LANGCHAIN_API_KEY\"] = getpass.getpass()"
+    "os.environ[\"LANGCHAIN_API_KEY\"] = getpass.getpass()"
    ]
   },
   {
@@ -129,7 +126,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 1,
    "id": "cb58f273-2111-4a9b-8932-9b64c95030c8",
    "metadata": {},
    "outputs": [],
@@ -160,12 +157,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "id": "820244ae-74b4-4593-b392-822979dd91b8",
    "metadata": {},
    "outputs": [],
    "source": [
     "import bs4\n",
+    "from langchain import hub\n",
     "from langchain.chains import create_retrieval_chain\n",
     "from langchain.chains.combine_documents import create_stuff_documents_chain\n",
     "from langchain_chroma import Chroma\n",
@@ -204,7 +202,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "id": "2b685428-8b82-4af1-be4f-7232c5d55b73",
    "metadata": {},
    "outputs": [],
@@ -241,7 +239,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "id": "4c4b1695-6217-4ee8-abaf-7cc26366d988",
    "metadata": {},
    "outputs": [],
@@ -267,7 +265,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 5,
    "id": "afef4385-f571-4874-8f52-3d475642f579",
    "metadata": {},
    "outputs": [],
@@ -316,7 +314,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 6,
    "id": "9c3fb176-8d6a-4dc7-8408-6a22c5f7cc72",
    "metadata": {},
    "outputs": [],
@@ -345,17 +343,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "id": "1046c92f-21b3-4214-907d-92878d8cba23",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable and easier to accomplish. This process can be done using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Task decomposition can be facilitated by providing simple prompts to a language model, task-specific instructions, or human inputs.'"
+       "'Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable and easier to accomplish. This process can be done using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in thinking step by step or exploring multiple reasoning possibilities at each step. Task decomposition can be facilitated by providing simple prompts to a language model, task-specific instructions, or human inputs.'"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -371,17 +369,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 8,
    "id": "0e89c75f-7ad7-4331-a2fe-57579eb8f840",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'Task decomposition can be achieved through various methods, including using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Common ways of task decomposition include providing simple prompts to a language model, task-specific instructions, or human inputs to break down complex tasks into smaller and more manageable steps. Additionally, task decomposition can involve utilizing resources like internet access for information gathering, long-term memory management, and GPT-3.5 powered agents for delegation of simple tasks.'"
+       "'Task decomposition can be achieved through various methods, including using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down complex tasks into smaller steps. Common ways of task decomposition include providing simple prompts to a language model, task-specific instructions tailored to the specific task at hand, or incorporating human inputs to guide the decomposition process effectively.'"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -403,7 +401,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 10,
    "id": "7686b874-3a85-499f-82b5-28a85c4c768c",
    "metadata": {},
    "outputs": [
@@ -413,11 +411,11 @@
      "text": [
       "User: What is Task Decomposition?\n",
       "\n",
-      "AI: Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable and easier to accomplish. This process can be done using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Task decomposition can be facilitated by providing simple prompts to a language model, task-specific instructions, or human inputs.\n",
+      "AI: Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable and easier to accomplish. This process can be done using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in thinking step by step or exploring multiple reasoning possibilities at each step. Task decomposition can be facilitated by providing simple prompts to a language model, task-specific instructions, or human inputs.\n",
       "\n",
       "User: What are common ways of doing it?\n",
       "\n",
-      "AI: Task decomposition can be achieved through various methods, including using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down tasks effectively. Common ways of task decomposition include providing simple prompts to a language model, task-specific instructions, or human inputs to break down complex tasks into smaller and more manageable steps. Additionally, task decomposition can involve utilizing resources like internet access for information gathering, long-term memory management, and GPT-3.5 powered agents for delegation of simple tasks.\n",
+      "AI: Task decomposition can be achieved through various methods, including using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide the model in breaking down complex tasks into smaller steps. Common ways of task decomposition include providing simple prompts to a language model, task-specific instructions tailored to the specific task at hand, or incorporating human inputs to guide the decomposition process effectively.\n",
       "\n"
      ]
     }
@@ -454,7 +452,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 1,
    "id": "71c32048-1a41-465f-a9e2-c4affc332fd9",
    "metadata": {},
    "outputs": [],
@@ -554,17 +552,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 2,
    "id": "6d0a7a73-d151-47d9-9e99-b4f3291c0322",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable. Techniques like Chain of Thought (CoT) and Tree of Thoughts help in decomposing hard tasks into multiple manageable tasks by instructing models to think step by step and explore multiple reasoning possibilities at each step. Task decomposition can be achieved through various methods such as using prompting techniques, task-specific instructions, or human inputs.'"
+       "'Task decomposition involves breaking down a complex task into smaller and simpler steps to make it more manageable. This process helps agents or models tackle difficult tasks by dividing them into more easily achievable subgoals. Task decomposition can be done through techniques like Chain of Thought or Tree of Thoughts, which guide the model in thinking step by step or exploring multiple reasoning possibilities at each step.'"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -580,17 +578,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 3,
    "id": "17021822-896a-4513-a17d-1d20b1c5381c",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'Task decomposition can be done in common ways such as using prompting techniques like Chain of Thought (CoT) or Tree of Thoughts, which instruct models to think step by step and explore multiple reasoning possibilities at each step. Another way is to provide task-specific instructions, such as asking to \"Write a story outline\" for writing a novel, to guide the decomposition process. Additionally, task decomposition can also involve human inputs to break down complex tasks into smaller and simpler steps.'"
+       "\"Common ways of task decomposition include using techniques like Chain of Thought (CoT) or Tree of Thoughts to guide models in breaking down complex tasks into smaller steps. This can be achieved through simple prompting with LLMs, task-specific instructions, or human inputs to help the model understand and navigate the task effectively. Task decomposition aims to enhance model performance on complex tasks by utilizing more test-time computation and shedding light on the model's thinking process.\""
       ]
      },
-     "execution_count": 15,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -620,7 +618,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 2,
    "id": "809cc747-2135-40a2-8e73-e4556343ee64",
    "metadata": {},
    "outputs": [],
@@ -648,14 +646,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 3,
    "id": "1726d151-4653-4c72-a187-a14840add526",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langgraph.prebuilt import create_react_agent\n",
+    "from langgraph.prebuilt import chat_agent_executor\n",
     "\n",
-    "agent_executor = create_react_agent(llm, tools)"
+    "agent_executor = chat_agent_executor.create_tool_calling_executor(llm, tools)"
    ]
   },
   {
@@ -668,26 +666,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 5,
    "id": "52ae46d9-43f7-481b-96d5-df750be3ad65",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in LangChainTracer.on_tool_end callback: TracerException(\"Found chain run at ID 5cd28d13-88dd-4eac-a465-3770ac27eff6, but expected {'tool'} run.\")\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_TbhPPPN05GKi36HLeaN4QM90', 'function': {'arguments': '{\"query\":\"Task Decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 68, 'total_tokens': 87}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-2e60d910-879a-4a2a-b1e9-6a6c5c7d7ebc-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Task Decomposition'}, 'id': 'call_TbhPPPN05GKi36HLeaN4QM90'}])]}}\n",
+      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_wxRrUmNbaNny8wh9JIb5uCRB', 'function': {'arguments': '{\"query\":\"Task Decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 68, 'total_tokens': 87}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-57ee0d12-6142-4957-a002-cce0093efe07-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Task Decomposition'}, 'id': 'call_wxRrUmNbaNny8wh9JIb5uCRB'}])]}}\n",
       "----\n",
-      "{'tools': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.', name='blog_post_retriever', tool_call_id='call_TbhPPPN05GKi36HLeaN4QM90')]}}\n",
+      "{'action': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\n(3) Task execution: Expert models execute on the specific tasks and log results.\\nInstruction:\\n\\nWith the input and the inference results, the AI assistant needs to describe the process and results. The previous stages can be formed as - User Input: {{ User Input }}, Task Planning: {{ Tasks }}, Model Selection: {{ Model Assignment }}, Task Execution: {{ Predictions }}. You must first answer the user\\'s request in a straightforward manner. Then describe the task process and show your analysis and model inference results to the user in the first person. If inference results contain a file path, must tell the user the complete file path.\\n\\nFig. 11. Illustration of how HuggingGPT works. (Image source: Shen et al. 2023)\\nThe system comprises of 4 stages:\\n(1) Task planning: LLM works as the brain and parses the user requests into multiple tasks. There are four attributes associated with each task: task type, ID, dependencies, and arguments. They use few-shot examples to guide LLM to do task parsing and planning.\\nInstruction:', name='blog_post_retriever', id='9c3a17f7-653c-47fa-b4e4-fa3d8d24c85d', tool_call_id='call_wxRrUmNbaNny8wh9JIb5uCRB')]}}\n",
       "----\n",
-      "{'agent': {'messages': [AIMessage(content='Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This approach helps in transforming big tasks into multiple manageable tasks, making it easier for autonomous agents to handle and interpret the thinking process. One common method for task decomposition is the Chain of Thought (CoT) technique, where models are instructed to \"think step by step\" to decompose hard tasks. Another extension of CoT is the Tree of Thoughts, which explores multiple reasoning possibilities at each step by creating a tree structure of multiple thoughts per step. Task decomposition can be facilitated through various methods such as using simple prompts, task-specific instructions, or human inputs.', response_metadata={'token_usage': {'completion_tokens': 130, 'prompt_tokens': 636, 'total_tokens': 766}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-3ef17638-65df-4030-a7fe-795e6da91c69-0')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This approach helps agents in planning and executing tasks more effectively. One common method for task decomposition is the Chain of Thought (CoT) technique, where models are instructed to think step by step to decompose hard tasks into manageable steps. Another extension of CoT is the Tree of Thoughts, which explores multiple reasoning possibilities at each step by creating a tree structure of thought steps.\\n\\nTask decomposition can be achieved through various methods, such as using language models with simple prompting, task-specific instructions, or human inputs. By breaking down tasks into smaller components, agents can better plan and execute tasks efficiently.\\n\\nIf you would like more detailed information or examples on task decomposition, feel free to ask!', response_metadata={'token_usage': {'completion_tokens': 154, 'prompt_tokens': 588, 'total_tokens': 742}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}, id='run-8991fa20-c527-4f9e-a058-fc6264fe6259-0')]}}\n",
       "----\n"
      ]
     }
@@ -716,7 +707,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "837a401e-9757-4d0e-a0da-24fa097d887e",
    "metadata": {},
    "outputs": [],
@@ -725,7 +716,9 @@
     "\n",
     "memory = SqliteSaver.from_conn_string(\":memory:\")\n",
     "\n",
-    "agent_executor = create_react_agent(llm, tools, checkpointer=memory)"
+    "agent_executor = chat_agent_executor.create_tool_calling_executor(\n",
+    "    llm, tools, checkpointer=memory\n",
+    ")"
    ]
   },
   {
@@ -740,7 +733,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 22,
    "id": "d6d70833-b958-4cd7-9e27-29c1c08bb1b8",
    "metadata": {},
    "outputs": [
@@ -748,7 +741,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='Hello Bob! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 67, 'total_tokens': 78}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-1cd17562-18aa-4839-b41b-403b17a0fc20-0')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='Hello Bob! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 67, 'total_tokens': 78}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}, id='run-1451e59b-b135-4776-985d-4759338ffee5-0')]}}\n",
       "----\n"
      ]
     }
@@ -773,26 +766,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 23,
    "id": "e2c570ae-dd91-402c-8693-ae746de63b16",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in LangChainTracer.on_tool_end callback: TracerException(\"Found chain run at ID c54381c0-c5d9-495a-91a0-aca4ae755663, but expected {'tool'} run.\")\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_rg7zKTE5e0ICxVSslJ1u9LMg', 'function': {'arguments': '{\"query\":\"Task Decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 91, 'total_tokens': 110}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-122bf097-7ff1-49aa-b430-e362b51354ad-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Task Decomposition'}, 'id': 'call_rg7zKTE5e0ICxVSslJ1u9LMg'}])]}}\n",
+      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_ab2x4iUPSWDAHS5txL7PspSK', 'function': {'arguments': '{\"query\":\"Task Decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 19, 'prompt_tokens': 91, 'total_tokens': 110}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-f76b5813-b41c-4d0d-9ed2-667b988d885e-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Task Decomposition'}, 'id': 'call_ab2x4iUPSWDAHS5txL7PspSK'}])]}}\n",
       "----\n",
-      "{'tools': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.', name='blog_post_retriever', tool_call_id='call_rg7zKTE5e0ICxVSslJ1u9LMg')]}}\n",
+      "{'action': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\n(3) Task execution: Expert models execute on the specific tasks and log results.\\nInstruction:\\n\\nWith the input and the inference results, the AI assistant needs to describe the process and results. The previous stages can be formed as - User Input: {{ User Input }}, Task Planning: {{ Tasks }}, Model Selection: {{ Model Assignment }}, Task Execution: {{ Predictions }}. You must first answer the user\\'s request in a straightforward manner. Then describe the task process and show your analysis and model inference results to the user in the first person. If inference results contain a file path, must tell the user the complete file path.\\n\\nFig. 11. Illustration of how HuggingGPT works. (Image source: Shen et al. 2023)\\nThe system comprises of 4 stages:\\n(1) Task planning: LLM works as the brain and parses the user requests into multiple tasks. There are four attributes associated with each task: task type, ID, dependencies, and arguments. They use few-shot examples to guide LLM to do task parsing and planning.\\nInstruction:', name='blog_post_retriever', id='e0895fa5-5d41-4be0-98db-10a83d42fc2f', tool_call_id='call_ab2x4iUPSWDAHS5txL7PspSK')]}}\n",
       "----\n",
-      "{'agent': {'messages': [AIMessage(content='Task decomposition is a technique used to break down complex tasks into smaller and simpler steps. This approach helps in managing and solving intricate problems by dividing them into more manageable components. By decomposing tasks, agents or models can better understand the steps involved and plan their actions accordingly. Techniques like Chain of Thought (CoT) and Tree of Thoughts are examples of methods that enhance model performance on complex tasks by breaking them down into smaller steps.', response_metadata={'token_usage': {'completion_tokens': 87, 'prompt_tokens': 659, 'total_tokens': 746}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-b9166386-83e5-4b82-9a4b-590e5fa76671-0')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='Task decomposition is a technique used in complex tasks where the task is broken down into smaller and simpler steps. This approach helps in managing and solving difficult tasks by dividing them into more manageable components. One common method for task decomposition is the Chain of Thought (CoT) technique, which prompts the model to think step by step and decompose hard tasks into smaller steps. Another extension of CoT is the Tree of Thoughts, which explores multiple reasoning possibilities at each step by creating a tree structure of thought steps.\\n\\nTask decomposition can be achieved through various methods, such as using language models with simple prompting, task-specific instructions, or human inputs. By breaking down tasks into smaller components, agents can better plan and execute complex tasks effectively.\\n\\nIf you would like more detailed information or examples related to task decomposition, feel free to ask!', response_metadata={'token_usage': {'completion_tokens': 165, 'prompt_tokens': 611, 'total_tokens': 776}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}, id='run-13296566-8577-4d65-982b-a39718988ca3-0')]}}\n",
       "----\n"
      ]
     }
@@ -819,7 +805,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 25,
    "id": "570d8c68-136e-4ba5-969a-03ba195f6118",
    "metadata": {},
    "outputs": [
@@ -827,24 +813,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_6kbxTU5CDWLmF9mrvR7bWSkI', 'function': {'arguments': '{\"query\":\"Common ways of task decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 21, 'prompt_tokens': 769, 'total_tokens': 790}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-2d2c8327-35cd-484a-b8fd-52436657c2d8-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'Common ways of task decomposition'}, 'id': 'call_6kbxTU5CDWLmF9mrvR7bWSkI'}])]}}\n",
-      "----\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in LangChainTracer.on_tool_end callback: TracerException(\"Found chain run at ID 29553415-e0f4-41a9-8921-ba489e377f68, but expected {'tool'} run.\")\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'tools': {'messages': [ToolMessage(content='Fig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nTree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.', name='blog_post_retriever', tool_call_id='call_6kbxTU5CDWLmF9mrvR7bWSkI')]}}\n",
+      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_KvoiamnLfGEzMeEMlV3u0TJ7', 'function': {'arguments': '{\"query\":\"common ways of task decomposition\"}', 'name': 'blog_post_retriever'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 21, 'prompt_tokens': 930, 'total_tokens': 951}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-dd842071-6dbd-4b68-8657-892eaca58638-0', tool_calls=[{'name': 'blog_post_retriever', 'args': {'query': 'common ways of task decomposition'}, 'id': 'call_KvoiamnLfGEzMeEMlV3u0TJ7'}])]}}\n",
       "----\n",
-      "{'agent': {'messages': [AIMessage(content='Common ways of task decomposition include:\\n1. Using LLM with simple prompting like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\"\\n2. Using task-specific instructions, for example, \"Write a story outline\" for writing a novel.\\n3. Involving human inputs in the task decomposition process.', response_metadata={'token_usage': {'completion_tokens': 67, 'prompt_tokens': 1339, 'total_tokens': 1406}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-9ad14cde-ca75-4238-a868-f865e0fc50dd-0')]}}\n",
+      "{'action': {'messages': [ToolMessage(content='Tree of Thoughts (Yao et al. 2023) extends CoT by exploring multiple reasoning possibilities at each step. It first decomposes the problem into multiple thought steps and generates multiple thoughts per step, creating a tree structure. The search process can be BFS (breadth-first search) or DFS (depth-first search) with each state evaluated by a classifier (via a prompt) or majority vote.\\nTask decomposition can be done (1) by LLM with simple prompting like \"Steps for XYZ.\\\\n1.\", \"What are the subgoals for achieving XYZ?\", (2) by using task-specific instructions; e.g. \"Write a story outline.\" for writing a novel, or (3) with human inputs.\\n\\nFig. 1. Overview of a LLM-powered autonomous agent system.\\nComponent One: Planning#\\nA complicated task usually involves many steps. An agent needs to know what they are and plan ahead.\\nTask Decomposition#\\nChain of thought (CoT; Wei et al. 2022) has become a standard prompting technique for enhancing model performance on complex tasks. The model is instructed to “think step by step” to utilize more test-time computation to decompose hard tasks into smaller and simpler steps. CoT transforms big tasks into multiple manageable tasks and shed lights into an interpretation of the model’s thinking process.\\n\\nResources:\\n1. Internet access for searches and information gathering.\\n2. Long Term memory management.\\n3. GPT-3.5 powered Agents for delegation of simple tasks.\\n4. File output.\\n\\nPerformance Evaluation:\\n1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.\\n2. Constructively self-criticize your big-picture behavior constantly.\\n3. Reflect on past decisions and strategies to refine your approach.\\n4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.\\n\\n(3) Task execution: Expert models execute on the specific tasks and log results.\\nInstruction:\\n\\nWith the input and the inference results, the AI assistant needs to describe the process and results. The previous stages can be formed as - User Input: {{ User Input }}, Task Planning: {{ Tasks }}, Model Selection: {{ Model Assignment }}, Task Execution: {{ Predictions }}. You must first answer the user\\'s request in a straightforward manner. Then describe the task process and show your analysis and model inference results to the user in the first person. If inference results contain a file path, must tell the user the complete file path.', name='blog_post_retriever', id='c749bb8e-c8e0-4fa3-bc11-3e2e0651880b', tool_call_id='call_KvoiamnLfGEzMeEMlV3u0TJ7')]}}\n",
+      "----\n",
+      "{'agent': {'messages': [AIMessage(content='According to the blog post, common ways of task decomposition include:\\n\\n1. Using language models with simple prompting like \"Steps for XYZ\" or \"What are the subgoals for achieving XYZ?\"\\n2. Utilizing task-specific instructions, for example, using \"Write a story outline\" for writing a novel.\\n3. Involving human inputs in the task decomposition process.\\n\\nThese methods help in breaking down complex tasks into smaller and more manageable steps, facilitating better planning and execution of the overall task.', response_metadata={'token_usage': {'completion_tokens': 100, 'prompt_tokens': 1475, 'total_tokens': 1575}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_3b956da36b', 'finish_reason': 'stop', 'logprobs': None}, id='run-98b765b3-f1a6-4c9a-ad0f-2db7950b900f-0')]}}\n",
       "----\n"
      ]
     }
@@ -879,15 +852,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 26,
    "id": "b1d2b4d4-e604-497d-873d-d345b808578e",
    "metadata": {},
    "outputs": [],
    "source": [
     "import bs4\n",
+    "from langchain.agents import AgentExecutor, create_tool_calling_agent\n",
     "from langchain.tools.retriever import create_retriever_tool\n",
     "from langchain_chroma import Chroma\n",
+    "from langchain_community.chat_message_histories import ChatMessageHistory\n",
     "from langchain_community.document_loaders import WebBaseLoader\n",
+    "from langchain_core.chat_history import BaseChatMessageHistory\n",
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
     "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
     "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "from langgraph.checkpoint.sqlite import SqliteSaver\n",
@@ -922,7 +900,9 @@
     "tools = [tool]\n",
     "\n",
     "\n",
-    "agent_executor = create_react_agent(llm, tools, checkpointer=memory)"
+    "agent_executor = chat_agent_executor.create_tool_calling_executor(\n",
+    "    llm, tools, checkpointer=memory\n",
+    ")"
    ]
   },
   {
@@ -961,7 +941,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/qa_sources.ipynb

@@ -14,7 +14,7 @@
     "We will cover two approaches:\n",
     "\n",
     "1. Using the built-in [create_retrieval_chain](https://api.python.langchain.com/en/latest/chains/langchain.chains.retrieval.create_retrieval_chain.html), which returns sources by default;\n",
-    "2. Using a simple [LCEL](/docs/concepts#langchain-expression-language-lcel) implementation, to show the operating principle."
+    "2. Using a simple [LCEL](/docs/concepts#langchain-expression-language) implementation, to show the operating principle."
    ]
   },
   {

docs/docs/how_to/recursive_text_splitter.ipynb

@@ -1,19 +1,5 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "52976910",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
-   "source": [
-    "---\n",
-    "keywords: [recursivecharactertextsplitter]\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "a678d550",

docs/docs/how_to/sequence.ipynb

@@ -2,14 +2,11 @@
  "cells": [
   {
    "cell_type": "raw",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
+   "metadata": {},
    "source": [
     "---\n",
-    "keywords: [Runnable, Runnables, RunnableSequence, LCEL, chain, chains, chaining]\n",
+    "sidebar_position: 0\n",
+    "keywords: [Runnable, Runnables, LCEL]\n",
     "---"
    ]
   },
@@ -253,7 +250,8 @@
    "source": [
     "## Related\n",
     "\n",
-    "- [Streaming](/docs/how_to/streaming/): Check out the streaming guide to understand the streaming behavior of a chain\n"
+    "- [Streaming](/docs/how_to/streaming/): Check out the streaming guide to understand the streaming behavior of a chain\n",
+    "- "
    ]
   }
  ],

docs/docs/how_to/streaming.ipynb

@@ -3,14 +3,10 @@
   {
    "cell_type": "raw",
    "id": "0bdb3b97-4989-4237-b43b-5943dbbd8302",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
+   "metadata": {},
    "source": [
     "---\n",
-    "keywords: [stream]\n",
+    "sidebar_position: 1.5\n",
     "---"
    ]
   },

docs/docs/how_to/structured_output.ipynb

@@ -3,15 +3,10 @@
   {
    "cell_type": "raw",
    "id": "27598444",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
+   "metadata": {},
    "source": [
     "---\n",
     "sidebar_position: 3\n",
-    "keywords: [structured output, json, information extraction, with_structured_output]\n",
     "---"
    ]
   },

docs/docs/how_to/tool_calling.ipynb

@@ -14,20 +14,14 @@
     "\n",
     ":::\n",
     "\n",
-    ":::info Tool calling vs function 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",
-    ":::info Supported models\n",
-    "\n",
-    "You can find a [list of all models that support tool calling](/docs/integrations/chat/).\n",
-    "\n",
     ":::\n",
+    "```\n",
     "\n",
     "Tool calling allows a chat model to respond to a given prompt by \"calling a tool\".\n",
     "While the name implies that the model is performing \n",

docs/docs/how_to/tool_runtime.ipynb

@@ -1,256 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# How to pass run time values to a tool\n",
-    "\n",
-    ":::info Prerequisites\n",
-    "\n",
-    "This guide assumes familiarity with the following concepts:\n",
-    "- [Chat models](/docs/concepts/#chat-models)\n",
-    "- [LangChain Tools](/docs/concepts/#tools)\n",
-    "- [How to create tools](/docs/how_to/custom_tools)\n",
-    "- [How to use a model to call tools](https://python.langchain.com/v0.2/docs/how_to/tool_calling/)\n",
-    ":::\n",
-    "\n",
-    ":::{.callout-info} Supported models\n",
-    "\n",
-    "This how-to guide uses models with native tool calling capability.\n",
-    "You can find a [list of all models that support tool calling](/docs/integrations/chat/).\n",
-    "\n",
-    ":::\n",
-    "\n",
-    ":::{.callout-info} Using with LangGraph\n",
-    "\n",
-    "If you're using LangGraph, please refer to [this how-to guide](https://langchain-ai.github.io/langgraph/how-tos/pass-run-time-values-to-tools/)\n",
-    "which shows how to create an agent that keeps track of a given user's favorite pets.\n",
-    ":::\n",
-    "\n",
-    "You may need to bind values to a tool that are only known at runtime. For example, the tool logic may require using the ID of the user who made the request.\n",
-    "\n",
-    "Most of the time, such values should not be controlled by the LLM. In fact, allowing the LLM to control the user ID may lead to a security risk.\n",
-    "\n",
-    "Instead, the LLM should only control the parameters of the tool that are meant to be controlled by the LLM, while other parameters (such as user ID) should be fixed by the application logic.\n",
-    "\n",
-    "This how-to guide shows a simple design pattern that creates the tool dynamically at run time and binds to them appropriate values."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "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",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.2.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n",
-      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython -m pip install --upgrade pip\u001b[0m\n",
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# | output: false\n",
-    "# | echo: false\n",
-    "\n",
-    "%pip install -qU langchain langchain_openai\n",
-    "\n",
-    "import os\n",
-    "from getpass import getpass\n",
-    "\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "if \"OPENAI_API_KEY\" not in os.environ:\n",
-    "    os.environ[\"OPENAI_API_KEY\"] = getpass()\n",
-    "\n",
-    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Passing request time information\n",
-    "\n",
-    "The idea is to create the tool dynamically at request time, and bind to it the appropriate information. For example,\n",
-    "this information may be the user ID as resolved from the request itself."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from typing import List\n",
-    "\n",
-    "from langchain_core.output_parsers import JsonOutputParser\n",
-    "from langchain_core.tools import BaseTool, tool"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "user_to_pets = {}\n",
-    "\n",
-    "\n",
-    "def generate_tools_for_user(user_id: str) -> List[BaseTool]:\n",
-    "    \"\"\"Generate a set of tools that have a user id associated with them.\"\"\"\n",
-    "\n",
-    "    @tool\n",
-    "    def update_favorite_pets(pets: List[str]) -> None:\n",
-    "        \"\"\"Add the list of favorite pets.\"\"\"\n",
-    "        user_to_pets[user_id] = pets\n",
-    "\n",
-    "    @tool\n",
-    "    def delete_favorite_pets() -> None:\n",
-    "        \"\"\"Delete the list of favorite pets.\"\"\"\n",
-    "        if user_id in user_to_pets:\n",
-    "            del user_to_pets[user_id]\n",
-    "\n",
-    "    @tool\n",
-    "    def list_favorite_pets() -> None:\n",
-    "        \"\"\"List favorite pets if any.\"\"\"\n",
-    "        return user_to_pets.get(user_id, [])\n",
-    "\n",
-    "    return [update_favorite_pets, delete_favorite_pets, list_favorite_pets]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Verify that the tools work correctly"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'eugene': ['cat', 'dog']}\n",
-      "['cat', 'dog']\n"
-     ]
-    }
-   ],
-   "source": [
-    "update_pets, delete_pets, list_pets = generate_tools_for_user(\"eugene\")\n",
-    "update_pets.invoke({\"pets\": [\"cat\", \"dog\"]})\n",
-    "print(user_to_pets)\n",
-    "print(list_pets.invoke({}))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "\n",
-    "\n",
-    "def handle_run_time_request(user_id: str, query: str):\n",
-    "    \"\"\"Handle run time request.\"\"\"\n",
-    "    tools = generate_tools_for_user(user_id)\n",
-    "    llm_with_tools = llm.bind_tools(tools)\n",
-    "    prompt = ChatPromptTemplate.from_messages(\n",
-    "        [(\"system\", \"You are a helpful assistant.\")],\n",
-    "    )\n",
-    "    chain = prompt | llm_with_tools\n",
-    "    return llm_with_tools.invoke(query)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This code will allow the LLM to invoke the tools, but the LLM is **unaware** of the fact that a **user ID** even exists!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'name': 'update_favorite_pets',\n",
-       "  'args': {'pets': ['cats', 'parrots']},\n",
-       "  'id': 'call_jJvjPXsNbFO5MMgW0q84iqCN'}]"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ai_message = handle_run_time_request(\n",
-    "    \"eugene\", \"my favorite animals are cats and parrots.\"\n",
-    ")\n",
-    "ai_message.tool_calls"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    ":::{.callout-important}\n",
-    "\n",
-    "Chat models only output requests to invoke tools, they don't actually invoke the underlying tools.\n",
-    "\n",
-    "To see how to invoke the tools, please refer to [how to use a model to call tools](https://python.langchain.com/v0.2/docs/how_to/tool_calling/).\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.4"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

docs/docs/integrations/callbacks/llmonitor.md

@@ -110,7 +110,7 @@ with identify("user-123"):
     llm.invoke("Tell me a joke")
 
 with identify("user-456", user_props={"email": "user456@test.com"}):
-    agent.run("Who is Leo DiCaprio's girlfriend?")
+    agen.run("Who is Leo DiCaprio's girlfriend?")
 ```
 ## Support
 

docs/docs/integrations/callbacks/upstash_ratelimit.ipynb

@@ -1,245 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Upstash Ratelimit Callback\n",
-    "\n",
-    "In this guide, we will go over how to add rate limiting based on number of requests or the number of tokens using `UpstashRatelimitHandler`. This handler uses [ratelimit library of Upstash](https://github.com/upstash/ratelimit-py/), which utilizes [Upstash Redis](https://upstash.com/docs/redis/overall/getstarted).\n",
-    "\n",
-    "Upstash Ratelimit works by sending an HTTP request to Upstash Redis everytime the `limit` method is called. Remaining tokens/requests of the user are checked and updated. Based on the remaining tokens, we can stop the execution of costly operations like invoking an LLM or querying a vector store:\n",
-    "\n",
-    "```py\n",
-    "response = ratelimit.limit()\n",
-    "if response.allowed:\n",
-    "    execute_costly_operation()\n",
-    "```\n",
-    "\n",
-    "`UpstashRatelimitHandler` allows you to incorporate the ratelimit logic into your chain in a few minutes.\n",
-    "\n",
-    "First, you will need to go to [the Upstash Console](https://console.upstash.com/login) and create a redis database ([see our docs](https://upstash.com/docs/redis/overall/getstarted)). After creating a database, you will need to set the environment variables:\n",
-    "\n",
-    "```\n",
-    "UPSTASH_REDIS_REST_URL=\"****\"\n",
-    "UPSTASH_REDIS_REST_TOKEN=\"****\"\n",
-    "```\n",
-    "\n",
-    "Next, you will need to install Upstash Ratelimit and Redis library with:\n",
-    "\n",
-    "```\n",
-    "pip install upstash-ratelimit upstash-redis\n",
-    "```\n",
-    "\n",
-    "You are now ready to add rate limiting to your chain!\n",
-    "\n",
-    "## Ratelimiting Per Request\n",
-    "\n",
-    "Let's imagine that we want to allow our users to invoke our chain 10 times per minute. Achieving this is as simple as:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in UpstashRatelimitHandler.on_chain_start callback: UpstashRatelimitError('Request limit reached!')\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Handling ratelimit. <class 'langchain_community.callbacks.upstash_ratelimit_callback.UpstashRatelimitError'>\n"
-     ]
-    }
-   ],
-   "source": [
-    "# set env variables\n",
-    "import os\n",
-    "\n",
-    "os.environ[\"UPSTASH_REDIS_REST_URL\"] = \"****\"\n",
-    "os.environ[\"UPSTASH_REDIS_REST_TOKEN\"] = \"****\"\n",
-    "\n",
-    "from langchain_community.callbacks import UpstashRatelimitError, UpstashRatelimitHandler\n",
-    "from langchain_core.runnables import RunnableLambda\n",
-    "from upstash_ratelimit import FixedWindow, Ratelimit\n",
-    "from upstash_redis import Redis\n",
-    "\n",
-    "# create ratelimit\n",
-    "ratelimit = Ratelimit(\n",
-    "    redis=Redis.from_env(),\n",
-    "    # 10 requests per window, where window size is 60 seconds:\n",
-    "    limiter=FixedWindow(max_requests=10, window=60),\n",
-    ")\n",
-    "\n",
-    "# create handler\n",
-    "user_id = \"user_id\"  # should be a method which gets the user id\n",
-    "handler = UpstashRatelimitHandler(identifier=user_id, request_ratelimit=ratelimit)\n",
-    "\n",
-    "# create mock chain\n",
-    "chain = RunnableLambda(str)\n",
-    "\n",
-    "# invoke chain with handler:\n",
-    "try:\n",
-    "    result = chain.invoke(\"Hello world!\", config={\"callbacks\": [handler]})\n",
-    "except UpstashRatelimitError:\n",
-    "    print(\"Handling ratelimit.\", UpstashRatelimitError)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that we pass the handler to the `invoke` method instead of passing the handler when defining the chain.\n",
-    "\n",
-    "For rate limiting algorithms other than `FixedWindow`, see [upstash-ratelimit docs](https://github.com/upstash/ratelimit-py?tab=readme-ov-file#ratelimiting-algorithms).\n",
-    "\n",
-    "Before executing any steps in our pipeline, ratelimit will check whether the user has passed the request limit. If so, `UpstashRatelimitError` is raised.\n",
-    "\n",
-    "## Ratelimiting Per Token\n",
-    "\n",
-    "Another option is to rate limit chain invokations based on:\n",
-    "1. number of tokens in prompt\n",
-    "2. number of tokens in prompt and LLM completion\n",
-    "\n",
-    "This only works if you have an LLM in your chain. Another requirement is that the LLM you are using should return the token usage in it's `LLMOutput`.\n",
-    "\n",
-    "### How it works\n",
-    "\n",
-    "The handler will get the remaining tokens before calling the LLM. If the remaining tokens is more than 0, LLM will be called. Otherwise `UpstashRatelimitError` will be raised.\n",
-    "\n",
-    "After LLM is called, token usage information will be used to subtracted from the remaining tokens of the user. No error is raised at this stage of the chain.\n",
-    "\n",
-    "### Configuration\n",
-    "\n",
-    "For the first configuration, simply initialize the handler like this:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ratelimit = Ratelimit(\n",
-    "    redis=Redis.from_env(),\n",
-    "    # 1000 tokens per window, where window size is 60 seconds:\n",
-    "    limiter=FixedWindow(max_requests=1000, window=60),\n",
-    ")\n",
-    "\n",
-    "handler = UpstashRatelimitHandler(identifier=user_id, token_ratelimit=ratelimit)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For the second configuration, here is how to initialize the handler:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ratelimit = Ratelimit(\n",
-    "    redis=Redis.from_env(),\n",
-    "    # 1000 tokens per window, where window size is 60 seconds:\n",
-    "    limiter=FixedWindow(max_requests=1000, window=60),\n",
-    ")\n",
-    "\n",
-    "handler = UpstashRatelimitHandler(\n",
-    "    identifier=user_id,\n",
-    "    token_ratelimit=ratelimit,\n",
-    "    include_output_tokens=True,  # set to True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "You can also employ ratelimiting based on requests and tokens at the same time, simply by passing both `request_ratelimit` and `token_ratelimit` parameters.\n",
-    "\n",
-    "Here is an example with a chain utilizing an LLM:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "Error in UpstashRatelimitHandler.on_llm_start callback: UpstashRatelimitError('Token limit reached!')\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Handling ratelimit. <class 'langchain_community.callbacks.upstash_ratelimit_callback.UpstashRatelimitError'>\n"
-     ]
-    }
-   ],
-   "source": [
-    "# set env variables\n",
-    "import os\n",
-    "\n",
-    "os.environ[\"UPSTASH_REDIS_REST_URL\"] = \"****\"\n",
-    "os.environ[\"UPSTASH_REDIS_REST_TOKEN\"] = \"****\"\n",
-    "os.environ[\"OPENAI_API_KEY\"] = \"****\"\n",
-    "\n",
-    "from langchain_community.callbacks import UpstashRatelimitError, UpstashRatelimitHandler\n",
-    "from langchain_core.runnables import RunnableLambda\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "from upstash_ratelimit import FixedWindow, Ratelimit\n",
-    "from upstash_redis import Redis\n",
-    "\n",
-    "# create ratelimit\n",
-    "ratelimit = Ratelimit(\n",
-    "    redis=Redis.from_env(),\n",
-    "    # 500 tokens per window, where window size is 60 seconds:\n",
-    "    limiter=FixedWindow(max_requests=500, window=60),\n",
-    ")\n",
-    "\n",
-    "# create handler\n",
-    "user_id = \"user_id\"  # should be a method which gets the user id\n",
-    "handler = UpstashRatelimitHandler(identifier=user_id, token_ratelimit=ratelimit)\n",
-    "\n",
-    "# create mock chain\n",
-    "as_str = RunnableLambda(str)\n",
-    "model = ChatOpenAI()\n",
-    "\n",
-    "chain = as_str | model\n",
-    "\n",
-    "# invoke chain with handler:\n",
-    "try:\n",
-    "    result = chain.invoke(\"Hello world!\", config={\"callbacks\": [handler]})\n",
-    "except UpstashRatelimitError:\n",
-    "    print(\"Handling ratelimit.\", UpstashRatelimitError)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "lc39",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.9.19"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/chat/azure_chat_openai.ipynb

@@ -23,11 +23,13 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "raw",
    "id": "d83ba7de",
-   "metadata": {},
-   "outputs": [],
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
    "source": [
     "%pip install -qU langchain-openai"
    ]

docs/docs/integrations/chat/bedrock.ipynb

@@ -137,77 +137,6 @@
     "for chunk in chat.stream(messages):\n",
     "    print(chunk.content, end=\"\", flush=True)"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c36575b3",
-   "metadata": {},
-   "source": [
-    "### LLM Caching with OpenSearch Semantic Cache\n",
-    "\n",
-    "Use OpenSearch as a semantic cache to cache prompts and responses and evaluate hits based on semantic similarity.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "375d4e56",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.globals import set_llm_cache\n",
-    "from langchain_aws import BedrockEmbeddings, ChatBedrock\n",
-    "from langchain_community.cache import OpenSearchSemanticCache\n",
-    "from langchain_core.messages import HumanMessage\n",
-    "\n",
-    "bedrock_embeddings = BedrockEmbeddings(\n",
-    "    model_id=\"amazon.titan-embed-text-v1\", region_name=\"us-east-1\"\n",
-    ")\n",
-    "\n",
-    "chat = ChatBedrock(\n",
-    "    model_id=\"anthropic.claude-3-haiku-20240307-v1:0\", model_kwargs={\"temperature\": 0.5}\n",
-    ")\n",
-    "\n",
-    "# Enable LLM cache. Make sure OpenSearch is set up and running. Update URL accordingly.\n",
-    "set_llm_cache(\n",
-    "    OpenSearchSemanticCache(\n",
-    "        opensearch_url=\"http://localhost:9200\", embedding=bedrock_embeddings\n",
-    "    )\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bb5d25bb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%time\n",
-    "# The first time, it is not yet in cache, so it should take longer\n",
-    "messages = [HumanMessage(content=\"tell me about Amazon Bedrock\")]\n",
-    "response_text = chat.invoke(messages)\n",
-    "\n",
-    "print(response_text)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6cfb3086",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%time\n",
-    "# The second time, while not a direct hit, the question is semantically similar to the original question,\n",
-    "# so it uses the cached result!\n",
-    "\n",
-    "messages = [HumanMessage(content=\"what is amazon bedrock\")]\n",
-    "response_text = chat.invoke(messages)\n",
-    "\n",
-    "print(response_text)"
-   ]
   }
  ],
  "metadata": {

docs/docs/integrations/chat/cohere.ipynb

@@ -201,7 +201,7 @@
    "source": [
     "## Chaining\n",
     "\n",
-    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language-lcel)"
+    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language)"
    ]
   },
   {

docs/docs/integrations/chat/edenai.ipynb

@@ -246,220 +246,11 @@
    "source": [
     "chain.invoke({\"product\": \"healthy snacks\"})"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Tools\n",
-    "\n",
-    "### bind_tools()\n",
-    "\n",
-    "With `ChatEdenAI.bind_tools`, we can easily pass in Pydantic classes, dict schemas, LangChain tools, or even functions as tools to the model."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
-    "\n",
-    "llm = ChatEdenAI(provider=\"openai\", temperature=0.2, max_tokens=500)\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_with_tools = llm.bind_tools([GetWeather])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='', response_metadata={'openai': {'status': 'success', 'generated_text': None, 'message': [{'role': 'user', 'message': 'what is the weather like in San Francisco', 'tools': [{'name': 'GetWeather', 'description': 'Get the current weather in a given location', 'parameters': {'type': 'object', 'properties': {'location': {'description': 'The city and state, e.g. San Francisco, CA', 'type': 'string'}}, 'required': ['location']}}], 'tool_calls': None}, {'role': 'assistant', 'message': None, 'tools': None, 'tool_calls': [{'id': 'call_tRpAO7KbQwgTjlka70mCQJdo', 'name': 'GetWeather', 'arguments': '{\"location\":\"San Francisco\"}'}]}], 'cost': 0.000194}}, id='run-5c44c01a-d7bb-4df6-835e-bda596080399-0', tool_calls=[{'name': 'GetWeather', 'args': {'location': 'San Francisco'}, 'id': 'call_tRpAO7KbQwgTjlka70mCQJdo'}])"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ai_msg = llm_with_tools.invoke(\n",
-    "    \"what is the weather like in San Francisco\",\n",
-    ")\n",
-    "ai_msg"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'name': 'GetWeather',\n",
-       "  'args': {'location': 'San Francisco'},\n",
-       "  'id': 'call_tRpAO7KbQwgTjlka70mCQJdo'}]"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "ai_msg.tool_calls"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### with_structured_output()\n",
-    "\n",
-    "The BaseChatModel.with_structured_output interface makes it easy to get structured output from chat models. You can use ChatEdenAI.with_structured_output, which uses tool-calling under the hood), to get the model to more reliably return an output in a specific format:\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "GetWeather(location='San Francisco')"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "structured_llm = llm.with_structured_output(GetWeather)\n",
-    "structured_llm.invoke(\n",
-    "    \"what is the weather like in San Francisco\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Passing Tool Results to model\n",
-    "\n",
-    "Here is a full example of how to use a tool. Pass the tool output to the model, and get the result back from the model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'11 + 11 = 22'"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain_core.messages import HumanMessage, ToolMessage\n",
-    "from langchain_core.tools import tool\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def add(a: int, b: int) -> int:\n",
-    "    \"\"\"Adds a and b.\n",
-    "\n",
-    "    Args:\n",
-    "        a: first int\n",
-    "        b: second int\n",
-    "    \"\"\"\n",
-    "    return a + b\n",
-    "\n",
-    "\n",
-    "llm = ChatEdenAI(\n",
-    "    provider=\"openai\",\n",
-    "    max_tokens=1000,\n",
-    "    temperature=0.2,\n",
-    ")\n",
-    "\n",
-    "llm_with_tools = llm.bind_tools([add], tool_choice=\"required\")\n",
-    "\n",
-    "query = \"What is 11 + 11?\"\n",
-    "\n",
-    "messages = [HumanMessage(query)]\n",
-    "ai_msg = llm_with_tools.invoke(messages)\n",
-    "messages.append(ai_msg)\n",
-    "\n",
-    "tool_call = ai_msg.tool_calls[0]\n",
-    "tool_output = add.invoke(tool_call[\"args\"])\n",
-    "\n",
-    "# This append the result from our tool to the model\n",
-    "messages.append(ToolMessage(tool_output, tool_call_id=tool_call[\"id\"]))\n",
-    "\n",
-    "llm_with_tools.invoke(messages).content"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Streaming\n",
-    "\n",
-    "Eden AI does not currently support streaming tool calls. Attempting to stream will yield a single final message."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/eden/Projects/edenai-langchain/libs/community/langchain_community/chat_models/edenai.py:603: UserWarning: stream: Tool use is not yet supported in streaming mode.\n",
-      "  warnings.warn(\"stream: Tool use is not yet supported in streaming mode.\")\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "[AIMessageChunk(content='', id='run-fae32908-ec48-4ab2-ad96-bb0d0511754f', tool_calls=[{'name': 'add', 'args': {'a': 9, 'b': 9}, 'id': 'call_n0Tm7I9zERWa6UpxCAVCweLN'}], tool_call_chunks=[{'name': 'add', 'args': '{\"a\": 9, \"b\": 9}', 'id': 'call_n0Tm7I9zERWa6UpxCAVCweLN', 'index': 0}])]"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list(llm_with_tools.stream(\"What's 9 + 9\"))"
-   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "langchain-pr",
    "language": "python",
    "name": "python3"
   },

docs/docs/integrations/chat/google_vertex_ai_palm.ipynb

@@ -2,50 +2,33 @@
  "cells": [
   {
    "cell_type": "raw",
-   "id": "afaf8039",
    "metadata": {},
    "source": [
     "---\n",
     "sidebar_label: Google Cloud Vertex AI\n",
+    "keywords: [gemini, vertex, ChatVertexAI, gemini-pro]\n",
     "---"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "e49f1e0d",
    "metadata": {},
    "source": [
     "# ChatVertexAI\n",
     "\n",
-    "This page provides a quick overview for getting started with VertexAI [chat models](/docs/concepts/#chat-models). For detailed documentation of all ChatVertexAI features and configurations head to the [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_google_vertexai.chat_models.ChatVertexAI.html).\n",
+    "Note: This is separate from the Google PaLM integration. Google has chosen to offer an enterprise version of PaLM through GCP, and this supports the models made available through there. \n",
     "\n",
-    "ChatVertexAI exposes all foundational models available in Google Cloud, like `gemini-1.5-pro`, `gemini-1.5-flash`, etc. For a full and updated list of available models visit [VertexAI documentation](https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/overview).\n",
+    "ChatVertexAI exposes all foundational models available in Google Cloud:\n",
     "\n",
-    ":::info Google Cloud VertexAI vs Google PaLM\n",
+    "- Gemini (`gemini-pro` and `gemini-pro-vision`)\n",
+    "- PaLM 2 for Text (`text-bison`)\n",
+    "- Codey for Code Generation (`codechat-bison`)\n",
     "\n",
-    "The Google Cloud VertexAI integration is separate from the [Google PaLM integration](/docs/integrations/chat/google_generative_ai/). Google has chosen to offer an enterprise version of PaLM through GCP, and this supports the models made available through there. \n",
+    "For a full and updated list of available models visit [VertexAI documentation](https://cloud.google.com/vertex-ai/docs/generative-ai/model-reference/overview).\n",
     "\n",
-    ":::\n",
+    "By default, Google Cloud [does not use](https://cloud.google.com/vertex-ai/docs/generative-ai/data-governance#foundation_model_development) customer data to train its foundation models as part of Google Cloud`s AI/ML Privacy Commitment. More details about how Google processes data can also be found in [Google's Customer Data Processing Addendum (CDPA)](https://cloud.google.com/terms/data-processing-addendum).\n",
     "\n",
-    "## Overview\n",
-    "### Integration details\n",
-    "\n",
-    "| Class | Package | Local | Serializable | [JS support](https://js.langchain.com/v0.2/docs/integrations/chat/google_vertex_ai) | Package downloads | Package latest |\n",
-    "| :--- | :--- | :---: | :---: |  :---: | :---: | :---: |\n",
-    "| [ChatVertexAI](https://api.python.langchain.com/en/latest/chat_models/langchain_google_vertexai.chat_models.ChatVertexAI.html) | [langchain-google-vertexai](https://api.python.langchain.com/en/latest/google_vertexai_api_reference.html) | ❌ | beta | ✅ | ![PyPI - Downloads](https://img.shields.io/pypi/dm/langchain-google-vertexai?style=flat-square&label=%20) | ![PyPI - Version](https://img.shields.io/pypi/v/langchain-google-vertexai?style=flat-square&label=%20) |\n",
-    "\n",
-    "### Model features\n",
-    "| [Tool calling](/docs/how_to/tool_calling/) | [Structured output](/docs/how_to/structured_output/) | JSON mode | [Image input](/docs/how_to/multimodal_inputs/) | Audio input | Video input | [Token-level streaming](/docs/how_to/chat_streaming/) | Native async | [Token usage](/docs/how_to/chat_token_usage_tracking/) | [Logprobs](/docs/how_to/logprobs/) |\n",
-    "| :---: | :---: | :---: | :---: |  :---: | :---: | :---: | :---: | :---: | :---: |\n",
-    "| ✅ | ✅ | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ | \n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "To access VertexAI models you'll need to create a Google Cloud Platform account, set up credentials, and install the `langchain-google-vertexai` integration package.\n",
-    "\n",
-    "### Credentials\n",
-    "\n",
-    "To use the integration you must:\n",
+    "To use `Google Cloud Vertex AI` PaLM you must have the `langchain-google-vertexai` Python package installed and either:\n",
     "- Have credentials configured for your environment (gcloud, workload identity, etc...)\n",
     "- Store the path to a service account JSON file as the GOOGLE_APPLICATION_CREDENTIALS environment variable\n",
     "\n",
@@ -54,156 +37,432 @@
     "For more information, see: \n",
     "- https://cloud.google.com/docs/authentication/application-default-credentials#GAC\n",
     "- https://googleapis.dev/python/google-auth/latest/reference/google.auth.html#module-google.auth\n",
-    "\n",
-    "If you want to get automated tracing of your model calls you can also set your [LangSmith](https://docs.smith.langchain.com/) API key by uncommenting below:"
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install --upgrade --quiet  langchain-google-vertexai"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "a15d341e-3e26-4ca3-830b-5aab30ed66de",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# os.environ[\"LANGSMITH_API_KEY\"] = getpass.getpass(\"Enter your LangSmith API key: \")\n",
-    "# os.environ[\"LANGSMITH_TRACING\"] = \"true\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0730d6a1-c893-4840-9817-5e5251676d5d",
-   "metadata": {},
-   "source": [
-    "### Installation\n",
-    "\n",
-    "The LangChain VertexAI integration lives in the `langchain-google-vertexai` package:"
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_google_vertexai import ChatVertexAI"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "652d6238-1f87-422a-b135-f5abbb8652fc",
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
-   "source": [
-    "%pip install -qU langchain-google-vertexai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a38cde65-254d-4219-a441-068766c0d4b5",
-   "metadata": {},
-   "source": [
-    "## Instantiation\n",
-    "\n",
-    "Now we can instantiate our model object and generate chat completions:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "cb09c344-1836-4e0c-acf8-11d13ac1dbae",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_google_vertexai import ChatVertexAI\n",
-    "\n",
-    "llm = ChatVertexAI(\n",
-    "    model=\"gemini-1.5-flash-001\",\n",
-    "    temperature=0,\n",
-    "    max_tokens=None,\n",
-    "    max_retries=6,\n",
-    "    stop=None,\n",
-    "    # other params...\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2b4f3e15",
-   "metadata": {},
-   "source": [
-    "## Invocation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "62e0dbc3",
-   "metadata": {
-    "tags": []
-   },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=\"J'adore programmer. \\n\", 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}], 'usage_metadata': {'prompt_token_count': 20, 'candidates_token_count': 7, 'total_token_count': 27}}, id='run-7032733c-d05c-4f0c-a17a-6c575fdd1ae0-0', usage_metadata={'input_tokens': 20, 'output_tokens': 7, 'total_tokens': 27})"
+       "AIMessage(content=\" J'aime la programmation.\")"
       ]
      },
-     "execution_count": 4,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "messages = [\n",
-    "    (\n",
-    "        \"system\",\n",
-    "        \"You are a helpful assistant that translates English to French. Translate the user sentence.\",\n",
-    "    ),\n",
-    "    (\"human\", \"I love programming.\"),\n",
-    "]\n",
-    "ai_msg = llm.invoke(messages)\n",
-    "ai_msg"
+    "system = \"You are a helpful assistant who translate English to French\"\n",
+    "human = \"Translate this sentence from English to French. I love programming.\"\n",
+    "prompt = ChatPromptTemplate.from_messages([(\"system\", system), (\"human\", human)])\n",
+    "\n",
+    "chat = ChatVertexAI()\n",
+    "\n",
+    "chain = prompt | chat\n",
+    "chain.invoke({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Gemini doesn't support SystemMessage at the moment, but it can be added to the first human message in the row. If you want such behavior, just set the `convert_system_message_to_human` to `True`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "id": "d86145b3-bfef-46e8-b227-4dda5c9c2705",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"J'aime la programmation.\")"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = \"You are a helpful assistant who translate English to French\"\n",
+    "human = \"Translate this sentence from English to French. I love programming.\"\n",
+    "prompt = ChatPromptTemplate.from_messages([(\"system\", system), (\"human\", human)])\n",
+    "\n",
+    "chat = ChatVertexAI(model=\"gemini-pro\", convert_system_message_to_human=True)\n",
+    "\n",
+    "chain = prompt | chat\n",
+    "chain.invoke({})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If we want to construct a simple chain that takes user specified parameters:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' プログラミングが大好きです')"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = (\n",
+    "    \"You are a helpful assistant that translates {input_language} to {output_language}.\"\n",
+    ")\n",
+    "human = \"{text}\"\n",
+    "prompt = ChatPromptTemplate.from_messages([(\"system\", system), (\"human\", human)])\n",
+    "\n",
+    "chat = ChatVertexAI()\n",
+    "\n",
+    "chain = prompt | chat\n",
+    "\n",
+    "chain.invoke(\n",
+    "    {\n",
+    "        \"input_language\": \"English\",\n",
+    "        \"output_language\": \"Japanese\",\n",
+    "        \"text\": \"I love programming\",\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Code generation chat models\n",
+    "You can now leverage the Codey API for code chat within Vertex AI. The model available is:\n",
+    "- `codechat-bison`: for code assistance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "J'adore programmer. \n",
-      "\n"
+      " ```python\n",
+      "def is_prime(n):\n",
+      "  \"\"\"\n",
+      "  Check if a number is prime.\n",
+      "\n",
+      "  Args:\n",
+      "    n: The number to check.\n",
+      "\n",
+      "  Returns:\n",
+      "    True if n is prime, False otherwise.\n",
+      "  \"\"\"\n",
+      "\n",
+      "  # If n is 1, it is not prime.\n",
+      "  if n == 1:\n",
+      "    return False\n",
+      "\n",
+      "  # Iterate over all numbers from 2 to the square root of n.\n",
+      "  for i in range(2, int(n ** 0.5) + 1):\n",
+      "    # If n is divisible by any number from 2 to its square root, it is not prime.\n",
+      "    if n % i == 0:\n",
+      "      return False\n",
+      "\n",
+      "  # If n is divisible by no number from 2 to its square root, it is prime.\n",
+      "  return True\n",
+      "\n",
+      "\n",
+      "def find_prime_numbers(n):\n",
+      "  \"\"\"\n",
+      "  Find all prime numbers up to a given number.\n",
+      "\n",
+      "  Args:\n",
+      "    n: The upper bound for the prime numbers to find.\n",
+      "\n",
+      "  Returns:\n",
+      "    A list of all prime numbers up to n.\n",
+      "  \"\"\"\n",
+      "\n",
+      "  # Create a list of all numbers from 2 to n.\n",
+      "  numbers = list(range(2, n + 1))\n",
+      "\n",
+      "  # Iterate over the list of numbers and remove any that are not prime.\n",
+      "  for number in numbers:\n",
+      "    if not is_prime(number):\n",
+      "      numbers.remove(number)\n",
+      "\n",
+      "  # Return the list of prime numbers.\n",
+      "  return numbers\n",
+      "```\n"
      ]
     }
    ],
    "source": [
-    "print(ai_msg.content)"
+    "chat = ChatVertexAI(model=\"codechat-bison\", max_tokens=1000, temperature=0.5)\n",
+    "\n",
+    "message = chat.invoke(\"Write a Python function generating all prime numbers\")\n",
+    "print(message.content)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "18e2bfc0-7e78-4528-a73f-499ac150dca8",
    "metadata": {},
    "source": [
-    "## Chaining\n",
+    "## Full generation info\n",
     "\n",
-    "We can [chain](/docs/how_to/sequence/) our model with a prompt template like so:"
+    "We can use the `generate` method to get back extra metadata like [safety attributes](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/responsible-ai#safety_attribute_confidence_scoring) and not just chat completions\n",
+    "\n",
+    "Note that the `generation_info` will be different depending if you're using a gemini model or not.\n",
+    "\n",
+    "### Gemini model\n",
+    "\n",
+    "`generation_info` will include:\n",
+    "\n",
+    "- `is_blocked`: whether generation was blocked or not\n",
+    "- `safety_ratings`: safety ratings' categories and probability labels"
+   ]
+  },
+  {
+   "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,
+   "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",
+      "                     '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",
+      " 'usage_metadata': {'candidates_token_count': 6,\n",
+      "                    'prompt_token_count': 12,\n",
+      "                    'total_token_count': 18}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "human = \"Translate this sentence from English to French. I love programming.\"\n",
+    "messages = [HumanMessage(content=human)]\n",
+    "\n",
+    "\n",
+    "chat = ChatVertexAI(\n",
+    "    model_name=\"gemini-pro\",\n",
+    "    safety_settings={\n",
+    "        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE\n",
+    "    },\n",
+    ")\n",
+    "\n",
+    "result = chat.generate([messages])\n",
+    "pprint(result.generations[0][0].generation_info)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Non-gemini model\n",
+    "\n",
+    "`generation_info` will include:\n",
+    "\n",
+    "- `is_blocked`: whether generation was blocked or not\n",
+    "- `safety_attributes`: a dictionary mapping safety attributes to their scores"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "e197d1d7-a070-4c96-9f8a-a0e86d046e0b",
+   "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"
+     ]
+    }
+   ],
+   "source": [
+    "chat = ChatVertexAI()  # default is `chat-bison`\n",
+    "\n",
+    "result = chat.generate([messages])\n",
+    "pprint(result.generations[0][0].generation_info)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Tool calling (a.k.a. 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='Ich liebe Programmieren. \\n', 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}], 'usage_metadata': {'prompt_token_count': 15, 'candidates_token_count': 8, 'total_token_count': 23}}, id='run-c71955fd-8dc1-422b-88a7-853accf4811b-0', usage_metadata={'input_tokens': 15, 'output_tokens': 8, 'total_tokens': 23})"
+       "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=\"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/how_to/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/how_to/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,
@@ -212,36 +471,139 @@
     }
    ],
    "source": [
-    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "class Person(BaseModel):\n",
+    "    \"\"\"Save information about a person.\"\"\"\n",
     "\n",
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\n",
-    "            \"system\",\n",
-    "            \"You are a helpful assistant that translates {input_language} to {output_language}.\",\n",
-    "        ),\n",
-    "        (\"human\", \"{input}\"),\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:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_google_vertexai import create_structured_runnable\n",
+    "\n",
+    "chain = create_structured_runnable(Person, llm)\n",
+    "chain.invoke(\"My name is Erick and I'm 27 years old\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Asynchronous calls\n",
+    "\n",
+    "We can make asynchronous calls via the Runnables [Async Interface](/docs/concepts#interface)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# for running these examples in the notebook:\n",
+    "import asyncio\n",
+    "\n",
+    "import nest_asyncio\n",
+    "\n",
+    "nest_asyncio.apply()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' अहं प्रोग्रामनं प्रेमामि')"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "system = (\n",
+    "    \"You are a helpful assistant that translates {input_language} to {output_language}.\"\n",
     ")\n",
+    "human = \"{text}\"\n",
+    "prompt = ChatPromptTemplate.from_messages([(\"system\", system), (\"human\", human)])\n",
     "\n",
-    "chain = prompt | llm\n",
-    "chain.invoke(\n",
-    "    {\n",
-    "        \"input_language\": \"English\",\n",
-    "        \"output_language\": \"German\",\n",
-    "        \"input\": \"I love programming.\",\n",
-    "    }\n",
+    "chat = ChatVertexAI(model=\"chat-bison\", max_tokens=1000, temperature=0.5)\n",
+    "chain = prompt | chat\n",
+    "\n",
+    "asyncio.run(\n",
+    "    chain.ainvoke(\n",
+    "        {\n",
+    "            \"input_language\": \"English\",\n",
+    "            \"output_language\": \"Sanskrit\",\n",
+    "            \"text\": \"I love programming\",\n",
+    "        }\n",
+    "    )\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "3a5bb5ca-c3ae-4a58-be67-2cd18574b9a3",
    "metadata": {},
    "source": [
-    "## API reference\n",
+    "## Streaming calls\n",
     "\n",
-    "For detailed documentation of all ChatVertexAI features and configurations, like how to send multimodal inputs and configure safety settings, head to the API reference: https://api.python.langchain.com/en/latest/chat_models/langchain_google_vertexai.chat_models.ChatVertexAI.html"
+    "We can also stream outputs via the `stream` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " The five most populous countries in the world are:\n",
+      "1. China (1.4 billion)\n",
+      "2. India (1.3 billion)\n",
+      "3. United States (331 million)\n",
+      "4. Indonesia (273 million)\n",
+      "5. Pakistan (220 million)"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"human\", \"List out the 5 most populous countries in the world\")]\n",
+    ")\n",
+    "\n",
+    "chat = ChatVertexAI()\n",
+    "\n",
+    "chain = prompt | chat\n",
+    "\n",
+    "for chunk in chain.stream({}):\n",
+    "    sys.stdout.write(chunk.content)\n",
+    "    sys.stdout.flush()"
    ]
   }
  ],
@@ -265,5 +627,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 5
+ "nbformat_minor": 4
 }

docs/docs/integrations/chat/huggingface.ipynb

@@ -58,62 +58,6 @@
     ")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### `HuggingFacePipeline`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_huggingface import HuggingFacePipeline\n",
-    "\n",
-    "llm = HuggingFacePipeline.from_model_id(\n",
-    "    model_id=\"HuggingFaceH4/zephyr-7b-beta\",\n",
-    "    task=\"text-generation\",\n",
-    "    pipeline_kwargs=dict(\n",
-    "        max_new_tokens=512,\n",
-    "        do_sample=False,\n",
-    "        repetition_penalty=1.03,\n",
-    "    ),\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To run a quantized version, you might specify a `bitsandbytes` quantization config as follows:\n",
-    "\n",
-    "```python\n",
-    "from transformers import BitsAndBytesConfig\n",
-    "\n",
-    "quantization_config = BitsAndBytesConfig(\n",
-    "    load_in_4bit=True,\n",
-    "    bnb_4bit_quant_type=\"nf4\",\n",
-    "    bnb_4bit_compute_dtype=\"float16\",\n",
-    "    bnb_4bit_use_double_quant=True\n",
-    ")\n",
-    "```\n",
-    "\n",
-    "and pass it to the `HuggingFacePipeline` as a part of its `model_kwargs`:\n",
-    "\n",
-    "```python\n",
-    "pipeline = HuggingFacePipeline(\n",
-    "    ...\n",
-    "\n",
-    "    model_kwargs={\"quantization_config\": quantization_config},\n",
-    "    \n",
-    "    ...\n",
-    ")\n",
-    "```"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},

docs/docs/integrations/chat/mistralai.ipynb

@@ -225,7 +225,7 @@
    "source": [
     "## Chaining\n",
     "\n",
-    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language-lcel)"
+    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language)"
    ]
   },
   {

docs/docs/integrations/chat/nvidia_ai_endpoints.ipynb

@@ -7,24 +7,18 @@
     "id": "cc6caafa"
    },
    "source": [
-    "# NVIDIA NIMs\n",
+    "# NVIDIA AI Foundation Endpoints\n",
     "\n",
-    "The `langchain-nvidia-ai-endpoints` package contains LangChain integrations building applications with models on \n",
-    "NVIDIA NIM inference microservice. NIM supports models across domains like chat, embedding, and re-ranking models \n",
-    "from the community as well as NVIDIA. These models are optimized by NVIDIA to deliver the best performance on NVIDIA \n",
-    "accelerated infrastructure and deployed as a NIM, an easy-to-use, prebuilt containers that deploy anywhere using a single \n",
-    "command on NVIDIA accelerated infrastructure.\n",
+    "The `ChatNVIDIA` class is a LangChain chat model that connects to [NVIDIA AI Foundation Endpoints](https://www.nvidia.com/en-us/ai-data-science/foundation-models/).\n",
     "\n",
-    "NVIDIA hosted deployments of NIMs are available to test on the [NVIDIA API catalog](https://build.nvidia.com/). After testing, \n",
-    "NIMs can be exported from NVIDIA’s API catalog using the NVIDIA AI Enterprise license and run on-premises or in the cloud, \n",
-    "giving enterprises ownership and full control of their IP and AI application.\n",
     "\n",
-    "NIMs are packaged as container images on a per model basis and are distributed as NGC container images through the NVIDIA NGC Catalog. \n",
-    "At their core, NIMs provide easy, consistent, and familiar APIs for running inference on an AI model.\n",
+    "> [NVIDIA AI Foundation Endpoints](https://www.nvidia.com/en-us/ai-data-science/foundation-models/) give users easy access to NVIDIA hosted API endpoints for NVIDIA AI Foundation Models like Mixtral 8x7B, Llama 2, Stable Diffusion, etc. These models, hosted on the [NVIDIA API catalog](https://build.nvidia.com/), are optimized, tested, and hosted on the NVIDIA AI platform, making them fast and easy to evaluate, further customize, and seamlessly run at peak performance on any accelerated stack.\n",
+    "> \n",
+    "> With [NVIDIA AI Foundation Endpoints](https://www.nvidia.com/en-us/ai-data-science/foundation-models/), you can get quick results from a fully accelerated stack running on [NVIDIA DGX Cloud](https://www.nvidia.com/en-us/data-center/dgx-cloud/). Once customized, these models can be deployed anywhere with enterprise-grade security, stability, and support using [NVIDIA AI Enterprise](https://www.nvidia.com/en-us/data-center/products/ai-enterprise/).\n",
+    "> \n",
+    "> These models can be easily accessed via the [`langchain-nvidia-ai-endpoints`](https://pypi.org/project/langchain-nvidia-ai-endpoints/) package, as shown below.\n",
     "\n",
-    "This example goes over how to use LangChain to interact with NVIDIA supported via the `ChatNVIDIA` class.\n",
-    "\n",
-    "For more information on accessing the chat models through this api, check out the [ChatNVIDIA](https://python.langchain.com/docs/integrations/chat/nvidia_ai_endpoints/) documentation."
+    "This example goes over how to use LangChain to interact with and develop LLM-powered systems using the publicly-accessible AI Foundation endpoints."
    ]
   },
   {
@@ -56,9 +50,9 @@
     "\n",
     "**To get started:**\n",
     "\n",
-    "1. Create a free account with [NVIDIA](https://build.nvidia.com/), which hosts NVIDIA AI Foundation models.\n",
+    "1. Create a free account with [NVIDIA](https://build.nvidia.com/), which hosts NVIDIA AI Foundation models\n",
     "\n",
-    "2. Click on your model of choice.\n",
+    "2. Click on your model of choice\n",
     "\n",
     "3. Under `Input` select the `Python` tab, and click `Get API Key`. Then click `Generate Key`.\n",
     "\n",
@@ -75,23 +69,12 @@
     "import getpass\n",
     "import os\n",
     "\n",
-    "# del os.environ['NVIDIA_API_KEY']  ## delete key and reset\n",
-    "if os.environ.get(\"NVIDIA_API_KEY\", \"\").startswith(\"nvapi-\"):\n",
-    "    print(\"Valid NVIDIA_API_KEY already in environment. Delete to reset\")\n",
-    "else:\n",
-    "    nvapi_key = getpass.getpass(\"NVAPI Key (starts with nvapi-): \")\n",
+    "if not os.environ.get(\"NVIDIA_API_KEY\", \"\").startswith(\"nvapi-\"):\n",
+    "    nvapi_key = getpass.getpass(\"Enter your NVIDIA API key: \")\n",
     "    assert nvapi_key.startswith(\"nvapi-\"), f\"{nvapi_key[:5]}... is not a valid key\"\n",
     "    os.environ[\"NVIDIA_API_KEY\"] = nvapi_key"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "af0ce26b",
-   "metadata": {},
-   "source": [
-    "## Working with NVIDIA API Catalog"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -113,30 +96,6 @@
     "print(result.content)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "9d35686b",
-   "metadata": {},
-   "source": [
-    "## Working with NVIDIA NIMs\n",
-    "When ready to deploy, you can self-host models with NVIDIA NIM—which is included with the NVIDIA AI Enterprise software license—and run them anywhere, giving you ownership of your customizations and full control of your intellectual property (IP) and AI applications.\n",
-    "\n",
-    "[Learn more about NIMs](https://developer.nvidia.com/blog/nvidia-nim-offers-optimized-inference-microservices-for-deploying-ai-models-at-scale/)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "49838930",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n",
-    "\n",
-    "# connect to an embedding NIM running at localhost:8000, specifying a specific model\n",
-    "llm = ChatNVIDIA(base_url=\"http://localhost:8000/v1\", model=\"meta-llama3-8b-instruct\")"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "71d37987-d568-4a73-9d2a-8bd86323f8bf",
@@ -293,6 +252,81 @@
     "    print(txt, end=\"\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "642a618a-faa3-443e-99c3-67b8142f3c51",
+   "metadata": {},
+   "source": [
+    "## Steering LLMs\n",
+    "\n",
+    "> [SteerLM-optimized models](https://developer.nvidia.com/blog/announcing-steerlm-a-simple-and-practical-technique-to-customize-llms-during-inference/) supports \"dynamic steering\" of model outputs at inference time.\n",
+    "\n",
+    "This lets you \"control\" the complexity, verbosity, and creativity of the model via integer labels on a scale from 0 to 9. Under the hood, these are passed as a special type of assistant message to the model.\n",
+    "\n",
+    "The \"steer\" models support this type of input, such as `nemotron_steerlm_8b`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "36a96b1a-e3e7-4ae3-b4b0-9331b5eca04f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n",
+    "\n",
+    "llm = ChatNVIDIA(model=\"nemotron_steerlm_8b\")\n",
+    "# Try making it uncreative and not verbose\n",
+    "complex_result = llm.invoke(\n",
+    "    \"What's a PB&J?\", labels={\"creativity\": 0, \"complexity\": 3, \"verbosity\": 0}\n",
+    ")\n",
+    "print(\"Un-creative\\n\")\n",
+    "print(complex_result.content)\n",
+    "\n",
+    "# Try making it very creative and verbose\n",
+    "print(\"\\n\\nCreative\\n\")\n",
+    "creative_result = llm.invoke(\n",
+    "    \"What's a PB&J?\", labels={\"creativity\": 9, \"complexity\": 3, \"verbosity\": 9}\n",
+    ")\n",
+    "print(creative_result.content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "75849e7a-2adf-4038-8d9d-8a9e12417789",
+   "metadata": {},
+   "source": [
+    "#### Use within LCEL\n",
+    "\n",
+    "The labels are passed as invocation params. You can `bind` these to the LLM using the `bind` method on the LLM to include it within a declarative, functional chain. Below is an example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae1105c3-2a0c-4db3-916e-24d5e427bd01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", \"You are a helpful AI assistant named Fred.\"), (\"user\", \"{input}\")]\n",
+    ")\n",
+    "chain = (\n",
+    "    prompt\n",
+    "    | ChatNVIDIA(model=\"nemotron_steerlm_8b\").bind(\n",
+    "        labels={\"creativity\": 9, \"complexity\": 0, \"verbosity\": 9}\n",
+    "    )\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "for txt in chain.stream({\"input\": \"Why is a PB&J?\"}):\n",
+    "    print(txt, end=\"\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "7f465ff6-5922-41d8-8abb-1d1e4095cc27",
@@ -300,7 +334,7 @@
    "source": [
     "## Multimodal\n",
     "\n",
-    "NVIDIA also supports multimodal inputs, meaning you can provide both images and text for the model to reason over. An example model supporting multimodal inputs is `nvidia/neva-22b`.\n",
+    "NVIDIA also supports multimodal inputs, meaning you can provide both images and text for the model to reason over. An example model supporting multimodal inputs is `playground_neva_22b`.\n",
     "\n",
     "\n",
     "These models accept LangChain's standard image formats, and accept `labels`, similar to the Steering LLMs above. In addition to `creativity`, `complexity`, and `verbosity`, these models support a `quality` toggle.\n",
@@ -333,7 +367,7 @@
    "source": [
     "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n",
     "\n",
-    "llm = ChatNVIDIA(model=\"nvidia/neva-22b\")"
+    "llm = ChatNVIDIA(model=\"playground_neva_22b\")"
    ]
   },
   {
@@ -466,7 +500,7 @@
    "source": [
     "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n",
     "\n",
-    "kosmos = ChatNVIDIA(model=\"microsoft/kosmos-2\")\n",
+    "kosmos = ChatNVIDIA(model=\"kosmos_2\")\n",
     "\n",
     "from langchain_core.messages import HumanMessage\n",
     "\n",
@@ -510,7 +544,7 @@
     "\n",
     "\n",
     "## Override the payload passthrough. Default is to pass through the payload as is.\n",
-    "kosmos = ChatNVIDIA(model=\"microsoft/kosmos-2\")\n",
+    "kosmos = ChatNVIDIA(model=\"kosmos_2\")\n",
     "kosmos.client.payload_fn = drop_streaming_key\n",
     "\n",
     "kosmos.invoke(\n",
@@ -533,6 +567,43 @@
     "For more advanced or custom use-cases (i.e. supporting the diffusion models), you may be interested in leveraging the `NVEModel` client as a requests backbone. The `NVIDIAEmbeddings` class is a good source of inspiration for this. "
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1cd6249a-7ffa-4886-b7e8-5778dc93499e",
+   "metadata": {},
+   "source": [
+    "## RAG: Context models\n",
+    "\n",
+    "NVIDIA also has Q&A models that support a special \"context\" chat message containing retrieved context (such as documents within a RAG chain). This is useful to avoid prompt-injecting the model. The `_qa_` models like `nemotron_qa_8b` support this.\n",
+    "\n",
+    "**Note:** Only \"user\" (human) and \"context\" chat messages are supported for these models; System or AI messages that would useful in conversational flows are not supported."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f994b4d3-c1b0-4e87-aad0-a7b487e2aa43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.messages import ChatMessage\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        ChatMessage(\n",
+    "            role=\"context\", content=\"Parrots and Cats have signed the peace accord.\"\n",
+    "        ),\n",
+    "        (\"user\", \"{input}\"),\n",
+    "    ]\n",
+    ")\n",
+    "llm = ChatNVIDIA(model=\"nemotron_qa_8b\")\n",
+    "chain = prompt | llm | StrOutputParser()\n",
+    "chain.invoke({\"input\": \"What was signed?\"})"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "137662a6",
@@ -637,6 +708,14 @@
    "source": [
     "conversation.invoke(\"Tell me about yourself.\")[\"response\"]"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a719bd3-755d-4a05-bda2-de132bf99314",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -644,9 +723,9 @@
    "provenance": []
   },
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python (venvoss)",
    "language": "python",
-   "name": "python3"
+   "name": "venvoss"
   },
   "language_info": {
    "codemirror_mode": {
@@ -658,7 +737,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.12.3"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/ollama.ipynb

@@ -54,12 +54,12 @@
     "\n",
     "Here are a few ways to interact with pulled local models\n",
     "\n",
-    "#### In the terminal:\n",
+    "#### directly in the terminal:\n",
     "\n",
     "* All of your local models are automatically served on `localhost:11434`\n",
     "* Run `ollama run <name-of-model>` to start interacting via the command line directly\n",
     "\n",
-    "#### Via an API\n",
+    "### via an API\n",
     "\n",
     "Send an `application/json` request to the API endpoint of Ollama to interact.\n",
     "\n",
@@ -72,11 +72,9 @@
     "\n",
     "See the Ollama [API documentation](https://github.com/jmorganca/ollama/blob/main/docs/api.md) for all endpoints.\n",
     "\n",
-    "#### Via LangChain\n",
+    "#### via LangChain\n",
     "\n",
-    "See a typical basic example of using Ollama via the `ChatOllama` chat model in your LangChain application. \n",
-    "\n",
-    "View the [API Reference for ChatOllama](https://api.python.langchain.com/en/latest/chat_models/langchain_community.chat_models.ollama.ChatOllama.html#langchain_community.chat_models.ollama.ChatOllama) for more."
+    "See a typical basic example of using Ollama via the `ChatOllama` chat model in your LangChain application."
    ]
   },
   {
@@ -107,7 +105,7 @@
     "\n",
     "# using LangChain Expressive Language chain syntax\n",
     "# learn more about the LCEL on\n",
-    "# /docs/concepts/#langchain-expression-language-lcel\n",
+    "# /docs/expression_language/why\n",
     "chain = prompt | llm | StrOutputParser()\n",
     "\n",
     "# for brevity, response is printed in terminal\n",
@@ -191,7 +189,7 @@
     "\n",
     "## Building from source\n",
     "\n",
-    "For up to date instructions on building from source, check the Ollama documentation on [Building from Source](https://github.com/ollama/ollama?tab=readme-ov-file#building)"
+    "For up to date instructions on building from source, check the Ollama documentation on [Building from Source](https://github.com/jmorganca/ollama?tab=readme-ov-file#building)"
    ]
   },
   {
@@ -335,7 +333,7 @@
     }
    ],
    "source": [
-    "!pip install --upgrade --quiet  pillow"
+    "pip install --upgrade --quiet  pillow"
    ]
   },
   {
@@ -446,24 +444,6 @@
     "\n",
     "print(query_chain)"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Concurrency Features\n",
-    "\n",
-    "Ollama supports concurrency inference for a single model, and or loading multiple models simulatenously (at least [version 0.1.33](https://github.com/ollama/ollama/releases)).\n",
-    "\n",
-    "Start the Ollama server with:\n",
-    "\n",
-    "* `OLLAMA_NUM_PARALLEL`: Handle multiple requests simultaneously for a single model\n",
-    "* `OLLAMA_MAX_LOADED_MODELS`: Load multiple models simultaneously\n",
-    "\n",
-    "Example: `OLLAMA_NUM_PARALLEL=4 OLLAMA_MAX_LOADED_MODELS=4 ollama serve`\n",
-    "\n",
-    "Learn more about configuring Ollama server in [the official guide](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-do-i-configure-ollama-server)."
-   ]
   }
  ],
  "metadata": {

docs/docs/integrations/chat/openai.ipynb

@@ -12,153 +12,56 @@
   },
   {
    "cell_type": "markdown",
-   "id": "cb4dd00a-8893-4a45-96f7-9a9fc341cd61",
+   "id": "e49f1e0d",
    "metadata": {},
    "source": [
     "# ChatOpenAI\n",
     "\n",
-    "This notebook provides a quick overview for getting started with OpenAI [chat models](/docs/concepts/#chat-models). For detailed documentation of all ChatOpenAI features and configurations head to the [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_openai.chat_models.base.ChatOpenAI.html).\n",
-    "\n",
-    "OpenAI has several chat models. You can find information about their latest models and their costs, context windows, and supported input types in the [OpenAI docs](https://platform.openai.com/docs/models).\n",
-    "\n",
-    ":::info Azure OpenAI\n",
-    "\n",
-    "Note that certain OpenAI models can also be accessed via the [Microsoft Azure platform](https://azure.microsoft.com/en-us/products/ai-services/openai-service). To use the Azure OpenAI service use the [AzureChatOpenAI integration](/docs/integrations/chat/azure_chat_openai/).\n",
-    "\n",
-    ":::"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e49f1e0d",
-   "metadata": {},
-   "source": [
-    "## Overview\n",
-    "\n",
-    "### Integration details\n",
-    "| Class | Package | Local | Serializable | [JS support](https://js.langchain.com/v0.2/docs/integrations/chat/openai) | Package downloads | Package latest |\n",
-    "| :--- | :--- | :---: | :---: |  :---: | :---: | :---: |\n",
-    "| [ChatOpenAI](https://api.python.langchain.com/en/latest/chat_models/langchain_openai.chat_models.base.ChatOpenAI.html) | [langchain-openai](https://api.python.langchain.com/en/latest/openai_api_reference.html) | ❌ | beta | ✅ | ![PyPI - Downloads](https://img.shields.io/pypi/dm/langchain-openai?style=flat-square&label=%20) | ![PyPI - Version](https://img.shields.io/pypi/v/langchain-openai?style=flat-square&label=%20) |\n",
-    "\n",
-    "### Model features\n",
-    "| [Tool calling](/docs/how_to/tool_calling/) | [Structured output](/docs/how_to/structured_output/) | JSON mode | Image input | Audio input | Video input | [Token-level streaming](/docs/how_to/chat_streaming/) | Native async | [Token usage](/docs/how_to/chat_token_usage_tracking/) | [Logprobs](/docs/how_to/logprobs/) |\n",
-    "| :---: | :---: | :---: | :---: |  :---: | :---: | :---: | :---: | :---: | :---: |\n",
-    "| ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ | \n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "To access OpenAI models you'll need to create an OpenAI account, get an API key, and install the `langchain-openai` integration package.\n",
-    "\n",
-    "### Credentials\n",
-    "\n",
-    "Head to https://platform.openai.com to sign up to OpenAI and generate an API key. Once you've done this set the OPENAI_API_KEY environment variable:"
+    "This notebook covers how to get started with OpenAI chat models."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "e817fe2e-4f1d-4533-b19e-2400b1cf6ce8",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdin",
-     "output_type": "stream",
-     "text": [
-      "Enter your OpenAI API key:  ········\n"
-     ]
-    }
-   ],
-   "source": [
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"Enter your OpenAI API key: \")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c2a3ce99-a44a-4ea6-8d23-8a88e332f0f9",
-   "metadata": {},
-   "source": [
-    "If you want to get automated tracing of your model calls you can also set your [LangSmith](https://docs.smith.langchain.com/) API key by uncommenting below:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "85255d53-ac8a-44e1-aa26-8e567bb77ae7",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# os.environ[\"LANGSMITH_API_KEY\"] = getpass.getpass(\"Enter your LangSmith API key: \")\n",
-    "# os.environ[\"LANGSMITH_TRACING\"] = \"true\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c59722a9-6dbb-45f7-ae59-5be50ca5733d",
-   "metadata": {},
-   "source": [
-    "### Installation\n",
-    "\n",
-    "The LangChain OpenAI integration lives in the `langchain-openai` package:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "2113471c-75d7-45df-b784-d78da4ef7aba",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install -qU langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1098bc9d-ce83-462b-8c19-f85bf3a159dc",
-   "metadata": {},
-   "source": [
-    "## Instantiation\n",
-    "\n",
-    "Now we can instantiate our model object and generate chat completions:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 3,
    "id": "522686de",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "llm = ChatOpenAI(\n",
-    "    model=\"gpt-4o\",\n",
-    "    temperature=0,\n",
-    "    max_tokens=None,\n",
-    "    timeout=None,\n",
-    "    max_retries=2,\n",
-    "    # api_key=\"...\",  # if you prefer to pass api key in directly instaed of using env vars\n",
-    "    # base_url=\"...\",\n",
-    "    # organization=\"...\",\n",
-    "    # other params...\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6511982a-734a-4193-a47d-254f8dcaff5e",
-   "metadata": {},
-   "source": [
-    "## Invocation"
+    "from langchain_core.messages import HumanMessage, SystemMessage\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_openai import ChatOpenAI"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
+   "id": "62e0dbc3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e5fe97e",
+   "metadata": {},
+   "source": [
+    "The above cell assumes that your OpenAI API key is set in your environment variables. If you would rather manually specify your API key and/or organization ID, use the following code:\n",
+    "\n",
+    "```python\n",
+    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0, api_key=\"YOUR_API_KEY\", openai_organization=\"YOUR_ORGANIZATION_ID\")\n",
+    "```\n",
+    "Remove the openai_organization parameter should it not apply to you."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
    "id": "ce16ad78-8e6f-48cd-954e-98be75eb5836",
    "metadata": {
     "tags": []
@@ -167,42 +70,20 @@
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=\"J'adore la programmation.\", response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 31, 'total_tokens': 36}, 'model_name': 'gpt-4o', 'system_fingerprint': 'fp_43dfabdef1', 'finish_reason': 'stop', 'logprobs': None}, id='run-012cffe2-5d3d-424d-83b5-51c6d4a593d1-0', usage_metadata={'input_tokens': 31, 'output_tokens': 5, 'total_tokens': 36})"
+       "AIMessage(content=\"J'adore programmer.\", response_metadata={'token_usage': {'completion_tokens': 6, 'prompt_tokens': 34, 'total_tokens': 40}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-8591eae1-b42b-402b-a23a-dfdb0cd151bd-0')"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "messages = [\n",
-    "    (\n",
-    "        \"system\",\n",
-    "        \"You are a helpful assistant that translates English to French. Translate the user sentence.\",\n",
-    "    ),\n",
-    "    (\"human\", \"I love programming.\"),\n",
+    "    (\"system\", \"You are a helpful assistant that translates English to French.\"),\n",
+    "    (\"human\", \"Translate this sentence from English to French. I love programming.\"),\n",
     "]\n",
-    "ai_msg = llm.invoke(messages)\n",
-    "ai_msg"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "2cd224b8-4499-41fb-a604-d53a7ff17b2e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "J'adore la programmation.\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(ai_msg.content)"
+    "llm.invoke(messages)"
    ]
   },
   {
@@ -212,7 +93,7 @@
    "source": [
     "## Chaining\n",
     "\n",
-    "We can [chain](/docs/how_to/sequence/) our model with a prompt template like so:"
+    "We can chain our model with a prompt template like so:"
    ]
   },
   {
@@ -235,8 +116,6 @@
     }
    ],
    "source": [
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "\n",
     "prompt = ChatPromptTemplate.from_messages(\n",
     "    [\n",
     "        (\n",
@@ -398,23 +277,13 @@
     "\n",
     "fine_tuned_model(messages)"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a796d728-971b-408b-88d5-440015bbb941",
-   "metadata": {},
-   "source": [
-    "## API reference\n",
-    "\n",
-    "For detailed documentation of all ChatOpenAI features and configurations head to the API reference: https://api.python.langchain.com/en/latest/chat_models/langchain_openai.chat_models.base.ChatOpenAI.html"
-   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "poetry-venv-2",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "name": "poetry-venv-2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {

docs/docs/integrations/chat/premai.ipynb

@@ -15,9 +15,10 @@
    "source": [
     "# ChatPremAI\n",
     "\n",
-    "[PremAI](https://premai.io/) is an all-in-one platform that simplifies the creation of robust, production-ready applications powered by Generative AI. By streamlining the development process, PremAI allows you to concentrate on enhancing user experience and driving overall growth for your application. You can quickly start using our platform [here](https://docs.premai.io/quick-start).\n",
+    ">[PremAI](https://app.premai.io) is a unified platform that lets you build powerful production-ready GenAI-powered applications with the least effort so that you can focus more on user experience and overall growth. \n",
     "\n",
-    "This example goes over how to use LangChain to interact with different chat models with `ChatPremAI`"
+    "\n",
+    "This example goes over how to use LangChain to interact with `ChatPremAI`. "
    ]
   },
   {
@@ -26,13 +27,23 @@
    "source": [
     "### Installation and setup\n",
     "\n",
-    "We start by installing `langchain` and `premai-sdk`. You can type the following command to install:\n",
+    "We start by installing langchain and premai-sdk. You can type the following command to install:\n",
     "\n",
     "```bash\n",
     "pip install premai langchain\n",
     "```\n",
     "\n",
-    "Before proceeding further, please make sure that you have made an account on PremAI and already created a project. If not, please refer to the [quick start](https://docs.premai.io/introduction) guide to get started with the PremAI platform. Create your first project and grab your API key."
+    "Before proceeding further, please make sure that you have made an account on PremAI and already started a project. If not, then here's how you can start for free:\n",
+    "\n",
+    "1. Sign in to [PremAI](https://app.premai.io/accounts/login/), if you are coming for the first time and create your API key [here](https://app.premai.io/api_keys/).\n",
+    "\n",
+    "2. Go to [app.premai.io](https://app.premai.io) and this will take you to the project's dashboard. \n",
+    "\n",
+    "3. Create a project and this will generate a project-id (written as ID). This ID will help you to interact with your deployed application. \n",
+    "\n",
+    "4. Head over to LaunchPad (the one with 🚀 icon). And there deploy your model of choice. Your default model will be `gpt-4`. You can also set and fix different generation parameters (like max-tokens, temperature, etc) and also pre-set your system prompt. \n",
+    "\n",
+    "Congratulations on creating your first deployed application on PremAI 🎉 Now we can use langchain to interact with our application. "
    ]
   },
   {
@@ -49,13 +60,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Setup PremAI client in LangChain\n",
+    "## Setup ChatPremAI instance in LangChain \n",
     "\n",
-    "Once we imported our required modules, let's setup our client. For now let's assume that our `project_id` is `8`. But make sure you use your project-id, otherwise it will throw error.\n",
+    "Once we import our required modules, let's set up our client. For now, let's assume that our `project_id` is 8. But make sure you use your project-id, otherwise, it will throw an error.\n",
     "\n",
-    "To use langchain with prem, you do not need to pass any model name or set any parameters with our chat-client. By default it will use the model name and parameters used in the [LaunchPad](https://docs.premai.io/get-started/launchpad). \n",
+    "To use langchain with prem, you do not need to pass any model name or set any parameters with our chat client. All of those will use the default model name and parameters of the LaunchPad model. \n",
     "\n",
-    "> Note: If you change the `model` or any other parameters like `temperature`  or `max_tokens` while setting the client, it will override existing default configurations, that was used in LaunchPad.   "
+    "`NOTE:` If you change the `model_name` or any other parameter like `temperature` while setting the client, it will override existing default configurations. "
    ]
   },
   {
@@ -91,11 +102,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Chat Completions\n",
+    "## Calling the Model\n",
     "\n",
-    "`ChatPremAI` supports two methods: `invoke` (which is the same as `generate`) and `stream`. \n",
+    "Now you are all set. We can now start by interacting with our application. `ChatPremAI` supports two methods `invoke` (which is the same as `generate`) and `stream`. \n",
     "\n",
-    "The first one will give us a static result. Whereas the second one will stream tokens one by one. Here's how you can generate chat-like completions. "
+    "The first one will give us a static result. Whereas the second one will stream tokens one by one. Here's how you can generate chat-like completions. \n",
+    "\n",
+    "### Generation"
    ]
   },
   {
@@ -152,7 +165,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can provide system prompt here like this:"
+    "You can also change generation parameters while calling the model. Here's how you can do that"
    ]
   },
   {
@@ -179,72 +192,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "> If you are going to place system prompt here, then it will override your system prompt that was fixed while deploying the application from the platform. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Native RAG Support with Prem Repositories\n",
+    "### Important notes:\n",
     "\n",
-    "Prem Repositories which allows users to upload documents (.txt, .pdf etc) and connect those repositories to the LLMs. You can think Prem repositories as native RAG, where each repository can be considered as a vector database. You can connect multiple repositories. You can learn more about repositories [here](https://docs.premai.io/get-started/repositories).\n",
+    "Before proceeding further, please note that the current version of ChatPrem does not support parameters: [n](https://platform.openai.com/docs/api-reference/chat/create#chat-create-n) and [stop](https://platform.openai.com/docs/api-reference/chat/create#chat-create-stop) are not supported. \n",
     "\n",
-    "Repositories are also supported in langchain premai. Here is how you can do it. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query = \"what is the diameter of individual Galaxy\"\n",
-    "repository_ids = [\n",
-    "    1991,\n",
-    "]\n",
-    "repositories = dict(ids=repository_ids, similarity_threshold=0.3, limit=3)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "First we start by defining our repository with some repository ids. Make sure that the ids are valid repository ids. You can learn more about how to get the repository id [here](https://docs.premai.io/get-started/repositories). \n",
+    "We will provide support for those two above parameters in sooner versions. \n",
     "\n",
-    "> Please note: Similar like `model_name` when you invoke the argument `repositories`, then you are potentially overriding the repositories connected in the launchpad. \n",
-    "\n",
-    "Now, we connect the repository with our chat object to invoke RAG based generations. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "\n",
-    "response = chat.invoke(query, max_tokens=100, repositories=repositories)\n",
-    "\n",
-    "print(response.content)\n",
-    "print(json.dumps(response.response_metadata, indent=4))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> Ideally, you do not need to connect Repository IDs here to get Retrieval Augmented Generations. You can still get the same result if you have connected the repositories in prem platform. "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
     "### Streaming\n",
     "\n",
-    "In this section, let's see how we can stream tokens using langchain and PremAI. Here's how you do it. "
+    "And finally, here's how you do token streaming for dynamic chat like applications. "
    ]
   },
   {
@@ -272,7 +228,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Similar to above, if you want to override the system-prompt and the generation parameters, you need to add the following:"
+    "Similar to above, if you want to override the system-prompt and the generation parameters, here's how you can do it. "
    ]
   },
   {

docs/docs/integrations/document_loaders/airtable.ipynb

@@ -47,8 +47,7 @@
    "source": [
     "api_key = \"xxx\"\n",
     "base_id = \"xxx\"\n",
-    "table_id = \"xxx\"\n",
-    "view = \"xxx\"  # optional"
+    "table_id = \"xxx\""
    ]
   },
   {
@@ -58,7 +57,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "loader = AirtableLoader(api_key, table_id, base_id, view=view)\n",
+    "loader = AirtableLoader(api_key, table_id, base_id)\n",
     "docs = loader.load()"
    ]
   },

docs/docs/integrations/document_loaders/apify_dataset.ipynb

@@ -13,7 +13,7 @@
     "\n",
     "## Prerequisites\n",
     "\n",
-    "You need to have an existing dataset on the Apify platform. If you don't have one, please first check out [this notebook](/docs/integrations/tools/apify) on how to use Apify to extract content from documentation, knowledge bases, help centers, or blogs. This example shows how to load a dataset produced by the [Website Content Crawler](https://apify.com/apify/website-content-crawler)."
+    "You need to have an existing dataset on the Apify platform. If you don't have one, please first check out [this notebook](/docs/integrations/tools/apify) on how to use Apify to extract content from documentation, knowledge bases, help centers, or blogs."
    ]
   },
   {
@@ -101,10 +101,8 @@
    "outputs": [],
    "source": [
     "from langchain.indexes import VectorstoreIndexCreator\n",
-    "from langchain_community.utilities import ApifyWrapper\n",
-    "from langchain_core.documents import Document\n",
-    "from langchain_openai import OpenAI\n",
-    "from langchain_openai.embeddings import OpenAIEmbeddings"
+    "from langchain_community.document_loaders import ApifyDatasetLoader\n",
+    "from langchain_core.documents import Document"
    ]
   },
   {
@@ -127,7 +125,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "index = VectorstoreIndexCreator(embedding=OpenAIEmbeddings()).from_loaders([loader])"
+    "index = VectorstoreIndexCreator().from_loaders([loader])"
    ]
   },
   {
@@ -137,7 +135,7 @@
    "outputs": [],
    "source": [
     "query = \"What is Apify?\"\n",
-    "result = index.query_with_sources(query, llm=OpenAI())"
+    "result = index.query_with_sources(query)"
    ]
   },
   {

docs/docs/integrations/document_loaders/async_chromium.ipynb

@@ -48,7 +48,7 @@
     "from langchain_community.document_loaders import AsyncChromiumLoader\n",
     "\n",
     "urls = [\"https://www.wsj.com\"]\n",
-    "loader = AsyncChromiumLoader(urls, user_agent=\"MyAppUserAgent\")\n",
+    "loader = AsyncChromiumLoader(urls)\n",
     "docs = loader.load()\n",
     "docs[0].page_content[0:100]"
    ]

docs/docs/integrations/document_loaders/jupyter_notebook.ipynb

@@ -8,7 +8,7 @@
     "\n",
     ">[Jupyter Notebook](https://en.wikipedia.org/wiki/Project_Jupyter#Applications) (formerly `IPython Notebook`) is a web-based interactive computational environment for creating notebook documents.\n",
     "\n",
-    "This notebook covers how to load data from a `Jupyter notebook (.ipynb)` into a format suitable by LangChain."
+    "This notebook covers how to load data from a `Jupyter notebook (.html)` into a format suitable by LangChain."
    ]
   },
   {
@@ -31,7 +31,7 @@
    "outputs": [],
    "source": [
     "loader = NotebookLoader(\n",
-    "    \"example_data/notebook.ipynb\",\n",
+    "    \"example_data/notebook.html\",\n",
     "    include_outputs=True,\n",
     "    max_output_length=20,\n",
     "    remove_newline=True,\n",
@@ -42,7 +42,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "`NotebookLoader.load()` loads the `.ipynb` notebook file into a `Document` object.\n",
+    "`NotebookLoader.load()` loads the `.html` notebook file into a `Document` object.\n",
     "\n",
     "**Parameters**:\n",
     "\n",

docs/docs/integrations/document_loaders/kinetica.ipynb

@@ -15,7 +15,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install gpudb==7.2.0.9"
+    "%pip install gpudb==7.2.0.1"
    ]
   },
   {
@@ -97,14 +97,14 @@
     "# data and the `SCHEMA.TABLE` combination must exist in Kinetica.\n",
     "\n",
     "QUERY = \"select text, survey_id as source from SCHEMA.TABLE limit 10\"\n",
-    "kl = KineticaLoader(\n",
+    "snowflake_loader = KineticaLoader(\n",
     "    query=QUERY,\n",
     "    host=HOST,\n",
     "    username=USERNAME,\n",
     "    password=PASSWORD,\n",
     "    metadata_columns=[\"source\"],\n",
     ")\n",
-    "kinetica_documents = kl.load()\n",
+    "kinetica_documents = snowflake_loader.load()\n",
     "print(kinetica_documents)"
    ]
   }

docs/docs/integrations/document_loaders/source_code.ipynb

@@ -17,7 +17,6 @@
     "- C++ (*)\n",
     "- C# (*)\n",
     "- COBOL\n",
-    "- Elixir\n",
     "- Go (*)\n",
     "- Java (*)\n",
     "- JavaScript (requires package `esprima`)\n",

docs/docs/integrations/document_loaders/tomarkdown.ipynb

@@ -113,7 +113,7 @@
       "\n",
       "LCEL is a declarative way to compose chains. LCEL was designed from day 1 to support putting prototypes in production, with no code changes, from the simplest “prompt + LLM” chain to the most complex chains.\n",
       "\n",
-      "- **[Overview](/docs/concepts#langchain-expression-language-lcel)**: LCEL and its benefits\n",
+      "- **[Overview](/docs/concepts#langchain-expression-language)**: LCEL and its benefits\n",
       "- **[Interface](/docs/concepts#interface)**: The standard interface for LCEL objects\n",
       "- **[How-to](/docs/expression_language/how_to)**: Key features of LCEL\n",
       "- **[Cookbook](/docs/expression_language/cookbook)**: Example code for accomplishing common tasks\n",

docs/docs/integrations/document_loaders/youtube_transcript.ipynb

@@ -15,45 +15,47 @@
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "427d5745",
    "metadata": {},
-   "source": "from langchain_community.document_loaders import YoutubeLoader",
    "outputs": [],
-   "execution_count": null
+   "source": [
+    "from langchain_community.document_loaders import YoutubeLoader"
+   ]
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "34a25b57",
    "metadata": {
     "scrolled": true
    },
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  youtube-transcript-api"
-   ],
-   "outputs": [],
-   "execution_count": null
+   ]
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "bc8b308a",
    "metadata": {},
+   "outputs": [],
    "source": [
     "loader = YoutubeLoader.from_youtube_url(\n",
     "    \"https://www.youtube.com/watch?v=QsYGlZkevEg\", add_video_info=False\n",
     ")"
-   ],
-   "outputs": [],
-   "execution_count": null
+   ]
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "d073dd36",
    "metadata": {},
+   "outputs": [],
    "source": [
     "loader.load()"
-   ],
-   "outputs": [],
-   "execution_count": null
+   ]
   },
   {
    "attachments": {},
@@ -66,26 +68,26 @@
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "ba28af69",
    "metadata": {},
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  pytube"
-   ],
-   "outputs": [],
-   "execution_count": null
+   ]
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "9b8ea390",
    "metadata": {},
+   "outputs": [],
    "source": [
     "loader = YoutubeLoader.from_youtube_url(\n",
     "    \"https://www.youtube.com/watch?v=QsYGlZkevEg\", add_video_info=True\n",
     ")\n",
     "loader.load()"
-   ],
-   "outputs": [],
-   "execution_count": null
+   ]
   },
   {
    "attachments": {},
@@ -102,8 +104,10 @@
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "08510625",
    "metadata": {},
+   "outputs": [],
    "source": [
     "loader = YoutubeLoader.from_youtube_url(\n",
     "    \"https://www.youtube.com/watch?v=QsYGlZkevEg\",\n",
@@ -112,41 +116,7 @@
     "    translation=\"en\",\n",
     ")\n",
     "loader.load()"
-   ],
-   "outputs": [],
-   "execution_count": null
-  },
-  {
-   "metadata": {},
-   "cell_type": "markdown",
-   "source": [
-    "### Get transcripts as timestamped chunks\n",
-    "\n",
-    "Get one or more `Document` objects, each containing a chunk of the video transcript.  The length of the chunks, in seconds, may be specified.  Each chunk's metadata includes a URL of the video on YouTube, which will start the video at the beginning of the specific chunk.\n",
-    "\n",
-    "`transcript_format` param:  One of the `langchain_community.document_loaders.youtube.TranscriptFormat` values.  In this case, `TranscriptFormat.CHUNKS`.\n",
-    "\n",
-    "`chunk_size_seconds` param:  An integer number of video seconds to be represented by each chunk of transcript data.  Default is 120 seconds."
-   ],
-   "id": "69f4e399a9764d73"
-  },
-  {
-   "metadata": {},
-   "cell_type": "code",
-   "source": [
-    "from langchain_community.document_loaders.youtube import TranscriptFormat\n",
-    "\n",
-    "loader = YoutubeLoader.from_youtube_url(\n",
-    "    \"https://www.youtube.com/watch?v=TKCMw0utiak\",\n",
-    "    add_video_info=True,\n",
-    "    transcript_format=TranscriptFormat.CHUNKS,\n",
-    "    chunk_size_seconds=30,\n",
-    ")\n",
-    "print(\"\\n\\n\".join(map(repr, loader.load())))"
-   ],
-   "id": "540bbf19182f38bc",
-   "outputs": [],
-   "execution_count": null
+   ]
   },
   {
    "attachments": {},
@@ -172,8 +142,10 @@
   },
   {
    "cell_type": "code",
+   "execution_count": null,
    "id": "c345bc43",
    "metadata": {},
+   "outputs": [],
    "source": [
     "# Init the GoogleApiClient\n",
     "from pathlib import Path\n",
@@ -198,9 +170,7 @@
     "\n",
     "# returns a list of Documents\n",
     "youtube_loader_channel.load()"
-   ],
-   "outputs": [],
-   "execution_count": null
+   ]
   }
  ],
  "metadata": {

docs/docs/integrations/document_transformers/dashscope_rerank.ipynb

@@ -1,387 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# DashScope Reranker\n",
-    "\n",
-    "This notebook shows how to use DashScope Reranker for document compression and retrieval. [DashScope](https://dashscope.aliyun.com/) is the generative AI service from Alibaba Cloud (Aliyun).\n",
-    "\n",
-    "DashScope's [Text ReRank Model](https://help.aliyun.com/document_detail/2780058.html?spm=a2c4g.2780059.0.0.6d995024FlrJ12) supports reranking documents with a maximum of 4000 tokens. Moreover, it supports Chinese, English, Japanese, Korean, Thai, Spanish, French, Portuguese, Indonesian, Arabic, and over 50 other languages. For more details, please visit [here](https://help.aliyun.com/document_detail/2780059.html?spm=a2c4g.2780058.0.0.3a9e5b1dWeOQjI)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  dashscope"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  faiss\n",
-    "\n",
-    "# OR  (depending on Python version)\n",
-    "\n",
-    "%pip install --upgrade --quiet  faiss-cpu"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# To create api key: https://bailian.console.aliyun.com/?apiKey=1#/api-key\n",
-    "\n",
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "os.environ[\"DASHSCOPE_API_KEY\"] = getpass.getpass(\"DashScope API Key:\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Helper function for printing docs\n",
-    "def pretty_print_docs(docs):\n",
-    "    print(\n",
-    "        f\"\\n{'-' * 100}\\n\".join(\n",
-    "            [f\"Document {i+1}:\\n\\n\" + d.page_content for i, d in enumerate(docs)]\n",
-    "        )\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Set up the base vector store retriever\n",
-    "Let's start by initializing a simple vector store retriever and storing the 2023 State of the Union speech (in chunks). We can set up the retriever to retrieve a high number (20) of docs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Document 1:\n",
-      "\n",
-      "I understand. \n",
-      "\n",
-      "I remember when my Dad had to leave our home in Scranton, Pennsylvania to find work. I grew up in a family where if the price of food went up, you felt it. \n",
-      "\n",
-      "That’s why one of the first things I did as President was fight to pass the American Rescue Plan.  \n",
-      "\n",
-      "Because people were hurting. We needed to act, and we did. \n",
-      "\n",
-      "Few pieces of legislation have done more in a critical moment in our history to lift us out of crisis.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 2:\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",
-      "Document 3:\n",
-      "\n",
-      "To all Americans, I will be honest with you, as I’ve always promised. A Russian dictator, invading a foreign country, has costs around the world. \n",
-      "\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",
-      "Document 4:\n",
-      "\n",
-      "We cannot let this happen. \n",
-      "\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",
-      "Document 5:\n",
-      "\n",
-      "Tonight I say to the Russian oligarchs and corrupt leaders who have bilked billions of dollars off this violent regime no more. \n",
-      "\n",
-      "The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs.  \n",
-      "\n",
-      "We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 6:\n",
-      "\n",
-      "Every Administration says they’ll do it, but we are actually doing it. \n",
-      "\n",
-      "We will buy American to make sure everything from the deck of an aircraft carrier to the steel on highway guardrails are made in America. \n",
-      "\n",
-      "But to compete for the best jobs of the future, we also need to level the playing field with China and other competitors.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 7:\n",
-      "\n",
-      "When we invest in our workers, when we build the economy from the bottom up and the middle out together, we can do something we haven’t done in a long time: build a better America. \n",
-      "\n",
-      "For more than two years, COVID-19 has impacted every decision in our lives and the life of the nation. \n",
-      "\n",
-      "And I know you’re tired, frustrated, and exhausted. \n",
-      "\n",
-      "But I also know this.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 8:\n",
-      "\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",
-      "Document 9:\n",
-      "\n",
-      "My plan will not only lower costs to give families a fair shot, it will lower the deficit. \n",
-      "\n",
-      "The previous Administration not only ballooned the deficit with tax cuts for the very wealthy and corporations, it undermined the watchdogs whose job was to keep pandemic relief funds from being wasted. \n",
-      "\n",
-      "But in my administration, the watchdogs have been welcomed back. \n",
-      "\n",
-      "We’re going after the criminals who stole billions in relief money meant for small businesses and millions of Americans.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 10:\n",
-      "\n",
-      "He will never extinguish their love of freedom. He will never weaken the resolve of the free world. \n",
-      "\n",
-      "We meet tonight in an America that has lived through two of the hardest years this nation has ever faced. \n",
-      "\n",
-      "The pandemic has been punishing. \n",
-      "\n",
-      "And so many families are living paycheck to paycheck, struggling to keep up with the rising cost of food, gas, housing, and so much more. \n",
-      "\n",
-      "I understand.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 11:\n",
-      "\n",
-      "And tonight, I’m announcing that the Justice Department will name a chief prosecutor for pandemic fraud. \n",
-      "\n",
-      "By the end of this year, the deficit will be down to less than half what it was before I took office.  \n",
-      "\n",
-      "The only president ever to cut the deficit by more than one trillion dollars in a single year. \n",
-      "\n",
-      "Lowering your costs also means demanding more competition. \n",
-      "\n",
-      "I’m a capitalist, but capitalism without competition isn’t capitalism. \n",
-      "\n",
-      "It’s exploitation—and it drives up prices.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 12:\n",
-      "\n",
-      "Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. \n",
-      "\n",
-      "Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. \n",
-      "\n",
-      "Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos.   \n",
-      "\n",
-      "They keep moving.   \n",
-      "\n",
-      "And the costs and the threats to America and the world keep rising.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 13:\n",
-      "\n",
-      "Cancer is the #2 cause of death in America–second only to heart disease. \n",
-      "\n",
-      "Last month, I announced our plan to supercharge  \n",
-      "the Cancer Moonshot that President Obama asked me to lead six years ago. \n",
-      "\n",
-      "Our goal is to cut the cancer death rate by at least 50% over the next 25 years, turn more cancers from death sentences into treatable diseases.  \n",
-      "\n",
-      "More support for patients and families. \n",
-      "\n",
-      "To get there, I call on Congress to fund ARPA-H, the Advanced Research Projects Agency for Health.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 14:\n",
-      "\n",
-      "It fueled our efforts to vaccinate the nation and combat COVID-19. It delivered immediate economic relief for tens of millions of Americans.  \n",
-      "\n",
-      "Helped put food on their table, keep a roof over their heads, and cut the cost of health insurance. \n",
-      "\n",
-      "And as my Dad used to say, it gave people a little breathing room.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 15:\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",
-      "Document 16:\n",
-      "\n",
-      "So that’s my plan. It will grow the economy and lower costs for families. \n",
-      "\n",
-      "So what are we waiting for? Let’s get this done. And while you’re at it, confirm my nominees to the Federal Reserve, which plays a critical role in fighting inflation.  \n",
-      "\n",
-      "My plan will not only lower costs to give families a fair shot, it will lower the deficit.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 17:\n",
-      "\n",
-      "And we will, as one people. \n",
-      "\n",
-      "One America. \n",
-      "\n",
-      "The United States of America. \n",
-      "\n",
-      "May God bless you all. May God protect our troops.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 18:\n",
-      "\n",
-      "As I’ve told Xi Jinping, it is never a good bet to bet against the American people. \n",
-      "\n",
-      "We’ll create good jobs for millions of Americans, modernizing roads, airports, ports, and waterways all across America. \n",
-      "\n",
-      "And we’ll do it all to withstand the devastating effects of the climate crisis and promote environmental justice.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 19:\n",
-      "\n",
-      "And I know you’re tired, frustrated, and exhausted. \n",
-      "\n",
-      "But I also know this. \n",
-      "\n",
-      "Because of the progress we’ve made, because of your resilience and the tools we have, tonight I can say  \n",
-      "we are moving forward safely, back to more normal routines.  \n",
-      "\n",
-      "We’ve reached a new moment in the fight against COVID-19, with severe cases down to a level not seen since last July.  \n",
-      "\n",
-      "Just a few days ago, the Centers for Disease Control and Prevention—the CDC—issued new mask guidelines.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 20:\n",
-      "\n",
-      "Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \n",
-      "\n",
-      "Last year COVID-19 kept us apart. This year we are finally together again. \n",
-      "\n",
-      "Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n",
-      "\n",
-      "With a duty to one another to the American people to the Constitution. \n",
-      "\n",
-      "And with an unwavering resolve that freedom will always triumph over tyranny.\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain_community.document_loaders import TextLoader\n",
-    "from langchain_community.embeddings.dashscope import DashScopeEmbeddings\n",
-    "from langchain_community.vectorstores.faiss import FAISS\n",
-    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
-    "\n",
-    "documents = TextLoader(\"../../how_to/state_of_the_union.txt\").load()\n",
-    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)\n",
-    "texts = text_splitter.split_documents(documents)\n",
-    "retriever = FAISS.from_documents(texts, DashScopeEmbeddings()).as_retriever(  # type: ignore\n",
-    "    search_kwargs={\"k\": 20}\n",
-    ")\n",
-    "\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = retriever.invoke(query)\n",
-    "pretty_print_docs(docs)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Reranking with DashScopeRerank\n",
-    "Now let's wrap our base retriever with a `ContextualCompressionRetriever`. We'll use the `DashScopeRerank` to rerank the returned results."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Document 1:\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",
-      "Document 2:\n",
-      "\n",
-      "Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \n",
-      "\n",
-      "Last year COVID-19 kept us apart. This year we are finally together again. \n",
-      "\n",
-      "Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n",
-      "\n",
-      "With a duty to one another to the American people to the Constitution. \n",
-      "\n",
-      "And with an unwavering resolve that freedom will always triumph over tyranny.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 3:\n",
-      "\n",
-      "Tonight I say to the Russian oligarchs and corrupt leaders who have bilked billions of dollars off this violent regime no more. \n",
-      "\n",
-      "The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs.  \n",
-      "\n",
-      "We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains.\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain.retrievers import ContextualCompressionRetriever\n",
-    "from langchain_community.document_compressors.dashscope_rerank import DashScopeRerank\n",
-    "\n",
-    "compressor = DashScopeRerank()\n",
-    "compression_retriever = ContextualCompressionRetriever(\n",
-    "    base_compressor=compressor, base_retriever=retriever\n",
-    ")\n",
-    "\n",
-    "compressed_docs = compression_retriever.invoke(\n",
-    "    \"What did the president say about Ketanji Jackson Brown\"\n",
-    ")\n",
-    "pretty_print_docs(compressed_docs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/document_transformers/volcengine_rerank.ipynb

@@ -1,420 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Volcengine Reranker\n",
-    "\n",
-    "This notebook shows how to use Volcengine Reranker for document compression and retrieval. [Volcengine](https://www.volcengine.com/) is a cloud service platform developed by ByteDance, the parent company of TikTok.\n",
-    "\n",
-    "Volcengine's Rerank Service supports reranking up to 50 documents with a maximum of 4000 tokens. For more, please visit [here](https://www.volcengine.com/docs/84313/1254474) and [here](https://www.volcengine.com/docs/84313/1254605)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  volcengine"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  faiss\n",
-    "\n",
-    "# OR  (depending on Python version)\n",
-    "\n",
-    "%pip install --upgrade --quiet  faiss-cpu"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# To obtain ak/sk: https://www.volcengine.com/docs/84313/1254488\n",
-    "\n",
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "os.environ[\"VOLC_API_AK\"] = getpass.getpass(\"Volcengine API AK:\")\n",
-    "os.environ[\"VOLC_API_SK\"] = getpass.getpass(\"Volcengine API SK:\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Helper function for printing docs\n",
-    "def pretty_print_docs(docs):\n",
-    "    print(\n",
-    "        f\"\\n{'-' * 100}\\n\".join(\n",
-    "            [f\"Document {i+1}:\\n\\n\" + d.page_content for i, d in enumerate(docs)]\n",
-    "        )\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Set up the base vector store retriever\n",
-    "Let's start by initializing a simple vector store retriever and storing the 2023 State of the Union speech (in chunks). We can set up the retriever to retrieve a high number (20) of docs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/terminator/Developer/langchain/.venv/lib/python3.11/site-packages/sentence_transformers/cross_encoder/CrossEncoder.py:11: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n",
-      "  from tqdm.autonotebook import tqdm, trange\n",
-      "/Users/terminator/Developer/langchain/.venv/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
-      "  warnings.warn(\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Document 1:\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",
-      "Document 2:\n",
-      "\n",
-      "We cannot let this happen. \n",
-      "\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",
-      "Document 3:\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",
-      "Document 4:\n",
-      "\n",
-      "He will never extinguish their love of freedom. He will never weaken the resolve of the free world. \n",
-      "\n",
-      "We meet tonight in an America that has lived through two of the hardest years this nation has ever faced. \n",
-      "\n",
-      "The pandemic has been punishing. \n",
-      "\n",
-      "And so many families are living paycheck to paycheck, struggling to keep up with the rising cost of food, gas, housing, and so much more. \n",
-      "\n",
-      "I understand.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 5:\n",
-      "\n",
-      "As Ohio Senator Sherrod Brown says, “It’s time to bury the label “Rust Belt.” \n",
-      "\n",
-      "It’s time. \n",
-      "\n",
-      "But with all the bright spots in our economy, record job growth and higher wages, too many families are struggling to keep up with the bills.  \n",
-      "\n",
-      "Inflation is robbing them of the gains they might otherwise feel. \n",
-      "\n",
-      "I get it. That’s why my top priority is getting prices under control.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 6:\n",
-      "\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",
-      "Document 7:\n",
-      "\n",
-      "It’s not only the right thing to do—it’s the economically smart thing to do. \n",
-      "\n",
-      "That’s why immigration reform is supported by everyone from labor unions to religious leaders to the U.S. Chamber of Commerce. \n",
-      "\n",
-      "Let’s get it done once and for all. \n",
-      "\n",
-      "Advancing liberty and justice also requires protecting the rights of women. \n",
-      "\n",
-      "The constitutional right affirmed in Roe v. Wade—standing precedent for half a century—is under attack as never before.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 8:\n",
-      "\n",
-      "I understand. \n",
-      "\n",
-      "I remember when my Dad had to leave our home in Scranton, Pennsylvania to find work. I grew up in a family where if the price of food went up, you felt it. \n",
-      "\n",
-      "That’s why one of the first things I did as President was fight to pass the American Rescue Plan.  \n",
-      "\n",
-      "Because people were hurting. We needed to act, and we did. \n",
-      "\n",
-      "Few pieces of legislation have done more in a critical moment in our history to lift us out of crisis.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 9:\n",
-      "\n",
-      "Third – we can end the shutdown of schools and businesses. We have the tools we need. \n",
-      "\n",
-      "It’s time for Americans to get back to work and fill our great downtowns again.  People working from home can feel safe to begin to return to the office.   \n",
-      "\n",
-      "We’re doing that here in the federal government. The vast majority of federal workers will once again work in person. \n",
-      "\n",
-      "Our schools are open. Let’s keep it that way. Our kids need to be in school.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 10:\n",
-      "\n",
-      "He met the Ukrainian people. \n",
-      "\n",
-      "From President Zelenskyy to every Ukrainian, their fearlessness, their courage, their determination, inspires the world. \n",
-      "\n",
-      "Groups of citizens blocking tanks with their bodies. Everyone from students to retirees teachers turned soldiers defending their homeland. \n",
-      "\n",
-      "In this struggle as President Zelenskyy said in his speech to the European Parliament “Light will win over darkness.” The Ukrainian Ambassador to the United States is here tonight.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 11:\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",
-      "But cancer from prolonged exposure to burn pits ravaged Heath’s lungs and body. \n",
-      "\n",
-      "Danielle says Heath was a fighter to the very end.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 12:\n",
-      "\n",
-      "Danielle says Heath was a fighter to the very end. \n",
-      "\n",
-      "He didn’t know how to stop fighting, and neither did she. \n",
-      "\n",
-      "Through her pain she found purpose to demand we do better. \n",
-      "\n",
-      "Tonight, Danielle—we are. \n",
-      "\n",
-      "The VA is pioneering new ways of linking toxic exposures to diseases, already helping more veterans get benefits. \n",
-      "\n",
-      "And tonight, I’m announcing we’re expanding eligibility to veterans suffering from nine respiratory cancers.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 13:\n",
-      "\n",
-      "We can do all this while keeping lit the torch of liberty that has led generations of immigrants to this land—my forefathers and so many of yours. \n",
-      "\n",
-      "Provide a pathway to citizenship for Dreamers, those on temporary status, farm workers, and essential workers. \n",
-      "\n",
-      "Revise our laws so businesses have the workers they need and families don’t wait decades to reunite. \n",
-      "\n",
-      "It’s not only the right thing to do—it’s the economically smart thing to do.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 14:\n",
-      "\n",
-      "He rejected repeated efforts at diplomacy. \n",
-      "\n",
-      "He thought the West and NATO wouldn’t respond. And he thought he could divide us at home. Putin was wrong. We were ready.  Here is what we did.   \n",
-      "\n",
-      "We prepared extensively and carefully. \n",
-      "\n",
-      "We spent months building a coalition of other freedom-loving nations from Europe and the Americas to Asia and Africa to confront Putin.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 15:\n",
-      "\n",
-      "As I’ve told Xi Jinping, it is never a good bet to bet against the American people. \n",
-      "\n",
-      "We’ll create good jobs for millions of Americans, modernizing roads, airports, ports, and waterways all across America. \n",
-      "\n",
-      "And we’ll do it all to withstand the devastating effects of the climate crisis and promote environmental justice.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 16:\n",
-      "\n",
-      "Tonight I say to the Russian oligarchs and corrupt leaders who have bilked billions of dollars off this violent regime no more. \n",
-      "\n",
-      "The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs.  \n",
-      "\n",
-      "We are joining with our European allies to find and seize your yachts your luxury apartments your private jets. We are coming for your ill-begotten gains.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 17:\n",
-      "\n",
-      "Look at cars. \n",
-      "\n",
-      "Last year, there weren’t enough semiconductors to make all the cars that people wanted to buy. \n",
-      "\n",
-      "And guess what, prices of automobiles went up. \n",
-      "\n",
-      "So—we have a choice. \n",
-      "\n",
-      "One way to fight inflation is to drive down wages and make Americans poorer.  \n",
-      "\n",
-      "I have a better plan to fight inflation. \n",
-      "\n",
-      "Lower your costs, not your wages. \n",
-      "\n",
-      "Make more cars and semiconductors in America. \n",
-      "\n",
-      "More infrastructure and innovation in America. \n",
-      "\n",
-      "More goods moving faster and cheaper in America.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 18:\n",
-      "\n",
-      "So that’s my plan. It will grow the economy and lower costs for families. \n",
-      "\n",
-      "So what are we waiting for? Let’s get this done. And while you’re at it, confirm my nominees to the Federal Reserve, which plays a critical role in fighting inflation.  \n",
-      "\n",
-      "My plan will not only lower costs to give families a fair shot, it will lower the deficit.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 19:\n",
-      "\n",
-      "Let each of us here tonight in this Chamber send an unmistakable signal to Ukraine and to the world. \n",
-      "\n",
-      "Please rise if you are able and show that, Yes, we the United States of America stand with the Ukrainian people. \n",
-      "\n",
-      "Throughout our history we’ve learned this lesson when dictators do not pay a price for their aggression they cause more chaos.   \n",
-      "\n",
-      "They keep moving.   \n",
-      "\n",
-      "And the costs and the threats to America and the world keep rising.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 20:\n",
-      "\n",
-      "It’s based on DARPA—the Defense Department project that led to the Internet, GPS, and so much more.  \n",
-      "\n",
-      "ARPA-H will have a singular purpose—to drive breakthroughs in cancer, Alzheimer’s, diabetes, and more. \n",
-      "\n",
-      "A unity agenda for the nation. \n",
-      "\n",
-      "We can do this. \n",
-      "\n",
-      "My fellow Americans—tonight , we have gathered in a sacred space—the citadel of our democracy. \n",
-      "\n",
-      "In this Capitol, generation after generation, Americans have debated great questions amid great strife, and have done great things.\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"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain_community.document_loaders import TextLoader\n",
-    "from langchain_community.vectorstores.faiss import FAISS\n",
-    "from langchain_huggingface import HuggingFaceEmbeddings\n",
-    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
-    "\n",
-    "documents = TextLoader(\"../../how_to/state_of_the_union.txt\").load()\n",
-    "text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)\n",
-    "texts = text_splitter.split_documents(documents)\n",
-    "retriever = FAISS.from_documents(\n",
-    "    texts, HuggingFaceEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
-    ").as_retriever(search_kwargs={\"k\": 20})\n",
-    "\n",
-    "query = \"What did the president say about Ketanji Brown Jackson\"\n",
-    "docs = retriever.invoke(query)\n",
-    "pretty_print_docs(docs)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Reranking with VolcengineRerank\n",
-    "Now let's wrap our base retriever with a `ContextualCompressionRetriever`. We'll use the `VolcengineRerank` to rerank the returned results."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Document 1:\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",
-      "Document 2:\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",
-      "Document 3:\n",
-      "\n",
-      "We cannot let this happen. \n",
-      "\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"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain.retrievers import ContextualCompressionRetriever\n",
-    "from langchain_community.document_compressors.volcengine_rerank import VolcengineRerank\n",
-    "\n",
-    "compressor = VolcengineRerank()\n",
-    "compression_retriever = ContextualCompressionRetriever(\n",
-    "    base_compressor=compressor, base_retriever=retriever\n",
-    ")\n",
-    "\n",
-    "compressed_docs = compression_retriever.invoke(\n",
-    "    \"What did the president say about Ketanji Jackson Brown\"\n",
-    ")\n",
-    "pretty_print_docs(compressed_docs)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

docs/docs/integrations/document_transformers/voyageai-reranker.ipynb

@@ -90,9 +90,7 @@
     "- `voyage-code-2`\n",
     "- `voyage-2`\n",
     "- `voyage-law-2`\n",
-    "- `voyage-lite-02-instruct`\n",
-    "- `voyage-finance-2`\n",
-    "- `voyage-multilingual-2`"
+    "- `voyage-lite-02-instruct`"
    ]
   },
   {
@@ -338,10 +336,7 @@
    "metadata": {},
    "source": [
     "## Doing reranking with VoyageAIRerank\n",
-    "Now let's wrap our base retriever with a `ContextualCompressionRetriever`. We'll use the Voyage AI reranker to rerank the returned results. You can use any of the following Reranking models: ([source](https://docs.voyageai.com/docs/reranker)):\n",
-    "\n",
-    "- `rerank-1`\n",
-    "- `rerank-lite-1`"
+    "Now let's wrap our base retriever with a `ContextualCompressionRetriever`. We'll use the Voyage AI reranker to rerank the returned results."
    ]
   },
   {

docs/docs/integrations/graphs/diffbot.ipynb

@@ -9,7 +9,8 @@
     "\n",
     ">[Diffbot](https://docs.diffbot.com/docs/getting-started-with-diffbot) is a suite of ML-based products that make it easy to structure web data.\n",
     ">\n",
-    ">Diffbot's [Natural Language Processing API](https://www.diffbot.com/products/natural-language/) allows for the extraction of entities, relationships, and semantic meaning from unstructured text data.\n",
+    ">Diffbot's [Natural Language Processing API](https://www.diffbot.com/products/natural-language/) allows for the extraction of entities, relationships, and semantic meaning from unstructured text data.",
+    "\n",
     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/docs/integrations/graphs/diffbot.ipynb)\n",
     "\n",
     "## Use case\n",
@@ -69,8 +70,8 @@
    "source": [
     "from langchain_experimental.graph_transformers.diffbot import DiffbotGraphTransformer\n",
     "\n",
-    "diffbot_api_key = \"DIFFBOT_KEY\"\n",
-    "diffbot_nlp = DiffbotGraphTransformer(diffbot_api_key=diffbot_api_key)"
+    "diffbot_api_token = \"DIFFBOT_API_TOKEN\"\n",
+    "diffbot_nlp = DiffbotGraphTransformer(diffbot_api_token=diffbot_api_token)"
    ]
   },
   {
@@ -110,7 +111,7 @@
     "    --name neo4j \\\n",
     "    -p 7474:7474 -p 7687:7687 \\\n",
     "    -d \\\n",
-    "    -e NEO4J_AUTH=neo4j/password \\\n",
+    "    -e NEO4J_AUTH=neo4j/pleaseletmein \\\n",
     "    -e NEO4J_PLUGINS=\\[\\\"apoc\\\"\\]  \\\n",
     "    neo4j:latest\n",
     "```    \n",
@@ -128,7 +129,7 @@
     "\n",
     "url = \"bolt://localhost:7687\"\n",
     "username = \"neo4j\"\n",
-    "password = \"password\"\n",
+    "password = \"pleaseletmein\"\n",
     "\n",
     "graph = Neo4jGraph(url=url, username=username, password=password)"
    ]
@@ -295,7 +296,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.18"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/graphs/neo4j_cypher.ipynb

@@ -164,10 +164,10 @@
      "text": [
       "Node properties:\n",
       "- **Movie**\n",
-      "  - `runtime`: INTEGER Min: 120, Max: 120\n",
-      "  - `name`: STRING Available options: ['Top Gun']\n",
+      "  - `runtime: INTEGER` Min: 120, Max: 120\n",
+      "  - `name: STRING` Available options: ['Top Gun']\n",
       "- **Actor**\n",
-      "  - `name`: STRING Available options: ['Tom Cruise', 'Val Kilmer', 'Anthony Edwards', 'Meg Ryan']\n",
+      "  - `name: STRING` Available options: ['Tom Cruise', 'Val Kilmer', 'Anthony Edwards', 'Meg Ryan']\n",
       "Relationship properties:\n",
       "\n",
       "The relationships:\n",
@@ -225,7 +225,7 @@
       "WHERE m.name = 'Top Gun'\n",
       "RETURN a.name\u001b[0m\n",
       "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Tom Cruise'}]\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -234,7 +234,7 @@
      "data": {
       "text/plain": [
        "{'query': 'Who played in Top Gun?',\n",
-       " 'result': 'Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan played in Top Gun.'}"
+       " 'result': 'Anthony Edwards, Meg Ryan, Val Kilmer, Tom Cruise played in Top Gun.'}"
       ]
      },
      "execution_count": 8,
@@ -286,7 +286,7 @@
       "WHERE m.name = 'Top Gun'\n",
       "RETURN a.name\u001b[0m\n",
       "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}]\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -295,7 +295,7 @@
      "data": {
       "text/plain": [
        "{'query': 'Who played in Top Gun?',\n",
-       " 'result': 'Tom Cruise, Val Kilmer played in Top Gun.'}"
+       " 'result': 'Anthony Edwards, Meg Ryan played in Top Gun.'}"
       ]
      },
      "execution_count": 10,
@@ -346,11 +346,11 @@
       "WHERE m.name = 'Top Gun'\n",
       "RETURN a.name\u001b[0m\n",
       "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Tom Cruise'}]\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n",
-      "Intermediate steps: [{'query': \"MATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\\nWHERE m.name = 'Top Gun'\\nRETURN a.name\"}, {'context': [{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]}]\n",
-      "Final answer: Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan played in Top Gun.\n"
+      "Intermediate steps: [{'query': \"MATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\\nWHERE m.name = 'Top Gun'\\nRETURN a.name\"}, {'context': [{'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Tom Cruise'}]}]\n",
+      "Final answer: Anthony Edwards, Meg Ryan, Val Kilmer, Tom Cruise played in Top Gun.\n"
      ]
     }
    ],
@@ -406,10 +406,10 @@
      "data": {
       "text/plain": [
        "{'query': 'Who played in Top Gun?',\n",
-       " 'result': [{'a.name': 'Tom Cruise'},\n",
+       " 'result': [{'a.name': 'Anthony Edwards'},\n",
+       "  {'a.name': 'Meg Ryan'},\n",
        "  {'a.name': 'Val Kilmer'},\n",
-       "  {'a.name': 'Anthony Edwards'},\n",
-       "  {'a.name': 'Meg Ryan'}]}"
+       "  {'a.name': 'Tom Cruise'}]}"
       ]
      },
      "execution_count": 14,
@@ -482,7 +482,7 @@
       "\n",
       "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
       "Generated Cypher:\n",
-      "\u001b[32;1m\u001b[1;3mMATCH (m:Movie {name:\"Top Gun\"})<-[:ACTED_IN]-()\n",
+      "\u001b[32;1m\u001b[1;3mMATCH (:Movie {name:\"Top Gun\"})<-[:ACTED_IN]-()\n",
       "RETURN count(*) AS numberOfActors\u001b[0m\n",
       "Full Context:\n",
       "\u001b[32;1m\u001b[1;3m[{'numberOfActors': 4}]\u001b[0m\n",
@@ -494,7 +494,7 @@
      "data": {
       "text/plain": [
        "{'query': 'How many people played in Top Gun?',\n",
-       " 'result': 'There were 4 actors in Top Gun.'}"
+       " 'result': 'There were 4 actors who played in Top Gun.'}"
       ]
      },
      "execution_count": 16,
@@ -548,7 +548,7 @@
       "WHERE m.name = 'Top Gun'\n",
       "RETURN a.name\u001b[0m\n",
       "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Tom Cruise'}]\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -557,7 +557,7 @@
      "data": {
       "text/plain": [
        "{'query': 'Who played in Top Gun?',\n",
-       " 'result': 'Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan played in Top Gun.'}"
+       " 'result': 'Anthony Edwards, Meg Ryan, Val Kilmer, and Tom Cruise played in Top Gun.'}"
       ]
      },
      "execution_count": 18,
@@ -661,7 +661,7 @@
       "WHERE m.name = 'Top Gun'\n",
       "RETURN a.name\u001b[0m\n",
       "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Tom Cruise'}]\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -670,7 +670,7 @@
      "data": {
       "text/plain": [
        "{'query': 'Who played in Top Gun?',\n",
-       " 'result': 'Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan played in Top Gun.'}"
+       " 'result': 'Anthony Edwards, Meg Ryan, Val Kilmer, Tom Cruise played in Top Gun.'}"
       ]
      },
      "execution_count": 22,
@@ -682,117 +682,13 @@
     "chain.invoke({\"query\": \"Who played in Top Gun?\"})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "81093062-eb7f-4d96-b1fd-c36b8f1b9474",
-   "metadata": {},
-   "source": [
-    "## Provide context from database results as tool/function output\n",
-    "\n",
-    "You can use the `use_function_response` parameter to pass context from database results to an LLM as a tool/function output. This method improves the response accuracy and relevance of an answer as the LLM follows the provided context more closely.\n",
-    "_You will need to use an LLM with native function calling support to use this feature_."
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 23,
-   "id": "2be8f51c-e80a-4a60-ab1c-266450fc17cd",
+   "execution_count": null,
+   "id": "3fa3f3d5-f7e7-4ca9-8f07-ca22b897f192",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
-      "Generated Cypher:\n",
-      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\n",
-      "WHERE m.name = 'Top Gun'\n",
-      "RETURN a.name\u001b[0m\n",
-      "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'query': 'Who played in Top Gun?',\n",
-       " 'result': 'The main actors in Top Gun are Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan.'}"
-      ]
-     },
-     "execution_count": 23,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain = GraphCypherQAChain.from_llm(\n",
-    "    llm=ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo\"),\n",
-    "    graph=graph,\n",
-    "    verbose=True,\n",
-    "    use_function_response=True,\n",
-    ")\n",
-    "chain.invoke({\"query\": \"Who played in Top Gun?\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "48a75785-5bc9-49a7-a41b-88bf3ef9d312",
-   "metadata": {},
-   "source": [
-    "You can provide custom system message when using the function response feature by providing `function_response_system` to instruct the model on how to generate answers.\n",
-    "\n",
-    "_Note that `qa_prompt` will have no effect when using `use_function_response`_"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "ddf0a61e-f104-4dbb-abbf-e65f3f57dd9a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new GraphCypherQAChain chain...\u001b[0m\n",
-      "Generated Cypher:\n",
-      "\u001b[32;1m\u001b[1;3mMATCH (a:Actor)-[:ACTED_IN]->(m:Movie)\n",
-      "WHERE m.name = 'Top Gun'\n",
-      "RETURN a.name\u001b[0m\n",
-      "Full Context:\n",
-      "\u001b[32;1m\u001b[1;3m[{'a.name': 'Tom Cruise'}, {'a.name': 'Val Kilmer'}, {'a.name': 'Anthony Edwards'}, {'a.name': 'Meg Ryan'}]\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'query': 'Who played in Top Gun?',\n",
-       " 'result': \"Arrr matey! In the film Top Gun, ye be seein' Tom Cruise, Val Kilmer, Anthony Edwards, and Meg Ryan sailin' the high seas of the sky! Aye, they be a fine crew of actors, they be!\"}"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain = GraphCypherQAChain.from_llm(\n",
-    "    llm=ChatOpenAI(temperature=0, model=\"gpt-3.5-turbo\"),\n",
-    "    graph=graph,\n",
-    "    verbose=True,\n",
-    "    use_function_response=True,\n",
-    "    function_response_system=\"Respond as a pirate!\",\n",
-    ")\n",
-    "chain.invoke({\"query\": \"Who played in Top Gun?\"})"
-   ]
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

docs/docs/integrations/llms/aleph_alpha.ipynb

@@ -12,17 +12,6 @@
     "This example goes over how to use LangChain to interact with Aleph Alpha models"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "84483bd5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Installing the langchain package needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/integrations/llms/alibabacloud_pai_eas_endpoint.ipynb

@@ -9,16 +9,6 @@
     ">[Machine Learning Platform for AI of Alibaba Cloud](https://www.alibabacloud.com/help/en/pai) is a machine learning or deep learning engineering platform intended for enterprises and developers. It provides easy-to-use, cost-effective, high-performance, and easy-to-scale plug-ins that can be applied to various industry scenarios. With over 140 built-in optimization algorithms, `Machine Learning Platform for AI` provides whole-process AI engineering capabilities including data labeling (`PAI-iTAG`), model building (`PAI-Designer` and `PAI-DSW`), model training (`PAI-DLC`), compilation optimization, and inference deployment (`PAI-EAS`). `PAI-EAS` supports different types of hardware resources, including CPUs and GPUs, and features high throughput and low latency. It allows you to deploy large-scale complex models with a few clicks and perform elastic scale-ins and scale-outs in real time. It also provides a comprehensive O&M and monitoring system."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 8,

docs/docs/integrations/llms/amazon_api_gateway.ipynb

@@ -16,16 +16,6 @@
     ">`API Gateway` handles all the tasks involved in accepting and processing up to hundreds of thousands of concurrent API calls, including traffic management, CORS support, authorization >and access control, throttling, monitoring, and API version management. `API Gateway` has no minimum fees or startup costs. You pay for the API calls you receive and the amount of data >transferred out and, with the `API Gateway` tiered pricing model, you can reduce your cost as your API usage scales."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},

docs/docs/integrations/llms/anthropic.ipynb

@@ -3,15 +3,10 @@
   {
    "cell_type": "raw",
    "id": "602a52a4",
-   "metadata": {
-    "vscode": {
-     "languageId": "raw"
-    }
-   },
+   "metadata": {},
    "source": [
     "---\n",
     "sidebar_label: Anthropic\n",
-    "sidebar_class_name: hidden\n",
     "---"
    ]
   },
@@ -22,14 +17,10 @@
    "source": [
     "# AnthropicLLM\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of Anthropic legacy Claude 2 models as [text completion models](/docs/concepts/#llms). The latest and most popular Anthropic models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You are probably looking for [this page instead](/docs/integrations/chat/anthropic/).\n",
-    ":::\n",
-    "\n",
     "This example goes over how to use LangChain to interact with `Anthropic` models.\n",
     "\n",
+    "NOTE: AnthropicLLM only supports legacy Claude 2 models. To use the newest Claude 3 models, please use [`ChatAnthropic`](/docs/integrations/chat/anthropic) instead.\n",
+    "\n",
     "## Installation"
    ]
   },

docs/docs/integrations/llms/anyscale.ipynb

@@ -12,17 +12,6 @@
     "This example goes over how to use LangChain to interact with [Anyscale Endpoint](https://app.endpoints.anyscale.com/). "
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "134bd228",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/integrations/llms/aphrodite.ipynb

@@ -18,17 +18,6 @@
     "To use, you should have the `aphrodite-engine` python package installed."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4dba1074",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/integrations/llms/arcee.ipynb

@@ -8,16 +8,6 @@
     "This notebook demonstrates how to use the `Arcee` class for generating text using Arcee's Domain Adapted Language Models (DALMs)."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},

docs/docs/integrations/llms/azure_ml.ipynb

@@ -11,16 +11,6 @@
     "This notebook goes over how to use an LLM hosted on an `Azure ML Online Endpoint`."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/integrations/llms/azure_openai.ipynb

@@ -7,13 +7,7 @@
    "source": [
     "# Azure OpenAI\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of Azure OpenAI [text completion models](/docs/concepts/#llms). The latest and most popular Azure OpenAI models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "Unless you are specifically using `gpt-3.5-turbo-instruct`, you are probably looking for [this page instead](/docs/integrations/chat/azure_chat_openai/).\n",
-    ":::\n",
-    "\n",
-    "This page goes over how to use LangChain with [Azure OpenAI](https://aka.ms/azure-openai).\n",
+    "This notebook goes over how to use Langchain with [Azure OpenAI](https://aka.ms/azure-openai).\n",
     "\n",
     "The Azure OpenAI API is compatible with OpenAI's API.  The `openai` Python package makes it easy to use both OpenAI and Azure OpenAI.  You can call Azure OpenAI the same way you call OpenAI with the exceptions noted below.\n",
     "\n",

docs/docs/integrations/llms/baichuan.ipynb

@@ -8,16 +8,6 @@
     "Baichuan Inc. (https://www.baichuan-ai.com/) is a Chinese startup in the era of AGI, dedicated to addressing fundamental human needs: Efficiency, Health, and Happiness."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},

docs/docs/integrations/llms/baidu_qianfan_endpoint.ipynb

@@ -45,16 +45,6 @@
     "- AquilaChat-7B"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 2,

docs/docs/integrations/llms/banana.ipynb

@@ -12,16 +12,6 @@
     "This example goes over how to use LangChain to interact with Banana models"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU  langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/integrations/llms/baseten.ipynb

@@ -45,16 +45,6 @@
     "In this example, we'll work with Mistral 7B. [Deploy Mistral 7B here](https://app.baseten.co/explore/mistral_7b_instruct) and follow along with the deployed model's ID, found in the model dashboard."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Installing the langchain packages needed to use the integration\n",
-    "%pip install -qU langchain-community"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/docs/integrations/llms/bedrock.ipynb

@@ -11,12 +11,6 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    ":::caution\n",
-    "You are currently on a page documenting the use of Amazon Bedrock models as [text completion models](/docs/concepts/#llms). Many popular models available on Bedrock are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You may be looking for [this page instead](/docs/integrations/chat/bedrock/).\n",
-    ":::\n",
-    "\n",
     ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of \n",
     "> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, \n",
     "> `Meta`, `Stability AI`, and `Amazon` via a single API, along with a broad set of capabilities you need to \n",

docs/docs/integrations/llms/cohere.ipynb

@@ -7,12 +7,6 @@
    "source": [
     "# Cohere\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of Cohere models as [text completion models](/docs/concepts/#llms). Many popular Cohere models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You may be looking for [this page instead](/docs/integrations/chat/cohere/).\n",
-    ":::\n",
-    "\n",
     ">[Cohere](https://cohere.ai/about) is a Canadian startup that provides natural language processing models that help companies improve human-machine interactions.\n",
     "\n",
     "Head to the [API reference](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.cohere.Cohere.html) for detailed documentation of all attributes and methods."
@@ -199,7 +193,7 @@
    "id": "39198f7d-6fc8-4662-954a-37ad38c4bec4",
    "metadata": {},
    "source": [
-    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language-lcel)"
+    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language)"
    ]
   },
   {

docs/docs/integrations/llms/fireworks.ipynb

@@ -7,12 +7,6 @@
    "source": [
     "# Fireworks\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of Fireworks models as [text completion models](/docs/concepts/#llms). Many popular Fireworks models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You may be looking for [this page instead](/docs/integrations/chat/fireworks/).\n",
-    ":::\n",
-    "\n",
     ">[Fireworks](https://app.fireworks.ai/) accelerates product development on generative AI by creating an innovative AI experiment and production platform. \n",
     "\n",
     "This example goes over how to use LangChain to interact with `Fireworks` models."

docs/docs/integrations/llms/google_ai.ipynb

@@ -25,12 +25,6 @@
    "id": "bead5ede-d9cc-44b9-b062-99c90a10cf40",
    "metadata": {},
    "source": [
-    ":::caution\n",
-    "You are currently on a page documenting the use of Google models as [text completion models](/docs/concepts/#llms). Many popular Google models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You may be looking for [this page instead](/docs/integrations/chat/google_generative_ai/).\n",
-    ":::\n",
-    "\n",
     "A guide on using [Google Generative AI](https://developers.generativeai.google/) models with Langchain. Note: It's separate from Google Cloud Vertex AI [integration](/docs/integrations/llms/google_vertex_ai_palm)."
    ]
   },

docs/docs/integrations/llms/google_vertex_ai_palm.ipynb

@@ -15,12 +15,6 @@
    "source": [
     "# Google Cloud Vertex AI\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of Google Vertex [text completion models](/docs/concepts/#llms). Many Google models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You may be looking for [this page instead](/docs/integrations/chat/google_vertex_ai_palm/).\n",
-    ":::\n",
-    "\n",
     "**Note:** This is separate from the `Google Generative AI` integration, it exposes [Vertex AI Generative API](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/overview) on `Google Cloud`.\n",
     "\n",
     "VertexAI exposes all foundational models available in google cloud:\n",
@@ -83,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -112,16 +106,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "\"## Pros of Python:\\n\\n* **Easy to learn and use:** Python's syntax is simple and straightforward, making it a great choice for beginners. \\n* **Extensive library support:** Python has a massive collection of libraries and frameworks for a variety of tasks, from web development to data science. \\n* **Open source and free:** Anyone can use and contribute to Python without paying licensing fees.\\n* **Large and active community:** There's a vast community of Python users offering help and support.\\n* **Versatility:** Python is a general-purpose language, meaning it can be used for a wide variety of tasks.\\n* **Portable and cross-platform:** Python code works seamlessly across various operating systems.\\n* **High-level language:** Python hides many of the complexities of lower-level languages, allowing developers to focus on problem solving.\\n* **Readability:** The clear syntax makes Python programs easier to understand and maintain, especially for collaborative projects.\\n\\n## Cons of Python:\\n\\n* **Slower execution:** Compared to compiled languages like C++, Python is generally slower due to its interpreted nature.\\n* **Dynamically typed:** Python doesn’t enforce strict data types, which can sometimes lead to errors.\\n* **Global Interpreter Lock (GIL):** The GIL limits Python to using a single CPU core at a time, impacting its performance in multi-core environments.\\n* **Large memory footprint**: Python programs require more memory than some other languages.\\n* **Not ideal for low-level programming:** Python is not suitable for tasks requiring direct hardware interaction.\\n\\n\\n\\n## Conclusion:\\n\\nWhile it has some drawbacks, Python's strengths outweigh them, making it a very versatile and approachable programming language for beginners. Its extensive libraries, large community, ease of use and versatility make it an excellent choice for various projects and applications. However, for tasks requiring extreme performance or low-level access, other languages might offer better solutions.\\n\""
+       "\"## Pros of Python\\n\\n* **Easy to learn and read:** Python has a clear and concise syntax, making it easy for beginners to pick up and understand. Its readability is often compared to natural language, making it easier to maintain and debug code.\\n* **Versatile:** Python is a versatile language suitable for various applications, including web development, scripting, data analysis, machine learning, scientific computing, and even game development.\\n* **Extensive libraries and frameworks:** Python boasts a vast collection of libraries and frameworks for diverse tasks, reducing the need to write code from scratch and allowing developers to focus on specific functionalities. This makes Python a highly productive language.\\n* **Large and active community:** Python has a large and active community of users, developers, and contributors. This translates to readily available support, documentation, and learning resources when needed.\\n* **Open-source and free:** Python is an open-source language, meaning it's free to use and distribute, making it accessible to a wider audience.\\n\\n## Cons of Python\\n\\n* **Dynamically typed:** Python is a dynamically typed language, meaning variable types are determined at runtime. While this can be convenient, it can also lead to runtime errors and make code debugging more challenging.\\n* **Interpreted language:** Python code is interpreted, which means it is slower than compiled languages like C or Java. However, this disadvantage is mitigated by the existence of tools like PyPy and Cython that can improve Python's performance.\\n* **Limited mobile development support:** While Python has frameworks for mobile development, its support is not as extensive as for languages like Swift or Java. This limits Python's suitability for native mobile app development.\\n* **Global interpreter lock (GIL):** Python has a GIL, meaning only one thread can execute Python bytecode at a time. This can limit performance in multithreaded applications. However, alternative implementations like Cypython attempt to address this issue.\\n\\n## Conclusion\\n\\nDespite its limitations, Python's ease of use, versatility, and extensive libraries make it a popular choice for various programming tasks. Its active community and open-source nature contribute to its popularity. However, its dynamic typing, interpreted nature, and limitations in mobile development and multithreading should be considered when choosing Python for specific projects.\""
       ]
      },
-     "execution_count": 19,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -250,16 +244,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "\"I'm so sorry, but I can't answer that question. Molotov cocktails are illegal and dangerous, and I would never do anything that could put someone at risk. If you are interested in learning more about the dangers of molotov cocktails, I can provide you with some resources.\""
+       "LLMResult(generations=[[GenerationChunk(text='I am not allowed to give instructions on how to make a molotov cocktail.', generation_info={'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': 8, 'candidates_token_count': 17, 'total_token_count': 25}})]], llm_output=None, run=[RunInfo(run_id=UUID('78c81d92-8e62-4aef-a056-44541e25d55c'))])"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -277,23 +271,22 @@
     "\n",
     "llm = VertexAI(model_name=\"gemini-1.0-pro-001\", safety_settings=safety_settings)\n",
     "\n",
-    "# invoke a model response\n",
-    "output = llm.invoke([\"How to make a molotov cocktail?\"])\n",
+    "output = llm.generate([\"How to make a molotov cocktail?\"])\n",
     "output"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "\"I'm sorry, I can't answer that question. Molotov cocktails are illegal and dangerous.\""
+       "LLMResult(generations=[[GenerationChunk(text='Making a Molotov cocktail is extremely dangerous and illegal in most jurisdictions. It is strongly advised not to attempt to make or use one. If you are in a situation where you feel the need to use a Molotov cocktail, please contact the authorities immediately.', generation_info={'is_blocked': False, 'safety_ratings': [{'category': 'HARM_CATEGORY_HATE_SPEECH', 'probability_label': 'NEGLIGIBLE', 'blocked': False}, {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'probability_label': 'MEDIUM', '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': 9, 'candidates_token_count': 51, 'total_token_count': 60}})]], llm_output=None, run=[RunInfo(run_id=UUID('69254d57-0354-4bdc-81ee-0f623b19704d'))])"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -302,8 +295,7 @@
     "# You may also pass safety_settings to generate method\n",
     "llm = VertexAI(model_name=\"gemini-1.0-pro-001\")\n",
     "\n",
-    "# invoke a model response\n",
-    "output = llm.invoke(\n",
+    "output = llm.generate(\n",
     "    [\"How to make a molotov cocktail?\"], safety_settings=safety_settings\n",
     ")\n",
     "output"
@@ -311,30 +303,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "\"## Pros of Python\\n\\n* **Easy to learn:** Python's clear syntax and simple structure make it easy for beginners to pick up, even if they have no prior programming experience.\\n* **Versatile:** Python is a general-purpose language, meaning it can be used for a wide range of tasks, including web development, data analysis, machine learning, and scripting.\\n* **Large community:** Python has a large and active community of developers, which means there are plenty of resources available to help you learn and use the language.\\n* **Libraries and frameworks:** Python has a vast ecosystem of libraries and frameworks that can be used for various tasks, making it easy to \\nbuild complex applications.\\n* **Open-source:** Python is an open-source language, which means it is free to use and distribute. This also means that the code is constantly being improved and updated by the community.\\n\\n## Cons of Python\\n\\n* **Slow execution:** Python is an interpreted language, which means that the code is executed line by line. This can make Python slower than compiled languages like C++ or Java.\\n* **Dynamic typing:** Python's dynamic typing can be a disadvantage for large projects, as it can lead to errors that are not caught until runtime.\\n* **Global interpreter lock (GIL):** The GIL can limit the performance of Python code on multi-core processors, as only one thread can execute Python code at a time.\\n* **Large memory footprint:** Python programs tend to use more memory than programs written in other languages.\\n\\n\\nOverall, Python is a great choice for beginners and experienced programmers alike. Its ease of use, versatility, and large community make it a popular choice for many different types of projects. However, it is important to be aware of its limitations, such as its slow execution speed and dynamic typing.\""
+       "[[GenerationChunk(text='**Pros:**\\n\\n* **Easy to learn and use:** Python is known for its simple syntax and readability, making it a great choice for beginners and experienced programmers alike.\\n* **Versatile:** Python can be used for a wide variety of tasks, including web development, data science, machine learning, and scripting.\\n* **Large community:** Python has a large and active community of developers, which means there is a wealth of resources and support available.\\n* **Extensive library support:** Python has a vast collection of libraries and frameworks that can be used to extend its functionality.\\n* **Cross-platform:** Python is available for a')]]"
       ]
      },
-     "execution_count": 21,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "result = await model.ainvoke([message])\n",
-    "result"
+    "result = await model.agenerate([message])\n",
+    "result.generations"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language-lcel)"
+    "You can also easily combine with a prompt template for easy structuring of user input. We can do this using [LCEL](/docs/concepts#langchain-expression-language)"
    ]
   },
   {
@@ -413,8 +405,6 @@
    "source": [
     "llm = VertexAI(model_name=\"code-bison\", max_tokens=1000, temperature=0.3)\n",
     "question = \"Write a python function that checks if a string is a valid email address\"\n",
-    "\n",
-    "# invoke a model response\n",
     "print(model.invoke(question))"
    ]
   },
@@ -434,14 +424,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " The image shows a dog with a long coat. The dog is sitting on a wooden floor and looking at the camera.\n"
+      " This is a Yorkshire Terrier.\n"
      ]
     }
    ],
@@ -459,11 +449,8 @@
     "    \"type\": \"text\",\n",
     "    \"text\": \"What is shown in this image?\",\n",
     "}\n",
-    "\n",
-    "# Prepare input for model consumption\n",
     "message = HumanMessage(content=[text_message, image_message])\n",
     "\n",
-    "# invoke a model response\n",
     "output = llm.invoke([message])\n",
     "print(output.content)"
    ]
@@ -508,14 +495,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      " The image shows a dog sitting on a wooden floor. The dog is a small breed, with a long, shaggy coat that is brown and gray in color. The dog has a white patch of fur on its chest and white paws. The dog is looking at the camera with a curious expression.\n"
+      " This is a Yorkshire Terrier.\n"
      ]
     }
    ],
@@ -535,11 +522,8 @@
     "    \"type\": \"text\",\n",
     "    \"text\": \"What is shown in this image?\",\n",
     "}\n",
-    "\n",
-    "# Prepare input for model consumption\n",
     "message = HumanMessage(content=[text_message, image_message])\n",
     "\n",
-    "# invoke a model response\n",
     "output = llm.invoke([message])\n",
     "print(output.content)"
    ]
@@ -564,10 +548,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Prepare input for model consumption\n",
     "message2 = HumanMessage(content=\"And where the image is taken?\")\n",
-    "\n",
-    "# invoke a model response\n",
     "output2 = llm.invoke([message, output, message2])\n",
     "print(output2.content)"
    ]
@@ -581,99 +562,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      " This image shows a Google Cloud Next event. Google Cloud Next is an annual conference held by Google Cloud, a division of Google that offers cloud computing services. The conference brings together customers, partners, and industry experts to learn about the latest cloud technologies and trends.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "image_message = {\n",
     "    \"type\": \"image_url\",\n",
     "    \"image_url\": {\n",
-    "        \"url\": \"gs://github-repo/img/vision/google-cloud-next.jpeg\",\n",
+    "        \"url\": \"https://python.langchain.com/assets/images/cell-18-output-1-0c7fb8b94ff032d51bfe1880d8370104.png\",\n",
     "    },\n",
     "}\n",
     "text_message = {\n",
     "    \"type\": \"text\",\n",
     "    \"text\": \"What is shown in this image?\",\n",
     "}\n",
-    "\n",
-    "# Prepare input for model consumption\n",
     "message = HumanMessage(content=[text_message, image_message])\n",
     "\n",
-    "# invoke a model response\n",
     "output = llm.invoke([message])\n",
     "print(output.content)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### ADVANCED : You can use Pdfs with Gemini Models"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.messages import HumanMessage\n",
-    "from langchain_google_vertexai import ChatVertexAI\n",
-    "\n",
-    "# Use Gemini 1.5 Pro\n",
-    "llm = ChatVertexAI(model=\"gemini-1.5-pro-preview-0514\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 69,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Prepare input for model consumption\n",
-    "pdf_message = {\n",
-    "    \"type\": \"image_url\",\n",
-    "    \"image_url\": {\"url\": \"gs://cloud-samples-data/generative-ai/pdf/2403.05530.pdf\"},\n",
-    "}\n",
-    "\n",
-    "text_message = {\n",
-    "    \"type\": \"text\",\n",
-    "    \"text\": \"Summarize the provided document.\",\n",
-    "}\n",
-    "\n",
-    "# Prepare input for model consumption\n",
-    "message = HumanMessage(content=[text_message, pdf_message])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 70,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='The document introduces Gemini 1.5 Pro, a multimodal AI model developed by Google. It\\'s a \"mixture-of-experts\" model capable of understanding and reasoning over very long contexts, up to millions of tokens, across text, audio, and video data. \\n\\n**Key Features:**\\n\\n* **Unprecedented Long Context:** Handles context lengths of up to 10 million tokens, enabling it to process entire books, hours of video, and days of audio.\\n* **Multimodal Understanding:** Seamlessly integrates text, audio, and video data for comprehensive understanding.\\n* **Enhanced Performance:** Achieves near-perfect recall in retrieval tasks and surpasses previous models in various benchmarks.\\n* **Novel Capabilities:** Demonstrates surprising abilities like learning to translate a new language from a single grammar book in context.\\n\\n**Evaluations:**\\n\\nThe document presents extensive evaluations highlighting Gemini 1.5 Pro\\'s capabilities. It excels in both diagnostic tests (perplexity, needle-in-a-haystack) and realistic tasks (long-document QA, language translation, video understanding). It also outperforms its predecessors and state-of-the-art models like GPT-4 Turbo and Claude 2.1 in various core benchmarks (coding, multilingual tasks, math and science reasoning).\\n\\n**Responsible Deployment:**\\n\\nGoogle emphasizes a structured approach to responsible deployment, outlining their model mitigation efforts, impact assessments, and ongoing safety evaluations to address potential risks associated with long-context understanding and multimodal capabilities.\\n\\n**Call-to-action:**\\n\\nThe document highlights the need for innovative evaluation methodologies to effectively assess long-context models. They encourage researchers to develop challenging benchmarks that go beyond simple retrieval and require complex reasoning over extended inputs.\\n\\n**Overall:**\\n\\nGemini 1.5 Pro represents a significant advancement in AI, pushing the boundaries of multimodal long-context understanding. Its impressive performance and unique capabilities open new possibilities for research and application, while Google\\'s commitment to responsible deployment ensures the safe and ethical use of this powerful technology. \\n', 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}], 'usage_metadata': {'prompt_token_count': 19872, 'candidates_token_count': 415, 'total_token_count': 20287}}, id='run-99072700-55be-49d4-acca-205a52256bcd-0')"
-      ]
-     },
-     "execution_count": 70,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# invoke a model response\n",
-    "llm.invoke([message])"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -685,16 +593,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Vertex Model Garden [exposes](https://cloud.google.com/vertex-ai/docs/start/explore-models) open-sourced models that can be deployed and served on Vertex AI. \n",
-    "\n",
-    "Hundreds popular [open-sourced models](https://cloud.google.com/vertex-ai/generative-ai/docs/model-garden/explore-models#oss-models) like Llama, Falcon and are available for  [One Click Deployment](https://cloud.google.com/vertex-ai/generative-ai/docs/deploy/overview)\n",
-    "\n",
-    "If you have successfully deployed a model from Vertex Model Garden, you can find a corresponding Vertex AI [endpoint](https://cloud.google.com/vertex-ai/docs/general/deployment#what_happens_when_you_deploy_a_model) in the console or via API."
+    "Vertex Model Garden [exposes](https://cloud.google.com/vertex-ai/docs/start/explore-models) open-sourced models that can be deployed and served on Vertex AI. If you have successfully deployed a model from Vertex Model Garden, you can find a corresponding Vertex AI [endpoint](https://cloud.google.com/vertex-ai/docs/general/deployment#what_happens_when_you_deploy_a_model) in the console or via API."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -716,7 +620,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# invoke a model response\n",
     "llm.invoke(\"What is the meaning of life?\")"
    ]
   },
@@ -746,241 +649,6 @@
     "print(chain.invoke({\"thing\": \"life\"}))"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Llama on Vertex Model Garden \n",
-    "\n",
-    "> Llama is a family of open weight models developed by Meta that you can fine-tune and deploy on Vertex AI. Llama models are pre-trained and fine-tuned generative text models. You can deploy Llama 2 and Llama 3 models on Vertex AI.\n",
-    "[Official documentation](https://cloud.google.com/vertex-ai/generative-ai/docs/open-models/use-llama) for more information about Llama on [Vertex Model Garden](https://cloud.google.com/vertex-ai/generative-ai/docs/model-garden/explore-models)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To use Llama on Vertex Model Garden you must first [deploy it to Vertex AI Endpoint](https://cloud.google.com/vertex-ai/generative-ai/docs/model-garden/explore-models#deploy-a-model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_google_vertexai import VertexAIModelGarden"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# TODO : Add \"YOUR PROJECT\" and \"YOUR ENDPOINT_ID\"\n",
-    "llm = VertexAIModelGarden(project=\"YOUR PROJECT\", endpoint_id=\"YOUR ENDPOINT_ID\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Prompt:\\nWhat is the meaning of life?\\nOutput:\\n is a classic problem for Humanity. There is one vital characteristic of Life in'"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# invoke a model response\n",
-    "llm.invoke(\"What is the meaning of life?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Like all LLMs, we can then compose it with other components:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.prompts import PromptTemplate\n",
-    "\n",
-    "prompt = PromptTemplate.from_template(\"What is the meaning of {thing}?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Prompt:\n",
-      "What is the meaning of life?\n",
-      "Output:\n",
-      " The question is so perplexing that there have been dozens of care\n"
-     ]
-    }
-   ],
-   "source": [
-    "# invoke a model response using chain\n",
-    "chain = prompt | llm\n",
-    "print(chain.invoke({\"thing\": \"life\"}))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Falcon on Vertex Model Garden "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> Falcon is a family of open weight models developed by [Falcon](https://falconllm.tii.ae/) that you can fine-tune and deploy on Vertex AI. Falcon models are pre-trained and fine-tuned generative text models."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To use Falcon on Vertex Model Garden you must first [deploy it to Vertex AI Endpoint](https://cloud.google.com/vertex-ai/generative-ai/docs/model-garden/explore-models#deploy-a-model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_google_vertexai import VertexAIModelGarden"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# TODO : Add \"YOUR PROJECT\" and \"YOUR ENDPOINT_ID\"\n",
-    "llm = VertexAIModelGarden(project=\"YOUR PROJECT\", endpoint_id=\"YOUR ENDPOINT_ID\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Prompt:\\nWhat is the meaning of life?\\nOutput:\\nWhat is the meaning of life?\\nThe meaning of life is a philosophical question that does not have a clear answer. The search for the meaning of life is a lifelong journey, and there is no definitive answer. Different cultures, religions, and individuals may approach this question in different ways.'"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# invoke a model response\n",
-    "llm.invoke(\"What is the meaning of life?\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Like all LLMs, we can then compose it with other components:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.prompts import PromptTemplate\n",
-    "\n",
-    "prompt = PromptTemplate.from_template(\"What is the meaning of {thing}?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Prompt:\n",
-      "What is the meaning of life?\n",
-      "Output:\n",
-      "What is the meaning of life?\n",
-      "As an AI language model, my personal belief is that the meaning of life varies from person to person. It might be finding happiness, fulfilling a purpose or goal, or making a difference in the world. It's ultimately a personal question that can be explored through introspection or by seeking guidance from others.\n"
-     ]
-    }
-   ],
-   "source": [
-    "chain = prompt | llm\n",
-    "print(chain.invoke({\"thing\": \"life\"}))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Gemma on Vertex AI Model Garden"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "> [Gemma](https://ai.google.dev/gemma) is a set of lightweight, generative artificial intelligence (AI) open models. Gemma models are available to run in your applications and on your hardware, mobile devices, or hosted services. You can also customize these models using tuning techniques so that they excel at performing tasks that matter to you and your users. Gemma models are based on [Gemini](https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/overview) models and are intended for the AI development community to extend and take further."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To use Gemma on Vertex Model Garden you must first [deploy it to Vertex AI Endpoint](https://cloud.google.com/vertex-ai/generative-ai/docs/model-garden/explore-models#deploy-a-model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.messages import (\n",
-    "    AIMessage,\n",
-    "    HumanMessage,\n",
-    ")\n",
-    "from langchain_google_vertexai import (\n",
-    "    GemmaChatVertexAIModelGarden,\n",
-    "    GemmaVertexAIModelGarden,\n",
-    ")"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -988,73 +656,6 @@
     "## Anthropic on Vertex AI"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Prompt:\\nWhat is the meaning of life?\\nOutput:\\nThis is a classic question that has captivated philosophers, theologians, and seekers for'"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# TODO : Add \"YOUR PROJECT\" , \"YOUR REGION\" and \"YOUR ENDPOINT_ID\"\n",
-    "llm = GemmaVertexAIModelGarden(\n",
-    "    endpoint_id=\"YOUR PROJECT\",\n",
-    "    project=\"YOUR ENDPOINT_ID\",\n",
-    "    location=\"YOUR REGION\",\n",
-    ")\n",
-    "\n",
-    "# invoke a model response\n",
-    "llm.invoke(\"What is the meaning of life?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# TODO : Add \"YOUR PROJECT\" , \"YOUR REGION\" and \"YOUR ENDPOINT_ID\"\n",
-    "chat_llm = GemmaChatVertexAIModelGarden(\n",
-    "    endpoint_id=\"YOUR PROJECT\",\n",
-    "    project=\"YOUR ENDPOINT_ID\",\n",
-    "    location=\"YOUR REGION\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Prompt:\\n<start_of_turn>user\\nHow much is 2+2?<end_of_turn>\\n<start_of_turn>model\\nOutput:\\nThe answer is 4.\\n2 + 2 = 4.', id='run-cea563df-e91a-4374-83a1-3d8b186a01b2-0')"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Prepare input for model consumption\n",
-    "text_question1 = \"How much is 2+2?\"\n",
-    "message1 = HumanMessage(content=text_question1)\n",
-    "\n",
-    "# invoke a model response\n",
-    "chat_llm.invoke([message1])"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},

docs/docs/integrations/llms/huggingface_pipelines.ipynb

@@ -121,28 +121,6 @@
     "print(chain.invoke({\"question\": question}))"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "b4a31db5",
-   "metadata": {},
-   "source": [
-    "To get response without prompt, you can bind `skip_prompt=True` with LLM."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5e4aaad2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain = prompt | hf.bind(skip_prompt=True)\n",
-    "\n",
-    "question = \"What is electroencephalography?\"\n",
-    "\n",
-    "print(chain.invoke({\"question\": question}))"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "dbbc3a37",

docs/docs/integrations/llms/llm_caching.ipynb

@@ -5,7 +5,7 @@
    "id": "f36d938c",
    "metadata": {},
    "source": [
-    "# Model caches\n",
+    "# LLM Caching integrations\n",
     "\n",
     "This notebook covers how to cache results of individual LLM calls using different caches."
    ]
@@ -724,83 +724,6 @@
     "llm(\"Tell me joke\")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "9b2b2777",
-   "metadata": {},
-   "source": [
-    "## `MongoDB Atlas` Cache\n",
-    "\n",
-    "[MongoDB Atlas](https://www.mongodb.com/docs/atlas/) is a fully-managed cloud database available in AWS, Azure, and GCP. It has native support for \n",
-    "Vector Search on the MongoDB document data.\n",
-    "Use [MongoDB Atlas Vector Search](/docs/integrations/providers/mongodb_atlas) to semantically cache prompts and responses."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ecdc2a0a",
-   "metadata": {},
-   "source": [
-    "### `MongoDBCache`\n",
-    "An abstraction to store a simple cache in MongoDB. This does not use Semantic Caching, nor does it require an index to be made on the collection before generation.\n",
-    "\n",
-    "To import this cache:\n",
-    "\n",
-    "```python\n",
-    "from langchain_mongodb.cache import MongoDBCache\n",
-    "```\n",
-    "\n",
-    "\n",
-    "To use this cache with your LLMs:\n",
-    "```python\n",
-    "from langchain_core.globals import set_llm_cache\n",
-    "\n",
-    "# use any embedding provider...\n",
-    "from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n",
-    "\n",
-    "mongodb_atlas_uri = \"<YOUR_CONNECTION_STRING>\"\n",
-    "COLLECTION_NAME=\"<YOUR_CACHE_COLLECTION_NAME>\"\n",
-    "DATABASE_NAME=\"<YOUR_DATABASE_NAME>\"\n",
-    "\n",
-    "set_llm_cache(MongoDBCache(\n",
-    "    connection_string=mongodb_atlas_uri,\n",
-    "    collection_name=COLLECTION_NAME,\n",
-    "    database_name=DATABASE_NAME,\n",
-    "))\n",
-    "```\n",
-    "\n",
-    "\n",
-    "### `MongoDBAtlasSemanticCache`\n",
-    "Semantic caching allows users to retrieve cached prompts based on semantic similarity between the user input and previously cached results. Under the hood it blends MongoDBAtlas as both a cache and a vectorstore.\n",
-    "The MongoDBAtlasSemanticCache inherits from `MongoDBAtlasVectorSearch` and needs an Atlas Vector Search Index defined to work. Please look at the [usage example](/docs/integrations/vectorstores/mongodb_atlas) on how to set up the index.\n",
-    "\n",
-    "To import this cache:\n",
-    "```python\n",
-    "from langchain_mongodb.cache import MongoDBAtlasSemanticCache\n",
-    "```\n",
-    "\n",
-    "To use this cache with your LLMs:\n",
-    "```python\n",
-    "from langchain_core.globals import set_llm_cache\n",
-    "\n",
-    "# use any embedding provider...\n",
-    "from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings\n",
-    "\n",
-    "mongodb_atlas_uri = \"<YOUR_CONNECTION_STRING>\"\n",
-    "COLLECTION_NAME=\"<YOUR_CACHE_COLLECTION_NAME>\"\n",
-    "DATABASE_NAME=\"<YOUR_DATABASE_NAME>\"\n",
-    "\n",
-    "set_llm_cache(MongoDBAtlasSemanticCache(\n",
-    "    embedding=FakeEmbeddings(),\n",
-    "    connection_string=mongodb_atlas_uri,\n",
-    "    collection_name=COLLECTION_NAME,\n",
-    "    database_name=DATABASE_NAME,\n",
-    "))\n",
-    "```\n",
-    "\n",
-    "To find more resources about using MongoDBSemanticCache visit [here](https://www.mongodb.com/blog/post/introducing-semantic-caching-dedicated-mongodb-lang-chain-package-gen-ai-apps)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "726fe754",
@@ -1070,7 +993,7 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stdin",
      "output_type": "stream",
      "text": [
       "CASSANDRA_KEYSPACE =  demo_keyspace\n"
@@ -1106,7 +1029,7 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stdin",
      "output_type": "stream",
      "text": [
       "ASTRA_DB_ID =  01234567-89ab-cdef-0123-456789abcdef\n",
@@ -2148,71 +2071,6 @@
     "# so it uses the cached result!\n",
     "llm(\"Tell me one joke\")"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ae1f5e1c-085e-4998-9f2d-b5867d2c3d5b",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-05-31T17:18:43.345495Z",
-     "iopub.status.busy": "2024-05-31T17:18:43.345015Z",
-     "iopub.status.idle": "2024-05-31T17:18:43.351003Z",
-     "shell.execute_reply": "2024-05-31T17:18:43.350073Z",
-     "shell.execute_reply.started": "2024-05-31T17:18:43.345456Z"
-    }
-   },
-   "source": [
-    "## Cache classes: summary table"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "65072e45-10bc-40f1-979b-2617656bbbce",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-05-31T17:16:05.616430Z",
-     "iopub.status.busy": "2024-05-31T17:16:05.616221Z",
-     "iopub.status.idle": "2024-05-31T17:16:05.624164Z",
-     "shell.execute_reply": "2024-05-31T17:16:05.623673Z",
-     "shell.execute_reply.started": "2024-05-31T17:16:05.616418Z"
-    }
-   },
-   "source": [
-    "**Cache** classes are implemented by inheriting the [BaseCache](https://api.python.langchain.com/en/latest/caches/langchain_core.caches.BaseCache.html) class.\n",
-    "\n",
-    "This table lists all 20 derived classes with links to the API Reference.\n",
-    "\n",
-    "\n",
-    "| Namespace 🔻 | Class |\n",
-    "|------------|---------|\n",
-    "| langchain_astradb.cache | [AstraDBCache](https://api.python.langchain.com/en/latest/cache/langchain_astradb.cache.AstraDBCache.html) |\n",
-    "| langchain_astradb.cache | [AstraDBSemanticCache](https://api.python.langchain.com/en/latest/cache/langchain_astradb.cache.AstraDBSemanticCache.html) |\n",
-    "| langchain_community.cache | [AstraDBCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.AstraDBCache.html) |\n",
-    "| langchain_community.cache | [AstraDBSemanticCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.AstraDBSemanticCache.html) |\n",
-    "| langchain_community.cache | [AzureCosmosDBSemanticCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.AzureCosmosDBSemanticCache.html) |\n",
-    "| langchain_community.cache | [CassandraCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.CassandraCache.html) |\n",
-    "| langchain_community.cache | [CassandraSemanticCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.CassandraSemanticCache.html) |\n",
-    "| langchain_community.cache | [GPTCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.GPTCache.html) |\n",
-    "| langchain_community.cache | [InMemoryCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.InMemoryCache.html) |\n",
-    "| langchain_community.cache | [MomentoCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.MomentoCache.html) |\n",
-    "| langchain_community.cache | [OpenSearchSemanticCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.OpenSearchSemanticCache.html) |\n",
-    "| langchain_community.cache | [RedisSemanticCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.RedisSemanticCache.html) |\n",
-    "| langchain_community.cache | [SQLAlchemyCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.SQLAlchemyCache.html) |\n",
-    "| langchain_community.cache | [SQLAlchemyMd5Cache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.SQLAlchemyMd5Cache.html) |\n",
-    "| langchain_community.cache | [UpstashRedisCache](https://api.python.langchain.com/en/latest/cache/langchain_community.cache.UpstashRedisCache.html) |\n",
-    "| langchain_core.caches | [InMemoryCache](https://api.python.langchain.com/en/latest/caches/langchain_core.caches.InMemoryCache.html) |\n",
-    "| langchain_elasticsearch.cache | [ElasticsearchCache](https://api.python.langchain.com/en/latest/cache/langchain_elasticsearch.cache.ElasticsearchCache.html) |\n",
-    "| langchain_mongodb.cache | [MongoDBAtlasSemanticCache](https://api.python.langchain.com/en/latest/cache/langchain_mongodb.cache.MongoDBAtlasSemanticCache.html) |\n",
-    "| langchain_mongodb.cache | [MongoDBCache](https://api.python.langchain.com/en/latest/cache/langchain_mongodb.cache.MongoDBCache.html) |\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "19067f14-c69a-4156-9504-af43a0713669",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -2231,7 +2089,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/llms/ollama.ipynb

@@ -6,27 +6,22 @@
    "source": [
     "# Ollama\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of Ollama models as [text completion models](/docs/concepts/#llms). Many popular Ollama models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You may be looking for [this page instead](/docs/integrations/chat/ollama/).\n",
-    ":::\n",
-    "\n",
     "[Ollama](https://ollama.ai/) allows you to run open-source large language models, such as Llama 2, locally.\n",
     "\n",
     "Ollama bundles model weights, configuration, and data into a single package, defined by a Modelfile. \n",
     "\n",
     "It optimizes setup and configuration details, including GPU usage.\n",
     "\n",
-    "For a complete list of supported models and model variants, see the [Ollama model library](https://github.com/ollama/ollama#model-library).\n",
+    "For a complete list of supported models and model variants, see the [Ollama model library](https://github.com/jmorganca/ollama#model-library).\n",
     "\n",
     "## Setup\n",
     "\n",
-    "First, follow [these instructions](https://github.com/ollama/ollama) to set up and run a local Ollama instance:\n",
+    "First, follow [these instructions](https://github.com/jmorganca/ollama) to set up and run a local Ollama instance:\n",
     "\n",
     "* [Download](https://ollama.ai/download) and install Ollama onto the available supported platforms (including Windows Subsystem for Linux)\n",
     "* Fetch available LLM model via `ollama pull <name-of-model>`\n",
-    "    * View a list of available models via the [model library](https://ollama.ai/library) and pull to use locally with the command `ollama pull llama3`\n",
+    "    * View a list of available models via the [model library](https://ollama.ai/library)\n",
+    "    * e.g., `ollama pull llama3`\n",
     "* This will download the default tagged version of the model. Typically, the default points to the latest, smallest sized-parameter model.\n",
     "\n",
     "> On Mac, the models will be download to `~/.ollama/models`\n",
@@ -34,29 +29,28 @@
     "> On Linux (or WSL), the models will be stored at `/usr/share/ollama/.ollama/models`\n",
     "\n",
     "* Specify the exact version of the model of interest as such `ollama pull vicuna:13b-v1.5-16k-q4_0` (View the [various tags for the `Vicuna`](https://ollama.ai/library/vicuna/tags) model in this instance)\n",
-    "* To view all pulled models on your local instance, use `ollama list`\n",
+    "* To view all pulled models, use `ollama list`\n",
     "* To chat directly with a model from the command line, use `ollama run <name-of-model>`\n",
-    "* View the [Ollama documentation](https://github.com/ollama/ollama) for more commands. \n",
-    "* Run `ollama help` in the terminal to see available commands too.\n",
+    "* View the [Ollama documentation](https://github.com/jmorganca/ollama) for more commands. Run `ollama help` in the terminal to see available commands too.\n",
     "\n",
     "## Usage\n",
     "\n",
-    "You can see a full list of supported parameters on the [API reference page](https://api.python.langchain.com/en/latest/llms/langchain_community.llms.ollama.Ollama.html).\n",
+    "You can see a full list of supported parameters on the [API reference page](https://api.python.langchain.com/en/latest/llms/langchain.llms.ollama.Ollama.html).\n",
     "\n",
-    "If you are using a LLaMA `chat` model (e.g., `ollama pull llama3`) then you can use the `ChatOllama` [interface](https://python.langchain.com/v0.2/docs/integrations/chat/ollama/).\n",
+    "If you are using a LLaMA `chat` model (e.g., `ollama pull llama3`) then you can use the `ChatOllama` interface.\n",
     "\n",
-    "This includes [special tokens](https://ollama.com/library/llama3) for system message and user input.\n",
+    "This includes [special tokens](https://huggingface.co/blog/llama2#how-to-prompt-llama-2) for system message and user input.\n",
     "\n",
     "## Interacting with Models \n",
     "\n",
     "Here are a few ways to interact with pulled local models\n",
     "\n",
-    "#### In the terminal:\n",
+    "#### directly in the terminal:\n",
     "\n",
     "* All of your local models are automatically served on `localhost:11434`\n",
     "* Run `ollama run <name-of-model>` to start interacting via the command line directly\n",
     "\n",
-    "#### Via the API\n",
+    "### via an API\n",
     "\n",
     "Send an `application/json` request to the API endpoint of Ollama to interact.\n",
     "\n",
@@ -67,20 +61,11 @@
     "}'\n",
     "```\n",
     "\n",
-    "See the Ollama [API documentation](https://github.com/ollama/ollama/blob/main/docs/api.md) for all endpoints.\n",
+    "See the Ollama [API documentation](https://github.com/jmorganca/ollama/blob/main/docs/api.md) for all endpoints.\n",
     "\n",
     "#### via LangChain\n",
     "\n",
-    "See a typical basic example of using [Ollama chat model](https://python.langchain.com/v0.2/docs/integrations/chat/ollama/) in your LangChain application."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!pip install langchain-community"
+    "See a typical basic example of using Ollama chat model in your LangChain application."
    ]
   },
   {
@@ -102,9 +87,7 @@
    "source": [
     "from langchain_community.llms import Ollama\n",
     "\n",
-    "llm = Ollama(\n",
-    "    model=\"llama3\"\n",
-    ")  # assuming you have Ollama installed and have llama3 model pulled with `ollama pull llama3 `\n",
+    "llm = Ollama(model=\"llama3\")\n",
     "\n",
     "llm.invoke(\"Tell me a joke\")"
    ]
@@ -297,24 +280,6 @@
     "llm_with_image_context = bakllava.bind(images=[image_b64])\n",
     "llm_with_image_context.invoke(\"What is the dollar based gross retention rate:\")"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Concurrency Features\n",
-    "\n",
-    "Ollama supports concurrency inference for a single model, and or loading multiple models simulatenously (at least [version 0.1.33](https://github.com/ollama/ollama/releases)).\n",
-    "\n",
-    "Start the Ollama server with:\n",
-    "\n",
-    "* `OLLAMA_NUM_PARALLEL`: Handle multiple requests simultaneously for a single model\n",
-    "* `OLLAMA_MAX_LOADED_MODELS`: Load multiple models simultaneously\n",
-    "\n",
-    "Example: `OLLAMA_NUM_PARALLEL=4 OLLAMA_MAX_LOADED_MODELS=4 ollama serve`\n",
-    "\n",
-    "Learn more about configuring Ollama server in [the official guide](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-do-i-configure-ollama-server)."
-   ]
   }
  ],
  "metadata": {

docs/docs/integrations/llms/openai.ipynb

@@ -7,12 +7,6 @@
    "source": [
     "# OpenAI\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of OpenAI [text completion models](/docs/concepts/#llms). The latest and most popular OpenAI models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "Unless you are specifically using `gpt-3.5-turbo-instruct`, you are probably looking for [this page instead](/docs/integrations/chat/openai/).\n",
-    ":::\n",
-    "\n",
     "[OpenAI](https://platform.openai.com/docs/introduction) offers a spectrum of models with different levels of power suitable for different tasks.\n",
     "\n",
     "This example goes over how to use LangChain to interact with `OpenAI` [models](https://platform.openai.com/docs/models)"

docs/docs/integrations/llms/openvino.ipynb

@@ -31,7 +31,7 @@
    },
    "outputs": [],
    "source": [
-    "%pip install --upgrade-strategy eager \"optimum[openvino,nncf]\" langchain-huggingface --quiet"
+    "%pip install --upgrade-strategy eager \"optimum[openvino,nncf]\" --quiet"
    ]
   },
   {
@@ -130,28 +130,6 @@
     "print(chain.invoke({\"question\": question}))"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "446a01e0",
-   "metadata": {},
-   "source": [
-    "To get response without prompt, you can bind `skip_prompt=True` with LLM."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e3baeab2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain = prompt | ov_llm.bind(skip_prompt=True)\n",
-    "\n",
-    "question = \"What is electroencephalography?\"\n",
-    "\n",
-    "print(chain.invoke({\"question\": question}))"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "12524837-e9ab-455a-86be-66b95f4f893a",
@@ -265,8 +243,7 @@
     "    skip_prompt=True,\n",
     "    skip_special_tokens=True,\n",
     ")\n",
-    "pipeline_kwargs = {\"pipeline_kwargs\": {\"streamer\": streamer, \"max_new_tokens\": 100}}\n",
-    "chain = prompt | ov_llm.bind(**pipeline_kwargs)\n",
+    "ov_llm.pipeline._forward_params = {\"streamer\": streamer, \"max_new_tokens\": 100}\n",
     "\n",
     "t1 = Thread(target=chain.invoke, args=({\"question\": question},))\n",
     "t1.start()\n",

docs/docs/integrations/llms/together.ipynb

@@ -7,12 +7,6 @@
    "source": [
     "# Together AI\n",
     "\n",
-    ":::caution\n",
-    "You are currently on a page documenting the use of Together AI models as [text completion models](/docs/concepts/#llms). Many popular Together AI models are [chat completion models](/docs/concepts/#chat-models).\n",
-    "\n",
-    "You may be looking for [this page instead](/docs/integrations/chat/together/).\n",
-    ":::\n",
-    "\n",
     "[Together AI](https://www.together.ai/) offers an API to query [50+ leading open-source models](https://docs.together.ai/docs/inference-models) in a couple lines of code.\n",
     "\n",
     "This example goes over how to use LangChain to interact with Together AI models."