core: loosen packaging lib version

This downgrades `Function/tool calling` from a h3 to an h4 which means
it'll no longer show up in the right sidebar, but any direct links will
still work. I think that is ok, but LMK if you disapprove.

CC @hwchase17 @eyurtsev @rlancemartin

.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/ISSUE_TEMPLATE/documentation.yml

@@ -26,6 +26,13 @@ body:
       [LangChain Github Discussions](https://github.com/langchain-ai/langchain/discussions),
       [LangChain Github Issues](https://github.com/langchain-ai/langchain/issues?q=is%3Aissue),
       [LangChain ChatBot](https://chat.langchain.com/)
+- type: input
+  id: url
+  attributes:
+    label: URL
+    description: URL to documentation
+  validations:
+    required: false
 - type: checkboxes
   id: checks
   attributes:
@@ -48,4 +55,4 @@ body:
     label: "Idea or request for content:"
     description: >
       Please describe as clearly as possible what topics you think are missing
-      from the current documentation.
+      from the current documentation.

.github/PULL_REQUEST_TEMPLATE.md

@@ -26,4 +26,4 @@ Additional guidelines:
 - Changes should be backwards compatible.
 - If you are adding something to community, do not re-import it in langchain.
 
-If no one reviews your PR within a few days, please @-mention one of baskaryan, efriis, eyurtsev, hwchase17.
+If no one reviews your PR within a few days, please @-mention one of baskaryan, efriis, eyurtsev, ccurme, vbarda, hwchase17.

.github/actions/people/app/main.py

@@ -537,7 +537,9 @@ if __name__ == "__main__":
         "nfcampos",
         "efriis",
         "eyurtsev",
-        "rlancemartin"
+        "rlancemartin",
+        "ccurme",
+        "vbarda",
     }
     hidden_logins = {
         "dev2049",

.github/scripts/check_diff.py

@@ -6,8 +6,8 @@ from typing import Dict
 LANGCHAIN_DIRS = [
     "libs/core",
     "libs/text-splitters",
-    "libs/community",
     "libs/langchain",
+    "libs/community",
     "libs/experimental",
 ]
 
@@ -91,4 +91,4 @@ if __name__ == "__main__":
     }
     for key, value in outputs.items():
         json_output = json.dumps(value)
-        print(f"{key}={json_output}")  # noqa: T201
+        print(f"{key}={json_output}")

.github/scripts/get_min_versions.py

@@ -76,4 +76,4 @@ if __name__ == "__main__":
 
     print(
         " ".join([f"{lib}=={version}" for lib, version in min_versions.items()])
-    )  # noqa: T201
+    )

.github/workflows/.codespell-exclude

@@ -0,0 +1,7 @@
+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/_compile_integration_test.yml

@@ -24,6 +24,7 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     name: "poetry run pytest -m compile tests/integration_tests #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4

.github/workflows/_dependencies.yml

@@ -28,6 +28,7 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     name: dependency checks ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@v4

.github/workflows/_lint.yml

@@ -34,7 +34,7 @@ jobs:
         # so linting on fewer versions makes CI faster.
         python-version:
           - "3.8"
-          - "3.11"
+          - "3.12"
     steps:
       - uses: actions/checkout@v4
 

.github/workflows/_release.yml

@@ -72,10 +72,67 @@ 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:
@@ -86,6 +143,7 @@ jobs:
   pre-release-checks:
     needs:
       - build
+      - release-notes
       - test-pypi-publish
     runs-on: ubuntu-latest
     steps:
@@ -177,7 +235,7 @@ jobs:
         env:
           MIN_VERSIONS: ${{ steps.min-version.outputs.min-versions }}
         run: |
-          poetry run pip install --force-reinstall $MIN_VERSIONS
+          poetry run pip install --force-reinstall $MIN_VERSIONS --editable .
           make tests
         working-directory: ${{ inputs.working-directory }}
 
@@ -222,12 +280,14 @@ jobs:
           MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
           VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
           UPSTAGE_API_KEY: ${{ secrets.UPSTAGE_API_KEY }}
+          FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
         run: make integration_tests
         working-directory: ${{ inputs.working-directory }}
 
   publish:
     needs:
       - build
+      - release-notes
       - test-pypi-publish
       - pre-release-checks
     runs-on: ubuntu-latest
@@ -269,6 +329,7 @@ jobs:
   mark-release:
     needs:
       - build
+      - release-notes
       - test-pypi-publish
       - pre-release-checks
       - publish
@@ -305,5 +366,6 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
           generateReleaseNotes: false
           tag: ${{needs.build.outputs.pkg-name}}==${{ needs.build.outputs.version }}
-          body: "# Release ${{needs.build.outputs.pkg-name}}==${{ needs.build.outputs.version }}\n\nPackage-specific release note generation coming soon."
+          body: ${{ needs.release-notes.outputs.release-body }}
           commit: ${{ github.sha }}
+          makeLatest: ${{ needs.build.outputs.pkg-name == 'langchain-core'}}

.github/workflows/_test.yml

@@ -28,6 +28,7 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     name: "make test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4

.github/workflows/_test_doc_imports.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       matrix:
         python-version:
-          - "3.11"
+          - "3.12"
     name: "check doc imports #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4

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

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

.github/workflows/check_diffs.yml

@@ -104,6 +104,7 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     runs-on: ubuntu-latest
     defaults:
       run:
@@ -123,7 +124,9 @@ jobs:
         shell: bash
         run: |
           echo "Running extended tests, installing dependencies with poetry..."
-          poetry install -E extended_testing --with test
+          poetry install --with test
+          poetry run pip install uv
+          poetry run uv pip install -r extended_testing_deps.txt
 
       - name: Run extended tests
         run: make extended_tests

.github/workflows/check_new_docs.yml

@@ -0,0 +1,31 @@
+---
+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: libs/community/langchain_community/llms/yuan2.py
+#      - 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

.github/workflows/extract_ignored_words_list.py

@@ -7,4 +7,4 @@ ignore_words_list = (
     pyproject_toml.get("tool", {}).get("codespell", {}).get("ignore-words-list")
 )
 
-print(f"::set-output name=ignore_words_list::{ignore_words_list}")  # noqa: T201
+print(f"::set-output name=ignore_words_list::{ignore_words_list}")

.github/workflows/scheduled_test.yml

@@ -10,6 +10,8 @@ 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
@@ -25,16 +27,52 @@ jobs:
           - "libs/partners/groq"
           - "libs/partners/mistralai"
           - "libs/partners/together"
-    name: Python ${{ matrix.python-version }} - ${{ matrix.working-directory }}
+          - "libs/partners/cohere"
+          - "libs/partners/google-vertexai"
+          - "libs/partners/google-genai"
+          - "libs/partners/aws"
+          - "libs/partners/nvidia-ai-endpoints"
+
     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: "./.github/actions/poetry_setup"
+        uses: "./langchain/.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ matrix.working-directory }}
+          working-directory: langchain/${{ matrix.working-directory }}
           cache-key: scheduled
 
       - name: 'Authenticate to Google Cloud'
@@ -43,16 +81,20 @@ 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 }}
@@ -67,12 +109,26 @@ 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: |
-          make integration_test
+          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
 
       - name: Ensure the tests did not create any additional files
-        working-directory: ${{ matrix.working-directory }}
-        shell: bash
+        working-directory: langchain
         run: |
           set -eu
 

.gitignore

@@ -133,6 +133,7 @@ env.bak/
 
 # mypy
 .mypy_cache/
+.mypy_cache_test/
 .dmypy.json
 dmypy.json
 
@@ -178,3 +179,4 @@ _dist
 docs/docs/templates
 
 prof
+virtualenv/

Makefile

@@ -3,7 +3,7 @@
 ## help: Show this help info.
 help: Makefile
 	@printf "\n\033[1mUsage: make <TARGETS> ...\033[0m\n\n\033[1mTargets:\033[0m\n\n"
-	@sed -n 's/^##//p' $< | awk -F':' '{printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' | sort | sed -e 's/^/ /'
+	@sed -n 's/^## //p' $< | awk -F':' '{printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' | sort | sed -e 's/^/  /'
 
 ## all: Default target, shows help.
 all: help
@@ -17,7 +17,7 @@ clean: docs_clean api_docs_clean
 
 ## docs_build: Build the documentation.
 docs_build:
-	cd docs && make build-local
+	cd docs && make build
 
 ## docs_clean: Clean the documentation build artifacts.
 docs_clean:
@@ -32,10 +32,19 @@ 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)
+	cd docs/api_reference && poetry run make html
+	open docs/api_reference/_build/html/$(shell echo $(API_PKG) | sed 's/-/_/g')_api_reference.html
+
 ## api_docs_clean: Clean the API Reference documentation build artifacts.
 api_docs_clean:
 	find ./docs/api_reference -name '*_api_reference.rst' -delete
-	cd docs/api_reference && poetry run make clean
+	git clean -fdX ./docs/api_reference
+	
 
 ## api_docs_linkcheck: Run linkchecker on the API Reference documentation.
 api_docs_linkcheck:

README.md

@@ -2,17 +2,17 @@
 
 ⚡ Build context-aware reasoning applications ⚡
 
-[![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/releases)
+[![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain?style=flat-square)](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)
-[![Downloads](https://static.pepy.tech/badge/langchain/month)](https://pepy.tech/project/langchain)
-[![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)
+[![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)
-[![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)
+[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
 
 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/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**: 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
 - **`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://python.langchain.com/docs/langgraph)**: A library for building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
+- **[`LangGraph`](https://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.
 
 ### Productionization:
-- **[LangSmith](https://python.langchain.com/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
+- **[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.
 
 ### Deployment:
-- **[LangServe](https://python.langchain.com/docs/langserve)**: A library for deploying LangChain chains as REST APIs.
+- **[LangServe](https://python.langchain.com/v0.2/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/docs/use_cases/question_answering/)
+- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/rag/)
 - 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/docs/use_cases/extraction/)
+- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/extraction/)
 - End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain-extract/)
 
 **🤖 Chatbots**
 
-- [Documentation](https://python.langchain.com/docs/use_cases/chatbots)
+- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/chatbot/)
 - 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 [Use cases](https://python.langchain.com/docs/use_cases/) section of the docs for more.
+And much more! Head to the [Tutorials](https://python.langchain.com/v0.2/docs/tutorials/) section of the docs for more.
 
 ## 🚀 How does LangChain help?
 The main value props of the LangChain libraries are:
@@ -87,49 +87,50 @@ 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/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
+- **[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
 
 ## Components
 
 Components fall into the following **modules**:
 
-**📃 Model I/O:**
+**📃 Model I/O**
 
-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/).
+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).
 
-**📚 Retrieval:**
+**📚 Retrieval**
 
-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.
+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.
 
-**🤖 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 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.
+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.
 
 ## 📖 Documentation
 
 Please see [here](https://python.langchain.com) for full documentation, which includes:
 
-- [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).
+- [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.
 
 ## 🌐 Ecosystem
 
-- [🦜🛠️ 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.
+- [🦜🛠️ 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.
 - [🦜🏓 LangServe](https://python.langchain.com/docs/langserve): Deploying LangChain runnables and chains as REST APIs.
-  - [LangChain Templates](https://python.langchain.com/docs/templates/): Example applications hosted with LangServe.
+  - [LangChain Templates](https://python.langchain.com/v0.2/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/docs/contributing/).
+For detailed information on how to contribute, see [here](https://python.langchain.com/v0.2/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 synce jupyter runs an async eventloop\n",
+    "# Needed since jupyter runs an async eventloop\n",
     "nest_asyncio.apply()"
    ]
   },

cookbook/nomic_multimodal_rag.ipynb

@@ -0,0 +1,497 @@
+{
+ "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

@@ -6,23 +6,24 @@
    "source": [
     "# Oracle AI Vector Search with Document Processing\n",
     "Oracle AI Vector Search is designed for Artificial Intelligence (AI) workloads that allows you to query data based on semantics, rather than keywords.\n",
-    "One of the biggest benefit of Oracle AI Vector Search is that semantic search on unstructured data can be combined with relational search on business data in one single system. This is not only powerful but also significantly more effective because you don't need to add a specialized vector database, eliminating the pain of data fragmentation between multiple systems.\n",
+    "One of the biggest benefits of Oracle AI Vector Search is that semantic search on unstructured data can be combined with relational search on business data in one single system.\n",
+    "This is not only powerful but also significantly more effective because you don't need to add a specialized vector database, eliminating the pain of data fragmentation between multiple systems.\n",
     "\n",
-    "In addition, because Oracle has been building database technologies for so long, your vectors can benefit from all of Oracle Database's most powerful features, like the following:\n",
+    "In addition, your vectors can benefit from all of Oracle Database’s most powerful features, like the following:\n",
     "\n",
-    " * Partitioning Support\n",
-    " * Real Application Clusters scalability\n",
-    " * Exadata smart scans\n",
-    " * Shard processing across geographically distributed databases\n",
-    " * Transactions\n",
-    " * Parallel SQL\n",
-    " * Disaster recovery\n",
-    " * Security\n",
-    " * Oracle Machine Learning\n",
-    " * Oracle Graph Database\n",
-    " * Oracle Spatial and Graph\n",
-    " * Oracle Blockchain\n",
-    " * JSON\n",
+    " * [Partitioning Support](https://www.oracle.com/database/technologies/partitioning.html)\n",
+    " * [Real Application Clusters scalability](https://www.oracle.com/database/real-application-clusters/)\n",
+    " * [Exadata smart scans](https://www.oracle.com/database/technologies/exadata/software/smartscan/)\n",
+    " * [Shard processing across geographically distributed databases](https://www.oracle.com/database/distributed-database/)\n",
+    " * [Transactions](https://docs.oracle.com/en/database/oracle/oracle-database/23/cncpt/transactions.html)\n",
+    " * [Parallel SQL](https://docs.oracle.com/en/database/oracle/oracle-database/21/vldbg/parallel-exec-intro.html#GUID-D28717E4-0F77-44F5-BB4E-234C31D4E4BA)\n",
+    " * [Disaster recovery](https://www.oracle.com/database/data-guard/)\n",
+    " * [Security](https://www.oracle.com/security/database-security/)\n",
+    " * [Oracle Machine Learning](https://www.oracle.com/artificial-intelligence/database-machine-learning/)\n",
+    " * [Oracle Graph Database](https://www.oracle.com/database/integrated-graph-database/)\n",
+    " * [Oracle Spatial and Graph](https://www.oracle.com/database/spatial/)\n",
+    " * [Oracle Blockchain](https://docs.oracle.com/en/database/oracle/oracle-database/23/arpls/dbms_blockchain_table.html#GUID-B469E277-978E-4378-A8C1-26D3FF96C9A6)\n",
+    " * [JSON](https://docs.oracle.com/en/database/oracle/oracle-database/23/adjsn/json-in-oracle-database.html)\n",
     "\n",
     "This guide demonstrates how Oracle AI Vector Search can be used with Langchain to serve an end-to-end RAG pipeline. This guide goes through examples of:\n",
     "\n",
@@ -33,6 +34,13 @@
     " * Storing and Indexing them in a Vector Store and querying them for queries in OracleVS"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you are just starting with Oracle Database, consider exploring the [free Oracle 23 AI](https://www.oracle.com/database/free/#resources) which provides a great introduction to setting up your database environment. While working with the database, it is often advisable to avoid using the system user by default; instead, you can create your own user for enhanced security and customization. For detailed steps on user creation, refer to our [end-to-end guide](https://github.com/langchain-ai/langchain/blob/master/cookbook/oracleai_demo.ipynb) which also shows how to set up a user in Oracle. Additionally, understanding user privileges is crucial for managing database security effectively. You can learn more about this topic in the official [Oracle guide](https://docs.oracle.com/en/database/oracle/oracle-database/19/admqs/administering-user-accounts-and-security.html#GUID-36B21D72-1BBB-46C9-A0C9-F0D2A8591B8D) on administering user accounts and security."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -78,8 +86,7 @@
     "\n",
     "import oracledb\n",
     "\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",
+    "# Update with your username, password, hostname, and service_name\n",
     "username = \"\"\n",
     "password = \"\"\n",
     "dsn = \"\"\n",
@@ -89,40 +96,45 @@
     "    print(\"Connection successful!\")\n",
     "\n",
     "    cursor = conn.cursor()\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",
+    "    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",
     "    conn.close()\n",
     "except Exception as e:\n",
-    "    print(\"User setup failed!\")\n",
-    "    cursor.close()\n",
-    "    conn.close()\n",
+    "    print(f\"Connection failed with error: {e}\")\n",
     "    sys.exit(1)"
    ]
   },
@@ -131,13 +143,13 @@
    "metadata": {},
    "source": [
     "## Process Documents using Oracle AI\n",
-    "Let's think about a scenario that the users have some documents in Oracle Database or in a file system. They want to use the data for Oracle AI Vector Search using Langchain.\n",
+    "Consider the following scenario: users possess documents stored either in an Oracle Database or a file system and intend to utilize this data with Oracle AI Vector Search powered by Langchain.\n",
     "\n",
-    "For that, the users need to do some document preprocessing. The first step would be to read the documents, generate their summary(if needed) and then chunk/split them if needed. After that, they need to generate the embeddings for those chunks and store into Oracle AI Vector Store. Finally, the users will perform some semantic queries on those data. \n",
+    "To prepare the documents for analysis, a comprehensive preprocessing workflow is necessary. Initially, the documents must be retrieved, summarized (if required), and chunked as needed. Subsequent steps involve generating embeddings for these chunks and integrating them into the Oracle AI Vector Store. Users can then conduct semantic searches on this data.\n",
     "\n",
-    "Oracle AI Vector Search Langchain library provides a range of document processing functionalities including document loading, splitting, generating summary and embeddings.\n",
+    "The Oracle AI Vector Search Langchain library encompasses a suite of document processing tools that facilitate document loading, chunking, summary generation, and embedding creation.\n",
     "\n",
-    "In the following sections, we will go through how to use Oracle AI Langchain APIs to achieve each of these functionalities individually. "
+    "In the sections that follow, we will detail the utilization of Oracle AI Langchain APIs to effectively implement each of these processes."
    ]
   },
   {
@@ -145,7 +157,7 @@
    "metadata": {},
    "source": [
     "### Connect to Demo User\n",
-    "The following sample code will show how to connect to Oracle Database. "
+    "The following sample code will show how to connect to Oracle Database. By default, python-oracledb runs in a ‘Thin’ mode which connects directly to Oracle Database. This mode does not need Oracle Client libraries. However, some additional functionality is available when python-oracledb uses them. Python-oracledb is said to be in ‘Thick’ mode when Oracle Client libraries are used. Both modes have comprehensive functionality supporting the Python Database API v2.0 Specification. See the following [guide](https://python-oracledb.readthedocs.io/en/latest/user_guide/appendix_a.html#featuresummary) that talks about features supported in each mode. You might want to switch to thick-mode if you are unable to use thin-mode."
    ]
   },
   {
@@ -242,9 +254,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "\n",
-    "\n",
-    "Now that we have a demo user and a demo table with some data, we just need to do one more setup. For embedding and summary, we have a few provider options that the users can choose from such as database, 3rd party providers like ocigenai, huggingface, openai, etc. If the users choose to use 3rd party provider, they need to create a credential with corresponding authentication information. On the other hand, if the users choose to use 'database' as provider, they need to load an onnx model to Oracle Database for embeddings; however, for summary, they don't need to do anything."
+    "With the inclusion of a demo user and a populated sample table, the remaining configuration involves setting up embedding and summary functionalities. Users are presented with multiple provider options, including local database solutions and third-party services such as Ocigenai, Hugging Face, and OpenAI. Should users opt for a third-party provider, they are required to establish credentials containing the necessary authentication details. Conversely, if selecting a database as the provider for embeddings, it is necessary to upload an ONNX model to the Oracle Database. No additional setup is required for summary functionalities when using the database option."
    ]
   },
   {
@@ -253,13 +263,13 @@
    "source": [
     "### Load ONNX Model\n",
     "\n",
-    "To generate embeddings, Oracle provides a few provider options for users to choose from. The users can choose 'database' provider or some 3rd party providers like OCIGENAI, HuggingFace, etc.\n",
+    "Oracle accommodates a variety of embedding providers, enabling users to choose between proprietary database solutions and third-party services such as OCIGENAI and HuggingFace. This selection dictates the methodology for generating and managing embeddings.\n",
     "\n",
-    "***Note*** If the users choose database option, they need to load an ONNX model to Oracle Database. The users do not need to load an ONNX model to Oracle Database if they choose to use 3rd party provider to generate embeddings.\n",
+    "***Important*** : Should users opt for the database option, they must upload an ONNX model into the Oracle Database. Conversely, if a third-party provider is selected for embedding generation, uploading an ONNX model to Oracle Database is not required.\n",
     "\n",
-    "One of the core benefits of using an ONNX model is that the users do not need to transfer their data to 3rd party to generate embeddings. And also, since it does not involve any network or REST API calls, it may provide better performance.\n",
+    "A significant advantage of utilizing an ONNX model directly within Oracle is the enhanced security and performance it offers by eliminating the need to transmit data to external parties. Additionally, this method avoids the latency typically associated with network or REST API calls.\n",
     "\n",
-    "Here is the sample code to load an ONNX model to Oracle Database:"
+    "Below is the example code to upload an ONNX model into Oracle Database:"
    ]
   },
   {
@@ -298,11 +308,11 @@
    "source": [
     "### Create Credential\n",
     "\n",
-    "On the other hand, if the users choose to use 3rd party provider to generate embeddings and summary, they need to create credential to access 3rd party provider's end points.\n",
+    "When selecting third-party providers for generating embeddings, users are required to establish credentials to securely access the provider's endpoints.\n",
     "\n",
-    "***Note:*** The users do not need to create any credential if they choose to use 'database' provider to generate embeddings and summary. Should the users choose to 3rd party provider, they need to create credential for the 3rd party provider they want to use. \n",
+    "***Important:*** No credentials are necessary when opting for the 'database' provider to generate embeddings. However, should users decide to utilize a third-party provider, they must create credentials specific to the chosen provider.\n",
     "\n",
-    "Here is a sample example:"
+    "Below is an illustrative example:"
    ]
   },
   {
@@ -352,11 +362,11 @@
    "metadata": {},
    "source": [
     "### Load Documents\n",
-    "The users can load the documents from Oracle Database or a file system or both. They just need to set the loader parameters accordingly. Please refer to the Oracle AI Vector Search Guide book for complete information about these parameters.\n",
+    "Users have the flexibility to load documents from either the Oracle Database, a file system, or both, by appropriately configuring the loader parameters. For comprehensive details on these parameters, please consult the [Oracle AI Vector Search Guide](https://docs.oracle.com/en/database/oracle/oracle-database/23/arpls/dbms_vector_chain1.html#GUID-73397E89-92FB-48ED-94BB-1AD960C4EA1F).\n",
     "\n",
-    "The main benefit of using OracleDocLoader is that it can handle 150+ different file formats. You don't need to use different types of loader for different file formats. Here is the list formats that we support: [Oracle Text Supported Document Formats](https://docs.oracle.com/en/database/oracle/oracle-database/23/ccref/oracle-text-supported-document-formats.html)\n",
+    "A significant advantage of utilizing OracleDocLoader is its capability to process over 150 distinct file formats, eliminating the need for multiple loaders for different document types. For a complete list of the supported formats, please refer to the [Oracle Text Supported Document Formats](https://docs.oracle.com/en/database/oracle/oracle-database/23/ccref/oracle-text-supported-document-formats.html).\n",
     "\n",
-    "The following sample code will show how to do that:"
+    "Below is a sample code snippet that demonstrates how to use OracleDocLoader"
    ]
   },
   {
@@ -399,7 +409,7 @@
    "metadata": {},
    "source": [
     "### Generate Summary\n",
-    "Now that the user loaded the documents, they may want to generate a summary for each document. The Oracle AI Vector Search Langchain library provides an API to do that. There are a few summary generation provider options including Database, OCIGENAI, HuggingFace and so on. The users can choose their preferred provider to generate a summary. Like before, they just need to set the summary parameters accordingly. Please refer to the Oracle AI Vector Search Guide book for complete information about these parameters."
+    "Now that the user loaded the documents, they may want to generate a summary for each document. The Oracle AI Vector Search Langchain library offers a suite of APIs designed for document summarization. It supports multiple summarization providers such as Database, OCIGENAI, HuggingFace, among others, allowing users to select the provider that best meets their needs. To utilize these capabilities, users must configure the summary parameters as specified. For detailed information on these parameters, please consult the [Oracle AI Vector Search Guide book](https://docs.oracle.com/en/database/oracle/oracle-database/23/arpls/dbms_vector_chain1.html#GUID-EC9DDB58-6A15-4B36-BA66-ECBA20D2CE57)."
    ]
   },
   {
@@ -470,9 +480,9 @@
    "metadata": {},
    "source": [
     "### Split Documents\n",
-    "The documents can be in different sizes: small, medium, large, or very large. The users like to split/chunk their documents into smaller pieces to generate embeddings. There are lots of different splitting customizations the users can do. Please refer to the Oracle AI Vector Search Guide book for complete information about these parameters.\n",
+    "The documents may vary in size, ranging from small to very large. Users often prefer to chunk their documents into smaller sections to facilitate the generation of embeddings. A wide array of customization options is available for this splitting process. For comprehensive details regarding these parameters, please consult the [Oracle AI Vector Search Guide](https://docs.oracle.com/en/database/oracle/oracle-database/23/arpls/dbms_vector_chain1.html#GUID-4E145629-7098-4C7C-804F-FC85D1F24240).\n",
     "\n",
-    "The following sample code will show how to do that:"
+    "Below is a sample code illustrating how to implement this:"
    ]
   },
   {
@@ -513,14 +523,14 @@
    "metadata": {},
    "source": [
     "### Generate Embeddings\n",
-    "Now that the documents are chunked as per requirements, the users may want to generate embeddings for these chunks. Oracle AI Vector Search provides a number of ways to generate embeddings. The users can load an ONNX embedding model to Oracle Database and use it to generate embeddings or use some 3rd party API's end points to generate embeddings. Please refer to the Oracle AI Vector Search Guide book for complete information about these parameters."
+    "Now that the documents are chunked as per requirements, the users may want to generate embeddings for these chunks. Oracle AI Vector Search provides multiple methods for generating embeddings, utilizing either locally hosted ONNX models or third-party APIs. For comprehensive instructions on configuring these alternatives, please refer to the [Oracle AI Vector Search Guide](https://docs.oracle.com/en/database/oracle/oracle-database/23/arpls/dbms_vector_chain1.html#GUID-C6439E94-4E86-4ECD-954E-4B73D53579DE)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "***Note:*** The users may need to set proxy if they want to use some 3rd party embedding generation providers other than 'database' provider (aka using ONNX model)."
+    "***Note:*** Users may need to configure a proxy to utilize third-party embedding generation providers, excluding the 'database' provider that utilizes an ONNX model."
    ]
   },
   {
@@ -752,20 +762,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The above example creates a vector store with DOT_PRODUCT distance strategy. \n",
-    "\n",
-    "However, the users can create Oracle AI Vector Store provides different distance strategies. Please see the [comprehensive guide](/docs/integrations/vectorstores/oracle) for more information."
+    "The example provided illustrates the creation of a vector store using the DOT_PRODUCT distance strategy. Users have the flexibility to employ various distance strategies with the Oracle AI Vector Store, as detailed in our [comprehensive guide](https://python.langchain.com/v0.1/docs/integrations/vectorstores/oracle/)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now that we have embeddings stored in vector stores, let's create an index on them to get better semantic search performance during query time.\n",
+    "With embeddings now stored in vector stores, it is advisable to establish an index to enhance semantic search performance during query execution.\n",
     "\n",
-    "***Note*** If you are getting some insufficient memory error, please increase ***vector_memory_size*** in your database.\n",
+    "***Note*** Should you encounter an \"insufficient memory\" error, it is recommended to increase the  ***vector_memory_size*** in your database configuration\n",
     "\n",
-    "Here is the sample code to create an index:"
+    "Below is a sample code snippet for creating an index:"
    ]
   },
   {
@@ -785,9 +793,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The above example creates a default HNSW index on the embeddings stored in 'oravs' table. The users can set different parameters as per their requirements. Please refer to the Oracle AI Vector Search Guide book for complete information about these parameters.\n",
+    "This example demonstrates the creation of a default HNSW index on embeddings within the 'oravs' table. Users may adjust various parameters according to their specific needs. For detailed information on these parameters, please consult the [Oracle AI Vector Search Guide book](https://docs.oracle.com/en/database/oracle/oracle-database/23/vecse/manage-different-categories-vector-indexes.html).\n",
     "\n",
-    "Also, there are different types of vector indices that the users can create. Please see the [comprehensive guide](/docs/integrations/vectorstores/oracle) for more information.\n"
+    "Additionally, various types of vector indices can be created to meet diverse requirements. More details can be found in our [comprehensive guide](https://python.langchain.com/v0.1/docs/integrations/vectorstores/oracle/).\n"
    ]
   },
   {
@@ -797,9 +805,9 @@
     "## Perform Semantic Search\n",
     "All set!\n",
     "\n",
-    "We have processed the documents, stored them to vector store, and then created index to get better query performance. Now let's do some semantic searches.\n",
+    "We have successfully processed the documents and stored them in the vector store, followed by the creation of an index to enhance query performance. We are now prepared to proceed with semantic searches.\n",
     "\n",
-    "Here is the sample code for this:"
+    "Below is the sample code for this process:"
    ]
   },
   {

cookbook/rag_upstage_layout_analysis_groundedness_check.ipynb

@@ -36,7 +36,9 @@
     "\n",
     "docs = loader.load()\n",
     "\n",
-    "vectorstore = DocArrayInMemorySearch.from_documents(docs, embedding=UpstageEmbeddings())\n",
+    "vectorstore = DocArrayInMemorySearch.from_documents(\n",
+    "    docs, embedding=UpstageEmbeddings(model=\"solar-embedding-1-large\")\n",
+    ")\n",
     "retriever = vectorstore.as_retriever()\n",
     "\n",
     "template = \"\"\"Answer the question based only on the following context:\n",

cookbook/rag_with_quantized_embeddings.ipynb

@@ -39,12 +39,10 @@
     "from langchain_community.document_loaders.recursive_url_loader import (\n",
     "    RecursiveUrlLoader,\n",
     ")\n",
-    "\n",
-    "# noqa\n",
     "from langchain_community.vectorstores import Chroma\n",
     "\n",
     "# For our example, we'll load docs from the web\n",
-    "from langchain_text_splitters import RecursiveCharacterTextSplitter  # noqa\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "\n",
     "DOCSTORE_DIR = \".\"\n",
     "DOCSTORE_ID_KEY = \"doc_id\""

cookbook/sql_db_qa.mdx

@@ -647,7 +647,7 @@ Sometimes you may not have the luxury of using OpenAI or other service-hosted la
 import logging
 import torch
 from transformers import AutoTokenizer, GPT2TokenizerFast, pipeline, AutoModelForSeq2SeqLM, AutoModelForCausalLM
-from langchain_community.llms import HuggingFacePipeline
+from langchain_huggingface import HuggingFacePipeline
 
 # Note: This model requires a large GPU, e.g. an 80GB A100. See documentation for other ways to run private non-OpenAI models.
 model_id = "google/flan-ul2"
@@ -992,7 +992,7 @@ Now that you have some examples (with manually corrected output SQL), you can do
 ```python
 from langchain.prompts import FewShotPromptTemplate, PromptTemplate
 from langchain.chains.sql_database.prompt import _sqlite_prompt, PROMPT_SUFFIX
-from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
+from langchain_huggingface import HuggingFaceEmbeddings
 from langchain.prompts.example_selector.semantic_similarity import SemanticSimilarityExampleSelector
 from langchain_community.vectorstores import Chroma
 

docs/Makefile

@@ -35,8 +35,6 @@ 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)
 
@@ -45,11 +43,6 @@ generate-files:
 	wget -q https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md -O $(INTERMEDIATE_DIR)/langserve.md
 	$(PYTHON) scripts/resolve_local_links.py $(INTERMEDIATE_DIR)/langserve.md https://github.com/langchain-ai/langserve/tree/main/
 
-	wget -q https://raw.githubusercontent.com/langchain-ai/langgraph/main/README.md -O $(INTERMEDIATE_DIR)/langgraph.md
-	$(PYTHON) scripts/resolve_local_links.py $(INTERMEDIATE_DIR)/langgraph.md https://github.com/langchain-ai/langgraph/tree/main/
-
-	$(PYTHON) scripts/generate_api_reference_links.py --docs_dir $(INTERMEDIATE_DIR)
-
 copy-infra:
 	mkdir -p $(OUTPUT_NEW_DIR)
 	cp -r src $(OUTPUT_NEW_DIR)
@@ -68,9 +61,12 @@ render:
 md-sync:
 	rsync -avm --include="*/" --include="*.mdx" --include="*.md" --include="*.png" --exclude="*" $(INTERMEDIATE_DIR)/ $(OUTPUT_NEW_DOCS_DIR)
 
+generate-references:
+	$(PYTHON) scripts/generate_api_reference_links.py --docs_dir $(OUTPUT_NEW_DOCS_DIR)
+
 build: install-py-deps generate-files copy-infra render md-sync
 
-vercel-build: install-vercel-deps build
+vercel-build: install-vercel-deps build generate-references
 	rm -rf docs
 	mv $(OUTPUT_NEW_DOCS_DIR) docs
 	rm -rf build
@@ -78,6 +74,7 @@ vercel-build: install-vercel-deps build
 	mv build v0.2
 	mkdir build
 	mv v0.2 build
+	mv build/v0.2/404.html build
 
 start:
 	cd $(OUTPUT_NEW_DIR) && yarn && yarn start --port=$(PORT)

docs/api_reference/_static/css/custom.css

@@ -24,18 +24,3 @@ table.longtable code {
 table.longtable td {
   max-width: 600px;
 }
-
-.sk-sidebar-toc-wrapper {
-  width: unset;
-  overflow-x: auto;
-}
-
-.sk-sidebar-toc-wrapper > [aria-label="rellinks"] {
-  position: sticky;
-  left: 0;
-}
-
-.navbar-nav .dropdown-menu {
-  max-height: 80vh;
-  overflow-y: auto;
-}

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: Path to the package directory.
-        submodule: Optional name of submodule to load.
+        package_directory (Union[str, Path]): Path to the package directory.
+        submodule (Optional[str]): Optional name of submodule to load.
 
     Returns:
-        list: A list of loaded module objects.
+        Dict[str, ModuleMembers]: A dictionary where keys are module names and values are ModuleMembers objects.
     """
     package_path = (
         Path(package_directory)
@@ -187,7 +187,7 @@ def _load_package_modules(
             modules_by_namespace[top_namespace] = _module_members
 
         except ImportError as e:
-            print(f"Error: Unable to import module '{namespace}' with error: {e}")  # noqa: T201
+            print(f"Error: Unable to import module '{namespace}' with error: {e}")
 
     return modules_by_namespace
 
@@ -359,9 +359,14 @@ def main(dirs: Optional[list] = None) -> None:
         dirs = [
             dir_
             for dir_ in os.listdir(ROOT_DIR / "libs")
-            if dir_ not in ("cli", "partners")
+            if dir_ not in ("cli", "partners", "standard-tests")
+        ]
+        dirs += [
+            dir_
+            for dir_ in os.listdir(ROOT_DIR / "libs" / "partners")
+            if os.path.isdir(ROOT_DIR / "libs" / "partners" / dir_)
+            and "pyproject.toml" in os.listdir(ROOT_DIR / "libs" / "partners" / dir_)
         ]
-        dirs += os.listdir(ROOT_DIR / "libs" / "partners")
     for dir_ in dirs:
         # Skip any hidden directories
         # Some of these could be present by mistake in the code base

docs/api_reference/themes/scikit-learn-modern/static/css/theme.css

@@ -1398,3 +1398,20 @@ table.sk-sponsor-table td {
 .highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
 .highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
 .highlight .il { color: #208050 } /* Literal.Number.Integer.Long */
+
+/** Custom styles overriding certain values */
+
+div.sk-sidebar-toc-wrapper {
+  width: unset;
+  overflow-x: auto;
+}
+
+div.sk-sidebar-toc-wrapper > [aria-label="rellinks"] {
+  position: sticky;
+  left: 0;
+}
+
+.navbar-nav .dropdown-menu {
+  max-height: 80vh;
+  overflow-y: auto;
+}

docs/docs/additional_resources/arxiv_references.mdx

@@ -0,0 +1,876 @@
+# arXiv
+            
+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).
+
+## 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)
+| `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)
+| `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)
+| `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)
+| `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)
+| `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
+- **Title:** Dense X Retrieval: What Retrieval Granularity Should We Use?
+- **Authors:** Tong Chen, Hongwei Wang, Sihao Chen,  et al.
+- **Published Date:** 2023-12-11
+- **URL:** http://arxiv.org/abs/2312.06648v2
+- **LangChain:**
+
+   - **Template:** [propositional-retrieval](https://python.langchain.com/docs/templates/propositional-retrieval)
+
+**Abstract:** Dense retrieval has become a prominent method to obtain relevant context or
+world knowledge in open-domain NLP tasks. When we use a learned dense retriever
+on a retrieval corpus at inference time, an often-overlooked design choice is
+the retrieval unit in which the corpus is indexed, e.g. document, passage, or
+sentence. We discover that the retrieval unit choice significantly impacts the
+performance of both retrieval and downstream tasks. Distinct from the typical
+approach of using passages or sentences, we introduce a novel retrieval unit,
+proposition, for dense retrieval. Propositions are defined as atomic
+expressions within text, each encapsulating a distinct factoid and presented in
+a concise, self-contained natural language format. We conduct an empirical
+comparison of different retrieval granularity. Our results reveal that
+proposition-based retrieval significantly outperforms traditional passage or
+sentence-based methods in dense retrieval. Moreover, retrieval by proposition
+also enhances the performance of downstream QA tasks, since the retrieved texts
+are more condensed with question-relevant information, reducing the need for
+lengthy input tokens and minimizing the inclusion of extraneous, irrelevant
+information.
+                
+## Chain-of-Note: Enhancing Robustness in Retrieval-Augmented Language Models
+
+- **arXiv id:** 2311.09210v1
+- **Title:** Chain-of-Note: Enhancing Robustness in Retrieval-Augmented Language Models
+- **Authors:** Wenhao Yu, Hongming Zhang, Xiaoman Pan,  et al.
+- **Published Date:** 2023-11-15
+- **URL:** http://arxiv.org/abs/2311.09210v1
+- **LangChain:**
+
+   - **Template:** [chain-of-note-wiki](https://python.langchain.com/docs/templates/chain-of-note-wiki)
+
+**Abstract:** Retrieval-augmented language models (RALMs) represent a substantial
+advancement in the capabilities of large language models, notably in reducing
+factual hallucination by leveraging external knowledge sources. However, the
+reliability of the retrieved information is not always guaranteed. The
+retrieval of irrelevant data can lead to misguided responses, and potentially
+causing the model to overlook its inherent knowledge, even when it possesses
+adequate information to address the query. Moreover, standard RALMs often
+struggle to assess whether they possess adequate knowledge, both intrinsic and
+retrieved, to provide an accurate answer. In situations where knowledge is
+lacking, these systems should ideally respond with "unknown" when the answer is
+unattainable. In response to these challenges, we introduces Chain-of-Noting
+(CoN), a novel approach aimed at improving the robustness of RALMs in facing
+noisy, irrelevant documents and in handling unknown scenarios. The core idea of
+CoN is to generate sequential reading notes for retrieved documents, enabling a
+thorough evaluation of their relevance to the given question and integrating
+this information to formulate the final answer. We employed ChatGPT to create
+training data for CoN, which was subsequently trained on an LLaMa-2 7B model.
+Our experiments across four open-domain QA benchmarks show that RALMs equipped
+with CoN significantly outperform standard RALMs. Notably, CoN achieves an
+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
+- **Title:** Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models
+- **Authors:** Huaixiu Steven Zheng, Swaroop Mishra, Xinyun Chen,  et al.
+- **Published Date:** 2023-10-09
+- **URL:** http://arxiv.org/abs/2310.06117v2
+- **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
+instances containing specific details. Using the concepts and principles to
+guide reasoning, LLMs significantly improve their abilities in following a
+correct reasoning path towards the solution. We conduct experiments of
+Step-Back Prompting with PaLM-2L, GPT-4 and Llama2-70B models, and observe
+substantial performance gains on various challenging reasoning-intensive tasks
+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
+- **Title:** Query Rewriting for Retrieval-Augmented Large Language Models
+- **Authors:** Xinbei Ma, Yeyun Gong, Pengcheng He,  et al.
+- **Published Date:** 2023-05-23
+- **URL:** http://arxiv.org/abs/2305.14283v3
+- **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
+tasks. This work introduces a new framework, Rewrite-Retrieve-Read instead of
+the previous retrieve-then-read for the retrieval-augmented LLMs from the
+perspective of the query rewriting. Unlike prior studies focusing on adapting
+either the retriever or the reader, our approach pays attention to the
+adaptation of the search query itself, for there is inevitably a gap between
+the input text and the needed knowledge in retrieval. We first prompt an LLM to
+generate the query, then use a web search engine to retrieve contexts.
+Furthermore, to better align the query to the frozen modules, we propose a
+trainable scheme for our pipeline. A small language model is adopted as a
+trainable rewriter to cater to the black-box LLM reader. The rewriter is
+trained using the feedback of the LLM reader by reinforcement learning.
+Evaluation is conducted on downstream tasks, open-domain QA and multiple-choice
+QA. Experiments results show consistent performance improvement, indicating
+that our framework is proven effective and scalable, and brings a new framework
+for retrieval-augmented LLM.
+                
+## Large Language Model Guided Tree-of-Thought
+
+- **arXiv id:** 2305.08291v1
+- **Title:** Large Language Model Guided Tree-of-Thought
+- **Authors:** Jieyi Long
+- **Published Date:** 2023-05-15
+- **URL:** http://arxiv.org/abs/2305.08291v1
+- **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
+large language models (LLMs). The ToT technique is inspired by the human mind's
+approach for solving complex reasoning tasks through trial and error. In this
+process, the human mind explores the solution space through a tree-like thought
+process, allowing for backtracking when necessary. To implement ToT as a
+software system, we augment an LLM with additional modules including a prompter
+agent, a checker module, a memory module, and a ToT controller. In order to
+solve a given problem, these modules engage in a multi-round conversation with
+the LLM. The memory module records the conversation and state history of the
+problem solving process, which allows the system to backtrack to the previous
+steps of the thought-process and explore other directions from there. To verify
+the effectiveness of the proposed technique, we implemented a ToT-based solver
+for the Sudoku Puzzle. Experimental results show that the ToT framework can
+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
+- **Title:** HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face
+- **Authors:** Yongliang Shen, Kaitao Song, Xu Tan,  et al.
+- **Published Date:** 2023-03-30
+- **URL:** http://arxiv.org/abs/2303.17580v4
+- **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
+available for various domains and modalities, they cannot handle complicated AI
+tasks autonomously. Considering large language models (LLMs) have exhibited
+exceptional abilities in language understanding, generation, interaction, and
+reasoning, we advocate that LLMs could act as a controller to manage existing
+AI models to solve complicated AI tasks, with language serving as a generic
+interface to empower this. Based on this philosophy, we present HuggingGPT, an
+LLM-powered agent that leverages LLMs (e.g., ChatGPT) to connect various AI
+models in machine learning communities (e.g., Hugging Face) to solve AI tasks.
+Specifically, we use ChatGPT to conduct task planning when receiving a user
+request, select models according to their function descriptions available in
+Hugging Face, execute each subtask with the selected AI model, and summarize
+the response according to the execution results. By leveraging the strong
+language capability of ChatGPT and abundant AI models in Hugging Face,
+HuggingGPT can tackle a wide range of sophisticated AI tasks spanning different
+modalities and domains and achieve impressive results in language, vision,
+speech, and other challenging tasks, which paves a new way towards the
+realization of artificial general intelligence.
+                
+## GPT-4 Technical Report
+
+- **arXiv id:** 2303.08774v6
+- **Title:** GPT-4 Technical Report
+- **Authors:** OpenAI, Josh Achiam, Steven Adler,  et al.
+- **Published Date:** 2023-03-15
+- **URL:** http://arxiv.org/abs/2303.08774v6
+- **LangChain:**
+
+   - **Documentation:** [docs/integrations/vectorstores/mongodb_atlas](https://python.langchain.com/docs/integrations/vectorstores/mongodb_atlas)
+
+**Abstract:** We report the development of GPT-4, a large-scale, multimodal model which can
+accept image and text inputs and produce text outputs. While less capable than
+humans in many real-world scenarios, GPT-4 exhibits human-level performance on
+various professional and academic benchmarks, including passing a simulated bar
+exam with a score around the top 10% of test takers. GPT-4 is a
+Transformer-based model pre-trained to predict the next token in a document.
+The post-training alignment process results in improved performance on measures
+of factuality and adherence to desired behavior. A core component of this
+project was developing infrastructure and optimization methods that behave
+predictably across a wide range of scales. This allowed us to accurately
+predict some aspects of GPT-4's performance based on models trained with no
+more than 1/1,000th the compute of GPT-4.
+                
+## A Watermark for Large Language Models
+
+- **arXiv id:** 2301.10226v4
+- **Title:** A Watermark for Large Language Models
+- **Authors:** John Kirchenbauer, Jonas Geiping, Yuxin Wen,  et al.
+- **Published Date:** 2023-01-24
+- **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)
+
+**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
+humans but algorithmically detectable from a short span of tokens. We propose a
+watermarking framework for proprietary language models. The watermark can be
+embedded with negligible impact on text quality, and can be detected using an
+efficient open-source algorithm without access to the language model API or
+parameters. The watermark works by selecting a randomized set of "green" tokens
+before a word is generated, and then softly promoting use of green tokens
+during sampling. We propose a statistical test for detecting the watermark with
+interpretable p-values, and derive an information-theoretic framework for
+analyzing the sensitivity of the watermark. We test the watermark using a
+multi-billion parameter model from the Open Pretrained Transformer (OPT)
+family, and discuss robustness and security.
+                
+## Precise Zero-Shot Dense Retrieval without Relevance Labels
+
+- **arXiv id:** 2212.10496v1
+- **Title:** Precise Zero-Shot Dense Retrieval without Relevance Labels
+- **Authors:** Luyu Gao, Xueguang Ma, Jimmy Lin,  et al.
+- **Published Date:** 2022-12-20
+- **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)
+   - **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
+retrieval systems when no relevance label is available. In this paper, we
+recognize the difficulty of zero-shot learning and encoding relevance. Instead,
+we propose to pivot through Hypothetical Document Embeddings~(HyDE). Given a
+query, HyDE first zero-shot instructs an instruction-following language model
+(e.g. InstructGPT) to generate a hypothetical document. The document captures
+relevance patterns but is unreal and may contain false details. Then, an
+unsupervised contrastively learned encoder~(e.g. Contriever) encodes the
+document into an embedding vector. This vector identifies a neighborhood in the
+corpus embedding space, where similar real documents are retrieved based on
+vector similarity. This second step ground the generated document to the actual
+corpus, with the encoder's dense bottleneck filtering out the incorrect
+details. Our experiments show that HyDE significantly outperforms the
+state-of-the-art unsupervised dense retriever Contriever and shows strong
+performance comparable to fine-tuned retrievers, across various tasks (e.g. web
+search, QA, fact verification) and languages~(e.g. sw, ko, ja).
+                
+## Robust and Explainable Identification of Logical Fallacies in Natural Language Arguments
+
+- **arXiv id:** 2212.07425v3
+- **Title:** Robust and Explainable Identification of Logical Fallacies in Natural Language Arguments
+- **Authors:** Zhivar Sourati, Vishnu Priya Prasanna Venkatesh, Darshan Deshpande,  et al.
+- **Published Date:** 2022-12-12
+- **URL:** http://arxiv.org/abs/2212.07425v3
+- **LangChain:**
+
+   - **API Reference:** [langchain_experimental.fallacy_removal](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.fallacy_removal)
+
+**Abstract:** The spread of misinformation, propaganda, and flawed argumentation has been
+amplified in the Internet era. Given the volume of data and the subtlety of
+identifying violations of argumentation norms, supporting information analytics
+tasks, like content moderation, with trustworthy methods that can identify
+logical fallacies is essential. In this paper, we formalize prior theoretical
+work on logical fallacies into a comprehensive three-stage evaluation framework
+of detection, coarse-grained, and fine-grained classification. We adapt
+existing evaluation datasets for each stage of the evaluation. We employ three
+families of robust and explainable methods based on prototype reasoning,
+instance-based reasoning, and knowledge injection. The methods combine language
+models with background knowledge and explainable mechanisms. Moreover, we
+address data sparsity with strategies for data augmentation and curriculum
+learning. Our three-stage framework natively consolidates prior datasets and
+methods from existing tasks, like propaganda detection, serving as an
+overarching evaluation testbed. We extensively evaluate these methods on our
+datasets, focusing on their robustness and explainability. Our results provide
+insight into the strengths and weaknesses of the methods on different
+components and fallacy classes, indicating that fallacy identification is a
+challenging task that may require specialized forms of reasoning to capture
+various classes. We share our open-source code and data on GitHub to support
+further work on logical fallacy identification.
+                
+## Complementary Explanations for Effective In-Context Learning
+
+- **arXiv id:** 2211.13892v2
+- **Title:** Complementary Explanations for Effective In-Context Learning
+- **Authors:** Xi Ye, Srinivasan Iyer, Asli Celikyilmaz,  et al.
+- **Published Date:** 2022-11-25
+- **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)
+
+**Abstract:** Large language models (LLMs) have exhibited remarkable capabilities in
+learning from explanations in prompts, but there has been limited understanding
+of exactly how these explanations function or why they are effective. This work
+aims to better understand the mechanisms by which explanations are used for
+in-context learning. We first study the impact of two different factors on the
+performance of prompts with explanations: the computation trace (the way the
+solution is decomposed) and the natural language used to express the prompt. By
+perturbing explanations on three controlled tasks, we show that both factors
+contribute to the effectiveness of explanations. We further study how to form
+maximally effective sets of explanations for solving a given test query. We
+find that LLMs can benefit from the complementarity of the explanation set:
+diverse reasoning skills shown by different exemplars can lead to better
+performance. Therefore, we propose a maximal marginal relevance-based exemplar
+selection approach for constructing exemplar sets that are both relevant as
+well as complementary, which successfully improves the in-context learning
+performance across three real-world tasks on multiple LLMs.
+                
+## PAL: Program-aided Language Models
+
+- **arXiv id:** 2211.10435v2
+- **Title:** PAL: Program-aided Language Models
+- **Authors:** Luyu Gao, Aman Madaan, Shuyan Zhou,  et al.
+- **Published Date:** 2022-11-18
+- **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)
+
+**Abstract:** Large language models (LLMs) have recently demonstrated an impressive ability
+to perform arithmetic and symbolic reasoning tasks, when provided with a few
+examples at test time ("few-shot prompting"). Much of this success can be
+attributed to prompting methods such as "chain-of-thought'', which employ LLMs
+for both understanding the problem description by decomposing it into steps, as
+well as solving each step of the problem. While LLMs seem to be adept at this
+sort of step-by-step decomposition, LLMs often make logical and arithmetic
+mistakes in the solution part, even when the problem is decomposed correctly.
+In this paper, we present Program-Aided Language models (PAL): a novel approach
+that uses the LLM to read natural language problems and generate programs as
+the intermediate reasoning steps, but offloads the solution step to a runtime
+such as a Python interpreter. With PAL, decomposing the natural language
+problem into runnable steps remains the only learning task for the LLM, while
+solving is delegated to the interpreter. We demonstrate this synergy between a
+neural LLM and a symbolic interpreter across 13 mathematical, symbolic, and
+algorithmic reasoning tasks from BIG-Bench Hard and other benchmarks. In all
+these natural language reasoning tasks, generating code using an LLM and
+reasoning using a Python interpreter leads to more accurate results than much
+larger models. For example, PAL using Codex achieves state-of-the-art few-shot
+accuracy on the GSM8K benchmark of math word problems, surpassing PaLM-540B
+which uses chain-of-thought by absolute 15% top-1. Our code and data are
+publicly available at http://reasonwithpal.com/ .
+                
+## Deep Lake: a Lakehouse for Deep Learning
+
+- **arXiv id:** 2209.10785v2
+- **Title:** Deep Lake: a Lakehouse for Deep Learning
+- **Authors:** Sasun Hambardzumyan, Abhinav Tuli, Levon Ghukasyan,  et al.
+- **Published Date:** 2022-09-22
+- **URL:** http://arxiv.org/abs/2209.10785v2
+- **LangChain:**
+
+   - **Documentation:** [docs/integrations/providers/activeloop_deeplake](https://python.langchain.com/docs/integrations/providers/activeloop_deeplake)
+
+**Abstract:** Traditional data lakes provide critical data infrastructure for analytical
+workloads by enabling time travel, running SQL queries, ingesting data with
+ACID transactions, and visualizing petabyte-scale datasets on cloud storage.
+They allow organizations to break down data silos, unlock data-driven
+decision-making, improve operational efficiency, and reduce costs. However, as
+deep learning usage increases, traditional data lakes are not well-designed for
+applications such as natural language processing (NLP), audio processing,
+computer vision, and applications involving non-tabular datasets. This paper
+presents Deep Lake, an open-source lakehouse for deep learning applications
+developed at Activeloop. Deep Lake maintains the benefits of a vanilla data
+lake with one key difference: it stores complex data, such as images, videos,
+annotations, as well as tabular data, in the form of tensors and rapidly
+streams the data over the network to (a) Tensor Query Language, (b) in-browser
+visualization engine, or (c) deep learning frameworks without sacrificing GPU
+utilization. Datasets stored in Deep Lake can be accessed from PyTorch,
+TensorFlow, JAX, and integrate with numerous MLOps tools.
+                
+## Bitext Mining Using Distilled Sentence Representations for Low-Resource Languages
+
+- **arXiv id:** 2205.12654v1
+- **Title:** Bitext Mining Using Distilled Sentence Representations for Low-Resource Languages
+- **Authors:** Kevin Heffernan, Onur Çelebi, Holger Schwenk
+- **Published Date:** 2022-05-25
+- **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)
+
+**Abstract:** Scaling multilingual representation learning beyond the hundred most frequent
+languages is challenging, in particular to cover the long tail of low-resource
+languages. A promising approach has been to train one-for-all multilingual
+models capable of cross-lingual transfer, but these models often suffer from
+insufficient capacity and interference between unrelated languages. Instead, we
+move away from this approach and focus on training multiple language (family)
+specific representations, but most prominently enable all languages to still be
+encoded in the same representational space. To achieve this, we focus on
+teacher-student training, allowing all encoders to be mutually compatible for
+bitext mining, and enabling fast learning of new languages. We introduce a new
+teacher-student training scheme which combines supervised and self-supervised
+training, allowing encoders to take advantage of monolingual training data,
+which is valuable in the low-resource setting.
+  Our approach significantly outperforms the original LASER encoder. We study
+very low-resource languages and handle 50 African languages, many of which are
+not covered by any other model. For these languages, we train sentence
+encoders, mine bitexts, and validate the bitexts by training NMT systems.
+                
+## Evaluating the Text-to-SQL Capabilities of Large Language Models
+
+- **arXiv id:** 2204.00498v1
+- **Title:** Evaluating the Text-to-SQL Capabilities of Large Language Models
+- **Authors:** Nitarshan Rajkumar, Raymond Li, Dzmitry Bahdanau
+- **Published Date:** 2022-03-15
+- **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)
+
+**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
+baseline on the Spider benchmark; we also analyze the failure modes of Codex in
+this setting. Furthermore, we demonstrate on the GeoQuery and Scholar
+benchmarks that a small number of in-domain examples provided in the prompt
+enables Codex to perform better than state-of-the-art models finetuned on such
+few-shot examples.
+                
+## Locally Typical Sampling
+
+- **arXiv id:** 2202.00666v5
+- **Title:** Locally Typical Sampling
+- **Authors:** Clara Meister, Tiago Pimentel, Gian Wiher,  et al.
+- **Published Date:** 2022-02-01
+- **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)
+
+**Abstract:** Today's probabilistic language generators fall short when it comes to
+producing coherent and fluent text despite the fact that the underlying models
+perform well under standard metrics, e.g., perplexity. This discrepancy has
+puzzled the language generation community for the last few years. In this work,
+we posit that the abstraction of natural language generation as a discrete
+stochastic process--which allows for an information-theoretic analysis--can
+provide new insights into the behavior of probabilistic language generators,
+e.g., why high-probability texts can be dull or repetitive. Humans use language
+as a means of communicating information, aiming to do so in a simultaneously
+efficient and error-minimizing manner; in fact, psycholinguistics research
+suggests humans choose each word in a string with this subconscious goal in
+mind. We formally define the set of strings that meet this criterion: those for
+which each word has an information content close to the expected information
+content, i.e., the conditional entropy of our model. We then propose a simple
+and efficient procedure for enforcing this criterion when generating from
+probabilistic models, which we call locally typical sampling. Automatic and
+human evaluations show that, in comparison to nucleus and top-k sampling,
+locally typical sampling offers competitive performance (in both abstractive
+summarization and story generation) in terms of quality while consistently
+reducing degenerate repetitions.
+                
+## Learning Transferable Visual Models From Natural Language Supervision
+
+- **arXiv id:** 2103.00020v1
+- **Title:** Learning Transferable Visual Models From Natural Language Supervision
+- **Authors:** Alec Radford, Jong Wook Kim, Chris Hallacy,  et al.
+- **Published Date:** 2021-02-26
+- **URL:** http://arxiv.org/abs/2103.00020v1
+- **LangChain:**
+
+   - **API Reference:** [langchain_experimental.open_clip](https://api.python.langchain.com/en/latest/experimental_api_reference.html#module-langchain_experimental.open_clip)
+
+**Abstract:** State-of-the-art computer vision systems are trained to predict a fixed set
+of predetermined object categories. This restricted form of supervision limits
+their generality and usability since additional labeled data is needed to
+specify any other visual concept. Learning directly from raw text about images
+is a promising alternative which leverages a much broader source of
+supervision. We demonstrate that the simple pre-training task of predicting
+which caption goes with which image is an efficient and scalable way to learn
+SOTA image representations from scratch on a dataset of 400 million (image,
+text) pairs collected from the internet. After pre-training, natural language
+is used to reference learned visual concepts (or describe new ones) enabling
+zero-shot transfer of the model to downstream tasks. We study the performance
+of this approach by benchmarking on over 30 different existing computer vision
+datasets, spanning tasks such as OCR, action recognition in videos,
+geo-localization, and many types of fine-grained object classification. The
+model transfers non-trivially to most tasks and is often competitive with a
+fully supervised baseline without the need for any dataset specific training.
+For instance, we match the accuracy of the original ResNet-50 on ImageNet
+zero-shot without needing to use any of the 1.28 million training examples it
+was trained on. We release our code and pre-trained model weights at
+https://github.com/OpenAI/CLIP.
+                
+## CTRL: A Conditional Transformer Language Model for Controllable Generation
+
+- **arXiv id:** 1909.05858v2
+- **Title:** CTRL: A Conditional Transformer Language Model for Controllable Generation
+- **Authors:** Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney,  et al.
+- **Published Date:** 2019-09-11
+- **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)
+
+**Abstract:** Large-scale language models show promising text generation capabilities, but
+users cannot easily control particular aspects of the generated text. We
+release CTRL, a 1.63 billion-parameter conditional transformer language model,
+trained to condition on control codes that govern style, content, and
+task-specific behavior. Control codes were derived from structure that
+naturally co-occurs with raw text, preserving the advantages of unsupervised
+learning while providing more explicit control over text generation. These
+codes also allow CTRL to predict which parts of the training data are most
+likely given a sequence. This provides a potential method for analyzing large
+amounts of data via model-based source attribution. We have released multiple
+full-sized, pretrained versions of CTRL at https://github.com/salesforce/ctrl.
+                
+## Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks
+
+- **arXiv id:** 1908.10084v1
+- **Title:** Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks
+- **Authors:** Nils Reimers, Iryna Gurevych
+- **Published Date:** 2019-08-27
+- **URL:** http://arxiv.org/abs/1908.10084v1
+- **LangChain:**
+
+   - **Documentation:** [docs/integrations/text_embedding/sentence_transformers](https://python.langchain.com/docs/integrations/text_embedding/sentence_transformers)
+
+**Abstract:** BERT (Devlin et al., 2018) and RoBERTa (Liu et al., 2019) has set a new
+state-of-the-art performance on sentence-pair regression tasks like semantic
+textual similarity (STS). However, it requires that both sentences are fed into
+the network, which causes a massive computational overhead: Finding the most
+similar pair in a collection of 10,000 sentences requires about 50 million
+inference computations (~65 hours) with BERT. The construction of BERT makes it
+unsuitable for semantic similarity search as well as for unsupervised tasks
+like clustering.
+  In this publication, we present Sentence-BERT (SBERT), a modification of the
+pretrained BERT network that use siamese and triplet network structures to
+derive semantically meaningful sentence embeddings that can be compared using
+cosine-similarity. This reduces the effort for finding the most similar pair
+from 65 hours with BERT / RoBERTa to about 5 seconds with SBERT, while
+maintaining the accuracy from BERT.
+  We evaluate SBERT and SRoBERTa on common STS tasks and transfer learning
+tasks, where it outperforms other state-of-the-art sentence embeddings methods.
+                

docs/docs/additional_resources/tutorials.mdx

@@ -1,18 +1,10 @@
-# Tutorials
-
-## Books and Handbooks
-
-- [Generative AI with LangChain](https://www.amazon.com/Generative-AI-LangChain-language-ChatGPT/dp/1835083463/ref=sr_1_1?crid=1GMOMH0G7GLR&keywords=generative+ai+with+langchain&qid=1703247181&sprefix=%2Caps%2C298&sr=8-1) by [Ben Auffrath](https://www.amazon.com/stores/Ben-Auffarth/author/B08JQKSZ7D?ref=ap_rdr&store_ref=ap_rdr&isDramIntegrated=true&shoppingPortalEnabled=true), ©️ 2023 Packt Publishing
-- [LangChain AI Handbook](https://www.pinecone.io/learn/langchain/) By **James Briggs** and **Francisco Ingham**
-- [LangChain Cheatsheet](https://pub.towardsai.net/langchain-cheatsheet-all-secrets-on-a-single-page-8be26b721cde) by **Ivan Reznikov**
-
+# 3rd Party Tutorials
 
 ##  Tutorials
 
 ### [LangChain v 0.1 by LangChain.ai](https://www.youtube.com/playlist?list=PLfaIDFEXuae0gBSJ9T0w7cu7iJZbH3T31)
 ### [Build with Langchain - Advanced by LangChain.ai](https://www.youtube.com/playlist?list=PLfaIDFEXuae06tclDATrMYY0idsTdLg9v)
 ### [LangGraph by LangChain.ai](https://www.youtube.com/playlist?list=PLfaIDFEXuae16n2TWUkKq5PgJ0w6Pkwtg)
-
 ### [by Greg Kamradt](https://www.youtube.com/playlist?list=PLqZXAkvF1bPNQER9mLmDbntNfSpzdDIU5)
 ### [by Sam Witteveen](https://www.youtube.com/playlist?list=PL8motc6AQftk1Bs42EW45kwYbyJ4jOdiZ)
 ### [by James Briggs](https://www.youtube.com/playlist?list=PLIUOU7oqGTLieV9uTIFMm6_4PXg-hlN6F)
@@ -20,7 +12,6 @@
 ### [by Mayo Oshin](https://www.youtube.com/@chatwithdata/search?query=langchain)
 ### [by 1 little Coder](https://www.youtube.com/playlist?list=PLpdmBGJ6ELUK-v0MK-t4wZmVEbxM5xk6L)
 
-
 ## Courses
 
 ### Featured courses on Deeplearning.AI
@@ -33,6 +24,7 @@
 ### Online courses
 
 - [Udemy](https://www.udemy.com/courses/search/?q=langchain)
+- [DataCamp](https://www.datacamp.com/courses/developing-llm-applications-with-langchain)
 - [Pluralsight](https://www.pluralsight.com/search?q=langchain)
 - [Coursera](https://www.coursera.org/search?query=langchain)
 - [Maven](https://maven.com/courses?query=langchain)
@@ -48,7 +40,11 @@
 - [by Rabbitmetrics](https://youtu.be/aywZrzNaKjs)
 - [by Ivan Reznikov](https://medium.com/@ivanreznikov/langchain-101-course-updated-668f7b41d6cb)
 
-## [Documentation: Use cases](/docs/how_to#use-cases)
+## Books and Handbooks
+
+- [Generative AI with LangChain](https://www.amazon.com/Generative-AI-LangChain-language-ChatGPT/dp/1835083463/ref=sr_1_1?crid=1GMOMH0G7GLR&keywords=generative+ai+with+langchain&qid=1703247181&sprefix=%2Caps%2C298&sr=8-1) by [Ben Auffrath](https://www.amazon.com/stores/Ben-Auffarth/author/B08JQKSZ7D?ref=ap_rdr&store_ref=ap_rdr&isDramIntegrated=true&shoppingPortalEnabled=true), ©️ 2023 Packt Publishing
+- [LangChain AI Handbook](https://www.pinecone.io/learn/langchain/) By **James Briggs** and **Francisco Ingham**
+- [LangChain Cheatsheet](https://pub.towardsai.net/langchain-cheatsheet-all-secrets-on-a-single-page-8be26b721cde) by **Ivan Reznikov**
 
 ---------------------
 

docs/docs/additional_resources/youtube.mdx

@@ -1,137 +1,63 @@
 # YouTube videos
 
-⛓ icon marks a new addition [last update 2023-09-21]
+[Updated 2024-05-16]
 
 ### [Official LangChain YouTube channel](https://www.youtube.com/@LangChain)
 
-### Introduction to LangChain with Harrison Chase, creator of LangChain
-- [Building the Future with LLMs, `LangChain`, & `Pinecone`](https://youtu.be/nMniwlGyX-c) by [Pinecone](https://www.youtube.com/@pinecone-io)
-- [LangChain and Weaviate with Harrison Chase and Bob van Luijt - Weaviate Podcast #36](https://youtu.be/lhby7Ql7hbk) by [Weaviate • Vector Database](https://www.youtube.com/@Weaviate)
-- [LangChain Demo + Q&A with Harrison Chase](https://youtu.be/zaYTXQFR0_s?t=788) by [Full Stack Deep Learning](https://www.youtube.com/@The_Full_Stack)
-- [LangChain Agents: Build Personal Assistants For Your Data (Q&A with Harrison Chase and Mayo Oshin)](https://youtu.be/gVkF8cwfBLI) by [Chat with data](https://www.youtube.com/@chatwithdata)
+### [Tutorials on YouTube](/docs/additional_resources/tutorials/#tutorials)
 
 ## Videos (sorted by views)
 
-- [Using `ChatGPT` with YOUR OWN Data. This is magical. (LangChain OpenAI API)](https://youtu.be/9AXP7tCI9PI) by [TechLead](https://www.youtube.com/@TechLead)
-- [First look - `ChatGPT` + `WolframAlpha` (`GPT-3.5` and Wolfram|Alpha via LangChain by James Weaver)](https://youtu.be/wYGbY811oMo) by [Dr Alan D. Thompson](https://www.youtube.com/@DrAlanDThompson) 
-- [LangChain explained - The hottest new Python framework](https://youtu.be/RoR4XJw8wIc) by [AssemblyAI](https://www.youtube.com/@AssemblyAI)
-- [Chatbot with INFINITE MEMORY using `OpenAI` & `Pinecone` - `GPT-3`, `Embeddings`, `ADA`, `Vector DB`, `Semantic`](https://youtu.be/2xNzB7xq8nk) by [David Shapiro ~ AI](https://www.youtube.com/@DaveShap)
-- [LangChain for LLMs is... basically just an Ansible playbook](https://youtu.be/X51N9C-OhlE) by [David Shapiro ~ AI](https://www.youtube.com/@DaveShap)
-- [Build your own LLM Apps with LangChain & `GPT-Index`](https://youtu.be/-75p09zFUJY) by [1littlecoder](https://www.youtube.com/@1littlecoder)
-- [`BabyAGI` - New System of Autonomous AI Agents with LangChain](https://youtu.be/lg3kJvf1kXo) by [1littlecoder](https://www.youtube.com/@1littlecoder)
-- [Run `BabyAGI` with Langchain Agents (with Python Code)](https://youtu.be/WosPGHPObx8) by [1littlecoder](https://www.youtube.com/@1littlecoder)
-- [How to Use Langchain With `Zapier` | Write and Send Email with GPT-3 | OpenAI API Tutorial](https://youtu.be/p9v2-xEa9A0) by [StarMorph AI](https://www.youtube.com/@starmorph)
-- [Use Your Locally Stored Files To Get Response From GPT - `OpenAI` | Langchain | Python](https://youtu.be/NC1Ni9KS-rk) by [Shweta Lodha](https://www.youtube.com/@shweta-lodha)
-- [`Langchain JS` | How to Use GPT-3, GPT-4 to Reference your own Data | `OpenAI Embeddings` Intro](https://youtu.be/veV2I-NEjaM) by [StarMorph AI](https://www.youtube.com/@starmorph)
-- [The easiest way to work with large language models | Learn LangChain in 10min](https://youtu.be/kmbS6FDQh7c) by [Sophia Yang](https://www.youtube.com/@SophiaYangDS)
-- [4 Autonomous AI Agents: “Westworld” simulation `BabyAGI`, `AutoGPT`, `Camel`, `LangChain`](https://youtu.be/yWbnH6inT_U) by [Sophia Yang](https://www.youtube.com/@SophiaYangDS)
-- [AI CAN SEARCH THE INTERNET? Langchain Agents + OpenAI ChatGPT](https://youtu.be/J-GL0htqda8) by [tylerwhatsgood](https://www.youtube.com/@tylerwhatsgood)
-- [Query Your Data with GPT-4 | Embeddings, Vector Databases | Langchain JS Knowledgebase](https://youtu.be/jRnUPUTkZmU) by [StarMorph AI](https://www.youtube.com/@starmorph)
-- [`Weaviate` + LangChain for LLM apps presented by Erika Cardenas](https://youtu.be/7AGj4Td5Lgw) by [`Weaviate` • Vector Database](https://www.youtube.com/@Weaviate)
-- [Langchain Overview — How to Use Langchain & `ChatGPT`](https://youtu.be/oYVYIq0lOtI) by [Python In Office](https://www.youtube.com/@pythoninoffice6568)
-- [Langchain Overview - How to Use Langchain & `ChatGPT`](https://youtu.be/oYVYIq0lOtI) by [Python In Office](https://www.youtube.com/@pythoninoffice6568)
-- [LangChain Tutorials](https://www.youtube.com/watch?v=FuqdVNB_8c0&list=PL9V0lbeJ69brU-ojMpU1Y7Ic58Tap0Cw6) by [Edrick](https://www.youtube.com/@edrickdch):
-  - [LangChain, Chroma DB, OpenAI Beginner Guide | ChatGPT with your PDF](https://youtu.be/FuqdVNB_8c0)
-  - [LangChain 101: The Complete Beginner's Guide](https://youtu.be/P3MAbZ2eMUI)
-- [Custom langchain Agent & Tools with memory. Turn any `Python function` into langchain tool with Gpt 3](https://youtu.be/NIG8lXk0ULg) by [echohive](https://www.youtube.com/@echohive)
-- [Building AI LLM Apps with LangChain (and more?) - LIVE STREAM](https://www.youtube.com/live/M-2Cj_2fzWI?feature=share) by [Nicholas Renotte](https://www.youtube.com/@NicholasRenotte)
-- [`ChatGPT` with any `YouTube` video using langchain and `chromadb`](https://youtu.be/TQZfB2bzVwU) by [echohive](https://www.youtube.com/@echohive)
-- [How to Talk to a `PDF` using LangChain and `ChatGPT`](https://youtu.be/v2i1YDtrIwk) by [Automata Learning Lab](https://www.youtube.com/@automatalearninglab)
-- [Langchain Document Loaders Part 1: Unstructured Files](https://youtu.be/O5C0wfsen98) by [Merk](https://www.youtube.com/@heymichaeldaigler) 
-- [LangChain - Prompt Templates (what all the best prompt engineers use)](https://youtu.be/1aRu8b0XNOQ) by [Nick Daigler](https://www.youtube.com/@nickdaigler)
-- [LangChain. Crear aplicaciones Python impulsadas por GPT](https://youtu.be/DkW_rDndts8) by [Jesús Conde](https://www.youtube.com/@0utKast)
-- [Easiest Way to Use GPT In Your Products | LangChain Basics Tutorial](https://youtu.be/fLy0VenZyGc) by [Rachel Woods](https://www.youtube.com/@therachelwoods)
-- [`BabyAGI` + `GPT-4` Langchain Agent with Internet Access](https://youtu.be/wx1z_hs5P6E) by [tylerwhatsgood](https://www.youtube.com/@tylerwhatsgood)
-- [Learning LLM Agents. How does it actually work? LangChain, AutoGPT & OpenAI](https://youtu.be/mb_YAABSplk) by [Arnoldas Kemeklis](https://www.youtube.com/@processusAI)
-- [Get Started with LangChain in `Node.js`](https://youtu.be/Wxx1KUWJFv4) by [Developers Digest](https://www.youtube.com/@DevelopersDigest)
-- [LangChain + `OpenAI` tutorial: Building a Q&A system w/ own text data](https://youtu.be/DYOU_Z0hAwo) by [Samuel Chan](https://www.youtube.com/@SamuelChan)
-- [Langchain + `Zapier` Agent](https://youtu.be/yribLAb-pxA) by [Merk](https://www.youtube.com/@heymichaeldaigler)
-- [Connecting the Internet with `ChatGPT` (LLMs) using Langchain And Answers Your Questions](https://youtu.be/9Y0TBC63yZg) by [Kamalraj M M](https://www.youtube.com/@insightbuilder)
-- [Build More Powerful LLM Applications for Business’s with LangChain (Beginners Guide)](https://youtu.be/sp3-WLKEcBg) by[ No Code Blackbox](https://www.youtube.com/@nocodeblackbox)
-- [LangFlow LLM Agent Demo for 🦜🔗LangChain](https://youtu.be/zJxDHaWt-6o) by [Cobus Greyling](https://www.youtube.com/@CobusGreylingZA)
-- [Chatbot Factory: Streamline Python Chatbot Creation with LLMs and Langchain](https://youtu.be/eYer3uzrcuM) by [Finxter](https://www.youtube.com/@CobusGreylingZA)
-- [LangChain Tutorial - ChatGPT mit eigenen Daten](https://youtu.be/0XDLyY90E2c) by [Coding Crashkurse](https://www.youtube.com/@codingcrashkurse6429)
-- [Chat with a `CSV` | LangChain Agents Tutorial (Beginners)](https://youtu.be/tjeti5vXWOU) by [GoDataProf](https://www.youtube.com/@godataprof)
-- [Introdução ao Langchain - #Cortes - Live DataHackers](https://youtu.be/fw8y5VRei5Y) by [Prof. João Gabriel Lima](https://www.youtube.com/@profjoaogabriellima)
-- [LangChain: Level up `ChatGPT` !? | LangChain Tutorial Part 1](https://youtu.be/vxUGx8aZpDE) by [Code Affinity](https://www.youtube.com/@codeaffinitydev)
-- [KI schreibt krasses Youtube Skript 😲😳 | LangChain Tutorial Deutsch](https://youtu.be/QpTiXyK1jus) by [SimpleKI](https://www.youtube.com/@simpleki)
-- [Chat with Audio: Langchain, `Chroma DB`, OpenAI, and `Assembly AI`](https://youtu.be/Kjy7cx1r75g) by [AI Anytime](https://www.youtube.com/@AIAnytime)
-- [QA over documents with Auto vector index selection with Langchain router chains](https://youtu.be/9G05qybShv8) by [echohive](https://www.youtube.com/@echohive)
-- [Build your own custom LLM application with `Bubble.io` & Langchain (No Code & Beginner friendly)](https://youtu.be/O7NhQGu1m6c) by [No Code Blackbox](https://www.youtube.com/@nocodeblackbox)
-- [Simple App to Question Your Docs: Leveraging `Streamlit`, `Hugging Face Spaces`, LangChain, and `Claude`!](https://youtu.be/X4YbNECRr7o) by [Chris Alexiuk](https://www.youtube.com/@chrisalexiuk)
-- [LANGCHAIN AI- `ConstitutionalChainAI` + Databutton AI ASSISTANT Web App](https://youtu.be/5zIU6_rdJCU) by [Avra](https://www.youtube.com/@Avra_b)
-- [LANGCHAIN AI AUTONOMOUS AGENT WEB APP - 👶 `BABY AGI` 🤖 with EMAIL AUTOMATION using `DATABUTTON`](https://youtu.be/cvAwOGfeHgw) by [Avra](https://www.youtube.com/@Avra_b)
-- [The Future of Data Analysis: Using A.I. Models in Data Analysis (LangChain)](https://youtu.be/v_LIcVyg5dk) by [Absent Data](https://www.youtube.com/@absentdata)
-- [Memory in LangChain | Deep dive (python)](https://youtu.be/70lqvTFh_Yg) by [Eden Marco](https://www.youtube.com/@EdenMarco)
-- [9 LangChain UseCases | Beginner's Guide | 2023](https://youtu.be/zS8_qosHNMw) by [Data Science Basics](https://www.youtube.com/@datasciencebasics)
-- [Use Large Language Models in Jupyter Notebook | LangChain | Agents & Indexes](https://youtu.be/JSe11L1a_QQ) by [Abhinaw Tiwari](https://www.youtube.com/@AbhinawTiwariAT)
-- [How to Talk to Your Langchain Agent | `11 Labs` + `Whisper`](https://youtu.be/N4k459Zw2PU) by [VRSEN](https://www.youtube.com/@vrsen)
-- [LangChain Deep Dive: 5 FUN AI App Ideas To Build Quickly and Easily](https://youtu.be/mPYEPzLkeks) by [James NoCode](https://www.youtube.com/@jamesnocode)
-- [LangChain 101: Models](https://youtu.be/T6c_XsyaNSQ) by [Mckay Wrigley](https://www.youtube.com/@realmckaywrigley)
-- [LangChain with JavaScript Tutorial #1 | Setup & Using LLMs](https://youtu.be/W3AoeMrg27o) by [Leon van Zyl](https://www.youtube.com/@leonvanzyl)
-- [LangChain Overview & Tutorial for Beginners: Build Powerful AI Apps Quickly & Easily (ZERO CODE)](https://youtu.be/iI84yym473Q) by [James NoCode](https://www.youtube.com/@jamesnocode)
-- [LangChain In Action: Real-World Use Case With Step-by-Step Tutorial](https://youtu.be/UO699Szp82M) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
-- [Summarizing and Querying Multiple Papers with LangChain](https://youtu.be/p_MQRWH5Y6k) by [Automata Learning Lab](https://www.youtube.com/@automatalearninglab)
-- [Using Langchain (and `Replit`) through `Tana`, ask `Google`/`Wikipedia`/`Wolfram Alpha` to fill out a table](https://youtu.be/Webau9lEzoI) by [Stian Håklev](https://www.youtube.com/@StianHaklev)
-- [Langchain PDF App (GUI) | Create a ChatGPT For Your `PDF` in Python](https://youtu.be/wUAUdEw5oxM) by [Alejandro AO - Software & Ai](https://www.youtube.com/@alejandro_ao)
-- [Auto-GPT with LangChain 🔥 | Create Your Own Personal AI Assistant](https://youtu.be/imDfPmMKEjM) by [Data Science Basics](https://www.youtube.com/@datasciencebasics)
-- [Create Your OWN Slack AI Assistant with Python & LangChain](https://youtu.be/3jFXRNn2Bu8) by [Dave Ebbelaar](https://www.youtube.com/@daveebbelaar)
-- [How to Create LOCAL Chatbots with GPT4All and LangChain [Full Guide]](https://youtu.be/4p1Fojur8Zw) by [Liam Ottley](https://www.youtube.com/@LiamOttley)
-- [Build a `Multilingual PDF` Search App with LangChain, `Cohere` and `Bubble`](https://youtu.be/hOrtuumOrv8) by [Menlo Park Lab](https://www.youtube.com/@menloparklab)
-- [Building a LangChain Agent (code-free!) Using `Bubble` and `Flowise`](https://youtu.be/jDJIIVWTZDE) by [Menlo Park Lab](https://www.youtube.com/@menloparklab)
-- [Build a LangChain-based Semantic PDF Search App with No-Code Tools Bubble and Flowise](https://youtu.be/s33v5cIeqA4) by [Menlo Park Lab](https://www.youtube.com/@menloparklab)
-- [LangChain Memory Tutorial | Building a ChatGPT Clone in Python](https://youtu.be/Cwq91cj2Pnc) by [Alejandro AO - Software & Ai](https://www.youtube.com/@alejandro_ao)
-- [ChatGPT For Your DATA | Chat with Multiple Documents Using LangChain](https://youtu.be/TeDgIDqQmzs) by [Data Science Basics](https://www.youtube.com/@datasciencebasics)
-- [`Llama Index`: Chat with Documentation using URL Loader](https://youtu.be/XJRoDEctAwA) by [Merk](https://www.youtube.com/@heymichaeldaigler)
-- [Using OpenAI, LangChain, and `Gradio` to Build Custom GenAI Applications](https://youtu.be/1MsmqMg3yUc) by [David Hundley](https://www.youtube.com/@dkhundley)
-- [LangChain, Chroma DB, OpenAI Beginner Guide | ChatGPT with your PDF](https://youtu.be/FuqdVNB_8c0)
-- [Build AI chatbot with custom knowledge base using OpenAI API and GPT Index](https://youtu.be/vDZAZuaXf48) by [Irina Nik](https://www.youtube.com/@irina_nik)
-- [Build Your Own Auto-GPT Apps with LangChain (Python Tutorial)](https://youtu.be/NYSWn1ipbgg) by [Dave Ebbelaar](https://www.youtube.com/@daveebbelaar)
-- [Chat with Multiple `PDFs` | LangChain App Tutorial in Python (Free LLMs and Embeddings)](https://youtu.be/dXxQ0LR-3Hg) by [Alejandro AO - Software & Ai](https://www.youtube.com/@alejandro_ao)
-- [Chat with a `CSV` | `LangChain Agents` Tutorial (Beginners)](https://youtu.be/tjeti5vXWOU) by [Alejandro AO - Software & Ai](https://www.youtube.com/@alejandro_ao)
-- [Create Your Own ChatGPT with `PDF` Data in 5 Minutes (LangChain Tutorial)](https://youtu.be/au2WVVGUvc8) by [Liam Ottley](https://www.youtube.com/@LiamOttley)
-- [Build a Custom Chatbot with OpenAI: `GPT-Index` & LangChain | Step-by-Step Tutorial](https://youtu.be/FIDv6nc4CgU) by [Fabrikod](https://www.youtube.com/@fabrikod)
-- [`Flowise` is an open-source no-code UI visual tool to build 🦜🔗LangChain applications](https://youtu.be/CovAPtQPU0k) by [Cobus Greyling](https://www.youtube.com/@CobusGreylingZA)
-- [LangChain & GPT 4 For Data Analysis: The `Pandas` Dataframe Agent](https://youtu.be/rFQ5Kmkd4jc) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
-- [`GirlfriendGPT` - AI girlfriend with LangChain](https://youtu.be/LiN3D1QZGQw) by [Girlfriend GPT](https://www.youtube.com/@girlfriendGPT)
-- [How to build with Langchain 10x easier | ⛓️ LangFlow & `Flowise`](https://youtu.be/Ya1oGL7ZTvU) by [AI Jason](https://www.youtube.com/@AIJasonZ)
-- [Getting Started With LangChain In 20 Minutes- Build Celebrity Search Application](https://youtu.be/_FpT1cwcSLg) by [Krish Naik](https://www.youtube.com/@krishnaik06)
-- ⛓ [Vector Embeddings Tutorial – Code Your Own AI Assistant with `GPT-4 API` + LangChain + NLP](https://youtu.be/yfHHvmaMkcA?si=5uJhxoh2tvdnOXok) by [FreeCodeCamp.org](https://www.youtube.com/@freecodecamp)
-- ⛓ [Fully LOCAL `Llama 2` Q&A with LangChain](https://youtu.be/wgYctKFnQ74?si=UX1F3W-B3MqF4-K-) by [1littlecoder](https://www.youtube.com/@1littlecoder)
-- ⛓ [Fully LOCAL `Llama 2` Langchain on CPU](https://youtu.be/yhECvKMu8kM?si=IvjxwlA1c09VwHZ4) by [1littlecoder](https://www.youtube.com/@1littlecoder)
-- ⛓ [Build LangChain Audio Apps with Python in 5 Minutes](https://youtu.be/7w7ysaDz2W4?si=BvdMiyHhormr2-vr) by [AssemblyAI](https://www.youtube.com/@AssemblyAI)
-- ⛓ [`Voiceflow` & `Flowise`: Want to Beat Competition? New Tutorial with Real AI Chatbot](https://youtu.be/EZKkmeFwag0?si=-4dETYDHEstiK_bb) by [AI SIMP](https://www.youtube.com/@aisimp)
-- ⛓ [THIS Is How You Build Production-Ready AI Apps (`LangSmith` Tutorial)](https://youtu.be/tFXm5ijih98?si=lfiqpyaivxHFyI94) by [Dave Ebbelaar](https://www.youtube.com/@daveebbelaar)
-- ⛓ [Build POWERFUL LLM Bots EASILY with Your Own Data - `Embedchain` - Langchain 2.0? (Tutorial)](https://youtu.be/jE24Y_GasE8?si=0yEDZt3BK5Q-LIuF) by [WorldofAI](https://www.youtube.com/@intheworldofai)
-- ⛓ [`Code Llama` powered Gradio App for Coding: Runs on CPU](https://youtu.be/AJOhV6Ryy5o?si=ouuQT6IghYlc1NEJ) by [AI Anytime](https://www.youtube.com/@AIAnytime)
-- ⛓ [LangChain Complete Course in One Video | Develop LangChain (AI) Based Solutions for Your Business](https://youtu.be/j9mQd-MyIg8?si=_wlNT3nP2LpDKztZ) by [UBprogrammer](https://www.youtube.com/@UBprogrammer)
-- ⛓ [How to Run `LLaMA` Locally on CPU or GPU | Python & Langchain & CTransformers Guide](https://youtu.be/SvjWDX2NqiM?si=DxFml8XeGhiLTzLV) by [Code With Prince](https://www.youtube.com/@CodeWithPrince)
-- ⛓ [PyData Heidelberg #11 - TimeSeries Forecasting & LLM Langchain](https://www.youtube.com/live/Glbwb5Hxu18?si=PIEY8Raq_C9PCHuW) by [PyData](https://www.youtube.com/@PyDataTV)
-- ⛓ [Prompt Engineering in Web Development | Using LangChain and Templates with OpenAI](https://youtu.be/pK6WzlTOlYw?si=fkcDQsBG2h-DM8uQ) by [Akamai Developer
-](https://www.youtube.com/@AkamaiDeveloper)
-- ⛓ [Retrieval-Augmented Generation (RAG) using LangChain and `Pinecone` - The RAG Special Episode](https://youtu.be/J_tCD_J6w3s?si=60Mnr5VD9UED9bGG) by [Generative AI and Data Science On AWS](https://www.youtube.com/@GenerativeAIOnAWS)
-- ⛓ [`LLAMA2 70b-chat` Multiple Documents Chatbot with Langchain & Streamlit |All OPEN SOURCE|Replicate API](https://youtu.be/vhghB81vViM?si=dszzJnArMeac7lyc) by [DataInsightEdge](https://www.youtube.com/@DataInsightEdge01)
-- ⛓ [Chatting with 44K Fashion Products: LangChain Opportunities and Pitfalls](https://youtu.be/Zudgske0F_s?si=8HSshHoEhh0PemJA) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
-- ⛓ [Structured Data Extraction from `ChatGPT` with LangChain](https://youtu.be/q1lYg8JISpQ?si=0HctzOHYZvq62sve) by [MG](https://www.youtube.com/@MG_cafe)
-- ⛓ [Chat with Multiple PDFs using `Llama 2`, `Pinecone` and LangChain (Free LLMs and Embeddings)](https://youtu.be/TcJ_tVSGS4g?si=FZYnMDJyoFfL3Z2i) by [Muhammad Moin](https://www.youtube.com/@muhammadmoinfaisal)
-- ⛓ [Integrate Audio into `LangChain.js` apps in 5 Minutes](https://youtu.be/hNpUSaYZIzs?si=Gb9h7W9A8lzfvFKi) by [AssemblyAI](https://www.youtube.com/@AssemblyAI)
-- ⛓ [`ChatGPT` for your data with Local LLM](https://youtu.be/bWrjpwhHEMU?si=uM6ZZ18z9og4M90u) by [Jacob Jedryszek](https://www.youtube.com/@jj09)
-- ⛓ [Training `Chatgpt` with your personal data using langchain step by step in detail](https://youtu.be/j3xOMde2v9Y?si=179HsiMU-hEPuSs4) by [NextGen Machines](https://www.youtube.com/@MayankGupta-kb5yc)
-- ⛓ [Use ANY language in `LangSmith` with REST](https://youtu.be/7BL0GEdMmgY?si=iXfOEdBLqXF6hqRM) by [Nerding I/O](https://www.youtube.com/@nerding_io)
-- ⛓ [How to Leverage the Full Potential of LLMs for Your Business with Langchain - Leon Ruddat](https://youtu.be/vZmoEa7oWMg?si=ZhMmydq7RtkZd56Q) by [PyData](https://www.youtube.com/@PyDataTV)
-- ⛓ [`ChatCSV` App: Chat with CSV files using LangChain and `Llama 2`](https://youtu.be/PvsMg6jFs8E?si=Qzg5u5gijxj933Ya) by [Muhammad Moin](https://www.youtube.com/@muhammadmoinfaisal)
-- ⛓ [Build Chat PDF app in Python with LangChain, OpenAI, Streamlit | Full project | Learn Coding](https://www.youtube.com/watch?v=WYzFzZg4YZI) by [Jutsupoint](https://www.youtube.com/@JutsuPoint)
-- ⛓ [Build Eminem Bot App with LangChain, Streamlit, OpenAI | Full Python Project | Tutorial | AI ChatBot](https://www.youtube.com/watch?v=a2shHB4MRZ4) by [Jutsupoint](https://www.youtube.com/@JutsuPoint)
-
-
-### [Prompt Engineering and LangChain](https://www.youtube.com/watch?v=muXbPpG_ys4&list=PLEJK-H61Xlwzm5FYLDdKt_6yibO33zoMW) by [Venelin Valkov](https://www.youtube.com/@venelin_valkov)
-- [Getting Started with LangChain: Load Custom Data, Run OpenAI Models, Embeddings and `ChatGPT`](https://www.youtube.com/watch?v=muXbPpG_ys4)
-- [Loaders, Indexes & Vectorstores in LangChain: Question Answering on `PDF` files with `ChatGPT`](https://www.youtube.com/watch?v=FQnvfR8Dmr0)
-- [LangChain Models: `ChatGPT`, `Flan Alpaca`, `OpenAI Embeddings`, Prompt Templates & Streaming](https://www.youtube.com/watch?v=zy6LiK5F5-s)
-- [LangChain Chains: Use `ChatGPT` to Build Conversational Agents, Summaries and Q&A on Text With LLMs](https://www.youtube.com/watch?v=h1tJZQPcimM)
-- [Analyze Custom CSV Data with `GPT-4` using Langchain](https://www.youtube.com/watch?v=Ew3sGdX8at4)
-- [Build ChatGPT Chatbots with LangChain Memory: Understanding and Implementing Memory in Conversations](https://youtu.be/CyuUlf54wTs)
+Only videos with 40K+ views:
 
+- [Using `ChatGPT` with YOUR OWN Data. This is magical. (LangChain `OpenAI API`)](https://youtu.be/9AXP7tCI9PI)
+- [Chat with Multiple `PDFs` | LangChain App Tutorial in Python (Free LLMs and Embeddings)](https://youtu.be/dXxQ0LR-3Hg?si=pjXKhsHRzn10vOqX)
+- [`Hugging Face` + Langchain in 5 mins | Access 200k+ FREE AI models for your AI apps](https://youtu.be/_j7JEDWuqLE?si=psimQscN3qo2dOa9)
+- [LangChain Crash Course For Beginners | LangChain Tutorial](https://youtu.be/nAmC7SoVLd8?si=qJdvyG5-rnjqfdj1)
+- [Vector Embeddings Tutorial – Code Your Own AI Assistant with GPT-4 API + LangChain + NLP](https://youtu.be/yfHHvmaMkcA?si=UBP3yw50cLm3a2nj)
+- [Development with Large Language Models Tutorial – `OpenAI`, Langchain, Agents, `Chroma`](https://youtu.be/xZDB1naRUlk?si=v8J1q6oFHRyTkf7Y)
+- [Langchain: `PDF` Chat App (GUI) | ChatGPT for Your PDF FILES | Step-by-Step Tutorial](https://youtu.be/RIWbalZ7sTo?si=LbKsCcuyv0BtnrTY)
+- [Vector Search `RAG` Tutorial – Combine Your Data with LLMs with Advanced Search](https://youtu.be/JEBDfGqrAUA?si=pD7oxpfwWeJCxfBt)
+- [LangChain Crash Course for Beginners](https://youtu.be/lG7Uxts9SXs?si=Yte4S5afN7KNCw0F)
+- [Learn `RAG` From Scratch – Python AI Tutorial from a LangChain Engineer](https://youtu.be/sVcwVQRHIc8?si=_LN4g0vOgSdtlB3S)
+- [`Llama 2` in LangChain — FIRST Open Source Conversational Agent!](https://youtu.be/6iHVJyX2e50?si=rtq1maPrzWKHbwVV)
+- [LangChain Tutorial for Beginners | Generative AI Series](https://youtu.be/cQUUkZnyoD0?si=KYz-bvcocdqGh9f_)
+- [Chatbots with `RAG`: LangChain Full Walkthrough](https://youtu.be/LhnCsygAvzY?si=yS7T98VLfcWdkDek)
+- [LangChain Explained In 15 Minutes - A MUST Learn For Python Programmers](https://youtu.be/mrjq3lFz23s?si=wkQGcSKUJjuiiEPf)
+- [LLM Project | End to End LLM Project Using Langchain, `OpenAI` in Finance Domain](https://youtu.be/MoqgmWV1fm8?si=oVl-5kJVgd3a07Y_)
+- [What is LangChain?](https://youtu.be/1bUy-1hGZpI?si=NZ0D51VM5y-DhjGe)
+- [`RAG` + Langchain Python Project: Easy AI/Chat For Your Doc](https://youtu.be/tcqEUSNCn8I?si=RLcWPBVLIErRqdmU)
+- [Getting Started With LangChain In 20 Minutes- Build Celebrity Search Application](https://youtu.be/_FpT1cwcSLg?si=X9qVazlXYucN_JBP)
+- [LangChain GEN AI Tutorial – 6 End-to-End Projects using OpenAI, Google `Gemini Pro`, `LLAMA2`](https://youtu.be/x0AnCE9SE4A?si=_92gJYm7kb-V2bi0)
+- [Complete Langchain GEN AI Crash Course With 6 End To End LLM Projects With OPENAI, `LLAMA2`, `Gemini Pro`](https://youtu.be/aWKrL4z5H6w?si=NVLi7Yiq0ccE7xXE)
+- [AI Leader Reveals The Future of AI AGENTS (LangChain CEO)](https://youtu.be/9ZhbA0FHZYc?si=1r4P6kRvKVvEhRgE)
+- [Learn How To Query Pdf using Langchain Open AI in 5 min](https://youtu.be/5Ghv-F1wF_0?si=ZZRjrWfeiFOVrcvu)
+- [Reliable, fully local RAG agents with `LLaMA3`](https://youtu.be/-ROS6gfYIts?si=75CXA8W_BbnkIxcV)
+- [Learn `LangChain.js` - Build LLM apps with JavaScript and `OpenAI`](https://youtu.be/HSZ_uaif57o?si=Icj-RAhwMT-vHaYA)
+- [LLM Project | End to End LLM Project Using LangChain, Google Palm In Ed-Tech Industry](https://youtu.be/AjQPRomyd-k?si=eC3NT6kn02Lhpz-_)
+- [Chatbot Answering from Your Own Knowledge Base: Langchain, `ChatGPT`, `Pinecone`, and `Streamlit`: | Code](https://youtu.be/nAKhxQ3hcMA?si=9Zd_Nd_jiYhtml5w)
+- [LangChain is AMAZING | Quick Python Tutorial](https://youtu.be/I4mFqyqFkxg?si=aJ66qh558OfNAczD)
+- [`GirlfriendGPT` - AI girlfriend with LangChain](https://youtu.be/LiN3D1QZGQw?si=kZR-lnJwixeVrjmh)
+- [Using NEW `MPT-7B` in `Hugging Face` and LangChain](https://youtu.be/DXpk9K7DgMo?si=99JDpV_ueimwJhMi)
+- [LangChain - COMPLETE TUTORIAL - Basics to advanced concept!](https://youtu.be/a89vqgK-Qcs?si=0aVO2EOqsw7GE5e3)
+- [LangChain Agents: Simply Explained!](https://youtu.be/Xi9Ui-9qcPw?si=DCuG7nGx8dxcfhkx)
+- [Chat With Multiple `PDF` Documents With Langchain And Google `Gemini Pro`](https://youtu.be/uus5eLz6smA?si=YUwvHtaZsGeIl0WD)
+- [LLM Project | End to end LLM project Using Langchain, `Google Palm` in Retail Industry](https://youtu.be/4wtrl4hnPT8?si=_eOKPpdLfWu5UXMQ)
+- [Tutorial | Chat with any Website using Python and Langchain](https://youtu.be/bupx08ZgSFg?si=KRrjYZFnuLsstGwW)
+- [Prompt Engineering And LLM's With LangChain In One Shot-Generative AI](https://youtu.be/t2bSApmPzU4?si=87vPQQtYEWTyu2Kx)
+- [Build a Custom Chatbot with `OpenAI`: `GPT-Index` & LangChain | Step-by-Step Tutorial](https://youtu.be/FIDv6nc4CgU?si=gR1u3DUG9lvzBIKK)
+- [Search Your `PDF` App using Langchain, `ChromaDB`, and Open Source LLM: No OpenAI API (Runs on CPU)](https://youtu.be/rIV1EseKwU4?si=UxZEoXSiPai8fXgl)
+- [Building a `RAG` application from scratch using Python, LangChain, and the `OpenAI API`](https://youtu.be/BrsocJb-fAo?si=hvkh9iTGzJ-LnsX-)
+- [Function Calling via `ChatGPT API` - First Look With LangChain](https://youtu.be/0-zlUy7VUjg?si=Vc6LFseckEc6qvuk)
+- [Private GPT, free deployment! Langchain-Chachat helps you easily play with major mainstream AI models! | Zero Degree Commentary](https://youtu.be/3LLUyaHP-3I?si=AZumEeFXsvqaLl0f)
+- [Create a ChatGPT clone using `Streamlit` and LangChain](https://youtu.be/IaTiyQ2oYUQ?si=WbgsYmqPDnMidSUK)
+- [What's next for AI agents ft. LangChain's Harrison Chase](https://youtu.be/pBBe1pk8hf4?si=H4vdBF9nmkNZxiHt)
+- [`LangFlow`: Build Chatbots without Writing Code - LangChain](https://youtu.be/KJ-ux3hre4s?si=TJuDu4bAlva1myNL)
+- [Building a LangChain Custom Medical Agent with Memory](https://youtu.be/6UFtRwWnHws?si=wymYad26VgigRkHy)
+- [`Ollama` meets LangChain](https://youtu.be/k_1pOF1mj8k?si=RlBiCrmaR3s7SnMK)
+- [End To End LLM Langchain Project using `Pinecone` Vector Database](https://youtu.be/erUfLIi9OFM?si=aHpuHXdIEmAfS4eF)
+- [`LLaMA2` with LangChain - Basics | LangChain TUTORIAL](https://youtu.be/cIRzwSXB4Rc?si=FUs0OLVJpzKhut0h)
+- [Understanding `ReACT` with LangChain](https://youtu.be/Eug2clsLtFs?si=imgj534ggxlypS0d)
 
 ---------------------
-⛓ icon marks a new addition [last update 2024-02-04]
+[Updated 2024-05-16]

docs/docs/concepts.mdx

@@ -7,16 +7,7 @@ This section contains introductions to key parts of LangChain.
 
 ## Architecture
 
-LangChain as a framework consists of several pieces. The below diagram shows how they relate.
-
-<ThemedImage
-  alt="Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers."
-  sources={{
-    light: useBaseUrl('/svg/langchain_stack.svg'),
-    dark: useBaseUrl('/svg/langchain_stack_dark.svg'),
-  }}
-  title="LangChain Framework Overview"
-/>
+LangChain as a framework consists of a number of packages.
 
 ### `langchain-core`
 This package contains base abstractions of different components and ways to compose them together.
@@ -24,13 +15,6 @@ The interfaces for core components like LLMs, vectorstores, retrievers and more
 No third party integrations are defined here.
 The dependencies are kept purposefully very lightweight.
 
-### `langchain-community`
-
-This package contains third party integrations that are maintained by the LangChain community.
-Key partner packages are separated out (see below).
-This contains all integrations for various components (LLMs, vectorstores, retrievers).
-All dependencies in this package are optional to keep the package as lightweight as possible.
-
 ### Partner packages
 
 While the long tail of integrations are in `langchain-community`, we split popular integrations into their own packages (e.g. `langchain-openai`, `langchain-anthropic`, etc).
@@ -42,50 +26,48 @@ The main `langchain` package contains chains, agents, and retrieval strategies t
 These are NOT third party integrations.
 All chains, agents, and retrieval strategies here are NOT specific to any one integration, but rather generic across all integrations.
 
-### [LangGraph](/docs/langgraph)
+### `langchain-community`
 
-Not currently in this repo, `langgraph` is an extension of `langchain` aimed at
+This package contains third party integrations that are maintained by the LangChain community.
+Key partner packages are separated out (see below).
+This contains all integrations for various components (LLMs, vectorstores, retrievers).
+All dependencies in this package are optional to keep the package as lightweight as possible.
+
+### [`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 exposes high level interfaces for creating common types of agents, as well as a low-level API for constructing more contr
+LangGraph exposes high level interfaces for creating common types of agents, as well as a low-level API for composing custom flows.
 
-### [langserve](/docs/langserve)
+### [`langserve`](/docs/langserve)
 
 A package to deploy LangChain chains as REST APIs. Makes it easy to get a production ready API up and running.
 
-### [LangSmith](/docs/langsmith)
+### [LangSmith](https://docs.smith.langchain.com)
 
 A developer platform that lets you debug, test, evaluate, and monitor LLM applications.
 
-## Installation
+<ThemedImage
+  alt="Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers."
+  sources={{
+    light: useBaseUrl('/svg/langchain_stack.svg'),
+    dark: useBaseUrl('/svg/langchain_stack_dark.svg'),
+  }}
+  title="LangChain Framework Overview"
+/>
 
-If you want to work with high level abstractions, you should install the `langchain` package.
+## LangChain Expression Language (LCEL)
+<span data-heading-keywords="lcel"></span>
 
-```shell
-pip install langchain
-```
-
-If you want to work with specific integrations, you will need to install them separately.
-See [here](/docs/integrations/platforms/) for a list of integrations and how to install them.
-
-For working with LangSmith, you will need to set up a LangSmith developer account [here](https://smith.langchain.com) and get an API key.
-After that, you can enable it by setting environment variables:
-
-```shell
-export LANGCHAIN_TRACING_V2=true
-export LANGCHAIN_API_KEY=ls__...
-```
-
-## LangChain Expression Language
-
-LangChain Expression Language, or LCEL, is a declarative way to easily compose chains together.
+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:
 
 **First-class streaming support**
 When you build your chains with LCEL you get the best possible time-to-first-token (time elapsed until the first chunk of output comes out). For some chains this means eg. we stream tokens straight from an LLM to a streaming output parser, and you get back parsed, incremental chunks of output at the same rate as the LLM provider outputs the raw tokens.
 
 **Async support**
-Any chain built with LCEL can be called both with the synchronous API (eg. in your Jupyter notebook while prototyping) as well as with the asynchronous API (eg. in a [LangServe](/docs/langsmith) server). This enables using the same code for prototypes and in production, with great performance, and the ability to handle many concurrent requests in the same server.
+Any chain built with LCEL can be called both with the synchronous API (eg. in your Jupyter notebook while prototyping) as well as with the asynchronous API (eg. in a [LangServe](/docs/langserve/) server). This enables using the same code for prototypes and in production, with great performance, and the ability to handle many concurrent requests in the same server.
 
 **Optimized parallel execution**
 Whenever your LCEL chains have steps that can be executed in parallel (eg if you fetch documents from multiple retrievers) we automatically do it, both in the sync and the async interfaces, for the smallest possible latency.
@@ -99,23 +81,24 @@ For more complex chains it’s often very useful to access the results of interm
 **Input and output schemas**
 Input and output schemas give every LCEL chain Pydantic and JSONSchema schemas inferred from the structure of your chain. This can be used for validation of inputs and outputs, and is an integral part of LangServe.
 
-[**Seamless LangSmith tracing**](/docs/langsmith)
+[**Seamless LangSmith tracing**](https://docs.smith.langchain.com)
 As your chains get more and more complex, it becomes increasingly important to understand what exactly is happening at every step.
-With LCEL, **all** steps are automatically logged to [LangSmith](/docs/langsmith/) for maximum observability and debuggability.
+With LCEL, **all** steps are automatically logged to [LangSmith](https://docs.smith.langchain.com/) for maximum observability and debuggability.
 
 [**Seamless LangServe deployment**](/docs/langserve)
 Any chain created with LCEL can be easily deployed using [LangServe](/docs/langserve).
 
-### Interface
+### 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): stream back chunks of the response
-- [`invoke`](#invoke): call the chain on an input
-- [`batch`](#batch): call the chain on a list of inputs
+- `stream`: stream back chunks of the response
+- `invoke`: call the chain on an input
+- `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:
 
@@ -146,71 +129,47 @@ All runnables expose input and output **schemas** to inspect the inputs and outp
 LangChain provides standard, extendable interfaces and external integrations for various components useful for building with LLMs.
 Some components LangChain implements, some components we rely on third-party integrations for, and others are a mix.
 
-### LLMs
-Language models that takes a string as input and returns a string.
-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 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.
-
 ### 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).
+These are traditionally newer models (older models are generally `LLMs`, see below).
 Chat models support the assignment of distinct roles to conversation messages, helping to distinguish messages from the AI, users, and instructions such as system messages.
 
-Although the underlying models are messages in, message out, the LangChain wrappers also allow these models to take a string as input.
-This makes them interchangeable with LLMs (and simpler to use).
-When a string is passed in as input, it will be converted to a HumanMessage under the hood before being passed to the underlying model.
+Although the underlying models are messages in, message out, the LangChain wrappers also allow these models to take a string as input. This means you can easily use chat models in place of LLMs.
 
-LangChain does not provide any ChatModels, rather we rely on third party integrations.
+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.
 
 We have some standardized parameters when constructing ChatModels:
 - `model`: the name of the model
 
 ChatModels also accept other parameters that are specific to that integration.
 
-### Function/Tool Calling
-
-:::info
-We use the term tool calling interchangeably with function calling. Although
-function calling is sometimes meant to refer to invocations of a single function,
-we treat all models as though they can return multiple tool or function calls in
-each message.
+:::important
+**Tool Calling** Some chat models have been fine-tuned for tool calling and provide a dedicated API for tool calling.
+Generally, such models are better at tool calling than non-fine-tuned models, and are recommended for use cases that require tool calling.
+Please see the [tool calling section](/docs/concepts/#functiontool-calling) for more information.
 :::
 
-Tool calling allows a model to respond to a given prompt by generating output that
-matches a user-defined schema. While the name implies that the model is performing
-some action, this is actually not the case! The model is coming up with the
-arguments to a tool, and actually running the tool (or not) is up to the user -
-for example, if you want to [extract output matching some schema](/docs/tutorials/extraction)
-from unstructured text, you could give the model an "extraction" tool that takes
-parameters matching the desired schema, then treat the generated output as your final
-result.
+For specifics on how to use chat models, see the [relevant how-to guides here](/docs/how_to/#chat-models).
 
-A tool call includes a name, arguments dict, and an optional identifier. The
-arguments dict is structured `{argument_name: argument_value}`.
+### LLMs
+<span data-heading-keywords="llm,llms"></span>
 
-Many LLM providers, including [Anthropic](https://www.anthropic.com/),
-[Cohere](https://cohere.com/), [Google](https://cloud.google.com/vertex-ai),
-[Mistral](https://mistral.ai/), [OpenAI](https://openai.com/), and others,
-support variants of a tool calling feature. These features typically allow requests
-to the LLM to include available tools and their schemas, and for responses to include
-calls to these tools. For instance, given a search engine tool, an LLM might handle a
-query by first issuing a call to the search engine. The system calling the LLM can
-receive the tool call, execute it, and return the output to the LLM to inform its
-response. LangChain includes a suite of [built-in tools](/docs/integrations/tools/)
-and supports several methods for defining your own [custom tools](/docs/how_to/custom_tools).
+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).
 
-There are two main use cases for function/tool calling:
+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).
+When messages are passed in as input, they will be formatted into a string under the hood before being passed to the underlying model.
 
-- [How to return structured data from an LLM](/docs/how_to/structured_output/)
-- [How to use a model to call tools](/docs/how_to/tool_calling/)
+LangChain does not host 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).
 
-### Message types
+### Messages
 
 Some language models take a list of messages as input and return a message.
 There are a few different types of messages.
@@ -223,7 +182,7 @@ The `content` property describes the content of the message.
 This can be a few different things:
 
 - A string (most models deal this type of content)
-- A List of dictionaries (this is used for multi-modal input, where the dictionary contains information about that input type and that input location)
+- A List of dictionaries (this is used for multimodal input, where the dictionary contains information about that input type and that input location)
 
 #### HumanMessage
 
@@ -263,6 +222,8 @@ 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.
 
@@ -271,7 +232,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
 
@@ -296,7 +257,7 @@ from langchain_core.prompts import ChatPromptTemplate
 
 prompt_template = ChatPromptTemplate.from_messages([
     ("system", "You are a helpful assistant"),
-    ("user", "Tell me a joke about {topic}"
+    ("user", "Tell me a joke about {topic}")
 ])
 
 prompt_template.invoke({"topic": "cats"})
@@ -307,6 +268,7 @@ 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.
@@ -338,14 +300,18 @@ prompt_template = ChatPromptTemplate.from_messages([
 ])
 ```
 
-### Example Selectors
+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
 
@@ -389,16 +355,19 @@ 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.                                            |
 
-### Chat History
+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.
 
-### Document
+### Documents
+<span data-heading-keywords="document,documents"></span>
 
 A Document object in LangChain contains information about some data. It has two attributes:
 
@@ -406,6 +375,7 @@ 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.
 
@@ -421,6 +391,8 @@ 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.
@@ -438,26 +410,38 @@ 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).
 
-### Vectorstores
+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.
 
-Vectorstores can be converted to the retriever interface by doing:
+Vector stores can be converted to the retriever interface by doing:
 
 ```python
 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.
@@ -465,48 +449,36 @@ 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.
 
-### Advanced Retrieval Types
-
-LangChain provides several advanced retrieval types. A full list is below, along with the following information:
-
-**Name**: Name of the retrieval algorithm.
-
-**Index Type**: Which index type (if any) this relies on.
-
-**Uses an LLM**: Whether this retrieval method uses an LLM.
-
-**When to Use**: Our commentary on when you should considering using this retrieval method.
-
-**Description**: Description of what this retrieval algorithm is doing.
-
-| Name                      | Index Type                   | Uses an LLM               | When to Use                                                                                                                                   | Description                                                                                                                                                                                                                                                                                      |
-|---------------------------|------------------------------|---------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| [Vectorstore](https://api.python.langchain.com/en/latest/vectorstores/langchain_core.vectorstores.VectorStoreRetriever.html#langchain_core.vectorstores.VectorStoreRetriever)               | Vectorstore                  | No                        | If you are just getting started and looking for something quick and easy.                                                                     | This is the simplest method and the one that is easiest to get started with. It involves creating embeddings for each piece of text.                                                                                                                                                             |
-| [ParentDocument](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.parent_document_retriever.ParentDocumentRetriever.html#langchain.retrievers.parent_document_retriever.ParentDocumentRetriever)            | Vectorstore + Document Store | No                        | If your pages have lots of smaller pieces of distinct information that are best indexed by themselves, but best retrieved all together.       | This involves indexing multiple chunks for each document. Then you find the chunks that are most similar in embedding space, but you retrieve the whole parent document and return that (rather than individual chunks).                                                                         |
-| [Multi Vector](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.multi_vector.MultiVectorRetriever.html#langchain.retrievers.multi_vector.MultiVectorRetriever)              | Vectorstore + Document Store | Sometimes during indexing | If you are able to extract information from documents that you think is more relevant to index than the text itself.                          | This involves creating multiple vectors for each document. Each vector could be created in a myriad of ways - examples include summaries of the text and hypothetical questions.                                                                                                                 |
-| [Self Query](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.self_query.base.SelfQueryRetriever.html#langchain.retrievers.self_query.base.SelfQueryRetriever)               | Vectorstore                  | Yes                       | If users are asking questions that are better answered by fetching documents based on metadata rather than similarity with the text.          | This uses an LLM to transform user input into two things: (1) a string to look up semantically, (2) a metadata filer to go along with it. This is useful because oftentimes questions are about the METADATA of documents (not the content itself).                                              |
-| [Contextual Compression](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.contextual_compression.ContextualCompressionRetriever.html#langchain.retrievers.contextual_compression.ContextualCompressionRetriever)    | Any                          | Sometimes                 | If you are finding that your retrieved documents contain too much irrelevant information and are distracting the LLM.                         | This puts a post-processing step on top of another retriever and extracts only the most relevant information from retrieved documents. This can be done with embeddings or an LLM.                                                                                                               |
-| [Time-Weighted Vectorstore](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.time_weighted_retriever.TimeWeightedVectorStoreRetriever.html#langchain.retrievers.time_weighted_retriever.TimeWeightedVectorStoreRetriever) | Vectorstore                  | No                        | If you have timestamps associated with your documents, and you want to retrieve the most recent ones                                          | This fetches documents based on a combination of semantic similarity (as in normal vector retrieval) and recency (looking at timestamps of indexed documents)                                                                                                                                    |
-| [Multi-Query Retriever](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.multi_query.MultiQueryRetriever.html#langchain.retrievers.multi_query.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](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.ensemble.EnsembleRetriever.html#langchain.retrievers.ensemble.EnsembleRetriever)                  | 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 specifics on how to use retrievers, see the [relevant how-to guides here](/docs/how_to/#retrievers).
 
 ### Tools
-Tools are interfaces that an agent, chain, or LLM can use to interact with the world.
-They combine a few things:
+<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.
+
+A tool consists of the following components:
 
 1. The name of the tool
-2. A description of what the tool is
+2. A description of what the tool does
 3. JSON schema of what the inputs to the tool are
 4. The function to call
-5. Whether the result of a tool should be returned directly to the user
+5. Whether the result of a tool should be returned directly to the user (only relevant for agents)
 
-It is useful to have all this information because this information can be used to build action-taking systems! The name, description, and JSON schema can be used to prompt the LLM so it knows how to specify what action to take, and then the function to call is equivalent to taking that action.
+The name, description and JSON schema are provided as context
+to the LLM, allowing the LLM to determine how to use the tool
+appropriately.
 
-The simpler the input to a tool is, the easier it is for an LLM to be able to use it.
-Many agents will only work with tools that have a single string input.
+Given a list of available tools and a prompt, an LLM can request
+that one or more tools be invoked with appropriate arguments.
 
-Importantly, the name, description, and JSON schema (if used) are all used in the prompt. Therefore, it is really important that they are clear and describe exactly how the tool should be used. You may need to change the default name, description, or JSON schema if the LLM is not understanding how to use the tool.
+Generally, when designing tools to be used by a chat model or LLM, it is important to keep in mind the following:
 
+- Chat models that have been fine-tuned for tool calling will be better at tool calling than non-fine-tuned models.
+- Non fine-tuned models may not be able to use tools at all, especially if the tools are complex or require multiple tool calls.
+- 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
 
@@ -527,7 +499,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 enginer 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 engine 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.
@@ -540,4 +512,394 @@ 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
+
+Some models are multimodal, accepting images, audio and even video as inputs. These are still less common, meaning model providers haven't standardized on the "best" way to define the API. Multimodal **outputs** are even less common. As such, we've kept our multimodal abstractions fairly light weight and plan to further solidify the multimodal APIs and interaction patterns as the field matures.
+
+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.
+
+You can subscribe to these events by using the `callbacks` argument available throughout the API. This argument is list of handler objects, which are expected to implement one or more of the methods described below in more detail.
+
+#### Callback Events
+
+| Event            | Event Trigger                               | Associated Method     |
+|------------------|---------------------------------------------|-----------------------|
+| Chat model start | When a chat model starts                    | `on_chat_model_start` |
+| LLM start        | When a llm starts                           | `on_llm_start`        |
+| LLM new token    | When an llm OR chat model emits a new token | `on_llm_new_token`    |
+| LLM ends         | When an llm OR chat model ends              | `on_llm_end`          |
+| LLM errors       | When an llm OR chat model errors            | `on_llm_error`        |
+| Chain start      | When a chain starts running                 | `on_chain_start`      |
+| Chain end        | When a chain ends                           | `on_chain_end`        |
+| Chain error      | When a chain errors                         | `on_chain_error`      |
+| Tool start       | When a tool starts running                  | `on_tool_start`       |
+| Tool end         | When a tool ends                            | `on_tool_end`         |
+| Tool error       | When a tool errors                          | `on_tool_error`       |
+| Agent action     | When an agent takes an action               | `on_agent_action`     |
+| Agent finish     | When an agent ends                          | `on_agent_finish`     |
+| Retriever start  | When a retriever starts                     | `on_retriever_start`  |
+| Retriever end    | When a retriever ends                       | `on_retriever_end`    |
+| Retriever error  | When a retriever errors                     | `on_retriever_error`  |
+| Text             | When arbitrary text is run                  | `on_text`             |
+| Retry            | When a retry event is run                   | `on_retry`            |
+
+#### Callback handlers
+
+Callback handlers can either be `sync` or `async`:
+
+* Sync callback handlers implement the [BaseCallbackHandler](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.base.BaseCallbackHandler.html) interface.
+* Async callback handlers implement the [AsyncCallbackHandler](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.base.AsyncCallbackHandler.html) interface.
+
+During run-time LangChain configures an appropriate callback manager (e.g., [CallbackManager](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.manager.CallbackManager.html) or [AsyncCallbackManager](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.manager.AsyncCallbackManager.html) which will be responsible for calling the appropriate method on each "registered" callback handler when the event is triggered.
+
+#### Passing callbacks
+
+The `callbacks` property is available on most objects throughout the API (Models, Tools, Agents, etc.) in two different places:
+
+The callbacks are available on most objects throughout the API (Models, Tools, Agents, etc.) in two different places:
+
+- **Request time callbacks**: Passed at the time of the request in addition to the input data.
+    Available on all standard `Runnable` objects. These callbacks are INHERITED by all children
+    of the object they are defined on. For example, `chain.invoke({"number": 25}, {"callbacks": [handler]})`.
+- **Constructor callbacks**: `chain = TheNameOfSomeChain(callbacks=[handler])`. These callbacks
+    are passed as arguments to the constructor of the object. The callbacks are scoped
+    only to the object they are defined on, and are **not** inherited by any children of the object.
+
+:::warning
+Constructor callbacks are scoped only to the object they are defined on. They are **not** inherited by children
+of the object.
+:::
+
+If you're creating a custom chain or runnable, you need to remember to propagate request time
+callbacks to any child objects.
+
+:::important Async in Python<=3.10
+
+Any `RunnableLambda`, a `RunnableGenerator`, or `Tool` that invokes other runnables
+and is running async in python<=3.10, will have to propagate callbacks to child
+objects manually. This is because LangChain cannot automatically propagate
+callbacks to child objects in this case.
+
+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".
+
+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.
+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.
+
+#### 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()` and `.astream()`
+
+LangChain also includes the `.stream()` method (and the equivalent `.astream()` method for [async](https://docs.python.org/3/library/asyncio.html) environments) 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()`.
+
+### Structured output
+
+LLMs are capable of generating arbitrary text. This enables the model to respond appropriately to a wide
+range of inputs, but for some use-cases, it can be useful to constrain the LLM's output
+to a specific format or structure. This is referred to as **structured output**.
+
+For example, if the output is to be stored in a relational database,
+it is much easier if the model generates output that adheres to a defined schema or format.
+[Extracting specific information](/docs/tutorials/extraction/) from unstructured text is another
+case where this is particularly useful. Most commonly, the output format will be JSON,
+though other formats such as [YAML](/docs/how_to/output_parser_yaml/) can be useful too. Below, we'll discuss
+a few ways to get structured output from models in LangChain.
+
+#### `.with_structured_output()`
+
+For convenience, some LangChain chat models support a `.with_structured_output()` method.
+This method only requires a schema as input, and returns a dict or Pydantic object.
+Generally, this method is only present on models that support one of the more advanced methods described below,
+and will use one of them under the hood. It takes care of importing a suitable output parser and
+formatting the schema in the right format for the model.
+
+For more information, check out this [how-to guide](/docs/how_to/structured_output/#the-with_structured_output-method).
+
+#### Raw prompting
+
+The most intuitive way to get a model to structure output is to ask nicely.
+In addition to your query, you can give instructions describing what kind of output you'd like, then
+parse the output using an [output parser](/docs/concepts/#output-parsers) to convert the raw
+model message or string output into something more easily manipulated.
+
+The biggest benefit to raw prompting is its flexibility:
+
+- Raw prompting does not require any special model features, only sufficient reasoning capability to understand
+the passed schema.
+- You can prompt for any format you'd like, not just JSON. This can be useful if the model you
+are using is more heavily trained on a certain type of data, such as XML or YAML.
+
+However, there are some drawbacks too:
+
+- LLMs are non-deterministic, and prompting a LLM to consistently output data in the exactly correct format
+for smooth parsing can be surprisingly difficult and model-specific.
+- Individual models have quirks depending on the data they were trained on, and optimizing prompts can be quite difficult.
+Some may be better at interpreting [JSON schema](https://json-schema.org/), others may be best with TypeScript definitions,
+and still others may prefer XML.
+
+While we'll next go over some ways that you can take advantage of features offered by
+model providers to increase reliability, prompting techniques remain important for tuning your
+results no matter what method you choose.
+
+#### JSON mode
+<span data-heading-keywords="json mode"></span>
+
+Some models, such as [Mistral](/docs/integrations/chat/mistralai/), [OpenAI](/docs/integrations/chat/openai/),
+[Together AI](/docs/integrations/chat/together/) and [Ollama](/docs/integrations/chat/ollama/),
+support a feature called **JSON mode**, usually enabled via config.
+
+When enabled, JSON mode will constrain the model's output to always be some sort of valid JSON.
+Often they require some custom prompting, but it's usually much less burdensome and along the lines of,
+`"you must always return JSON"`, and the [output is easier to parse](/docs/how_to/output_parser_json/).
+
+It's also generally simpler and more commonly available than tool calling.
+
+Here's an example:
+
+```python
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+from langchain.output_parsers.json import SimpleJsonOutputParser
+
+model = ChatOpenAI(
+    model="gpt-4o",
+    model_kwargs={ "response_format": { "type": "json_object" } },
+)
+
+prompt = ChatPromptTemplate.from_template(
+    "Answer the user's question to the best of your ability."
+    'You must always output a JSON object with an "answer" key and a "followup_question" key.'
+    "{question}"
+)
+
+chain = prompt | model | SimpleJsonOutputParser()
+
+chain.invoke({ "question": "What is the powerhouse of the cell?" })
+```
+
+```
+{'answer': 'The powerhouse of the cell is the mitochondrion. It is responsible for producing energy in the form of ATP through cellular respiration.',
+ 'followup_question': 'Would you like to know more about how mitochondria produce energy?'}
+```
+
+For a full list of model providers that support JSON mode, see [this table](/docs/integrations/chat/#advanced-features).
+
+#### Function/tool calling
+
+:::info
+We use the term tool calling interchangeably with function calling. Although
+function calling is sometimes meant to refer to invocations of a single function,
+we treat all models as though they can return multiple tool or function calls in
+each message.
+:::
+
+Tool calling allows a model to respond to a given prompt by generating output that
+matches a user-defined schema. While the name implies that the model is performing
+some action, this is actually not the case! The model is coming up with the
+arguments to a tool, and actually running the tool (or not) is up to the user -
+for example, if you want to [extract output matching some schema](/docs/tutorials/extraction)
+from unstructured text, you could give the model an "extraction" tool that takes
+parameters matching the desired schema, then treat the generated output as your final
+result.
+
+For models that support it, tool calling can be very convenient. It removes the
+guesswork around how best to prompt schemas in favor of a built-in model feature. It can also
+more naturally support agentic flows, since you can just pass multiple tool schemas instead
+of fiddling with enums or unions.
+
+Many LLM providers, including [Anthropic](https://www.anthropic.com/),
+[Cohere](https://cohere.com/), [Google](https://cloud.google.com/vertex-ai),
+[Mistral](https://mistral.ai/), [OpenAI](https://openai.com/), and others,
+support variants of a tool calling feature. These features typically allow requests
+to the LLM to include available tools and their schemas, and for responses to include
+calls to these tools. For instance, given a search engine tool, an LLM might handle a
+query by first issuing a call to the search engine. The system calling the LLM can
+receive the tool call, execute it, and return the output to the LLM to inform its
+response. LangChain includes a suite of [built-in tools](/docs/integrations/tools/)
+and supports several methods for defining your own [custom tools](/docs/how_to/custom_tools).
+
+LangChain provides a standardized interface for tool calling that is consistent across different models.
+
+The standard interface consists of:
+
+* `ChatModel.bind_tools()`: a method for specifying which tools are available for a model to call. This method accepts [LangChain tools](/docs/concepts/#tools) here.
+* `AIMessage.tool_calls`: an attribute on the `AIMessage` returned from the model for accessing the tool calls requested by the model.
+
+The following how-to guides are good practical resources for using function/tool calling:
+
+- [How to return structured data from an LLM](/docs/how_to/structured_output/)
+- [How to use a model to call tools](/docs/how_to/tool_calling/)
+
+For a full list of model providers that support tool calling, [see this table](/docs/integrations/chat/#advanced-features).
+
+### Retrieval
+
+LangChain provides several advanced retrieval types. A full list is below, along with the following information:
+
+**Name**: Name of the retrieval algorithm.
+
+**Index Type**: Which index type (if any) this relies on.
+
+**Uses an LLM**: Whether this retrieval method uses an LLM.
+
+**When to Use**: Our commentary on when you should considering using this retrieval method.
+
+**Description**: Description of what this retrieval algorithm is doing.
+
+| Name                      | Index Type                   | Uses an LLM               | When to Use                                                                                                                                   | Description                                                                                                                                                                                                                                                                                      |
+|---------------------------|------------------------------|---------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [Vectorstore](/docs/how_to/vectorstore_retriever/)               | Vectorstore                  | No                        | If you are just getting started and looking for something quick and easy.                                                                     | This is the simplest method and the one that is easiest to get started with. It involves creating embeddings for each piece of text.                                                                                                                                                             |
+| [ParentDocument](/docs/how_to/parent_document_retriever/)            | Vectorstore + Document Store | No                        | If your pages have lots of smaller pieces of distinct information that are best indexed by themselves, but best retrieved all together.       | This involves indexing multiple chunks for each document. Then you find the chunks that are most similar in embedding space, but you retrieve the whole parent document and return that (rather than individual chunks).                                                                         |
+| [Multi Vector](/docs/how_to/multi_vector/)              | Vectorstore + Document Store | Sometimes during indexing | If you are able to extract information from documents that you think is more relevant to index than the text itself.                          | This involves creating multiple vectors for each document. Each vector could be created in a myriad of ways - examples include summaries of the text and hypothetical questions.                                                                                                                 |
+| [Self Query](/docs/how_to/self_query/)               | Vectorstore                  | Yes                       | If users are asking questions that are better answered by fetching documents based on metadata rather than similarity with the text.          | This uses an LLM to transform user input into two things: (1) a string to look up semantically, (2) a metadata filer to go along with it. This is useful because oftentimes questions are about the METADATA of documents (not the content itself).                                              |
+| [Contextual Compression](/docs/how_to/contextual_compression/)    | Any                          | Sometimes                 | If you are finding that your retrieved documents contain too much irrelevant information and are distracting the LLM.                         | This puts a post-processing step on top of another retriever and extracts only the most relevant information from retrieved documents. This can be done with embeddings or an LLM.                                                                                                               |
+| [Time-Weighted Vectorstore](/docs/how_to/time_weighted_vectorstore/) | Vectorstore                  | No                        | If you have timestamps associated with your documents, and you want to retrieve the most recent ones                                          | This fetches documents based on a combination of semantic similarity (as in normal vector retrieval) and recency (looking at timestamps of indexed documents)                                                                                                                                    |
+| [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
+
+LangChain offers many different types of `text splitters`.
+These all live in the `langchain-text-splitters` package.
+
+Table columns:
+
+- **Name**: Name of the text splitter
+- **Classes**: Classes that implement this text splitter
+- **Splits On**: How this text splitter splits text
+- **Adds Metadata**: Whether or not this text splitter adds metadata about where each chunk came from.
+- **Description**: Description of the splitter, including recommendation on when to use it.
+
+
+| Name     | Classes                                                                                                                                                                                                             | Splits On                                                   | Adds Metadata | Description                                                                                                                                                                                                                                                                  |
+|----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|---------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Recursive | [RecursiveCharacterTextSplitter](/docs/how_to/recursive_text_splitter/), [RecursiveJsonSplitter](/docs/how_to/recursive_json_splitter/) | A list of user defined characters     |               | Recursively splits text. This splitting is trying to keep related pieces of text next to each other. This is the `recommended way` to start splitting text.                                                                                                                    |
+| HTML      | [HTMLHeaderTextSplitter](/docs/how_to/HTML_header_metadata_splitter/), [HTMLSectionSplitter](/docs/how_to/HTML_section_aware_splitter/)          | HTML specific characters                                                                                                 | ✅             | Splits text based on HTML-specific characters. Notably, this adds in relevant information about where that chunk came from (based on the HTML)                                                                                                                               |
+| Markdown  | [MarkdownHeaderTextSplitter](/docs/how_to/markdown_header_metadata_splitter/),                                                                                                           | Markdown specific characters                                                                                    | ✅             | Splits text based on Markdown-specific characters. Notably, this adds in relevant information about where that chunk came from (based on the Markdown)                                                                                                                       |
+| Code      | [many languages](/docs/how_to/code_splitter/)                                                                                                                                 | Code (Python, JS) specific characters                                                                           |               | Splits text based on characters specific to coding languages. 15 different languages are available to choose from.                                                                                                                                                           |
+| Token    | [many classes](/docs/how_to/split_by_token/)                                                                                                                                  | Tokens                                                                                                          |               | Splits text on tokens. There exist a few different ways to measure tokens.                                                                                                                                                                                                   |
+| Character  | [CharacterTextSplitter](/docs/how_to/character_text_splitter/)                                                                                                                | A user defined character                                                                                        |               | Splits text based on a user defined character. One of the simpler methods.                                                                                                                                                                                                   |
+| Semantic Chunker (Experimental) | [SemanticChunker](/docs/how_to/semantic-chunker/)                                                                                                                             | Sentences                                                                                                       |               | First splits on sentences. Then combines ones next to each other if they are semantically similar enough. Taken from [Greg Kamradt](https://github.com/FullStackRetrieval-com/RetrievalTutorials/blob/main/tutorials/LevelsOfTextSplitting/5_Levels_Of_Text_Splitting.ipynb) |
+| Integration: AI21 Semantic | [AI21SemanticTextSplitter](/docs/integrations/document_transformers/ai21_semantic_text_splitter/)                                                                                                                    |    ✅           | Identifies distinct topics that form coherent pieces of text and splits along those.                                                                                                                                                                                         |
+
+
+
+

docs/docs/contributing/code.mdx

@@ -206,9 +206,7 @@ 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 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.
+You'll notice that `pyproject.toml` and `poetry.lock` are **not** touched when you add optional dependencies below.
 
 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.
@@ -216,20 +214,12 @@ 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 the pyproject.toml file correctly, please do the following:
+To introduce the dependency to a library, please do the following:
 
-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
+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
 test makes use of lightweight fixtures to test the logic of the code.
-5. Please use the `@pytest.mark.requires(package_name)` decorator for any tests that require the dependency.
+3. Please use the `@pytest.mark.requires(package_name)` decorator for any unit 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) 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-lcel) 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,
@@ -88,7 +88,7 @@ Concepts covered in `Integrations` should generally exist in `langchain_communit
 
 ### Guides and Ecosystem
 
-The [Guides](/docs/tutorials) and [Ecosystem](/docs/langsmith/) sections should contain guides that address higher-level problems than the sections above.
+The [Guides](/docs/tutorials) and [Ecosystem](https://docs.smith.langchain.com/) sections should contain guides that address higher-level problems than the sections above.
 This includes, but is not limited to, considerations around productionization and development workflows.
 
 These should contain mostly **How-to guides**, **Explanations**, and **Tutorials**.

docs/docs/contributing/documentation/technical_logistics.mdx

@@ -71,6 +71,8 @@ make docs_clean
 make api_docs_clean
 ```
 
+
+
 Next, you can build the documentation as outlined below:
 
 ```bash
@@ -78,6 +80,18 @@ make docs_build
 make api_docs_build
 ```
 
+:::tip
+
+The `make api_docs_build` command takes a long time. If you're making cosmetic changes to the API docs and want to see how they look, use:
+
+```bash
+make api_docs_quick_preview
+```
+
+which will just build a small subset of the API reference.
+
+:::
+
 Finally, run the link checker to ensure all links are valid:
 
 ```bash

docs/docs/contributing/index.mdx

@@ -48,7 +48,7 @@ In a similar vein, we do enforce certain linting, formatting, and documentation
 If you are finding these difficult (or even just annoying) to work with, feel free to contact a maintainer for help -
 we do not want these to get in the way of getting good code into the codebase.
 
-# 🌟 Recognition
+### 🌟 Recognition
 
 If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
-If you have a Twitter account you would like us to mention, please let us know in the PR or through another means.
+If you have a Twitter account you would like us to mention, please let us know in the PR or through another means.

docs/docs/contributing/repo_structure.mdx

@@ -6,7 +6,7 @@ sidebar_position: 0.5
 If you plan on contributing to LangChain code or documentation, it can be useful
 to understand the high level structure of the repository.
 
-LangChain is organized as a [monorep](https://en.wikipedia.org/wiki/Monorepo) that contains multiple packages.
+LangChain is organized as a [monorepo](https://en.wikipedia.org/wiki/Monorepo) that contains multiple packages.
 
 Here's the structure visualized as a tree:
 
@@ -15,12 +15,22 @@ Here's the structure visualized as a tree:
 ├── cookbook # Tutorials and examples
 ├── docs # Contains content for the documentation here: https://python.langchain.com/
 ├── libs
-│   ├── langchain # Main package
+│   ├── langchain
+│   │   ├── langchain
 │   │   ├── tests/unit_tests # Unit tests (present in each package not shown for brevity)
 │   │   ├── tests/integration_tests # Integration tests (present in each package not shown for brevity)
-│   ├── langchain-community # Third-party integrations
-│   ├── langchain-core # Base interfaces for key abstractions
-│   ├── langchain-experimental # Experimental components and chains
+│   ├── community # Third-party integrations
+│   │   ├── langchain-community
+│   ├── core # Base interfaces for key abstractions
+│   │   ├── langchain-core
+│   ├── experimental # Experimental components and chains
+│   │   ├── langchain-experimental
+|   ├── cli # Command line interface
+│   │   ├── langchain-cli
+│   ├── text-splitters
+│   │   ├── langchain-text-splitters
+│   ├── standard-tests
+│   │   ├── langchain-standard-tests
 │   ├── partners
 │       ├── langchain-partner-1
 │       ├── langchain-partner-2

docs/docs/how_to/HTML_section_aware_splitter.ipynb

@@ -132,7 +132,7 @@
     }
    ],
    "source": [
-    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
     "\n",
     "html_string = \"\"\"\n",
     "    <!DOCTYPE html>\n",

docs/docs/how_to/MultiQueryRetriever.ipynb

@@ -7,14 +7,16 @@
    "source": [
     "# How to use the MultiQueryRetriever\n",
     "\n",
-    "Distance-based vector database retrieval embeds (represents) queries in high-dimensional space and finds similar embedded documents based on \"distance\". But, retrieval may produce different results with subtle changes in query wording or if the embeddings do not capture the semantics of the data well. Prompt engineering / tuning is sometimes done to manually address these problems, but can be tedious.\n",
+    "Distance-based vector database retrieval embeds (represents) queries in high-dimensional space and finds similar embedded documents based on a distance metric. But, retrieval may produce different results with subtle changes in query wording, or if the embeddings do not capture the semantics of the data well. Prompt engineering / tuning is sometimes done to manually address these problems, but can be tedious.\n",
     "\n",
-    "The `MultiQueryRetriever` automates the process of prompt tuning by using an LLM to generate multiple queries from different perspectives for a given user input query. For each query, it retrieves a set of relevant documents and takes the unique union across all queries to get a larger set of potentially relevant documents. By generating multiple perspectives on the same question, the `MultiQueryRetriever` might be able to overcome some of the limitations of the distance-based retrieval and get a richer set of results."
+    "The [MultiQueryRetriever](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.multi_query.MultiQueryRetriever.html) automates the process of prompt tuning by using an LLM to generate multiple queries from different perspectives for a given user input query. For each query, it retrieves a set of relevant documents and takes the unique union across all queries to get a larger set of potentially relevant documents. By generating multiple perspectives on the same question, the `MultiQueryRetriever` can mitigate some of the limitations of the distance-based retrieval and get a richer set of results.\n",
+    "\n",
+    "Let's build a vectorstore using the [LLM Powered Autonomous Agents](https://lilianweng.github.io/posts/2023-06-23-agent/) blog post by Lilian Weng from the [RAG tutorial](/docs/tutorials/rag):"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "994d6c74",
    "metadata": {},
    "outputs": [],
@@ -50,7 +52,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "edbca101",
    "metadata": {},
    "outputs": [],
@@ -67,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "9e6d3b69",
    "metadata": {},
    "outputs": [],
@@ -81,15 +83,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "id": "e5203612",
+   "execution_count": 4,
+   "id": "bc93dc2b-9407-48b0-9f9a-338247e7eb69",
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:langchain.retrievers.multi_query:Generated queries: ['1. How can Task Decomposition be approached?', '2. What are the different methods for Task Decomposition?', '3. What are the various approaches to decomposing tasks?']\n"
+      "INFO:langchain.retrievers.multi_query:Generated queries: ['1. How can Task Decomposition be achieved through different methods?', '2. What strategies are commonly used for Task Decomposition?', '3. What are the various techniques for breaking down tasks in Task Decomposition?']\n"
      ]
     },
     {
@@ -98,16 +100,24 @@
        "5"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "unique_docs = retriever_from_llm.get_relevant_documents(query=question)\n",
+    "unique_docs = retriever_from_llm.invoke(question)\n",
     "len(unique_docs)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "7e170263-facd-4065-bb68-d11fb9123a45",
+   "metadata": {},
+   "source": [
+    "Note that the underlying queries generated by the retriever are logged at the `INFO` level."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "c54a282f",
@@ -115,37 +125,35 @@
    "source": [
     "#### Supplying your own prompt\n",
     "\n",
-    "You can also supply a prompt along with an output parser to split the results into a list of queries."
+    "Under the hood, `MultiQueryRetriever` generates queries using a specific [prompt](https://api.python.langchain.com/en/latest/_modules/langchain/retrievers/multi_query.html#MultiQueryRetriever). To customize this prompt:\n",
+    "\n",
+    "1. Make a [PromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.prompt.PromptTemplate.html) with an input variable for the question;\n",
+    "2. Implement an [output parser](/docs/concepts#output-parsers) like the one below to split the result into a list of queries.\n",
+    "\n",
+    "The prompt and output parser together must support the generation of a list of queries."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "d9afb0ca",
    "metadata": {},
    "outputs": [],
    "source": [
     "from typing import List\n",
     "\n",
-    "from langchain.chains import LLMChain\n",
-    "from langchain.output_parsers import PydanticOutputParser\n",
+    "from langchain_core.output_parsers import BaseOutputParser\n",
     "from langchain_core.prompts import PromptTemplate\n",
-    "from pydantic import BaseModel, Field\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
     "\n",
     "\n",
     "# Output parser will split the LLM result into a list of queries\n",
-    "class LineList(BaseModel):\n",
-    "    # \"lines\" is the key (attribute name) of the parsed output\n",
-    "    lines: List[str] = Field(description=\"Lines of text\")\n",
+    "class LineListOutputParser(BaseOutputParser[List[str]]):\n",
+    "    \"\"\"Output parser for a list of lines.\"\"\"\n",
     "\n",
-    "\n",
-    "class LineListOutputParser(PydanticOutputParser):\n",
-    "    def __init__(self) -> None:\n",
-    "        super().__init__(pydantic_object=LineList)\n",
-    "\n",
-    "    def parse(self, text: str) -> LineList:\n",
+    "    def parse(self, text: str) -> List[str]:\n",
     "        lines = text.strip().split(\"\\n\")\n",
-    "        return LineList(lines=lines)\n",
+    "        return lines\n",
     "\n",
     "\n",
     "output_parser = LineListOutputParser()\n",
@@ -162,7 +170,7 @@
     "llm = ChatOpenAI(temperature=0)\n",
     "\n",
     "# Chain\n",
-    "llm_chain = LLMChain(llm=llm, prompt=QUERY_PROMPT, output_parser=output_parser)\n",
+    "llm_chain = QUERY_PROMPT | llm | output_parser\n",
     "\n",
     "# Other inputs\n",
     "question = \"What are the approaches to Task Decomposition?\""
@@ -170,24 +178,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "6660d7ee",
+   "execution_count": 6,
+   "id": "59c75c56-dbd7-4887-b9ba-0b5b21069f51",
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "INFO:langchain.retrievers.multi_query:Generated queries: [\"1. What is the course's perspective on regression?\", '2. Can you provide information on regression as discussed in the course?', '3. How does the course cover the topic of regression?', \"4. What are the course's teachings on regression?\", '5. In relation to the course, what is mentioned about regression?']\n"
+      "INFO:langchain.retrievers.multi_query:Generated queries: ['1. Can you provide insights on regression from the course material?', '2. How is regression discussed in the course content?', '3. What information does the course offer about regression?', '4. In what way is regression covered in the course?', '5. What are the teachings of the course regarding regression?']\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "11"
+       "9"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -199,9 +207,7 @@
     ")  # \"lines\" is the key (attribute name) of the parsed output\n",
     "\n",
     "# Results\n",
-    "unique_docs = retriever.get_relevant_documents(\n",
-    "    query=\"What does the course say about regression?\"\n",
-    ")\n",
+    "unique_docs = retriever.invoke(\"What does the course say about regression?\")\n",
     "len(unique_docs)"
    ]
   }
@@ -222,7 +228,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/add_scores_retriever.ipynb

@@ -0,0 +1,446 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "9d59582a-6473-4b34-929b-3e94cb443c3d",
+   "metadata": {},
+   "source": [
+    "# How to add scores to retriever results\n",
+    "\n",
+    "Retrievers will return sequences of [Document](https://api.python.langchain.com/en/latest/documents/langchain_core.documents.base.Document.html) objects, which by default include no information about the process that retrieved them (e.g., a similarity score against a query). Here we demonstrate how to add retrieval scores to the `.metadata` of documents:\n",
+    "1. From [vectorstore retrievers](/docs/how_to/vectorstore_retriever);\n",
+    "2. From higher-order LangChain retrievers, such as [SelfQueryRetriever](/docs/how_to/self_query) or [MultiVectorRetriever](/docs/how_to/multi_vector).\n",
+    "\n",
+    "For (1), we will implement a short wrapper function around the corresponding vector store. For (2), we will update a method of the corresponding class.\n",
+    "\n",
+    "## Create vector store\n",
+    "\n",
+    "First we populate a vector store with some data. We will use a [PineconeVectorStore](https://api.python.langchain.com/en/latest/vectorstores/langchain_pinecone.vectorstores.PineconeVectorStore.html), but this guide is compatible with any LangChain vector store that implements a `.similarity_search_with_score` method."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b8cfcb1b-64ee-4b91-8d82-ce7803834985",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.documents import Document\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "from langchain_pinecone import PineconeVectorStore\n",
+    "\n",
+    "docs = [\n",
+    "    Document(\n",
+    "        page_content=\"A bunch of scientists bring back dinosaurs and mayhem breaks loose\",\n",
+    "        metadata={\"year\": 1993, \"rating\": 7.7, \"genre\": \"science fiction\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Leo DiCaprio gets lost in a dream within a dream within a dream within a ...\",\n",
+    "        metadata={\"year\": 2010, \"director\": \"Christopher Nolan\", \"rating\": 8.2},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea\",\n",
+    "        metadata={\"year\": 2006, \"director\": \"Satoshi Kon\", \"rating\": 8.6},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"A bunch of normal-sized women are supremely wholesome and some men pine after them\",\n",
+    "        metadata={\"year\": 2019, \"director\": \"Greta Gerwig\", \"rating\": 8.3},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Toys come alive and have a blast doing so\",\n",
+    "        metadata={\"year\": 1995, \"genre\": \"animated\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Three men walk into the Zone, three men walk out of the Zone\",\n",
+    "        metadata={\n",
+    "            \"year\": 1979,\n",
+    "            \"director\": \"Andrei Tarkovsky\",\n",
+    "            \"genre\": \"thriller\",\n",
+    "            \"rating\": 9.9,\n",
+    "        },\n",
+    "    ),\n",
+    "]\n",
+    "\n",
+    "vectorstore = PineconeVectorStore.from_documents(\n",
+    "    docs, index_name=\"sample\", embedding=OpenAIEmbeddings()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "22ac5ef6-ce18-427f-a91c-62b38a8b41e9",
+   "metadata": {},
+   "source": [
+    "## Retriever\n",
+    "\n",
+    "To obtain scores from a vector store retriever, we wrap the underlying vector store's `.similarity_search_with_score` method in a short function that packages scores into the associated document's metadata.\n",
+    "\n",
+    "We add a `@chain` decorator to the function to create a [Runnable](/docs/concepts/#langchain-expression-language) that can be used similarly to a typical retriever."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "7e5677c3-f6ee-4974-ab5f-a0f50c199d45",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List\n",
+    "\n",
+    "from langchain_core.documents import Document\n",
+    "from langchain_core.runnables import chain\n",
+    "\n",
+    "\n",
+    "@chain\n",
+    "def retriever(query: str) -> List[Document]:\n",
+    "    docs, scores = zip(*vectorstore.similarity_search_with_score(query))\n",
+    "    for doc, score in zip(docs, scores):\n",
+    "        doc.metadata[\"score\"] = score\n",
+    "\n",
+    "    return docs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c9cad75e-b955-4012-989c-3c1820b49ba9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'genre': 'science fiction', 'rating': 7.7, 'year': 1993.0, 'score': 0.84429127}),\n",
+       " Document(page_content='Toys come alive and have a blast doing so', metadata={'genre': 'animated', 'year': 1995.0, 'score': 0.792038262}),\n",
+       " Document(page_content='Three men walk into the Zone, three men walk out of the Zone', metadata={'director': 'Andrei Tarkovsky', 'genre': 'thriller', 'rating': 9.9, 'year': 1979.0, 'score': 0.751571238}),\n",
+       " Document(page_content='A psychologist / detective gets lost in a series of dreams within dreams within dreams and Inception reused the idea', metadata={'director': 'Satoshi Kon', 'rating': 8.6, 'year': 2006.0, 'score': 0.747471571}))"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = retriever.invoke(\"dinosaur\")\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6671308a-be8d-4c15-ae1f-5bd07b342560",
+   "metadata": {},
+   "source": [
+    "Note that similarity scores from the retrieval step are included in the metadata of the above documents."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "af2e73a0-46a1-47e2-8103-68aaa637642a",
+   "metadata": {},
+   "source": [
+    "## SelfQueryRetriever\n",
+    "\n",
+    "`SelfQueryRetriever` will use a LLM to generate a query that is potentially structured-- for example, it can construct filters for the retrieval on top of the usual semantic-similarity driven selection. See [this guide](/docs/how_to/self_query) for more detail.\n",
+    "\n",
+    "`SelfQueryRetriever` includes a short (1 - 2 line) method `_get_docs_with_query` that executes the `vectorstore` search. We can subclass `SelfQueryRetriever` and override this method to propagate similarity scores.\n",
+    "\n",
+    "First, following the [how-to guide](/docs/how_to/self_query), we will need to establish some metadata on which to filter:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8280b829-2e81-4454-8adc-9a0930047fa2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains.query_constructor.base import AttributeInfo\n",
+    "from langchain.retrievers.self_query.base import SelfQueryRetriever\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "metadata_field_info = [\n",
+    "    AttributeInfo(\n",
+    "        name=\"genre\",\n",
+    "        description=\"The genre of the movie. One of ['science fiction', 'comedy', 'drama', 'thriller', 'romance', 'action', 'animated']\",\n",
+    "        type=\"string\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"year\",\n",
+    "        description=\"The year the movie was released\",\n",
+    "        type=\"integer\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"director\",\n",
+    "        description=\"The name of the movie director\",\n",
+    "        type=\"string\",\n",
+    "    ),\n",
+    "    AttributeInfo(\n",
+    "        name=\"rating\", description=\"A 1-10 rating for the movie\", type=\"float\"\n",
+    "    ),\n",
+    "]\n",
+    "document_content_description = \"Brief summary of a movie\"\n",
+    "llm = ChatOpenAI(temperature=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a6c6fa8-1e2f-45ee-83e9-a6cbd82292d2",
+   "metadata": {},
+   "source": [
+    "We then override the `_get_docs_with_query` to use the `similarity_search_with_score` method of the underlying vector store: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "62c8f3fa-8b64-4afb-87c4-ccbbf9a8bc54",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Any, Dict\n",
+    "\n",
+    "\n",
+    "class CustomSelfQueryRetriever(SelfQueryRetriever):\n",
+    "    def _get_docs_with_query(\n",
+    "        self, query: str, search_kwargs: Dict[str, Any]\n",
+    "    ) -> List[Document]:\n",
+    "        \"\"\"Get docs, adding score information.\"\"\"\n",
+    "        docs, scores = zip(\n",
+    "            *vectorstore.similarity_search_with_score(query, **search_kwargs)\n",
+    "        )\n",
+    "        for doc, score in zip(docs, scores):\n",
+    "            doc.metadata[\"score\"] = score\n",
+    "\n",
+    "        return docs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56e40109-1db6-44c7-a6e6-6989175e267c",
+   "metadata": {},
+   "source": [
+    "Invoking this retriever will now include similarity scores in the document metadata. Note that the underlying structured-query capabilities of `SelfQueryRetriever` are retained."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "3359a1ee-34ff-41b6-bded-64c05785b333",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(Document(page_content='A bunch of scientists bring back dinosaurs and mayhem breaks loose', metadata={'genre': 'science fiction', 'rating': 7.7, 'year': 1993.0, 'score': 0.84429127}),)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "retriever = CustomSelfQueryRetriever.from_llm(\n",
+    "    llm,\n",
+    "    vectorstore,\n",
+    "    document_content_description,\n",
+    "    metadata_field_info,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "result = retriever.invoke(\"dinosaur movie with rating less than 8\")\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "689ab3ba-3494-448b-836e-05fbe1ffd51c",
+   "metadata": {},
+   "source": [
+    "## MultiVectorRetriever\n",
+    "\n",
+    "`MultiVectorRetriever` allows you to associate multiple vectors with a single document. This can be useful in a number of applications. For example, we can index small chunks of a larger document and run the retrieval on the chunks, but return the larger \"parent\" document when invoking the retriever. [ParentDocumentRetriever](/docs/how_to/parent_document_retriever/), a subclass of `MultiVectorRetriever`, includes convenience methods for populating a vector store to support this. Further applications are detailed in this [how-to guide](/docs/how_to/multi_vector/).\n",
+    "\n",
+    "To propagate similarity scores through this retriever, we can again subclass `MultiVectorRetriever` and override a method. This time we will override `_get_relevant_documents`.\n",
+    "\n",
+    "First, we prepare some fake data. We generate fake \"whole documents\" and store them in a document store; here we will use a simple [InMemoryStore](https://api.python.langchain.com/en/latest/stores/langchain_core.stores.InMemoryBaseStore.html)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a112e545-7b53-4fcd-9c4a-7a42a5cc646d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.storage import InMemoryStore\n",
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "\n",
+    "# The storage layer for the parent documents\n",
+    "docstore = InMemoryStore()\n",
+    "fake_whole_documents = [\n",
+    "    (\"fake_id_1\", Document(page_content=\"fake whole document 1\")),\n",
+    "    (\"fake_id_2\", Document(page_content=\"fake whole document 2\")),\n",
+    "]\n",
+    "docstore.mset(fake_whole_documents)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "453b7415-4a6d-45d4-a329-9c1d7271d1b2",
+   "metadata": {},
+   "source": [
+    "Next we will add some fake \"sub-documents\" to our vector store. We can link these sub-documents to the parent documents by populating the `\"doc_id\"` key in its metadata."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "314519c0-dde4-41ea-a1ab-d3cf1c17c63f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['62a85353-41ff-4346-bff7-be6c8ec2ed89',\n",
+       " '5d4a0e83-4cc5-40f1-bc73-ed9cbad0ee15',\n",
+       " '8c1d9a56-120f-45e4-ba70-a19cd19a38f4']"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs = [\n",
+    "    Document(\n",
+    "        page_content=\"A snippet from a larger document discussing cats.\",\n",
+    "        metadata={\"doc_id\": \"fake_id_1\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"A snippet from a larger document discussing discourse.\",\n",
+    "        metadata={\"doc_id\": \"fake_id_1\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"A snippet from a larger document discussing chocolate.\",\n",
+    "        metadata={\"doc_id\": \"fake_id_2\"},\n",
+    "    ),\n",
+    "]\n",
+    "\n",
+    "vectorstore.add_documents(docs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e391f7f3-5a58-40fd-89fa-a0815c5146f7",
+   "metadata": {},
+   "source": [
+    "To propagate the scores, we subclass `MultiVectorRetriever` and override its `_get_relevant_documents` method. Here we will make two changes:\n",
+    "\n",
+    "1. We will add similarity scores to the metadata of the corresponding \"sub-documents\" using the `similarity_search_with_score` method of the underlying vector store as above;\n",
+    "2. We will include a list of these sub-documents in the metadata of the retrieved parent document. This surfaces what snippets of text were identified by the retrieval, together with their corresponding similarity scores."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "1de61de7-1b58-41d6-9dea-939fef7d741d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "from langchain.retrievers import MultiVectorRetriever\n",
+    "from langchain_core.callbacks import CallbackManagerForRetrieverRun\n",
+    "\n",
+    "\n",
+    "class CustomMultiVectorRetriever(MultiVectorRetriever):\n",
+    "    def _get_relevant_documents(\n",
+    "        self, query: str, *, run_manager: CallbackManagerForRetrieverRun\n",
+    "    ) -> List[Document]:\n",
+    "        \"\"\"Get documents relevant to a query.\n",
+    "        Args:\n",
+    "            query: String to find relevant documents for\n",
+    "            run_manager: The callbacks handler to use\n",
+    "        Returns:\n",
+    "            List of relevant documents\n",
+    "        \"\"\"\n",
+    "        results = self.vectorstore.similarity_search_with_score(\n",
+    "            query, **self.search_kwargs\n",
+    "        )\n",
+    "\n",
+    "        # Map doc_ids to list of sub-documents, adding scores to metadata\n",
+    "        id_to_doc = defaultdict(list)\n",
+    "        for doc, score in results:\n",
+    "            doc_id = doc.metadata.get(\"doc_id\")\n",
+    "            if doc_id:\n",
+    "                doc.metadata[\"score\"] = score\n",
+    "                id_to_doc[doc_id].append(doc)\n",
+    "\n",
+    "        # Fetch documents corresponding to doc_ids, retaining sub_docs in metadata\n",
+    "        docs = []\n",
+    "        for _id, sub_docs in id_to_doc.items():\n",
+    "            docstore_docs = self.docstore.mget([_id])\n",
+    "            if docstore_docs:\n",
+    "                if doc := docstore_docs[0]:\n",
+    "                    doc.metadata[\"sub_docs\"] = sub_docs\n",
+    "                    docs.append(doc)\n",
+    "\n",
+    "        return docs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7af27b38-631c-463f-9d66-bcc985f06a4f",
+   "metadata": {},
+   "source": [
+    "Invoking this retriever, we can see that it identifies the correct parent document, including the relevant snippet from the sub-document with similarity score."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "dc42a1be-22e1-4ade-b1bd-bafb85f2424f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='fake whole document 1', metadata={'sub_docs': [Document(page_content='A snippet from a larger document discussing cats.', metadata={'doc_id': 'fake_id_1', 'score': 0.831276655})]})]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "retriever = CustomMultiVectorRetriever(vectorstore=vectorstore, docstore=docstore)\n",
+    "\n",
+    "retriever.invoke(\"cat\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/how_to/agent_executor.ipynb

@@ -15,18 +15,18 @@
    "id": "f4c03f40-1328-412d-8a48-1db0cd481b77",
    "metadata": {},
    "source": [
-    "# Build an Agent\n",
+    "# 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",
     "\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 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",
+    "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",
     "\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",
+    "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",
     "## 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 followup questions. \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",
     "- Debugging and tracing your application using [LangSmith](/docs/concepts/#langsmith)\n",
     "\n",
     "## Setup\n",
@@ -66,7 +66,7 @@
     "```\n",
     "\n",
     "\n",
-    "For more details, see our [Installation guide](/docs/installation).\n",
+    "For more details, see our [Installation guide](/docs/how_to/installation).\n",
     "\n",
     "### LangSmith\n",
     "\n",

docs/docs/how_to/assign.ipynb

@@ -16,21 +16,20 @@
    "source": [
     "# How to add values to a chain's state\n",
     "\n",
-    "An alternate way of [passing data through](/docs/how_to/passthrough) steps of a chain is to leave the current values of the chain state unchanged while assigning a new value under a given key. The [`RunnablePassthrough.assign()`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.passthrough.RunnablePassthrough.html#langchain_core.runnables.passthrough.RunnablePassthrough.assign) static method takes an input value and adds the extra arguments passed to the assign function.\n",
+    ":::info Prerequisites\n",
     "\n",
-    "This is useful in the common [LangChain Expression Language](/docs/concepts/#langchain-expression-language) pattern of additively creating a dictionary to use as input to a later step.\n",
-    "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
+    "This guide assumes familiarity with the following concepts:\n",
     "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
     "- [Chaining runnables](/docs/how_to/sequence/)\n",
     "- [Calling runnables in parallel](/docs/how_to/parallel/)\n",
     "- [Custom functions](/docs/how_to/functions/)\n",
     "- [Passing data through](/docs/how_to/passthrough)\n",
-    "`} />\n",
-    "```\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "An alternate way of [passing data through](/docs/how_to/passthrough) steps of a chain is to leave the current values of the chain state unchanged while assigning a new value under a given key. The [`RunnablePassthrough.assign()`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.passthrough.RunnablePassthrough.html#langchain_core.runnables.passthrough.RunnablePassthrough.assign) static method takes an input value and adds the extra arguments passed to the assign function.\n",
+    "\n",
+    "This is useful in the common [LangChain Expression Language](/docs/concepts/#langchain-expression-language) pattern of additively creating a dictionary to use as input to a later step.\n",
     "\n",
     "Here's an example:"
    ]
@@ -184,9 +183,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

docs/docs/how_to/binding.ipynb

@@ -16,19 +16,18 @@
    "id": "711752cb-4f15-42a3-9838-a0c67f397771",
    "metadata": {},
    "source": [
-    "# How to attach runtime arguments to a Runnable\n",
+    "# How to add default invocation args to a Runnable\n",
     "\n",
-    "Sometimes we want to invoke a [`Runnable`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html) within a [RunnableSequence](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableSequence.html) with constant arguments that are not part of the output of the preceding Runnable in the sequence, and which are not part of the user input. We can use the [`Runnable.bind()`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable.bind) method to set these arguments ahead of time.\n",
+    ":::info Prerequisites\n",
     "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
+    "This guide assumes familiarity with the following concepts:\n",
     "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
     "- [Chaining runnables](/docs/how_to/sequence/)\n",
     "- [Tool calling](/docs/how_to/tool_calling/)\n",
-    "`} />\n",
-    "```\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "Sometimes we want to invoke a [`Runnable`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html) within a [RunnableSequence](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableSequence.html) with constant arguments that are not part of the output of the preceding Runnable in the sequence, and which are not part of the user input. We can use the [`Runnable.bind()`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable.bind) method to set these arguments ahead of time.\n",
     "\n",
     "## Binding stop sequences\n",
     "\n",
@@ -228,7 +227,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/caching_embeddings.ipynb

@@ -18,11 +18,12 @@
     "- document_embedding_cache: Any [`ByteStore`](/docs/integrations/stores/) for caching document embeddings.\n",
     "- batch_size: (optional, defaults to `None`) The number of documents to embed between store updates.\n",
     "- namespace: (optional, defaults to `\"\"`) The namespace to use for document cache. This namespace is used to avoid collisions with other caches. For example, set it to the name of the embedding model used.\n",
+    "- query_embedding_cache: (optional, defaults to `None` or not caching) A [`ByteStore`](/docs/integrations/stores/) for caching query embeddings, or `True` to use the same store as `document_embedding_cache`.\n",
     "\n",
     "**Attention**:\n",
     "\n",
     "- Be sure to set the `namespace` parameter to avoid collisions of the same text embedded using different embeddings models.\n",
-    "- Currently `CacheBackedEmbeddings` does not cache embedding created with `embed_query()` `aembed_query()` methods."
+    "- `CacheBackedEmbeddings` does not cache query embeddings by default. To enable query caching, one need to specify a `query_embedding_cache`."
    ]
   },
   {
@@ -123,7 +124,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "raw_documents = TextLoader(\"../../state_of_the_union.txt\").load()\n",
+    "raw_documents = TextLoader(\"state_of_the_union.txt\").load()\n",
     "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
     "documents = text_splitter.split_documents(raw_documents)"
    ]

docs/docs/how_to/callbacks_async.ipynb

@@ -0,0 +1,179 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to use callbacks in async environments\n",
+    "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "- [Callbacks](/docs/concepts/#callbacks)\n",
+    "- [Custom callback handlers](/docs/how_to/custom_callbacks)\n",
+    ":::\n",
+    "\n",
+    "If you are planning to use the async APIs, it is recommended to use and extend [`AsyncCallbackHandler`](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.base.AsyncCallbackHandler.html) to avoid blocking the event.\n",
+    "\n",
+    "\n",
+    ":::{.callout-warning}\n",
+    "If you use a sync `CallbackHandler` while using an async method to run your LLM / Chain / Tool / Agent, it will still work. However, under the hood, it will be called with [`run_in_executor`](https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.run_in_executor) which can cause issues if your `CallbackHandler` is not thread-safe.\n",
+    ":::\n",
+    "\n",
+    ":::{.callout-danger}\n",
+    "\n",
+    "If you're on `python<=3.10`, you need to remember to propagate `config` or `callbacks` when invoking other `runnable` from within a `RunnableLambda`, `RunnableGenerator` or `@tool`. If you do not do this,\n",
+    "the callbacks will not be propagated to the child runnables being invoked.\n",
+    ":::"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | output: false\n",
+    "# | echo: false\n",
+    "\n",
+    "%pip install -qU langchain langchain_anthropic\n",
+    "\n",
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"ANTHROPIC_API_KEY\"] = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "zzzz....\n",
+      "Hi! I just woke up. Your llm is starting\n",
+      "Sync handler being called in a `thread_pool_executor`: token: Here\n",
+      "Sync handler being called in a `thread_pool_executor`: token: 's\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  a\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  little\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  joke\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  for\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  you\n",
+      "Sync handler being called in a `thread_pool_executor`: token: :\n",
+      "Sync handler being called in a `thread_pool_executor`: token: \n",
+      "\n",
+      "Why\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  can\n",
+      "Sync handler being called in a `thread_pool_executor`: token: 't\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  a\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  bicycle\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  stan\n",
+      "Sync handler being called in a `thread_pool_executor`: token: d up\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  by\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  itself\n",
+      "Sync handler being called in a `thread_pool_executor`: token: ?\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  Because\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  it\n",
+      "Sync handler being called in a `thread_pool_executor`: token: 's\n",
+      "Sync handler being called in a `thread_pool_executor`: token:  two\n",
+      "Sync handler being called in a `thread_pool_executor`: token: -\n",
+      "Sync handler being called in a `thread_pool_executor`: token: tire\n",
+      "zzzz....\n",
+      "Hi! I just woke up. Your llm is ending\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "LLMResult(generations=[[ChatGeneration(text=\"Here's a little joke for you:\\n\\nWhy can't a bicycle stand up by itself? Because it's two-tire\", message=AIMessage(content=\"Here's a little joke for you:\\n\\nWhy can't a bicycle stand up by itself? Because it's two-tire\", id='run-8afc89e8-02c0-4522-8480-d96977240bd4-0'))]], llm_output={}, run=[RunInfo(run_id=UUID('8afc89e8-02c0-4522-8480-d96977240bd4'))])"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import asyncio\n",
+    "from typing import Any, Dict, List\n",
+    "\n",
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.callbacks import AsyncCallbackHandler, BaseCallbackHandler\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "from langchain_core.outputs import LLMResult\n",
+    "\n",
+    "\n",
+    "class MyCustomSyncHandler(BaseCallbackHandler):\n",
+    "    def on_llm_new_token(self, token: str, **kwargs) -> None:\n",
+    "        print(f\"Sync handler being called in a `thread_pool_executor`: token: {token}\")\n",
+    "\n",
+    "\n",
+    "class MyCustomAsyncHandler(AsyncCallbackHandler):\n",
+    "    \"\"\"Async callback handler that can be used to handle callbacks from langchain.\"\"\"\n",
+    "\n",
+    "    async def on_llm_start(\n",
+    "        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any\n",
+    "    ) -> None:\n",
+    "        \"\"\"Run when chain starts running.\"\"\"\n",
+    "        print(\"zzzz....\")\n",
+    "        await asyncio.sleep(0.3)\n",
+    "        class_name = serialized[\"name\"]\n",
+    "        print(\"Hi! I just woke up. Your llm is starting\")\n",
+    "\n",
+    "    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:\n",
+    "        \"\"\"Run when chain ends running.\"\"\"\n",
+    "        print(\"zzzz....\")\n",
+    "        await asyncio.sleep(0.3)\n",
+    "        print(\"Hi! I just woke up. Your llm is ending\")\n",
+    "\n",
+    "\n",
+    "# To enable streaming, we pass in `streaming=True` to the ChatModel constructor\n",
+    "# Additionally, we pass in a list with our custom handler\n",
+    "chat = ChatAnthropic(\n",
+    "    model=\"claude-3-sonnet-20240229\",\n",
+    "    max_tokens=25,\n",
+    "    streaming=True,\n",
+    "    callbacks=[MyCustomSyncHandler(), MyCustomAsyncHandler()],\n",
+    ")\n",
+    "\n",
+    "await chat.agenerate([[HumanMessage(content=\"Tell me a joke\")]])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Next steps\n",
+    "\n",
+    "You've now learned how to create your own custom callback handlers.\n",
+    "\n",
+    "Next, check out the other how-to guides in this section, such as [how to attach callbacks to a runnable](/docs/how_to/callbacks_attach)."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

docs/docs/how_to/callbacks_attach.ipynb

@@ -0,0 +1,149 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to attach callbacks to a runnable\n",
+    "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "- [Callbacks](/docs/concepts/#callbacks)\n",
+    "- [Custom callback handlers](/docs/how_to/custom_callbacks)\n",
+    "- [Chaining runnables](/docs/how_to/sequence)\n",
+    "- [Attach runtime arguments to a Runnable](/docs/how_to/binding)\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "If you are composing a chain of runnables and want to reuse callbacks across multiple executions, you can attach callbacks with the [`.with_config()`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable.with_config) method. This saves you the need to pass callbacks in each time you invoke the chain.\n",
+    "\n",
+    ":::{.callout-important}\n",
+    "\n",
+    "`with_config()` binds a configuration which will be interpreted as **runtime** configuration. So these callbacks will propagate to all child components.\n",
+    ":::\n",
+    "\n",
+    "Here's an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | output: false\n",
+    "# | echo: false\n",
+    "\n",
+    "%pip install -qU langchain langchain_anthropic\n",
+    "\n",
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"ANTHROPIC_API_KEY\"] = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Chain RunnableSequence started\n",
+      "Chain ChatPromptTemplate started\n",
+      "Chain ended, outputs: messages=[HumanMessage(content='What is 1 + 2?')]\n",
+      "Chat model started\n",
+      "Chat model ended, response: generations=[[ChatGeneration(text='1 + 2 = 3', message=AIMessage(content='1 + 2 = 3', response_metadata={'id': 'msg_01NTYMsH9YxkoWsiPYs4Lemn', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}}, id='run-d6bcfd72-9c94-466d-bac0-f39e456ad6e3-0'))]] llm_output={'id': 'msg_01NTYMsH9YxkoWsiPYs4Lemn', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}} run=None\n",
+      "Chain ended, outputs: content='1 + 2 = 3' response_metadata={'id': 'msg_01NTYMsH9YxkoWsiPYs4Lemn', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}} id='run-d6bcfd72-9c94-466d-bac0-f39e456ad6e3-0'\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='1 + 2 = 3', response_metadata={'id': 'msg_01NTYMsH9YxkoWsiPYs4Lemn', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}}, id='run-d6bcfd72-9c94-466d-bac0-f39e456ad6e3-0')"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from typing import Any, Dict, List\n",
+    "\n",
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.callbacks import BaseCallbackHandler\n",
+    "from langchain_core.messages import BaseMessage\n",
+    "from langchain_core.outputs import LLMResult\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "\n",
+    "\n",
+    "class LoggingHandler(BaseCallbackHandler):\n",
+    "    def on_chat_model_start(\n",
+    "        self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], **kwargs\n",
+    "    ) -> None:\n",
+    "        print(\"Chat model started\")\n",
+    "\n",
+    "    def on_llm_end(self, response: LLMResult, **kwargs) -> None:\n",
+    "        print(f\"Chat model ended, response: {response}\")\n",
+    "\n",
+    "    def on_chain_start(\n",
+    "        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs\n",
+    "    ) -> None:\n",
+    "        print(f\"Chain {serialized.get('name')} started\")\n",
+    "\n",
+    "    def on_chain_end(self, outputs: Dict[str, Any], **kwargs) -> None:\n",
+    "        print(f\"Chain ended, outputs: {outputs}\")\n",
+    "\n",
+    "\n",
+    "callbacks = [LoggingHandler()]\n",
+    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\")\n",
+    "prompt = ChatPromptTemplate.from_template(\"What is 1 + {number}?\")\n",
+    "\n",
+    "chain = prompt | llm\n",
+    "\n",
+    "chain_with_callbacks = chain.with_config(callbacks=callbacks)\n",
+    "\n",
+    "chain_with_callbacks.invoke({\"number\": \"2\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The bound callbacks will run for all nested module runs.\n",
+    "\n",
+    "## Next steps\n",
+    "\n",
+    "You've now learned how to attach callbacks to a chain.\n",
+    "\n",
+    "Next, check out the other how-to guides in this section, such as how to [pass callbacks in at runtime](/docs/how_to/callbacks_runtime)."
+   ]
+  }
+ ],
+ "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/how_to/callbacks_constructor.ipynb

@@ -0,0 +1,141 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to propagate callbacks  constructor\n",
+    "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "- [Callbacks](/docs/concepts/#callbacks)\n",
+    "- [Custom callback handlers](/docs/how_to/custom_callbacks)\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "Most LangChain modules allow you to pass `callbacks` directly into the constructor (i.e., initializer). In this case, the callbacks will only be called for that instance (and any nested runs).\n",
+    "\n",
+    ":::{.callout-warning}\n",
+    "Constructor callbacks are scoped only to the object they are defined on. They are **not** inherited by children of the object. This can lead to confusing behavior,\n",
+    "and it's generally better to pass callbacks as a run time argument.\n",
+    ":::\n",
+    "\n",
+    "Here's an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | output: false\n",
+    "# | echo: false\n",
+    "\n",
+    "%pip install -qU langchain langchain_anthropic\n",
+    "\n",
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"ANTHROPIC_API_KEY\"] = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Chat model started\n",
+      "Chat model ended, response: generations=[[ChatGeneration(text='1 + 2 = 3', message=AIMessage(content='1 + 2 = 3', response_metadata={'id': 'msg_01CdKsRmeS9WRb8BWnHDEHm7', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}}, id='run-2d7fdf2a-7405-4e17-97c0-67e6b2a65305-0'))]] llm_output={'id': 'msg_01CdKsRmeS9WRb8BWnHDEHm7', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}} run=None\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='1 + 2 = 3', response_metadata={'id': 'msg_01CdKsRmeS9WRb8BWnHDEHm7', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}}, id='run-2d7fdf2a-7405-4e17-97c0-67e6b2a65305-0')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from typing import Any, Dict, List\n",
+    "\n",
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.callbacks import BaseCallbackHandler\n",
+    "from langchain_core.messages import BaseMessage\n",
+    "from langchain_core.outputs import LLMResult\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "\n",
+    "\n",
+    "class LoggingHandler(BaseCallbackHandler):\n",
+    "    def on_chat_model_start(\n",
+    "        self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], **kwargs\n",
+    "    ) -> None:\n",
+    "        print(\"Chat model started\")\n",
+    "\n",
+    "    def on_llm_end(self, response: LLMResult, **kwargs) -> None:\n",
+    "        print(f\"Chat model ended, response: {response}\")\n",
+    "\n",
+    "    def on_chain_start(\n",
+    "        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs\n",
+    "    ) -> None:\n",
+    "        print(f\"Chain {serialized.get('name')} started\")\n",
+    "\n",
+    "    def on_chain_end(self, outputs: Dict[str, Any], **kwargs) -> None:\n",
+    "        print(f\"Chain ended, outputs: {outputs}\")\n",
+    "\n",
+    "\n",
+    "callbacks = [LoggingHandler()]\n",
+    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\", callbacks=callbacks)\n",
+    "prompt = ChatPromptTemplate.from_template(\"What is 1 + {number}?\")\n",
+    "\n",
+    "chain = prompt | llm\n",
+    "\n",
+    "chain.invoke({\"number\": \"2\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can see that we only see events from the chat model run - no chain events from the prompt or broader chain.\n",
+    "\n",
+    "## Next steps\n",
+    "\n",
+    "You've now learned how to pass callbacks into a constructor.\n",
+    "\n",
+    "Next, check out the other how-to guides in this section, such as how to [pass callbacks at runtime](/docs/how_to/callbacks_runtime)."
+   ]
+  }
+ ],
+ "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/how_to/callbacks_runtime.ipynb

@@ -0,0 +1,140 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to pass callbacks in at runtime\n",
+    "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "- [Callbacks](/docs/concepts/#callbacks)\n",
+    "- [Custom callback handlers](/docs/how_to/custom_callbacks)\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "In many cases, it is advantageous to pass in handlers instead when running the object. When we pass through [`CallbackHandlers`](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.base.BaseCallbackHandler.html#langchain-core-callbacks-base-basecallbackhandler) using the `callbacks` keyword arg when executing an run, those callbacks will be issued by all nested objects involved in the execution. For example, when a handler is passed through to an Agent, it will be used for all callbacks related to the agent and all the objects involved in the agent's execution, in this case, the Tools and LLM.\n",
+    "\n",
+    "This prevents us from having to manually attach the handlers to each individual nested object. Here's an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | output: false\n",
+    "# | echo: false\n",
+    "\n",
+    "%pip install -qU langchain langchain_anthropic\n",
+    "\n",
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"ANTHROPIC_API_KEY\"] = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Chain RunnableSequence started\n",
+      "Chain ChatPromptTemplate started\n",
+      "Chain ended, outputs: messages=[HumanMessage(content='What is 1 + 2?')]\n",
+      "Chat model started\n",
+      "Chat model ended, response: generations=[[ChatGeneration(text='1 + 2 = 3', message=AIMessage(content='1 + 2 = 3', response_metadata={'id': 'msg_01D8Tt5FdtBk5gLTfBPm2tac', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}}, id='run-bb0dddd8-85f3-4e6b-8553-eaa79f859ef8-0'))]] llm_output={'id': 'msg_01D8Tt5FdtBk5gLTfBPm2tac', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}} run=None\n",
+      "Chain ended, outputs: content='1 + 2 = 3' response_metadata={'id': 'msg_01D8Tt5FdtBk5gLTfBPm2tac', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}} id='run-bb0dddd8-85f3-4e6b-8553-eaa79f859ef8-0'\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='1 + 2 = 3', response_metadata={'id': 'msg_01D8Tt5FdtBk5gLTfBPm2tac', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 16, 'output_tokens': 13}}, id='run-bb0dddd8-85f3-4e6b-8553-eaa79f859ef8-0')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from typing import Any, Dict, List\n",
+    "\n",
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.callbacks import BaseCallbackHandler\n",
+    "from langchain_core.messages import BaseMessage\n",
+    "from langchain_core.outputs import LLMResult\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "\n",
+    "\n",
+    "class LoggingHandler(BaseCallbackHandler):\n",
+    "    def on_chat_model_start(\n",
+    "        self, serialized: Dict[str, Any], messages: List[List[BaseMessage]], **kwargs\n",
+    "    ) -> None:\n",
+    "        print(\"Chat model started\")\n",
+    "\n",
+    "    def on_llm_end(self, response: LLMResult, **kwargs) -> None:\n",
+    "        print(f\"Chat model ended, response: {response}\")\n",
+    "\n",
+    "    def on_chain_start(\n",
+    "        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs\n",
+    "    ) -> None:\n",
+    "        print(f\"Chain {serialized.get('name')} started\")\n",
+    "\n",
+    "    def on_chain_end(self, outputs: Dict[str, Any], **kwargs) -> None:\n",
+    "        print(f\"Chain ended, outputs: {outputs}\")\n",
+    "\n",
+    "\n",
+    "callbacks = [LoggingHandler()]\n",
+    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\")\n",
+    "prompt = ChatPromptTemplate.from_template(\"What is 1 + {number}?\")\n",
+    "\n",
+    "chain = prompt | llm\n",
+    "\n",
+    "chain.invoke({\"number\": \"2\"}, config={\"callbacks\": callbacks})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If there are already existing callbacks associated with a module, these will run in addition to any passed in at runtime.\n",
+    "\n",
+    "## Next steps\n",
+    "\n",
+    "You've now learned how to pass callbacks at runtime.\n",
+    "\n",
+    "Next, check out the other how-to guides in this section, such as how to [pass callbacks into a module constructor](/docs/how_to/custom_callbacks)."
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/how_to/character_text_splitter.ipynb

@@ -1,5 +1,19 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "f781411d",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "---\n",
+    "keywords: [charactertextsplitter]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "c3ee8d00",
@@ -45,7 +59,7 @@
     "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
     "# Load an example document\n",
-    "with open(\"../../../docs/modules/state_of_the_union.txt\") as f:\n",
+    "with open(\"state_of_the_union.txt\") as f:\n",
     "    state_of_the_union = f.read()\n",
     "\n",
     "text_splitter = CharacterTextSplitter(\n",

docs/docs/how_to/chat_model_caching.ipynb

@@ -7,21 +7,20 @@
    "source": [
     "# How to cache chat model responses\n",
     "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [Chat models](/docs/concepts/#chat-models)\n",
+    "- [LLMs](/docs/concepts/#llms)\n",
+    "\n",
+    ":::\n",
+    "\n",
     "LangChain provides an optional caching layer for chat models. This is useful for two main reasons:\n",
     "\n",
     "- It can save you money by reducing the number of API calls you make to the LLM provider, if you're often requesting the same completion multiple times. This is especially useful during app development.\n",
     "- It can speed up your application by reducing the number of API calls you make to the LLM provider.\n",
     "\n",
-    "This guide will walk you through how to enable this in your apps.\n",
-    "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [Chat models](/docs/concepts/#chat-models)\n",
-    "- [LLMs](/docs/concepts/#llms)\n",
-    "`} />\n",
-    "```"
+    "This guide will walk you through how to enable this in your apps."
    ]
   },
   {
@@ -171,7 +170,7 @@
    "outputs": [],
    "source": [
     "# We can do the same thing with a SQLite cache\n",
-    "from langchain.cache import SQLiteCache\n",
+    "from langchain_community.cache import SQLiteCache\n",
     "\n",
     "set_llm_cache(SQLiteCache(database_path=\".langchain.db\"))"
    ]
@@ -267,7 +266,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/chat_models_universal_init.ipynb

@@ -0,0 +1,157 @@
+{
+ "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

@@ -7,43 +7,58 @@
    "source": [
     "# How to track token usage in ChatModels\n",
     "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [Chat models](/docs/concepts/#chat-models)\n",
+    "\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",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [Chat models](/docs/concepts/#chat-models)\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"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "1a55e87a-3291-4e7f-8e8e-4c69b0854384",
+   "id": "598ae1e2-a52d-4459-81fd-cdc68b06742a",
    "metadata": {},
    "source": [
-    "## Using AIMessage.response_metadata\n",
+    "## Using LangSmith\n",
     "\n",
-    "A number of model providers return token usage information as part of the chat generation response. When available, this is included in the [`AIMessage.response_metadata`](/docs/how_to/response_metadata) field. Here's an example with OpenAI:"
+    "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**:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "467ccdeb-6b62-45e5-816e-167cd24d2586",
+   "id": "b39bf807-4125-4db4-bbf7-28a46afff6b4",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'token_usage': {'completion_tokens': 225,\n",
-       "  'prompt_tokens': 17,\n",
-       "  'total_tokens': 242},\n",
-       " 'model_name': 'gpt-4-turbo',\n",
-       " 'system_fingerprint': 'fp_76f018034d',\n",
-       " 'finish_reason': 'stop',\n",
-       " 'logprobs': None}"
+       "{'input_tokens': 8, 'output_tokens': 9, 'total_tokens': 17}"
       ]
      },
      "execution_count": 1,
@@ -52,37 +67,33 @@
     }
    ],
    "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-4-turbo\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
+    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\")\n",
+    "openai_response = llm.invoke(\"hello\")\n",
+    "openai_response.usage_metadata"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "9d5026e9-3ad4-41e6-9946-9f1a26f4a21f",
+   "id": "2299c44a-2fe6-4d52-a6a2-99ff6d231c73",
    "metadata": {},
    "source": [
-    "And here's an example with Anthropic:"
+    "**Anthropic**:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "145404f1-e088-4824-b468-236c486a9903",
+   "id": "9c82ff80-ec4e-4049-b019-5f0bbd7df82a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'id': 'msg_01P61rdHbapEo6h3fjpfpCQT',\n",
-       " 'model': 'claude-3-sonnet-20240229',\n",
-       " 'stop_reason': 'end_turn',\n",
-       " 'stop_sequence': None,\n",
-       " 'usage': {'input_tokens': 17, 'output_tokens': 306}}"
+       "{'input_tokens': 8, 'output_tokens': 12, 'total_tokens': 20}"
       ]
      },
      "execution_count": 2,
@@ -95,9 +106,222 @@
     "\n",
     "from langchain_anthropic import ChatAnthropic\n",
     "\n",
-    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\")\n",
-    "msg = llm.invoke([(\"human\", \"What's the oldest known example of cuneiform\")])\n",
-    "msg.response_metadata"
+    "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."
    ]
   },
   {
@@ -116,7 +340,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 9,
    "id": "31667d54",
    "metadata": {},
    "outputs": [
@@ -124,11 +348,11 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Tokens Used: 26\n",
+      "Tokens Used: 27\n",
       "\tPrompt Tokens: 11\n",
-      "\tCompletion Tokens: 15\n",
+      "\tCompletion Tokens: 16\n",
       "Successful Requests: 1\n",
-      "Total Cost (USD): $0.00056\n"
+      "Total Cost (USD): $2.95e-05\n"
      ]
     }
    ],
@@ -137,7 +361,7 @@
     "\n",
     "from langchain_community.callbacks.manager import get_openai_callback\n",
     "\n",
-    "llm = ChatOpenAI(model=\"gpt-4-turbo\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)\n",
     "\n",
     "with get_openai_callback() as cb:\n",
     "    result = llm.invoke(\"Tell me a joke\")\n",
@@ -154,7 +378,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 10,
    "id": "e09420f4",
    "metadata": {},
    "outputs": [
@@ -162,7 +386,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "52\n"
+      "55\n"
      ]
     }
    ],
@@ -173,6 +397,39 @@
     "    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",
@@ -183,7 +440,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 12,
    "id": "5d1125c6",
    "metadata": {},
    "outputs": [],
@@ -212,15 +469,15 @@
    "source": [
     "```{=mdx}\n",
     ":::note\n",
-    "We have to set `stream_runnable=False` for token counting to work. By default the AgentExecutor will stream the underlying agent so that you can get the most granular results when streaming events via AgentExecutor.stream_events. However, OpenAI does not return token counts when streaming model responses, so we need to turn off the underlying streaming.\n",
+    "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",
     ":::\n",
     "```"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
-   "id": "2f98c536",
+   "execution_count": 13,
+   "id": "3950d88b-8bfb-4294-b75b-e6fd421e633c",
    "metadata": {},
    "outputs": [
     {
@@ -231,46 +488,51 @@
       "\n",
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
       "\u001b[32;1m\u001b[1;3m\n",
-      "Invoking: `wikipedia` with `Hummingbird`\n",
+      "Invoking: `wikipedia` with `{'query': 'hummingbird scientific name'}`\n",
       "\n",
       "\n",
       "\u001b[0m\u001b[36;1m\u001b[1;3mPage: Hummingbird\n",
-      "Summary: Hummingbirds are birds native to the Americas and comprise the biological family Trochilidae. With approximately 366 species and 113 genera, they occur from Alaska to Tierra del Fuego, but most species are found in Central and South America. As of 2024, 21 hummingbird species are listed as endangered or critically endangered, with numerous species declining in population.Hummingbirds have varied specialized characteristics to enable rapid, maneuverable flight: exceptional metabolic capacity, adaptations to high altitude, sensitive visual and communication abilities, and long-distance migration in some species. Among all birds, male hummingbirds have the widest diversity of plumage color, particularly in blues, greens, and purples. Hummingbirds are the smallest mature birds, measuring 7.5–13 cm (3–5 in) in length. The smallest is the 5 cm (2.0 in) bee hummingbird, which weighs less than 2.0 g (0.07 oz), and the largest is the 23 cm (9 in) giant hummingbird, weighing 18–24 grams (0.63–0.85 oz). Noted for long beaks, hummingbirds are specialized for feeding on flower nectar, but all species also consume small insects.\n",
+      "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",
       "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: 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",
+      "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",
       "\n",
       "\n",
-      "\u001b[0m\u001b[36;1m\u001b[1;3mPage: Fastest animals\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",
       "Summary: This is a list of the fastest animals in the world, by types of animal.\n",
       "\n",
       "\n",
       "\n",
-      "Page: List of birds by flight speed\n",
-      "Summary: This is a list of the fastest flying birds in the world. A bird's velocity is necessarily variable; a hunting bird will reach much greater speeds while diving to catch prey than when flying horizontally. The bird that can achieve the greatest airspeed is the peregrine falcon, able to exceed 320 km/h (200 mph) in its dives. A close relative of the common swift, the white-throated needletail (Hirundapus caudacutus), is commonly reported as the fastest bird in level flight with a reported top speed of 169 km/h (105 mph). This record remains unconfirmed as the measurement methods have never been published or verified. The record for the fastest confirmed level flight by a bird is 111.5 km/h (69.3 mph) held by the common swift.\n",
-      "\n",
-      "Page: Ostrich\n",
-      "Summary: Ostriches are large flightless birds. They are the heaviest and largest living birds, with adult common ostriches weighing anywhere between 63.5 and 145 kilograms and laying the largest eggs of any living land animal. With the ability to run at 70 km/h (43.5 mph), they are the fastest birds on land. They are farmed worldwide, with significant industries in the Philippines and in Namibia. Ostrich leather is a lucrative commodity, and the large feathers are used as plumes for the decoration of ceremonial headgear. Ostrich eggs have been used by humans for millennia.\n",
-      "Ostriches are of the genus Struthio in the order Struthioniformes, part of the infra-class Palaeognathae, a diverse group of flightless birds also known as ratites that includes the emus, rheas, cassowaries, kiwis and the extinct elephant birds and moas. There are two living species of ostrich: the common ostrich, native to large areas of sub-Saharan Africa, and the Somali ostrich, native to the Horn of Africa.  The common ostrich was historically native to the Arabian Peninsula, and ostriches were present across Asia as far east as China and Mongolia during the Late Pleistocene and possibly into the Holocene.\u001b[0m\u001b[32;1m\u001b[1;3m### Hummingbird's Scientific Name\n",
-      "The scientific name for the bee hummingbird, which is the smallest known bird and a species of hummingbird, is **Mellisuga helenae**. It is native to Cuba.\n",
-      "\n",
-      "### Fastest Bird Species\n",
-      "The fastest bird in terms of airspeed is the **peregrine falcon**, which can exceed speeds of 320 km/h (200 mph) during its diving flight. In level flight, the fastest confirmed speed is held by the **common swift**, which can fly at 111.5 km/h (69.3 mph).\u001b[0m\n",
+      "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",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n",
-      "Total Tokens: 1583\n",
-      "Prompt Tokens: 1412\n",
-      "Completion Tokens: 171\n",
-      "Total Cost (USD): $0.019250000000000003\n"
+      "Total Tokens: 1787\n",
+      "Prompt Tokens: 1687\n",
+      "Completion Tokens: 100\n",
+      "Total Cost (USD): $0.0009935\n"
      ]
     }
    ],
@@ -299,19 +561,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "4a3eced5-2ff7-49a7-a48b-768af8658323",
+   "execution_count": 12,
+   "id": "1837c807-136a-49d8-9c33-060e58dc16d2",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Tokens Used: 0\n",
-      "\tPrompt Tokens: 0\n",
-      "\tCompletion Tokens: 0\n",
+      "Tokens Used: 96\n",
+      "\tPrompt Tokens: 26\n",
+      "\tCompletion Tokens: 70\n",
       "Successful Requests: 2\n",
-      "Total Cost (USD): $0.0\n"
+      "Total Cost (USD): $0.001888\n"
      ]
     }
    ],
@@ -365,7 +627,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/chatbots_memory.ipynb

@@ -165,7 +165,7 @@
     }
    ],
    "source": [
-    "from langchain.memory import ChatMessageHistory\n",
+    "from langchain_community.chat_message_histories import ChatMessageHistory\n",
     "\n",
     "demo_ephemeral_chat_history = ChatMessageHistory()\n",
     "\n",

docs/docs/how_to/chatbots_tools.ipynb

@@ -336,7 +336,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.memory import ChatMessageHistory\n",
+    "from langchain_community.chat_message_histories import ChatMessageHistory\n",
     "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
     "\n",
     "demo_ephemeral_chat_history_for_chain = ChatMessageHistory()\n",

docs/docs/how_to/configure.ipynb

@@ -18,23 +18,22 @@
    "source": [
     "# How to configure runtime chain internals\n",
     "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
+    "- [Chaining runnables](/docs/how_to/sequence/)\n",
+    "- [Binding runtime arguments](/docs/how_to/binding/)\n",
+    "\n",
+    ":::\n",
+    "\n",
     "Sometimes you may want to experiment with, or even expose to the end user, multiple different ways of doing things within your chains.\n",
     "This can include tweaking parameters such as temperature or even swapping out one model for another.\n",
     "In order to make this experience as easy as possible, we have defined two methods.\n",
     "\n",
     "- A `configurable_fields` method. This lets you configure particular fields of a runnable.\n",
     "  - This is related to the [`.bind`](/docs/how_to/binding) method on runnables, but allows you to specify parameters for a given step in a chain at runtime rather than specifying them beforehand.\n",
-    "- A `configurable_alternatives` method. With this method, you can list out alternatives for any particular runnable that can be set during runtime, and swap them for those specified alternatives.\n",
-    "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
-    "- [Chaining runnables](/docs/how_to/sequence/)\n",
-    "- [Binding runtime arguments](/docs/how_to/binding/)\n",
-    "`} />\n",
-    "```"
+    "- A `configurable_alternatives` method. With this method, you can list out alternatives for any particular runnable that can be set during runtime, and swap them for those specified alternatives."
    ]
   },
   {
@@ -90,7 +89,7 @@
     }
    ],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_core.runnables import ConfigurableField\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
@@ -313,8 +312,8 @@
     }
    ],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "from langchain_core.runnables import ConfigurableField\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
@@ -613,7 +612,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/contextual_compression.ipynb

@@ -12,13 +12,12 @@
     "Contextual compression is meant to fix this. The idea is simple: instead of immediately returning retrieved documents as-is, you can compress them using the context of the given query, so that only the relevant information is returned. “Compressing” here refers to both compressing the contents of an individual document and filtering out documents wholesale.\n",
     "\n",
     "To use the Contextual Compression Retriever, you'll need:\n",
+    "\n",
     "- a base retriever\n",
     "- a Document Compressor\n",
     "\n",
     "The Contextual Compression Retriever passes queries to the base retriever, takes the initial documents and passes them through the Document Compressor. The Document Compressor takes a list of documents and shortens it by reducing the contents of documents or dropping documents altogether.\n",
     "\n",
-    "![](https://drive.google.com/uc?id=1CtNgWODXZudxAWSRiWgSGEoTNrUFT98v)\n",
-    "\n",
     "## Get started"
    ]
   },
@@ -51,8 +50,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "2b0be066",
+   "execution_count": 2,
+   "id": "25c26947-958d-4219-8ca0-daa3a51bd344",
    "metadata": {},
    "outputs": [
     {
@@ -123,14 +122,12 @@
     "from langchain_openai import OpenAIEmbeddings\n",
     "from langchain_text_splitters import CharacterTextSplitter\n",
     "\n",
-    "documents = TextLoader(\"../../state_of_the_union.txt\").load()\n",
+    "documents = TextLoader(\"state_of_the_union.txt\").load()\n",
     "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)\n",
     "texts = text_splitter.split_documents(documents)\n",
     "retriever = FAISS.from_documents(texts, OpenAIEmbeddings()).as_retriever()\n",
     "\n",
-    "docs = retriever.get_relevant_documents(\n",
-    "    \"What did the president say about Ketanji Brown Jackson\"\n",
-    ")\n",
+    "docs = retriever.invoke(\"What did the president say about Ketanji Brown Jackson\")\n",
     "pretty_print_docs(docs)"
    ]
   },
@@ -145,24 +142,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "f08d19e6",
+   "execution_count": 3,
+   "id": "d83e3c63-bcde-43e9-998e-35bf2ebef49b",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n",
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n",
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n",
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -184,7 +167,7 @@
     "    base_compressor=compressor, base_retriever=retriever\n",
     ")\n",
     "\n",
-    "compressed_docs = compression_retriever.get_relevant_documents(\n",
+    "compressed_docs = compression_retriever.invoke(\n",
     "    \"What did the president say about Ketanji Jackson Brown\"\n",
     ")\n",
     "pretty_print_docs(compressed_docs)"
@@ -204,23 +187,9 @@
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "6fa3ec79",
+   "id": "39b13654-01d9-4006-9550-5f3e77cb4f23",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n",
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n",
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n",
-      "/Users/harrisonchase/workplace/langchain/libs/langchain/langchain/chains/llm.py:316: UserWarning: The predict_and_parse method is deprecated, instead pass an output parser directly to LLMChain.\n",
-      "  warnings.warn(\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -245,7 +214,7 @@
     "    base_compressor=_filter, base_retriever=retriever\n",
     ")\n",
     "\n",
-    "compressed_docs = compression_retriever.get_relevant_documents(\n",
+    "compressed_docs = compression_retriever.invoke(\n",
     "    \"What did the president say about Ketanji Jackson Brown\"\n",
     ")\n",
     "pretty_print_docs(compressed_docs)"
@@ -264,7 +233,7 @@
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "e84aceea",
+   "id": "ee8d9486-db9a-4e24-aa11-ae40f34cc908",
    "metadata": {},
    "outputs": [
     {
@@ -293,21 +262,7 @@
       "\n",
       "We’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. \n",
       "\n",
-      "We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.\n",
-      "----------------------------------------------------------------------------------------------------\n",
-      "Document 3:\n",
-      "\n",
-      "And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. \n",
-      "\n",
-      "As I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. \n",
-      "\n",
-      "While it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. \n",
-      "\n",
-      "And soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. \n",
-      "\n",
-      "So tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together.  \n",
-      "\n",
-      "First, beat the opioid epidemic.\n"
+      "We’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.\n"
      ]
     }
    ],
@@ -321,7 +276,7 @@
     "    base_compressor=embeddings_filter, base_retriever=retriever\n",
     ")\n",
     "\n",
-    "compressed_docs = compression_retriever.get_relevant_documents(\n",
+    "compressed_docs = compression_retriever.invoke(\n",
     "    \"What did the president say about Ketanji Jackson Brown\"\n",
     ")\n",
     "pretty_print_docs(compressed_docs)"
@@ -340,7 +295,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "id": "617a1756",
    "metadata": {},
    "outputs": [],
@@ -359,8 +314,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "c715228a",
+   "execution_count": 8,
+   "id": "40b9c1db-7ac2-4257-935a-b107da50bb43",
    "metadata": {},
    "outputs": [
     {
@@ -398,7 +353,7 @@
     "    base_compressor=pipeline_compressor, base_retriever=retriever\n",
     ")\n",
     "\n",
-    "compressed_docs = compression_retriever.get_relevant_documents(\n",
+    "compressed_docs = compression_retriever.invoke(\n",
     "    \"What did the president say about Ketanji Jackson Brown\"\n",
     ")\n",
     "pretty_print_docs(compressed_docs)"
@@ -429,7 +384,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/custom_callbacks.ipynb

@@ -0,0 +1,141 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# How to create custom callback handlers\n",
+    "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "\n",
+    "- [Callbacks](/docs/concepts/#callbacks)\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "LangChain has some built-in callback handlers, but you will often want to create your own handlers with custom logic.\n",
+    "\n",
+    "To create a custom callback handler, we need to determine the [event(s)](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.base.BaseCallbackHandler.html#langchain-core-callbacks-base-basecallbackhandler) we want our callback handler to handle as well as what we want our callback handler to do when the event is triggered. Then all we need to do is attach the callback handler to the object, for example via [the constructor](/docs/how_to/callbacks_constructor) or [at runtime](/docs/how_to/callbacks_runtime).\n",
+    "\n",
+    "In the example below, we'll implement streaming with a custom handler.\n",
+    "\n",
+    "In our custom callback handler `MyCustomHandler`, we implement the `on_llm_new_token` handler to print the token we have just received. We then attach our custom handler to the model object as a constructor callback."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | output: false\n",
+    "# | echo: false\n",
+    "\n",
+    "%pip install -qU langchain langchain_anthropic\n",
+    "\n",
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"ANTHROPIC_API_KEY\"] = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "My custom handler, token: Here\n",
+      "My custom handler, token: 's\n",
+      "My custom handler, token:  a\n",
+      "My custom handler, token:  bear\n",
+      "My custom handler, token:  joke\n",
+      "My custom handler, token:  for\n",
+      "My custom handler, token:  you\n",
+      "My custom handler, token: :\n",
+      "My custom handler, token: \n",
+      "\n",
+      "Why\n",
+      "My custom handler, token:  di\n",
+      "My custom handler, token: d the\n",
+      "My custom handler, token:  bear\n",
+      "My custom handler, token:  dissol\n",
+      "My custom handler, token: ve\n",
+      "My custom handler, token:  in\n",
+      "My custom handler, token:  water\n",
+      "My custom handler, token: ?\n",
+      "My custom handler, token: \n",
+      "Because\n",
+      "My custom handler, token:  it\n",
+      "My custom handler, token:  was\n",
+      "My custom handler, token:  a\n",
+      "My custom handler, token:  polar\n",
+      "My custom handler, token:  bear\n",
+      "My custom handler, token: !\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.callbacks import BaseCallbackHandler\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "\n",
+    "\n",
+    "class MyCustomHandler(BaseCallbackHandler):\n",
+    "    def on_llm_new_token(self, token: str, **kwargs) -> None:\n",
+    "        print(f\"My custom handler, token: {token}\")\n",
+    "\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages([\"Tell me a joke about {animal}\"])\n",
+    "\n",
+    "# To enable streaming, we pass in `streaming=True` to the ChatModel constructor\n",
+    "# Additionally, we pass in our custom handler as a list to the callbacks parameter\n",
+    "model = ChatAnthropic(\n",
+    "    model=\"claude-3-sonnet-20240229\", streaming=True, callbacks=[MyCustomHandler()]\n",
+    ")\n",
+    "\n",
+    "chain = prompt | model\n",
+    "\n",
+    "response = chain.invoke({\"animal\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can see [this reference page](https://api.python.langchain.com/en/latest/callbacks/langchain_core.callbacks.base.BaseCallbackHandler.html#langchain-core-callbacks-base-basecallbackhandler) for a list of events you can handle. Note that the `handle_chain_*` events run for most LCEL runnables.\n",
+    "\n",
+    "## Next steps\n",
+    "\n",
+    "You've now learned how to create your own custom callback handlers.\n",
+    "\n",
+    "Next, check out the other how-to guides in this section, such as [how to attach callbacks to a runnable](/docs/how_to/callbacks_attach)."
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/how_to/custom_chat_model.ipynb

@@ -7,20 +7,19 @@
    "source": [
     "# How to create a custom chat model class\n",
     "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [Chat models](/docs/concepts/#chat-models)\n",
+    "\n",
+    ":::\n",
+    "\n",
     "In this guide, we'll learn how to create a custom chat model using LangChain abstractions.\n",
     "\n",
     "Wrapping your LLM with the standard [`BaseChatModel`](https://api.python.langchain.com/en/latest/language_models/langchain_core.language_models.chat_models.BaseChatModel.html) interface allow you to use your LLM in existing LangChain programs with minimal code modifications!\n",
     "\n",
     "As an bonus, your LLM will automatically become a LangChain `Runnable` and will benefit from some optimizations out of the box (e.g., batch via a threadpool), async support, the `astream_events` API, etc.\n",
     "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [Chat models](/docs/concepts/#chat-models)\n",
-    "`} />\n",
-    "```\n",
-    "\n",
     "## Inputs and outputs\n",
     "\n",
     "First, we need to talk about **messages**, which are the inputs and outputs of chat models.\n",
@@ -562,7 +561,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/custom_tools.ipynb

@@ -5,35 +5,29 @@
    "id": "5436020b",
    "metadata": {},
    "source": [
-    "# How to create custom Tools\n",
+    "# How to create custom tools\n",
     "\n",
-    "When constructing your own agent, you will need to provide it with a list of Tools that it can use. Besides the actual function that is called, the Tool consists of several components:\n",
+    "When constructing an agent, you will need to provide it with a list of `Tool`s that it can use. Besides the actual function that is called, the Tool consists of several components:\n",
     "\n",
-    "- `name` (str), is required and must be unique within a set of tools provided to an agent\n",
-    "- `description` (str), is optional but recommended, as it is used by an agent to determine tool use\n",
-    "- `args_schema` (Pydantic BaseModel), is optional but recommended, can be used to provide more information (e.g., few-shot examples) or validation for expected parameters.\n",
+    "| Attribute       | Type                      | Description                                                                                                      |\n",
+    "|-----------------|---------------------------|------------------------------------------------------------------------------------------------------------------|\n",
+    "| name          | str                     | Must be unique within a set of tools provided to an LLM or agent.                                           |\n",
+    "| description   | str                     | Describes what the tool does. Used as context by the LLM or agent.                                       |\n",
+    "| args_schema   | Pydantic BaseModel      | Optional but recommended, can be used to provide more information (e.g., few-shot examples) or validation for expected parameters |\n",
+    "| return_direct   | boolean      | Only relevant for agents. When True, after invoking the given tool, the agent will stop and return the result direcly to the user.  |\n",
     "\n",
+    "LangChain provides 3 ways to create tools:\n",
     "\n",
-    "There are multiple ways to define a tool. In this guide, we will walk through how to do for two functions:\n",
+    "1. Using [@tool decorator](https://api.python.langchain.com/en/latest/tools/langchain_core.tools.tool.html#langchain_core.tools.tool) -- the simplest way to define a custom tool.\n",
+    "2. Using [StructuredTool.from_function](https://api.python.langchain.com/en/latest/tools/langchain_core.tools.StructuredTool.html#langchain_core.tools.StructuredTool.from_function) class method -- this is similar to the `@tool` decorator, but allows more configuration and specification of both sync and async implementations.\n",
+    "3. By sub-classing from [BaseTool](https://api.python.langchain.com/en/latest/tools/langchain_core.tools.BaseTool.html) -- This is the most flexible method, it provides the largest degree of control, at the expense of more effort and code.\n",
     "\n",
-    "1. A made up search function that always returns the string \"LangChain\"\n",
-    "2. A multiplier function that will multiply two numbers by eachother\n",
+    "The `@tool` or the `StructuredTool.from_function` class method should be sufficient for most use cases.\n",
     "\n",
-    "The biggest difference here is that the first function only requires one input, while the second one requires multiple. Many agents only work with functions that require single inputs, so it's important to know how to work with those. For the most part, defining these custom tools is the same, but there are some differences."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "id": "1aaba18c",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# Import things that are needed generically\n",
-    "from langchain.pydantic_v1 import BaseModel, Field\n",
-    "from langchain.tools import BaseTool, StructuredTool, tool"
+    ":::{.callout-tip}\n",
+    "\n",
+    "Models will perform better if the tools have well chosen names, descriptions and JSON schemas.\n",
+    ":::"
    ]
   },
   {
@@ -48,56 +42,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "b0ce7de8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@tool\n",
-    "def search(query: str) -> str:\n",
-    "    \"\"\"Look up things online.\"\"\"\n",
-    "    return \"LangChain\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "e889fa34",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "search\n",
-      "search(query: str) -> str - Look up things online.\n",
-      "{'query': {'title': 'Query', 'type': 'string'}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(search.name)\n",
-    "print(search.description)\n",
-    "print(search.args)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "0b9694d9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@tool\n",
-    "def multiply(a: int, b: int) -> int:\n",
-    "    \"\"\"Multiply two numbers.\"\"\"\n",
-    "    return a * b"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "d7f9395b",
+   "execution_count": 1,
+   "id": "cc7005cd-072f-4d37-8453-6297468e5192",
    "metadata": {},
    "outputs": [
     {
@@ -111,11 +57,45 @@
     }
    ],
    "source": [
+    "from langchain_core.tools import tool\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def multiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
+    "\n",
+    "\n",
+    "# Let's inspect some of the attributes associated with the tool.\n",
     "print(multiply.name)\n",
     "print(multiply.description)\n",
     "print(multiply.args)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "96698b67-993a-4c97-b867-333132e1eb14",
+   "metadata": {},
+   "source": [
+    "Or create an **async** implementation, like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "0c0991db-b997-4611-be37-4346e660506b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.tools import tool\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "async def amultiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "98d6eee9",
@@ -126,72 +106,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
-   "id": "dbbf4b6c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class SearchInput(BaseModel):\n",
-    "    query: str = Field(description=\"should be a search query\")\n",
-    "\n",
-    "\n",
-    "@tool(\"search-tool\", args_schema=SearchInput, return_direct=True)\n",
-    "def search(query: str) -> str:\n",
-    "    \"\"\"Look up things online.\"\"\"\n",
-    "    return \"LangChain\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 44,
-   "id": "5950ce32",
+   "execution_count": 3,
+   "id": "9216d03a-f6ea-4216-b7e1-0661823a4c0b",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "search-tool\n",
-      "search-tool(query: str) -> str - Look up things online.\n",
-      "{'query': {'title': 'Query', 'description': 'should be a search query', 'type': 'string'}}\n",
+      "multiplication-tool\n",
+      "multiplication-tool(a: int, b: int) -> int - Multiply two numbers.\n",
+      "{'a': {'title': 'A', 'description': 'first number', 'type': 'integer'}, 'b': {'title': 'B', 'description': 'second number', 'type': 'integer'}}\n",
       "True\n"
      ]
     }
    ],
    "source": [
-    "print(search.name)\n",
-    "print(search.description)\n",
-    "print(search.args)\n",
-    "print(search.return_direct)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9d11e80c",
-   "metadata": {},
-   "source": [
-    "## Subclass BaseTool\n",
-    "\n",
-    "You can also explicitly define a custom tool by subclassing the BaseTool class. This provides maximal control over the tool definition, but is a bit more work."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 45,
-   "id": "1dad8f8e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from typing import Optional, Type\n",
-    "\n",
-    "from langchain.callbacks.manager import (\n",
-    "    AsyncCallbackManagerForToolRun,\n",
-    "    CallbackManagerForToolRun,\n",
-    ")\n",
-    "\n",
-    "\n",
-    "class SearchInput(BaseModel):\n",
-    "    query: str = Field(description=\"should be a search query\")\n",
+    "from langchain.pydantic_v1 import BaseModel, Field\n",
     "\n",
     "\n",
     "class CalculatorInput(BaseModel):\n",
@@ -199,22 +130,145 @@
     "    b: int = Field(description=\"second number\")\n",
     "\n",
     "\n",
-    "class CustomSearchTool(BaseTool):\n",
-    "    name = \"custom_search\"\n",
-    "    description = \"useful for when you need to answer questions about current events\"\n",
-    "    args_schema: Type[BaseModel] = SearchInput\n",
+    "@tool(\"multiplication-tool\", args_schema=CalculatorInput, return_direct=True)\n",
+    "def multiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
     "\n",
-    "    def _run(\n",
-    "        self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None\n",
-    "    ) -> str:\n",
-    "        \"\"\"Use the tool.\"\"\"\n",
-    "        return \"LangChain\"\n",
     "\n",
-    "    async def _arun(\n",
-    "        self, query: str, run_manager: Optional[AsyncCallbackManagerForToolRun] = None\n",
-    "    ) -> str:\n",
-    "        \"\"\"Use the tool asynchronously.\"\"\"\n",
-    "        raise NotImplementedError(\"custom_search does not support async\")\n",
+    "# Let's inspect some of the attributes associated with the tool.\n",
+    "print(multiply.name)\n",
+    "print(multiply.description)\n",
+    "print(multiply.args)\n",
+    "print(multiply.return_direct)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b63fcc3b",
+   "metadata": {},
+   "source": [
+    "## StructuredTool\n",
+    "\n",
+    "The `StrurcturedTool.from_function` class method provides a bit more configurability than the `@tool` decorator, without requiring much additional code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "564fbe6f-11df-402d-b135-ef6ff25e1e63",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6\n",
+      "10\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.tools import StructuredTool\n",
+    "\n",
+    "\n",
+    "def multiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
+    "\n",
+    "\n",
+    "async def amultiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
+    "\n",
+    "\n",
+    "calculator = StructuredTool.from_function(func=multiply, coroutine=amultiply)\n",
+    "\n",
+    "print(calculator.invoke({\"a\": 2, \"b\": 3}))\n",
+    "print(await calculator.ainvoke({\"a\": 2, \"b\": 5}))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26b3712a-b38d-4582-b6e6-bc7cfb1d6680",
+   "metadata": {},
+   "source": [
+    "To configure it:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6bc055d4-1fbe-4db5-8881-9c382eba6b1b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "6\n",
+      "Calculator\n",
+      "Calculator(a: int, b: int) -> int - multiply numbers\n",
+      "{'a': {'title': 'A', 'description': 'first number', 'type': 'integer'}, 'b': {'title': 'B', 'description': 'second number', 'type': 'integer'}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "class CalculatorInput(BaseModel):\n",
+    "    a: int = Field(description=\"first number\")\n",
+    "    b: int = Field(description=\"second number\")\n",
+    "\n",
+    "\n",
+    "def multiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
+    "\n",
+    "\n",
+    "calculator = StructuredTool.from_function(\n",
+    "    func=multiply,\n",
+    "    name=\"Calculator\",\n",
+    "    description=\"multiply numbers\",\n",
+    "    args_schema=CalculatorInput,\n",
+    "    return_direct=True,\n",
+    "    # coroutine= ... <- you can specify an async method if desired as well\n",
+    ")\n",
+    "\n",
+    "print(calculator.invoke({\"a\": 2, \"b\": 3}))\n",
+    "print(calculator.name)\n",
+    "print(calculator.description)\n",
+    "print(calculator.args)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b840074b-9c10-4ca0-aed8-626c52b2398f",
+   "metadata": {},
+   "source": [
+    "## Subclass BaseTool\n",
+    "\n",
+    "You can define a custom tool by sub-classing from `BaseTool`. This provides maximal control over the tool definition, but requires writing more code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "1dad8f8e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Optional, Type\n",
+    "\n",
+    "from langchain.pydantic_v1 import BaseModel\n",
+    "from langchain_core.callbacks import (\n",
+    "    AsyncCallbackManagerForToolRun,\n",
+    "    CallbackManagerForToolRun,\n",
+    ")\n",
+    "from langchain_core.tools import BaseTool\n",
+    "\n",
+    "\n",
+    "class CalculatorInput(BaseModel):\n",
+    "    a: int = Field(description=\"first number\")\n",
+    "    b: int = Field(description=\"second number\")\n",
     "\n",
     "\n",
     "class CustomCalculatorTool(BaseTool):\n",
@@ -236,35 +290,17 @@
     "        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,\n",
     "    ) -> str:\n",
     "        \"\"\"Use the tool asynchronously.\"\"\"\n",
-    "        raise NotImplementedError(\"Calculator does not support async\")"
+    "        # If the calculation is cheap, you can just delegate to the sync implementation\n",
+    "        # as shown below.\n",
+    "        # If the sync calculation is expensive, you should delete the entire _arun method.\n",
+    "        # LangChain will automatically provide a better implementation that will\n",
+    "        # kick off the task in a thread to make sure it doesn't block other async code.\n",
+    "        return self._run(a, b, run_manager=run_manager.get_sync())"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
-   "id": "89933e27",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "custom_search\n",
-      "useful for when you need to answer questions about current events\n",
-      "{'query': {'title': 'Query', 'description': 'should be a search query', 'type': 'string'}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "search = CustomSearchTool()\n",
-    "print(search.name)\n",
-    "print(search.description)\n",
-    "print(search.args)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 7,
    "id": "bb551c33",
    "metadata": {},
    "outputs": [
@@ -275,7 +311,9 @@
       "Calculator\n",
       "useful for when you need to answer questions about math\n",
       "{'a': {'title': 'A', 'description': 'first number', 'type': 'integer'}, 'b': {'title': 'B', 'description': 'second number', 'type': 'integer'}}\n",
-      "True\n"
+      "True\n",
+      "6\n",
+      "6\n"
      ]
     }
    ],
@@ -284,80 +322,50 @@
     "print(multiply.name)\n",
     "print(multiply.description)\n",
     "print(multiply.args)\n",
-    "print(multiply.return_direct)"
+    "print(multiply.return_direct)\n",
+    "\n",
+    "print(multiply.invoke({\"a\": 2, \"b\": 3}))\n",
+    "print(await multiply.ainvoke({\"a\": 2, \"b\": 3}))"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "b63fcc3b",
+   "id": "97aba6cc-4bdf-4fab-aff3-d89e7d9c3a09",
    "metadata": {},
    "source": [
-    "## StructuredTool dataclass\n",
+    "## How to create async tools\n",
     "\n",
-    "You can also use a `StructuredTool` dataclass. This methods is a mix between the previous two. It's more convenient than inheriting from the BaseTool class, but provides more functionality than just using a decorator."
+    "LangChain Tools implement the [Runnable interface 🏃](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html).\n",
+    "\n",
+    "All Runnables expose the `invoke` and `ainvoke` methods (as well as other methods like `batch`, `abatch`, `astream` etc).\n",
+    "\n",
+    "So even if you only provide an `sync` implementation of a tool, you could still use the `ainvoke` interface, but there\n",
+    "are some important things to know:\n",
+    "\n",
+    "* LangChain's by default provides an async implementation that assumes that the function is expensive to compute, so it'll delegate execution to another thread.\n",
+    "* If you're working in an async codebase, you should create async tools rather than sync tools, to avoid incuring a small overhead due to that thread.\n",
+    "* If you need both sync and async implementations, use `StructuredTool.from_function` or sub-class from `BaseTool`.\n",
+    "* If implementing both sync and async, and the sync code is fast to run, override the default LangChain async implementation and simply call the sync code.\n",
+    "* You CANNOT and SHOULD NOT use the sync `invoke` with an `async` tool."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
-   "id": "56ff7670",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "def search_function(query: str):\n",
-    "    return \"LangChain\"\n",
-    "\n",
-    "\n",
-    "search = StructuredTool.from_function(\n",
-    "    func=search_function,\n",
-    "    name=\"Search\",\n",
-    "    description=\"useful for when you need to answer questions about current events\",\n",
-    "    # coroutine= ... <- you can specify an async method if desired as well\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "id": "d3fd3896",
+   "execution_count": 8,
+   "id": "6615cb77-fd4c-4676-8965-f92cc71d4944",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Search\n",
-      "Search(query: str) - useful for when you need to answer questions about current events\n",
-      "{'query': {'title': 'Query', 'type': 'string'}}\n"
+      "6\n",
+      "10\n"
      ]
     }
    ],
    "source": [
-    "print(search.name)\n",
-    "print(search.description)\n",
-    "print(search.args)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e9b560f7",
-   "metadata": {},
-   "source": [
-    "You can also define a custom `args_schema` to provide more information about inputs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "id": "712c1967",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class CalculatorInput(BaseModel):\n",
-    "    a: int = Field(description=\"first number\")\n",
-    "    b: int = Field(description=\"second number\")\n",
+    "from langchain_core.tools import StructuredTool\n",
     "\n",
     "\n",
     "def multiply(a: int, b: int) -> int:\n",
@@ -365,185 +373,223 @@
     "    return a * b\n",
     "\n",
     "\n",
-    "calculator = StructuredTool.from_function(\n",
-    "    func=multiply,\n",
-    "    name=\"Calculator\",\n",
-    "    description=\"multiply numbers\",\n",
-    "    args_schema=CalculatorInput,\n",
-    "    return_direct=True,\n",
-    "    # coroutine= ... <- you can specify an async method if desired as well\n",
-    ")"
+    "calculator = StructuredTool.from_function(func=multiply)\n",
+    "\n",
+    "print(calculator.invoke({\"a\": 2, \"b\": 3}))\n",
+    "print(\n",
+    "    await calculator.ainvoke({\"a\": 2, \"b\": 5})\n",
+    ")  # Uses default LangChain async implementation incurs small overhead"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
-   "id": "f634081e",
+   "execution_count": 9,
+   "id": "bb2af583-eadd-41f4-a645-bf8748bd3dcd",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Calculator\n",
-      "Calculator(a: int, b: int) -> int - multiply numbers\n",
-      "{'a': {'title': 'A', 'description': 'first number', 'type': 'integer'}, 'b': {'title': 'B', 'description': 'second number', 'type': 'integer'}}\n"
+      "6\n",
+      "10\n"
      ]
     }
    ],
    "source": [
-    "print(calculator.name)\n",
-    "print(calculator.description)\n",
-    "print(calculator.args)"
+    "from langchain_core.tools import StructuredTool\n",
+    "\n",
+    "\n",
+    "def multiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
+    "\n",
+    "\n",
+    "async def amultiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
+    "\n",
+    "\n",
+    "calculator = StructuredTool.from_function(func=multiply, coroutine=amultiply)\n",
+    "\n",
+    "print(calculator.invoke({\"a\": 2, \"b\": 3}))\n",
+    "print(\n",
+    "    await calculator.ainvoke({\"a\": 2, \"b\": 5})\n",
+    ")  # Uses use provided amultiply without additional overhead"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "f1da459d",
+   "id": "c80ffdaa-e4ba-4a70-8500-32bf4f60cc1a",
+   "metadata": {},
+   "source": [
+    "You should not and cannot use `.invoke` when providing only an async definition."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "4ad0932c-8610-4278-8c57-f9218f654c8a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Raised not implemented error. You should not be doing this.\n"
+     ]
+    }
+   ],
+   "source": [
+    "@tool\n",
+    "async def multiply(a: int, b: int) -> int:\n",
+    "    \"\"\"Multiply two numbers.\"\"\"\n",
+    "    return a * b\n",
+    "\n",
+    "\n",
+    "try:\n",
+    "    multiply.invoke({\"a\": 2, \"b\": 3})\n",
+    "except NotImplementedError:\n",
+    "    print(\"Raised not implemented error. You should not be doing this.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9c746a7-88d7-4afb-bcb8-0e98b891e8b6",
    "metadata": {},
    "source": [
     "## Handling Tool Errors \n",
-    "When a tool encounters an error and the exception is not caught, the agent will stop executing. If you want the agent to continue execution, you can raise a `ToolException` and set `handle_tool_error` accordingly. \n",
     "\n",
-    "When `ToolException` is thrown, the agent will not stop working, but will handle the exception according to the `handle_tool_error` variable of the tool, and the processing result will be returned to the agent as observation, and printed in red.\n",
+    "If you're using tools with agents, you will likely need an error handling strategy, so the agent can recover from the error and continue execution.\n",
     "\n",
-    "You can set `handle_tool_error` to `True`, set it a unified string value, or set it as a function. If it's set as a function, the function should take a `ToolException` as a parameter and return a `str` value.\n",
+    "A simple strategy is to throw a `ToolException` from inside the tool and specify an error handler using `handle_tool_error`. \n",
+    "\n",
+    "When the error handler is specified, the exception will be caught and the error handler will decide which output to return from the tool.\n",
+    "\n",
+    "You can set `handle_tool_error` to `True`, a string value, or a function. If it's a function, the function should take a `ToolException` as a parameter and return a value.\n",
     "\n",
     "Please note that only raising a `ToolException` won't be effective. You need to first set the `handle_tool_error` of the tool because its default value is `False`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "f8bf4668",
+   "execution_count": 11,
+   "id": "7094c0e8-6192-4870-a942-aad5b5ae48fd",
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain_core.tools import ToolException\n",
     "\n",
     "\n",
-    "def search_tool1(s: str):\n",
-    "    raise ToolException(\"The search tool1 is not available.\")"
+    "def get_weather(city: str) -> int:\n",
+    "    \"\"\"Get weather for the given city.\"\"\"\n",
+    "    raise ToolException(f\"Error: There is no city by the name of {city}.\")"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "7fb56757",
+   "id": "9d93b217-1d44-4d31-8956-db9ea680ff4f",
    "metadata": {},
    "source": [
-    "First, let's see what happens if we don't set `handle_tool_error` - it will error."
+    "Here's an example with the default `handle_tool_error=True` behavior."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
-   "id": "f3dfbcb0",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ToolException",
-     "evalue": "The search tool1 is not available.",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mToolException\u001b[0m                             Traceback (most recent call last)",
-      "Cell \u001b[0;32mIn[58], line 7\u001b[0m\n\u001b[1;32m      1\u001b[0m search \u001b[38;5;241m=\u001b[39m StructuredTool\u001b[38;5;241m.\u001b[39mfrom_function(\n\u001b[1;32m      2\u001b[0m     func\u001b[38;5;241m=\u001b[39msearch_tool1,\n\u001b[1;32m      3\u001b[0m     name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSearch_tool1\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m      4\u001b[0m     description\u001b[38;5;241m=\u001b[39mdescription,\n\u001b[1;32m      5\u001b[0m )\n\u001b[0;32m----> 7\u001b[0m \u001b[43msearch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mtest\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[0;32m~/workplace/langchain/libs/core/langchain_core/tools.py:344\u001b[0m, in \u001b[0;36mBaseTool.run\u001b[0;34m(self, tool_input, verbose, start_color, color, callbacks, tags, metadata, run_name, **kwargs)\u001b[0m\n\u001b[1;32m    342\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandle_tool_error:\n\u001b[1;32m    343\u001b[0m     run_manager\u001b[38;5;241m.\u001b[39mon_tool_error(e)\n\u001b[0;32m--> 344\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m e\n\u001b[1;32m    345\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandle_tool_error, \u001b[38;5;28mbool\u001b[39m):\n\u001b[1;32m    346\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m e\u001b[38;5;241m.\u001b[39margs:\n",
-      "File \u001b[0;32m~/workplace/langchain/libs/core/langchain_core/tools.py:337\u001b[0m, in \u001b[0;36mBaseTool.run\u001b[0;34m(self, tool_input, verbose, start_color, color, callbacks, tags, metadata, run_name, **kwargs)\u001b[0m\n\u001b[1;32m    334\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m    335\u001b[0m     tool_args, tool_kwargs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_to_args_and_kwargs(parsed_input)\n\u001b[1;32m    336\u001b[0m     observation \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m--> 337\u001b[0m         \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_run\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtool_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrun_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_manager\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mtool_kwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    338\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m new_arg_supported\n\u001b[1;32m    339\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_run(\u001b[38;5;241m*\u001b[39mtool_args, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mtool_kwargs)\n\u001b[1;32m    340\u001b[0m     )\n\u001b[1;32m    341\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m ToolException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    342\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandle_tool_error:\n",
-      "File \u001b[0;32m~/workplace/langchain/libs/core/langchain_core/tools.py:631\u001b[0m, in \u001b[0;36mStructuredTool._run\u001b[0;34m(self, run_manager, *args, **kwargs)\u001b[0m\n\u001b[1;32m    622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc:\n\u001b[1;32m    623\u001b[0m     new_argument_supported \u001b[38;5;241m=\u001b[39m signature(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc)\u001b[38;5;241m.\u001b[39mparameters\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcallbacks\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    624\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m (\n\u001b[1;32m    625\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc(\n\u001b[1;32m    626\u001b[0m             \u001b[38;5;241m*\u001b[39margs,\n\u001b[1;32m    627\u001b[0m             callbacks\u001b[38;5;241m=\u001b[39mrun_manager\u001b[38;5;241m.\u001b[39mget_child() \u001b[38;5;28;01mif\u001b[39;00m run_manager \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m    628\u001b[0m             \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs,\n\u001b[1;32m    629\u001b[0m         )\n\u001b[1;32m    630\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m new_argument_supported\n\u001b[0;32m--> 631\u001b[0m         \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    632\u001b[0m     )\n\u001b[1;32m    633\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTool does not support sync\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
-      "Cell \u001b[0;32mIn[55], line 5\u001b[0m, in \u001b[0;36msearch_tool1\u001b[0;34m(s)\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msearch_tool1\u001b[39m(s: \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m----> 5\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m ToolException(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe search tool1 is not available.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
-      "\u001b[0;31mToolException\u001b[0m: The search tool1 is not available."
-     ]
-    }
-   ],
-   "source": [
-    "search = StructuredTool.from_function(\n",
-    "    func=search_tool1,\n",
-    "    name=\"Search_tool1\",\n",
-    "    description=\"A bad tool\",\n",
-    ")\n",
-    "\n",
-    "search.run(\"test\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d2475acd",
-   "metadata": {},
-   "source": [
-    "Now, let's set `handle_tool_error` to be True"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 59,
-   "id": "ab81e0f0",
+   "execution_count": 12,
+   "id": "b4d22022-b105-4ccc-a15b-412cb9ea3097",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'The search tool1 is not available.'"
+       "'Error: There is no city by the name of foobar.'"
       ]
      },
-     "execution_count": 59,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "search = StructuredTool.from_function(\n",
-    "    func=search_tool1,\n",
-    "    name=\"Search_tool1\",\n",
-    "    description=\"A bad tool\",\n",
+    "get_weather_tool = StructuredTool.from_function(\n",
+    "    func=get_weather,\n",
     "    handle_tool_error=True,\n",
     ")\n",
     "\n",
-    "search.run(\"test\")"
+    "get_weather_tool.invoke({\"city\": \"foobar\"})"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "dafbbcbe",
+   "id": "f91d6dc0-3271-4adc-a155-21f2e62ffa56",
    "metadata": {},
    "source": [
-    "We can also define a custom way to handle the tool error"
+    "We can set `handle_tool_error` to a string that will always be returned."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
-   "id": "ad16fbcf",
+   "execution_count": 13,
+   "id": "3fad1728-d367-4e1b-9b54-3172981271cf",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'The following errors occurred during tool execution:The search tool1 is not available.Please try another tool.'"
+       "\"There is no such city, but it's probably above 0K there!\""
       ]
      },
-     "execution_count": 60,
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "get_weather_tool = StructuredTool.from_function(\n",
+    "    func=get_weather,\n",
+    "    handle_tool_error=\"There is no such city, but it's probably above 0K there!\",\n",
+    ")\n",
+    "\n",
+    "get_weather_tool.invoke({\"city\": \"foobar\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0a640c1-e08f-4413-83b6-f599f304935f",
+   "metadata": {},
+   "source": [
+    "Handling the error using a function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "ebfe7c1f-318d-4e58-99e1-f31e69473c46",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The following errors occurred during tool execution: `Error: There is no city by the name of foobar.`'"
+      ]
+     },
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "def _handle_error(error: ToolException) -> str:\n",
-    "    return (\n",
-    "        \"The following errors occurred during tool execution:\"\n",
-    "        + error.args[0]\n",
-    "        + \"Please try another tool.\"\n",
-    "    )\n",
+    "    return f\"The following errors occurred during tool execution: `{error.args[0]}`\"\n",
     "\n",
     "\n",
-    "search = StructuredTool.from_function(\n",
-    "    func=search_tool1,\n",
-    "    name=\"Search_tool1\",\n",
-    "    description=\"A bad tool\",\n",
+    "get_weather_tool = StructuredTool.from_function(\n",
+    "    func=get_weather,\n",
     "    handle_tool_error=_handle_error,\n",
     ")\n",
     "\n",
-    "search.run(\"test\")"
+    "get_weather_tool.invoke({\"city\": \"foobar\"})"
    ]
   }
  ],
@@ -563,7 +609,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.11.4"
   },
   "vscode": {
    "interpreter": {

docs/docs/how_to/debugging.ipynb

@@ -12,7 +12,7 @@
     "\n",
     "- Verbose Mode: This adds print statements for \"important\" events in your chain.\n",
     "- Debug Mode: This add logging statements for ALL events in your chain.\n",
-    "- LangSmith Tracing: This logs events to [LangSmith](/docs/langsmith/) to allow for visualization there.\n",
+    "- LangSmith Tracing: This logs events to [LangSmith](https://docs.smith.langchain.com/) to allow for visualization there.\n",
     "\n",
     "|                        | Verbose Mode | Debug Mode | LangSmith Tracing |\n",
     "|------------------------|--------------|------------|-------------------|\n",

docs/docs/how_to/document_loader_pdf.ipynb

@@ -463,7 +463,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.docstore.document import Document\n",
+    "from langchain_core.documents import Document\n",
     "\n",
     "cur_idx = -1\n",
     "semantic_snippets = []\n",

docs/docs/how_to/dynamic_chain.ipynb

@@ -0,0 +1,190 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "50d57bf2-7104-4570-b3e5-90fd71e1bea1",
+   "metadata": {},
+   "source": [
+    "# How to create a dynamic (self-constructing) chain\n",
+    "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following:\n",
+    "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
+    "- [How to turn any function into a runnable](/docs/how_to/functions)\n",
+    "\n",
+    ":::\n",
+    "\n",
+    "Sometimes we want to construct parts of a chain at runtime, depending on the chain inputs ([routing](/docs/how_to/routing/) is the most common example of this). We can create dynamic chains like this using a very useful property of RunnableLambda's, which is that if a RunnableLambda returns a Runnable, that Runnable is itself invoked. Let's see an example.\n",
+    "\n",
+    "```{=mdx}\n",
+    "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
+    "\n",
+    "<ChatModelTabs\n",
+    "  customVarName=\"llm\"\n",
+    "/>\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "406bffc2-86d0-4cb9-9262-5c1e3442397a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | echo: false\n",
+    "\n",
+    "from langchain_anthropic import ChatAnthropic\n",
+    "\n",
+    "llm = ChatAnthropic(model=\"claude-3-sonnet-20240229\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "0ae6692b-983e-40b8-aa2a-6c078d945b9e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"According to the context provided, Egypt's population in 2024 is estimated to be about 111 million.\""
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.runnables import Runnable, RunnablePassthrough, chain\n",
+    "\n",
+    "contextualize_instructions = \"\"\"Convert the latest user question into a standalone question given the chat history. Don't answer the question, return the question and nothing else (no descriptive text).\"\"\"\n",
+    "contextualize_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", contextualize_instructions),\n",
+    "        (\"placeholder\", \"{chat_history}\"),\n",
+    "        (\"human\", \"{question}\"),\n",
+    "    ]\n",
+    ")\n",
+    "contextualize_question = contextualize_prompt | llm | StrOutputParser()\n",
+    "\n",
+    "qa_instructions = (\n",
+    "    \"\"\"Answer the user question given the following context:\\n\\n{context}.\"\"\"\n",
+    ")\n",
+    "qa_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", qa_instructions), (\"human\", \"{question}\")]\n",
+    ")\n",
+    "\n",
+    "\n",
+    "@chain\n",
+    "def contextualize_if_needed(input_: dict) -> Runnable:\n",
+    "    if input_.get(\"chat_history\"):\n",
+    "        # NOTE: This is returning another Runnable, not an actual output.\n",
+    "        return contextualize_question\n",
+    "    else:\n",
+    "        return RunnablePassthrough()\n",
+    "\n",
+    "\n",
+    "@chain\n",
+    "def fake_retriever(input_: dict) -> str:\n",
+    "    return \"egypt's population in 2024 is about 111 million\"\n",
+    "\n",
+    "\n",
+    "full_chain = (\n",
+    "    RunnablePassthrough.assign(question=contextualize_if_needed).assign(\n",
+    "        context=fake_retriever\n",
+    "    )\n",
+    "    | qa_prompt\n",
+    "    | llm\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "full_chain.invoke(\n",
+    "    {\n",
+    "        \"question\": \"what about egypt\",\n",
+    "        \"chat_history\": [\n",
+    "            (\"human\", \"what's the population of indonesia\"),\n",
+    "            (\"ai\", \"about 276 million\"),\n",
+    "        ],\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5076ddb4-4a99-47ad-b549-8ac27ca3e2c6",
+   "metadata": {},
+   "source": [
+    "The key here is that `contextualize_if_needed` returns another Runnable and not an actual output. This returned Runnable is itself run when the full chain is executed.\n",
+    "\n",
+    "Looking at the trace we can see that, since we passed in chat_history, we executed the contextualize_question chain as part of the full chain: https://smith.langchain.com/public/9e0ae34c-4082-4f3f-beed-34a2a2f4c991/r"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4fe6ca44-a643-4859-a290-be68403f51f0",
+   "metadata": {},
+   "source": [
+    "Note that the streaming, batching, etc. capabilities of the returned Runnable are all preserved"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6def37fa-5105-4090-9b07-77cb488ecd9c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "What\n",
+      " is\n",
+      " the\n",
+      " population\n",
+      " of\n",
+      " Egypt\n",
+      "?\n"
+     ]
+    }
+   ],
+   "source": [
+    "for chunk in contextualize_if_needed.stream(\n",
+    "    {\n",
+    "        \"question\": \"what about egypt\",\n",
+    "        \"chat_history\": [\n",
+    "            (\"human\", \"what's the population of indonesia\"),\n",
+    "            (\"ai\", \"about 276 million\"),\n",
+    "        ],\n",
+    "    }\n",
+    "):\n",
+    "    print(chunk)"
+   ]
+  }
+ ],
+ "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/embed_text.mdx

@@ -75,6 +75,31 @@ 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,13 +4,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# How to create an Ensemble Retriever\n",
+    "# How to combine results from multiple retrievers\n",
     "\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",
+    "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",
     "\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."
+    "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)."
    ]
   },
   {
@@ -24,22 +28,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 3,
    "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"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
     "doc_list_1 = [\n",
     "    \"I like apples\",\n",
     "    \"I like oranges\",\n",
@@ -71,19 +68,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[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})]"
+       "[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})]"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -99,24 +96,17 @@
    "source": [
     "## Runtime Configuration\n",
     "\n",
-    "We can also configure the retrievers at runtime. In order to do this, we need to mark the fields as configurable"
+    "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:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.runnables import ConfigurableField"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 5,
    "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",
@@ -125,15 +115,8 @@
     "        name=\"Search Kwargs\",\n",
     "        description=\"The search kwargs to use\",\n",
     "    )\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    ")\n",
+    "\n",
     "ensemble_retriever = EnsembleRetriever(\n",
     "    retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5]\n",
     ")"
@@ -141,9 +124,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "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"
+    }
+   ],
    "source": [
     "config = {\"configurable\": {\"search_kwargs_faiss\": {\"k\": 1}}}\n",
     "docs = ensemble_retriever.invoke(\"apples\", config=config)\n",
@@ -181,7 +177,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/example_selectors.ipynb

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

docs/docs/how_to/example_selectors_length_based.ipynb

@@ -17,8 +17,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import FewShotPromptTemplate, PromptTemplate\n",
-    "from langchain.prompts.example_selector import LengthBasedExampleSelector\n",
+    "from langchain_core.example_selectors import LengthBasedExampleSelector\n",
+    "from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate\n",
     "\n",
     "# Examples of a pretend task of creating antonyms.\n",
     "examples = [\n",

docs/docs/how_to/example_selectors_mmr.ipynb

@@ -17,12 +17,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import FewShotPromptTemplate, PromptTemplate\n",
-    "from langchain.prompts.example_selector import (\n",
+    "from langchain_community.vectorstores import FAISS\n",
+    "from langchain_core.example_selectors import (\n",
     "    MaxMarginalRelevanceExampleSelector,\n",
     "    SemanticSimilarityExampleSelector,\n",
     ")\n",
-    "from langchain_community.vectorstores import FAISS\n",
+    "from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "example_prompt = PromptTemplate(\n",

docs/docs/how_to/example_selectors_ngram.ipynb

@@ -19,8 +19,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import FewShotPromptTemplate, PromptTemplate\n",
-    "from langchain.prompts.example_selector.ngram_overlap import NGramOverlapExampleSelector\n",
+    "from langchain_community.example_selectors import NGramOverlapExampleSelector\n",
+    "from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate\n",
     "\n",
     "example_prompt = PromptTemplate(\n",
     "    input_variables=[\"input\", \"output\"],\n",

docs/docs/how_to/example_selectors_similarity.ipynb

@@ -17,9 +17,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import FewShotPromptTemplate, PromptTemplate\n",
-    "from langchain.prompts.example_selector import SemanticSimilarityExampleSelector\n",
     "from langchain_chroma import Chroma\n",
+    "from langchain_core.example_selectors import SemanticSimilarityExampleSelector\n",
+    "from langchain_core.prompts import FewShotPromptTemplate, PromptTemplate\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "example_prompt = PromptTemplate(\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 peron's eyes if known\"\n",
+    "        ..., description=\"The color of the person's hair if known\"\n",
     "    )\n",
     "    height_in_meters: Optional[str] = Field(..., description=\"Height in METERs\")\n",
     "\n",

docs/docs/how_to/extraction_parse.ipynb

@@ -69,7 +69,7 @@
    "source": [
     "from typing import List, Optional\n",
     "\n",
-    "from langchain.output_parsers import PydanticOutputParser\n",
+    "from langchain_core.output_parsers import PydanticOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
     "from langchain_core.pydantic_v1 import BaseModel, Field, validator\n",
     "\n",

docs/docs/how_to/fallbacks.ipynb

@@ -1,11 +1,21 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "018f3868-e60d-4db6-a1c6-c6633c66b1f4",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "keywords: [LCEL, fallbacks]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "19c9cbd6",
    "metadata": {},
    "source": [
-    "# Fallbacks\n",
+    "# How to add fallbacks to a runnable\n",
     "\n",
     "When working with language models, you may often encounter issues from the underlying APIs, whether these be rate limiting or downtime. Therefore, as you go to move your LLM applications into production it becomes more and more important to safeguard against these. That's why we've introduced the concept of fallbacks. \n",
     "\n",
@@ -43,7 +53,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_community.chat_models import ChatAnthropic\n",
+    "from langchain_anthropic import ChatAnthropic\n",
     "from langchain_openai import ChatOpenAI"
    ]
   },
@@ -80,8 +90,8 @@
    "outputs": [],
    "source": [
     "# Note that we set max_retries = 0 to avoid retrying on RateLimits, etc\n",
-    "openai_llm = ChatOpenAI(max_retries=0)\n",
-    "anthropic_llm = ChatAnthropic()\n",
+    "openai_llm = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", max_retries=0)\n",
+    "anthropic_llm = ChatAnthropic(model=\"claude-3-haiku-20240307\")\n",
     "llm = openai_llm.with_fallbacks([anthropic_llm])"
    ]
   },
@@ -447,7 +457,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/few_shot_examples.ipynb

@@ -17,23 +17,22 @@
    "source": [
     "# How to use few shot examples\n",
     "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [Prompt templates](/docs/concepts/#prompt-templates)\n",
+    "- [Example selectors](/docs/concepts/#example-selectors)\n",
+    "- [LLMs](/docs/concepts/#llms)\n",
+    "- [Vectorstores](/docs/concepts/#vectorstores)\n",
+    "\n",
+    ":::\n",
+    "\n",
     "In this guide, we'll learn how to create a simple prompt template that provides the model with example inputs and outputs when generating. Providing the LLM with a few such examples is called few-shotting, and is a simple yet powerful way to guide generation and in some cases drastically improve model performance.\n",
     "\n",
     "A few-shot prompt template can be constructed from either a set of examples, or from an [Example Selector](https://api.python.langchain.com/en/latest/example_selectors/langchain_core.example_selectors.base.BaseExampleSelector.html) class responsible for choosing a subset of examples from the defined set.\n",
     "\n",
     "This guide will cover few-shotting with string prompt templates. For a guide on few-shotting with chat messages for chat models, see [here](/docs/how_to/few_shot_examples_chat/).\n",
     "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [Prompt templates](/docs/concepts/#prompt-templates)\n",
-    "- [Example selectors](/docs/concepts/#example-selectors)\n",
-    "- [LLMs](/docs/concepts/#llms)\n",
-    "- [Vectorstores](/docs/concepts/#vectorstores)\n",
-    "`} />\n",
-    "```\n",
-    "\n",
     "## Create a formatter for the few-shot examples\n",
     "\n",
     "Configure a formatter that will format the few-shot examples into a string. This formatter should be a `PromptTemplate` object."
@@ -46,7 +45,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "example_prompt = PromptTemplate.from_template(\"Question: {question}\\n{answer}\")"
    ]
@@ -223,7 +222,7 @@
     }
    ],
    "source": [
-    "from langchain.prompts.few_shot import FewShotPromptTemplate\n",
+    "from langchain_core.prompts import FewShotPromptTemplate\n",
     "\n",
     "prompt = FewShotPromptTemplate(\n",
     "    examples=examples,\n",
@@ -283,8 +282,8 @@
     }
    ],
    "source": [
-    "from langchain.prompts.example_selector import SemanticSimilarityExampleSelector\n",
     "from langchain_chroma import Chroma\n",
+    "from langchain_core.example_selectors import SemanticSimilarityExampleSelector\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "example_selector = SemanticSimilarityExampleSelector.from_examples(\n",
@@ -390,7 +389,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/few_shot_examples_chat.ipynb

@@ -17,24 +17,23 @@
    "source": [
     "# How to use few shot examples in chat models\n",
     "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [Prompt templates](/docs/concepts/#prompt-templates)\n",
+    "- [Example selectors](/docs/concepts/#example-selectors)\n",
+    "- [Chat models](/docs/concepts/#chat-model)\n",
+    "- [Vectorstores](/docs/concepts/#vectorstores)\n",
+    "\n",
+    ":::\n",
+    "\n",
     "This guide covers how to prompt a chat model with example inputs and outputs. Providing the model with a few such examples is called few-shotting, and is a simple yet powerful way to guide generation and in some cases drastically improve model performance.\n",
     "\n",
     "There does not appear to be solid consensus on how best to do few-shot prompting, and the optimal prompt compilation will likely vary by model. Because of this, we provide few-shot prompt templates like the [FewShotChatMessagePromptTemplate](https://api.python.langchain.com/en/latest/prompts/langchain_core.prompts.few_shot.FewShotChatMessagePromptTemplate.html?highlight=fewshot#langchain_core.prompts.few_shot.FewShotChatMessagePromptTemplate) as a flexible starting point, and you can modify or replace them as you see fit.\n",
     "\n",
     "The goal of few-shot prompt templates are to dynamically select examples based on an input, and then format the examples in a final prompt to provide for the model.\n",
     "\n",
-    "**Note:** The following code examples are for chat models only, since `FewShotChatMessagePromptTemplates` are designed to output formatted [chat messages](/docs/concepts/#message-types) rather than pure strings. For similar few-shot prompt examples for pure string templates compatible with completion models (LLMs), see the [few-shot prompt templates](/docs/how_to/few_shot_examples/) guide.\n",
-    "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [Prompt templates](/docs/concepts/#prompt-templates)\n",
-    "- [Example selectors](/docs/concepts/#example-selectors)\n",
-    "- [Chat models](/docs/concepts/#chat-model)\n",
-    "- [Vectorstores](/docs/concepts/#vectorstores)\n",
-    "`} />\n",
-    "```"
+    "**Note:** The following code examples are for chat models only, since `FewShotChatMessagePromptTemplates` are designed to output formatted [chat messages](/docs/concepts/#message-types) rather than pure strings. For similar few-shot prompt examples for pure string templates compatible with completion models (LLMs), see the [few-shot prompt templates](/docs/how_to/few_shot_examples/) guide."
    ]
   },
   {
@@ -89,10 +88,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import (\n",
-    "    ChatPromptTemplate,\n",
-    "    FewShotChatMessagePromptTemplate,\n",
-    ")\n",
+    "from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate\n",
     "\n",
     "examples = [\n",
     "    {\"input\": \"2+2\", \"output\": \"4\"},\n",
@@ -219,8 +215,8 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import SemanticSimilarityExampleSelector\n",
     "from langchain_chroma import Chroma\n",
+    "from langchain_core.example_selectors import SemanticSimilarityExampleSelector\n",
     "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "examples = [\n",
@@ -306,10 +302,7 @@
     }
    ],
    "source": [
-    "from langchain.prompts import (\n",
-    "    ChatPromptTemplate,\n",
-    "    FewShotChatMessagePromptTemplate,\n",
-    ")\n",
+    "from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate\n",
     "\n",
     "# Define the few-shot prompt.\n",
     "few_shot_prompt = FewShotChatMessagePromptTemplate(\n",
@@ -435,7 +428,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/function_calling.ipynb

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

docs/docs/how_to/functions.ipynb

@@ -18,6 +18,14 @@
    "source": [
     "# How to run custom functions\n",
     "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
+    "- [Chaining runnables](/docs/how_to/sequence/)\n",
+    "\n",
+    ":::\n",
+    "\n",
     "You can use arbitrary functions as [Runnables](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable). This is useful for formatting or when you need functionality not provided by other LangChain components, and custom functions used as Runnables are called [`RunnableLambdas`](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableLambda.html).\n",
     "\n",
     "Note that all inputs to these functions need to be a SINGLE argument. If you have a function that accepts multiple arguments, you should write a wrapper that accepts a single dict input and unpacks it into multiple argument.\n",
@@ -29,15 +37,6 @@
     "- How to accept and use run metadata in your custom function\n",
     "- How to stream with custom functions by having them return generators\n",
     "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
-    "- [Chaining runnables](/docs/how_to/sequence/)\n",
-    "`} />\n",
-    "```\n",
-    "\n",
     "## Using the constructor\n",
     "\n",
     "Below, we explicitly wrap our custom logic using the `RunnableLambda` constructor:"
@@ -168,7 +167,7 @@
    "source": [
     "Above, the `@chain` decorator is used to convert `custom_chain` into a runnable, which we invoke with the `.invoke()` method.\n",
     "\n",
-    "If you are using a tracing with [LangSmith](/docs/langsmith/), you should see a `custom_chain` trace in there, with the calls to OpenAI nested underneath.\n",
+    "If you are using a tracing with [LangSmith](https://docs.smith.langchain.com/), you should see a `custom_chain` trace in there, with the calls to OpenAI nested underneath.\n",
     "\n",
     "## Automatic coercion in chains\n",
     "\n",
@@ -526,7 +525,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/graph_mapping.ipynb

@@ -300,7 +300,7 @@
     "Entities in the question map to the following database values:\n",
     "{entities_list}\n",
     "Question: {question}\n",
-    "Cypher query:\"\"\"  # noqa: E501\n",
+    "Cypher query:\"\"\"\n",
     "\n",
     "cypher_prompt = ChatPromptTemplate.from_messages(\n",
     "    [\n",
@@ -377,7 +377,7 @@
     "response_template = \"\"\"Based on the the question, Cypher query, and Cypher response, write a natural language response:\n",
     "Question: {question}\n",
     "Cypher query: {query}\n",
-    "Cypher Response: {response}\"\"\"  # noqa: E501\n",
+    "Cypher Response: {response}\"\"\"\n",
     "\n",
     "response_prompt = ChatPromptTemplate.from_messages(\n",
     "    [\n",

docs/docs/how_to/graph_semantic.ipynb

@@ -177,14 +177,13 @@
    "source": [
     "from typing import Optional, Type\n",
     "\n",
-    "from langchain.callbacks.manager import (\n",
+    "# Import things that are needed generically\n",
+    "from langchain.pydantic_v1 import BaseModel, Field\n",
+    "from langchain_core.callbacks import (\n",
     "    AsyncCallbackManagerForToolRun,\n",
     "    CallbackManagerForToolRun,\n",
     ")\n",
-    "\n",
-    "# Import things that are needed generically\n",
-    "from langchain.pydantic_v1 import BaseModel, Field\n",
-    "from langchain.tools import BaseTool\n",
+    "from langchain_core.tools import BaseTool\n",
     "\n",
     "description_query = \"\"\"\n",
     "MATCH (m:Movie|Person)\n",
@@ -227,14 +226,13 @@
    "source": [
     "from typing import Optional, Type\n",
     "\n",
-    "from langchain.callbacks.manager import (\n",
+    "# Import things that are needed generically\n",
+    "from langchain.pydantic_v1 import BaseModel, Field\n",
+    "from langchain_core.callbacks import (\n",
     "    AsyncCallbackManagerForToolRun,\n",
     "    CallbackManagerForToolRun,\n",
     ")\n",
-    "\n",
-    "# Import things that are needed generically\n",
-    "from langchain.pydantic_v1 import BaseModel, Field\n",
-    "from langchain.tools import BaseTool\n",
+    "from langchain_core.tools import BaseTool\n",
     "\n",
     "\n",
     "class InformationInput(BaseModel):\n",
@@ -287,8 +285,8 @@
     "from langchain.agents import AgentExecutor\n",
     "from langchain.agents.format_scratchpad import format_to_openai_function_messages\n",
     "from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser\n",
-    "from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
     "from langchain_core.messages import AIMessage, HumanMessage\n",
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
     "from langchain_core.utils.function_calling import convert_to_openai_function\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",

docs/docs/how_to/hybrid.ipynb

@@ -0,0 +1,392 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "14d3fd06",
+   "metadata": {
+    "id": "14d3fd06"
+   },
+   "source": [
+    "# Hybrid Search\n",
+    "\n",
+    "The standard search in LangChain is done by vector similarity. However, a number of vectorstores implementations (Astra DB, ElasticSearch, Neo4J, AzureSearch, ...) also support more advanced search combining vector similarity search and other search techniques (full-text, BM25, and so on). This is generally referred to as \"Hybrid\" search.\n",
+    "\n",
+    "**Step 1: Make sure the vectorstore you are using supports hybrid search**\n",
+    "\n",
+    "At the moment, there is no unified way to perform hybrid search in LangChain. Each vectorstore may have their own way to do it. This is generally exposed as a keyword argument that is passed in during `similarity_search`. By reading the documentation or source code, figure out whether the vectorstore you are using supports hybrid search, and, if so, how to use it.\n",
+    "\n",
+    "**Step 2: Add that parameter as a configurable field for the chain**\n",
+    "\n",
+    "This will let you easily call the chain and configure any relevant flags at runtime. See [this documentation](/docs/how_to/configure) for more information on configuration.\n",
+    "\n",
+    "**Step 3: Call the chain with that configurable field**\n",
+    "\n",
+    "Now, at runtime you can call this chain with configurable field.\n",
+    "\n",
+    "## Code Example\n",
+    "\n",
+    "Let's see a concrete example of what this looks like in code. We will use the Cassandra/CQL interface of Astra DB for this example.\n",
+    "\n",
+    "Install the following Python package:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2efe35eea197769",
+   "metadata": {
+    "id": "c2efe35eea197769",
+    "outputId": "527275b4-076e-4b22-945c-e41a59188116"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install \"cassio>=0.1.7\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b4ef96d44341cd84",
+   "metadata": {
+    "collapsed": false,
+    "id": "b4ef96d44341cd84"
+   },
+   "source": [
+    "Get the [connection secrets](https://docs.datastax.com/en/astra/astra-db-vector/get-started/quickstart.html).\n",
+    "\n",
+    "Initialize cassio:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb2cef097277c32e",
+   "metadata": {
+    "id": "cb2cef097277c32e",
+    "outputId": "4c3d05a0-319a-44a0-8ec3-0a9c78453132"
+   },
+   "outputs": [],
+   "source": [
+    "import cassio\n",
+    "\n",
+    "cassio.init(\n",
+    "    database_id=\"Your database ID\",\n",
+    "    token=\"Your application token\",\n",
+    "    keyspace=\"Your key space\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e1e51444877f45eb",
+   "metadata": {
+    "collapsed": false,
+    "id": "e1e51444877f45eb"
+   },
+   "source": [
+    "Create the Cassandra VectorStore with a standard [index analyzer](https://docs.datastax.com/en/astra/astra-db-vector/cql/use-analyzers-with-cql.html). The index analyzer is needed to enable term matching."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7345de3c",
+   "metadata": {
+    "id": "7345de3c",
+    "outputId": "d38bcee0-0134-4ac6-8d35-afcce282481b"
+   },
+   "outputs": [],
+   "source": [
+    "from cassio.table.cql import STANDARD_ANALYZER\n",
+    "from langchain_community.vectorstores import Cassandra\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()\n",
+    "vectorstore = Cassandra(\n",
+    "    embedding=embeddings,\n",
+    "    table_name=\"test_hybrid\",\n",
+    "    body_index_options=[STANDARD_ANALYZER],\n",
+    "    session=None,\n",
+    "    keyspace=None,\n",
+    ")\n",
+    "\n",
+    "vectorstore.add_texts(\n",
+    "    [\n",
+    "        \"In 2023, I visited Paris\",\n",
+    "        \"In 2022, I visited New York\",\n",
+    "        \"In 2021, I visited New Orleans\",\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "73887f23bbab978c",
+   "metadata": {
+    "collapsed": false,
+    "id": "73887f23bbab978c"
+   },
+   "source": [
+    "If we do a standard similarity search, we get all the documents:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c2a39fa",
+   "metadata": {
+    "id": "3c2a39fa",
+    "outputId": "5290085b-896c-4c81-9b40-c315331b7009"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='In 2022, I visited New York'),\n",
+       "Document(page_content='In 2023, I visited Paris'),\n",
+       "Document(page_content='In 2021, I visited New Orleans')]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vectorstore.as_retriever().invoke(\"What city did I visit last?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78d4c3c79e67d8c3",
+   "metadata": {
+    "collapsed": false,
+    "id": "78d4c3c79e67d8c3"
+   },
+   "source": [
+    "The Astra DB vectorstore `body_search` argument can be used to filter the search on the term `new`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "56393baa",
+   "metadata": {
+    "id": "56393baa",
+    "outputId": "d1c939f3-342f-4df4-94a3-d25429b5a25e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Document(page_content='In 2022, I visited New York'),\n",
+       "Document(page_content='In 2021, I visited New Orleans')]"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vectorstore.as_retriever(search_kwargs={\"body_search\": \"new\"}).invoke(\n",
+    "    \"What city did I visit last?\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "88ae97ed",
+   "metadata": {
+    "id": "88ae97ed"
+   },
+   "source": [
+    "We can now create the chain that we will use to do question-answering over"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62707b4f",
+   "metadata": {
+    "id": "62707b4f"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.runnables import (\n",
+    "    ConfigurableField,\n",
+    "    RunnablePassthrough,\n",
+    ")\n",
+    "from langchain_openai import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b6778ffa",
+   "metadata": {
+    "id": "b6778ffa"
+   },
+   "source": [
+    "This is basic question-answering chain set up."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44a865f6",
+   "metadata": {
+    "id": "44a865f6"
+   },
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "retriever = vectorstore.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "72125166",
+   "metadata": {
+    "id": "72125166"
+   },
+   "source": [
+    "Here we mark the retriever as having a configurable field. All vectorstore retrievers have `search_kwargs` as a field. This is just a dictionary, with vectorstore specific fields"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "babbadff",
+   "metadata": {
+    "id": "babbadff"
+   },
+   "outputs": [],
+   "source": [
+    "configurable_retriever = retriever.configurable_fields(\n",
+    "    search_kwargs=ConfigurableField(\n",
+    "        id=\"search_kwargs\",\n",
+    "        name=\"Search Kwargs\",\n",
+    "        description=\"The search kwargs to use\",\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d481b70",
+   "metadata": {
+    "id": "2d481b70"
+   },
+   "source": [
+    "We can now create the chain using our configurable retriever"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "210b0446",
+   "metadata": {
+    "id": "210b0446"
+   },
+   "outputs": [],
+   "source": [
+    "chain = (\n",
+    "    {\"context\": configurable_retriever, \"question\": RunnablePassthrough()}\n",
+    "    | prompt\n",
+    "    | model\n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a38037b2",
+   "metadata": {
+    "id": "a38037b2",
+    "outputId": "1ea14996-5965-4a5e-9678-b9c35ce5c6de"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Paris"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"What city did I visit last?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f6458c3",
+   "metadata": {
+    "id": "7f6458c3"
+   },
+   "source": [
+    "We can now invoke the chain with configurable options. `search_kwargs` is the id of the configurable field. The value is the search kwargs to use for Astra DB."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9gYLqBTH8BFz",
+   "metadata": {
+    "id": "9gYLqBTH8BFz",
+    "outputId": "4358a2e6-f306-48f1-dd5c-781ac8a33e89"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "New York"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\n",
+    "    \"What city did I visit last?\",\n",
+    "    config={\"configurable\": {\"search_kwargs\": {\"body_search\": \"new\"}}},\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.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/how_to/index.mdx

@@ -3,170 +3,185 @@ sidebar_position: 0
 sidebar_class_name: hidden
 ---
 
-# How-to Guides
+# How-to guides
 
-Here you’ll find short answers to “How do I….?” types of questions. 
-These how-to guides don’t cover topics in depth – you’ll find that material in the [Tutorials](/docs/tutorials) and the [API Reference](https://api.python.langchain.com/en/latest/). 
-However, these guides will help you quickly accomplish common tasks.
+Here you’ll find answers to “How do I….?” types of questions.
+These guides are *goal-oriented* and *concrete*; they're meant to help you complete a specific task.
+For conceptual explanations see the [Conceptual guide](/docs/concepts/).
+For end-to-end walkthroughs see [Tutorials](/docs/tutorials).
+For comprehensive descriptions of every class and function see the [API Reference](https://api.python.langchain.com/en/latest/).
 
-## Core Functionality
+## Installation
 
-This covers functionality that is core to using LangChain
+- [How to: install LangChain packages](/docs/how_to/installation/)
 
-- [How to return structured data from an LLM](/docs/how_to/structured_output/)
-- [How to use a chat model to call tools](/docs/how_to/tool_calling/)
-- [How to stream](/docs/how_to/streaming)
-- [How to debug your LLM apps](/docs/how_to/debugging/)
+## Key features
+
+This highlights functionality that is core to using LangChain.
+
+- [How to: return structured data from a model](/docs/how_to/structured_output/)
+- [How to: use a model to call tools](/docs/how_to/tool_calling/)
+- [How to: stream runnables](/docs/how_to/streaming)
+- [How to: debug your LLM apps](/docs/how_to/debugging/)
 
 ## LangChain Expression Language (LCEL)
 
-LangChain Expression Language a way to create arbitrary custom chains.
+[LangChain Expression Language](/docs/concepts/#langchain-expression-language-lcel) is a way to create arbitrary custom chains. It is built on the [Runnable](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html) protocol.
 
-- [How to combine multiple runnables into a chain](/docs/how_to/sequence)
-- [How to invoke runnables in parallel](/docs/how_to/parallel/)
-- [How to attach runtime arguments to a runnable](/docs/how_to/binding/)
-- [How to run custom functions](/docs/how_to/functions)
-- [How to pass through arguments from one step to the next](/docs/how_to/passthrough)
-- [How to add values to a chain's state](/docs/how_to/assign)
-- [How to configure a chain at runtime](/docs/how_to/configure)
-- [How to add message history](/docs/how_to/message_history)
-- [How to route execution within a chain](/docs/how_to/routing)
-- [How to inspect your runnables](/docs/how_to/inspect)
-- [How to add fallbacks](/docs/how_to/fallbacks)
+[**LCEL cheatsheet**](/docs/how_to/lcel_cheatsheet/): For a quick overview of how to use the main LCEL primitives.
+
+- [How to: chain runnables](/docs/how_to/sequence)
+- [How to: stream runnables](/docs/how_to/streaming)
+- [How to: invoke runnables in parallel](/docs/how_to/parallel/)
+- [How to: add default invocation args to runnables](/docs/how_to/binding/)
+- [How to: turn any function into a runnable](/docs/how_to/functions)
+- [How to: pass through inputs from one chain step to the next](/docs/how_to/passthrough)
+- [How to: configure runnable behavior at runtime](/docs/how_to/configure)
+- [How to: add message history (memory) to a chain](/docs/how_to/message_history)
+- [How to: route between sub-chains](/docs/how_to/routing)
+- [How to: create a dynamic (self-constructing) chain](/docs/how_to/dynamic_chain/)
+- [How to: inspect runnables](/docs/how_to/inspect)
+- [How to: add fallbacks to a runnable](/docs/how_to/fallbacks)
 
 ## Components
 
 These are the core building blocks you can use when building applications.
 
-### Prompt Templates
+### Prompt templates
 
-Prompt Templates are responsible for formatting user input into a format that can be passed to a language model.
+[Prompt Templates](/docs/concepts/#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/)
-- [How to partially format prompt templates](/docs/how_to/prompts_partial)
-- [How to compose prompts together](/docs/how_to/prompts_composition)
+- [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/)
+- [How to: partially format prompt templates](/docs/how_to/prompts_partial)
+- [How to: compose prompts together](/docs/how_to/prompts_composition)
 
-### Example Selectors
+### Example selectors
 
-Example Selectors are responsible for selecting the correct few shot examples to pass to the prompt.
+[Example Selectors](/docs/concepts/#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)
-- [How to select examples by semantic similarity](/docs/how_to/example_selectors_similarity)
-- [How to select examples by semantic ngram overlap](/docs/how_to/example_selectors_ngram)
-- [How to select examples by maximal marginal relevance](/docs/how_to/example_selectors_mmr)
+- [How to: use example selectors](/docs/how_to/example_selectors)
+- [How to: select examples by length](/docs/how_to/example_selectors_length_based)
+- [How to: select examples by semantic similarity](/docs/how_to/example_selectors_similarity)
+- [How to: select examples by semantic ngram overlap](/docs/how_to/example_selectors_ngram)
+- [How to: select examples by maximal marginal relevance](/docs/how_to/example_selectors_mmr)
 
-### Chat Models
+### Chat models
 
-Chat Models are newer forms of language models that take messages in and output a message.
+[Chat Models](/docs/concepts/#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)
-- [How to cache model responses](/docs/how_to/chat_model_caching)
-- [How to get log probabilities from model calls](/docs/how_to/logprobs)
-- [How to create a custom chat model class](/docs/how_to/custom_chat_model)
-- [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: do function/tool calling](/docs/how_to/tool_calling)
+- [How to: get models to return structured output](/docs/how_to/structured_output)
+- [How to: cache model responses](/docs/how_to/chat_model_caching)
+- [How to: get log probabilities](/docs/how_to/logprobs)
+- [How to: create a custom chat model class](/docs/how_to/custom_chat_model)
+- [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 are older forms of language models that take a string in and output a string.
+What LangChain calls [LLMs](/docs/concepts/#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)
-- [How to stream a response back](/docs/how_to/streaming_llm)
-- [How to track token usage](/docs/how_to/llm_token_usage_tracking)
-- [How to work with local LLMs](/docs/how_to/local_llms)
+- [How to: cache model responses](/docs/how_to/llm_caching)
+- [How to: create a custom LLM class](/docs/how_to/custom_llm)
+- [How to: stream a response back](/docs/how_to/streaming_llm)
+- [How to: track token usage](/docs/how_to/llm_token_usage_tracking)
+- [How to: work with local LLMs](/docs/how_to/local_llms)
 
-### Output Parsers
+### Output parsers
 
-Output Parsers are responsible for taking the output of an LLM and parsing into more structured format.
+[Output Parsers](/docs/concepts/#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)
-- [How to parse XML output](/docs/how_to/output_parser_xml)
-- [How to parse YAML output](/docs/how_to/output_parser_yaml)
-- [How to retry when output parsing errors occur](/docs/how_to/output_parser_retry)
-- [How to try to fix errors in output parsing](/docs/how_to/output_parser_fixing)
-- [How to write a custom output parser class](/docs/how_to/output_parser_custom)
+- [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)
+- [How to: parse XML output](/docs/how_to/output_parser_xml)
+- [How to: parse YAML output](/docs/how_to/output_parser_yaml)
+- [How to: retry when output parsing errors occur](/docs/how_to/output_parser_retry)
+- [How to: try to fix errors in output parsing](/docs/how_to/output_parser_fixing)
+- [How to: write a custom output parser class](/docs/how_to/output_parser_custom)
 
-### Document Loaders
+### Document loaders
 
-Document Loaders are responsible for loading documents from a variety of sources.
+[Document Loaders](/docs/concepts/#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)
-- [How to load HTML data](/docs/how_to/document_loader_html)
-- [How to load JSON data](/docs/how_to/document_loader_json)
-- [How to load Markdown data](/docs/how_to/document_loader_markdown)
-- [How to load Microsoft Office data](/docs/how_to/document_loader_office_file)
-- [How to load PDF files](/docs/how_to/document_loader_pdf)
-- [How to write a custom document loader](/docs/how_to/document_loader_custom)
+- [How to: load CSV data](/docs/how_to/document_loader_csv)
+- [How to: load data from a directory](/docs/how_to/document_loader_directory)
+- [How to: load HTML data](/docs/how_to/document_loader_html)
+- [How to: load JSON data](/docs/how_to/document_loader_json)
+- [How to: load Markdown data](/docs/how_to/document_loader_markdown)
+- [How to: load Microsoft Office data](/docs/how_to/document_loader_office_file)
+- [How to: load PDF files](/docs/how_to/document_loader_pdf)
+- [How to: write a custom document loader](/docs/how_to/document_loader_custom)
 
-### Text Splitters
+### Text splitters
 
-Text Splitters take a document and split into chunks that can be used for retrieval.
+[Text Splitters](/docs/concepts/#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)
-- [How to split by HTML sections](/docs/how_to/HTML_section_aware_splitter)
-- [How to split by character](/docs/how_to/character_text_splitter)
-- [How to split code](/docs/how_to/code_splitter)
-- [How to split Markdown by headers](/docs/how_to/markdown_header_metadata_splitter)
-- [How to recursively split JSON](/docs/how_to/recursive_json_splitter)
-- [How to split text into semantic chunks](/docs/how_to/semantic-chunker)
-- [How to split by tokens](/docs/how_to/split_by_token)
+- [How to: recursively split text](/docs/how_to/recursive_text_splitter)
+- [How to: split by HTML headers](/docs/how_to/HTML_header_metadata_splitter)
+- [How to: split by HTML sections](/docs/how_to/HTML_section_aware_splitter)
+- [How to: split by character](/docs/how_to/character_text_splitter)
+- [How to: split code](/docs/how_to/code_splitter)
+- [How to: split Markdown by headers](/docs/how_to/markdown_header_metadata_splitter)
+- [How to: recursively split JSON](/docs/how_to/recursive_json_splitter)
+- [How to: split text into semantic chunks](/docs/how_to/semantic-chunker)
+- [How to: split by tokens](/docs/how_to/split_by_token)
 
-### Embedding Models
+### Embedding models
 
-Embedding Models take a piece of text and create a numerical representation of it.
+[Embedding Models](/docs/concepts/#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)
+- [How to: embed text data](/docs/how_to/embed_text)
+- [How to: cache embedding results](/docs/how_to/caching_embeddings)
 
-### Vector Stores
+### Vector stores
 
-Vector Stores are databases that can efficiently store and retrieve embeddings.
+[Vector stores](/docs/concepts/#vector-stores) are databases that can efficiently store and retrieve embeddings.
 
-- [How to use a vector store to retrieve data](/docs/how_to/vectorstores)
+- [How to: use a vector store to retrieve data](/docs/how_to/vectorstores)
 
 ### Retrievers
 
-Retrievers are responsible for taking a query and returning relevant documents.
+[Retrievers](/docs/concepts/#retrievers) are responsible for taking a query and returning relevant documents.
 
-- [How 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)
-- [How to use contextual compression to compress the data retrieved](/docs/how_to/contextual_compression)
-- [How to write a custom retriever class](/docs/how_to/custom_retriever)
-- [How to combine the results from multiple retrievers](/docs/how_to/ensemble_retriever)
-- [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)
-- [How to create a time-weighted retriever](/docs/how_to/time_weighted_vectorstore)
+- [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)
+- [How to: use contextual compression to compress the data retrieved](/docs/how_to/contextual_compression)
+- [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: 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)
+- [How to: create a time-weighted retriever](/docs/how_to/time_weighted_vectorstore)
+- [How to: use hybrid vector and keyword retrieval](/docs/how_to/hybrid)
 
 ### Indexing
 
 Indexing is the process of keeping your vectorstore in-sync with the underlying data source.
 
-- [How to reindex data to keep your vectorstore in-sync with the underlying data source](/docs/how_to/indexing)
+- [How to: reindex data to keep your vectorstore in-sync with the underlying data source](/docs/how_to/indexing)
 
 ### Tools
 
-LangChain 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](/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).
+
+- [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)
+
+### Multimodal
+
+- [How to: pass multimodal data directly to models](/docs/how_to/multimodal_inputs/)
+- [How to: use multimodal prompts](/docs/how_to/multimodal_prompts/)
 
-- [How to use LangChain tools](/docs/how_to/tools)
-- [How to use a chat model to call tools](/docs/how_to/tool_calling/)
-- [How to use LangChain toolkits](/docs/how_to/toolkits)
-- [How to define a custom tool](/docs/how_to/custom_tools)
-- [How to convert LangChain tools to OpenAI functions](/docs/how_to/tools_as_openai_functions)
-- [How to use tools without function calling](/docs/how_to/tools_prompting)
-- [How to let the LLM choose between multiple tools](/docs/how_to/tools_multiple)
-- [How to add a human in the loop to tool usage](/docs/how_to/tools_human)
-- [How to do parallel tool use](/docs/how_to/tools_parallel)
-- [How to handle errors when calling tools](/docs/how_to/tools_error)
 
 ### Agents
 
@@ -176,80 +191,110 @@ For in depth how-to guides for agents, please check out [LangGraph](https://gith
 
 :::
 
-- [How to use legacy LangChain Agents (AgentExecutor)](/docs/how_to/agent_executor)
-- [How to migrate from legacy LangChain agents to LangGraph](/docs/how_to/migrate_agent)
+- [How to: use legacy LangChain Agents (AgentExecutor)](/docs/how_to/agent_executor)
+- [How to: migrate from legacy LangChain agents to LangGraph](/docs/how_to/migrate_agent)
+
+### 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)
+- [How to: create custom callback handlers](/docs/how_to/custom_callbacks)
+- [How to: use callbacks in async environments](/docs/how_to/callbacks_async)
 
 ### Custom
 
 All of LangChain components can easily be extended to support your own versions.
 
-- [How to create a custom chat model class](/docs/how_to/custom_chat_model)
-- [How to create a custom LLM class](/docs/how_to/custom_llm)
-- [How to write a custom retriever class](/docs/how_to/custom_retriever)
-- [How to write a custom document loader](/docs/how_to/document_loader_custom)
-- [How to write a custom output parser class](/docs/how_to/output_parser_custom)
-
-- [How to define a custom tool](/docs/how_to/custom_tools)
+- [How to: create a custom chat model class](/docs/how_to/custom_chat_model)
+- [How to: create a custom LLM class](/docs/how_to/custom_llm)
+- [How to: write a custom retriever class](/docs/how_to/custom_retriever)
+- [How to: write a custom document loader](/docs/how_to/document_loader_custom)
+- [How to: write a custom output parser class](/docs/how_to/output_parser_custom)
+- [How to: create custom callback handlers](/docs/how_to/custom_callbacks)
+- [How to: define a custom tool](/docs/how_to/custom_tools)
 
 
-
-
-## Use Cases
+## Use cases
 
 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/)
-- [How to return sources](/docs/how_to/qa_sources/)
-- [How to return citations](/docs/how_to/qa_citations/)
-- [How to do per-user retrieval](/docs/how_to/qa_per_user/)
+- [How to: add chat history](/docs/how_to/qa_chat_history_how_to/)
+- [How to: stream](/docs/how_to/qa_streaming/)
+- [How to: return sources](/docs/how_to/qa_sources/)
+- [How to: return citations](/docs/how_to/qa_citations/)
+- [How to: do per-user retrieval](/docs/how_to/qa_per_user/)
 
 
 ### 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/)
-- [How to do extraction without using function calling](/docs/how_to/extraction_parse)
+- [How to: use reference examples](/docs/how_to/extraction_examples/)
+- [How to: handle long text](/docs/how_to/extraction_long_text/)
+- [How to: do extraction without using function calling](/docs/how_to/extraction_parse)
 
 ### 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)
-- [How to use tools](/docs/how_to/chatbots_tools)
+- [How to: manage memory](/docs/how_to/chatbots_memory)
+- [How to: do retrieval](/docs/how_to/chatbots_retrieval)
+- [How to: use tools](/docs/how_to/chatbots_tools)
 
-### Query Analysis
+### 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)
-- [How to handle multiple queries](/docs/how_to/query_multiple_queries)
-- [How to handle multiple retrievers](/docs/how_to/query_multiple_retrievers)
-- [How to construct filters](/docs/how_to/query_constructing_filters)
-- [How to deal with high cardinality categorical variables](/docs/how_to/query_high_cardinality)
+- [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)
+- [How to: handle multiple queries](/docs/how_to/query_multiple_queries)
+- [How to: handle multiple retrievers](/docs/how_to/query_multiple_retrievers)
+- [How to: construct filters](/docs/how_to/query_constructing_filters)
+- [How to: deal with high cardinality categorical variables](/docs/how_to/query_high_cardinality)
 
 ### 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)
-- [How to deal with large databases](/docs/how_to/sql_large_db)
-- [How to deal with CSV files](/docs/how_to/sql_csv)
+- [How to: use prompting to improve results](/docs/how_to/sql_prompting)
+- [How to: do query validation](/docs/how_to/sql_query_checking)
+- [How to: deal with large databases](/docs/how_to/sql_large_db)
+- [How to: deal with CSV files](/docs/how_to/sql_csv)
 
-### Q&A over Graph Databases
+### 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)
+- [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: `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",
+    "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",
     "  \n",
     "## Caution\n",
     "\n",
@@ -786,7 +786,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_community.document_loaders.base import BaseLoader\n",
+    "from langchain_core.document_loaders import BaseLoader\n",
     "\n",
     "\n",
     "class MyCustomLoader(BaseLoader):\n",

docs/docs/how_to/inspect.ipynb

@@ -5,21 +5,20 @@
    "id": "8c5eb99a",
    "metadata": {},
    "source": [
-    "# How to inspect your runnables\n",
+    "# How to inspect runnables\n",
+    "\n",
+    ":::info Prerequisites\n",
+    "\n",
+    "This guide assumes familiarity with the following concepts:\n",
+    "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
+    "- [Chaining runnables](/docs/how_to/sequence/)\n",
+    "\n",
+    ":::\n",
     "\n",
     "Once you create a runnable with [LangChain Expression Language](/docs/concepts/#langchain-expression-language), you may often want to inspect it to get a better sense for what is going on. This notebook covers some methods for doing so.\n",
     "\n",
     "This guide shows some ways you can programmatically introspect the internal steps of chains. If you are instead interested in debugging issues in your chain, see [this section](/docs/how_to/debugging) instead.\n",
     "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
-    "- [LangChain Expression Language (LCEL)](/docs/concepts/#langchain-expression-language)\n",
-    "- [Chaining runnables](/docs/how_to/sequence/)\n",
-    "`} />\n",
-    "```\n",
-    "\n",
     "First, let's create an example chain. We will create one that does retrieval:"
    ]
   },
@@ -40,9 +39,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.prompts import ChatPromptTemplate\n",
     "from langchain_community.vectorstores import FAISS\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
     "from langchain_core.runnables import RunnablePassthrough\n",
     "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
     "\n",
@@ -222,7 +221,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/installation.mdx

@@ -41,7 +41,7 @@ pip install langchain-core
 ```
 
 ## LangChain community
-The `langchain-community` package contains third-party integrations. It is automatically installed by `langchain`, but can also be used separately. Install with:
+The `langchain-community` package contains third-party integrations. Install with:
 
 ```bash
 pip install langchain-community

docs/docs/how_to/llm_caching.ipynb

@@ -119,7 +119,7 @@
    "outputs": [],
    "source": [
     "# We can do the same thing with a SQLite cache\n",
-    "from langchain.cache import SQLiteCache\n",
+    "from langchain_community.cache import SQLiteCache\n",
     "\n",
     "set_llm_cache(SQLiteCache(database_path=\".langchain.db\"))"
    ]

docs/docs/how_to/llm_token_usage_tracking.ipynb

@@ -2,169 +2,226 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "e5715368",
+   "id": "90dff237-bc28-4185-a2c0-d5203bbdeacd",
    "metadata": {},
    "source": [
     "# How to track token usage for LLMs\n",
     "\n",
-    "This notebook goes over how to track your token usage for specific calls. It is currently only implemented for the OpenAI API.\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",
-    "Let's first look at an extremely simple example of tracking token usage for a single LLM call."
+    ":::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"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "9455db35",
+   "id": "2eebbee2-6ca1-4fa8-a3aa-0376888ceefb",
    "metadata": {},
-   "outputs": [],
+   "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"
+     ]
+    }
+   ],
    "source": [
     "from langchain_community.callbacks import get_openai_callback\n",
-    "from langchain_openai import OpenAI"
+    "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."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "d1c55cc9",
+   "id": "3ec10419-294c-44bf-af85-86aabf457cb6",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "Why did the chicken go to the seance?\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"
+     ]
+    }
+   ],
    "source": [
-    "llm = OpenAI(model_name=\"gpt-3.5-turbo-instruct\", n=2, best_of=2)"
+    "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:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
-   "id": "31667d54",
-   "metadata": {},
+   "id": "cd61ed79-7858-49bb-afb5-d41291f597ba",
+   "metadata": {
+    "tags": []
+   },
    "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"
+      "\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": [
-    "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_community.callbacks import get_openai_callback\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": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3m I need to find 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",
-      "\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": [
+    "llm = OpenAI(model_name=\"gpt-3.5-turbo-instruct\")\n",
+    "\n",
     "with get_openai_callback() as cb:\n",
-    "    response = agent.run(\n",
-    "        \"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\"\n",
-    "    )\n",
-    "    print(f\"Total Tokens: {cb.total_tokens}\")\n",
-    "    print(f\"Prompt Tokens: {cb.prompt_tokens}\")\n",
-    "    print(f\"Completion Tokens: {cb.completion_tokens}\")\n",
-    "    print(f\"Total Cost (USD): ${cb.total_cost}\")"
+    "    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}\")"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "80ca77a3",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -183,7 +240,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/local_llms.ipynb

@@ -134,8 +134,7 @@
     }
    ],
    "source": [
-    "from langchain.callbacks.manager import CallbackManager\n",
-    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
+    "from langchain_core.callbacks import CallbackManager, StreamingStdOutCallbackHandler\n",
     "\n",
     "llm = Ollama(\n",
     "    model=\"llama2\", callback_manager=CallbackManager([StreamingStdOutCallbackHandler()])\n",
@@ -288,9 +287,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.callbacks.manager import CallbackManager\n",
-    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
     "from langchain_community.llms import LlamaCpp\n",
+    "from langchain_core.callbacks import CallbackManager, StreamingStdOutCallbackHandler\n",
     "\n",
     "llm = LlamaCpp(\n",
     "    model_path=\"/Users/rlm/Desktop/Code/llama.cpp/models/openorca-platypus2-13b.gguf.q4_0.bin\",\n",

docs/docs/how_to/logprobs.ipynb

@@ -5,17 +5,16 @@
    "id": "78b45321-7740-4399-b2ad-459811131de3",
    "metadata": {},
    "source": [
-    "# How to get log probabilities from model calls\n",
+    "# How to get log probabilities\n",
     "\n",
-    "Certain chat models can be configured to return token-level log probabilities representing the likelihood of a given token. This guide walks through how to get this information in LangChain.\n",
+    ":::info Prerequisites\n",
     "\n",
-    "```{=mdx}\n",
-    "import PrerequisiteLinks from \"@theme/PrerequisiteLinks\";\n",
-    "\n",
-    "<PrerequisiteLinks content={`\n",
+    "This guide assumes familiarity with the following concepts:\n",
     "- [Chat models](/docs/concepts/#chat-models)\n",
-    "`} />\n",
-    "```"
+    "\n",
+    ":::\n",
+    "\n",
+    "Certain chat models can be configured to return token-level log probabilities representing the likelihood of a given token. This guide walks through how to get this information in LangChain."
    ]
   },
   {
@@ -170,7 +169,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/how_to/long_context_reorder.ipynb

@@ -5,28 +5,38 @@
    "id": "fc0db1bc",
    "metadata": {},
    "source": [
-    "# How to reorder retrieved results to put most relevant documents not in the middle\n",
+    "# How to reorder retrieved results to mitigate the \"lost in the middle\" effect\n",
     "\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",
+    "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",
     "\n",
-    "To avoid this issue you can re-order documents after retrieval to avoid performance degradation."
+    "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."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "74d1ebe8",
+   "id": "2074fdaa-edff-468a-970f-6f5f26e93d4a",
    "metadata": {},
    "outputs": [],
    "source": [
-    "%pip install --upgrade --quiet  sentence-transformers langchain-chroma langchain langchain-openai > /dev/null"
+    "%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": 3,
+   "execution_count": 2,
    "id": "49cbcd8e",
    "metadata": {},
    "outputs": [
@@ -45,20 +55,14 @@
        " Document(page_content='This is just a random text.')]"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "from langchain.chains import LLMChain, StuffDocumentsChain\n",
-    "from langchain.prompts import PromptTemplate\n",
     "from langchain_chroma import Chroma\n",
-    "from langchain_community.document_transformers import (\n",
-    "    LongContextReorder,\n",
-    ")\n",
-    "from langchain_community.embeddings import HuggingFaceEmbeddings\n",
-    "from langchain_openai import OpenAI\n",
+    "from langchain_huggingface import HuggingFaceEmbeddings\n",
     "\n",
     "# Get embeddings.\n",
     "embeddings = HuggingFaceEmbeddings(model_name=\"all-MiniLM-L6-v2\")\n",
@@ -83,14 +87,22 @@
     "query = \"What can you tell me about the Celtics?\"\n",
     "\n",
     "# Get relevant documents ordered by relevance score\n",
-    "docs = retriever.get_relevant_documents(query)\n",
+    "docs = retriever.invoke(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": 4,
-   "id": "34fb9d6e",
+   "execution_count": 3,
+   "id": "9a1181f2-a3dc-4614-9233-2196ab65939e",
    "metadata": {},
    "outputs": [
     {
@@ -108,12 +120,14 @@
        " Document(page_content='This is a document about the Boston Celtics')]"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 3,
      "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",
@@ -125,58 +139,54 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "ceccab87",
+   "cell_type": "markdown",
+   "id": "a8d2ef0c-c397-4d8d-8118-3f7acf86d241",
    "metadata": {},
-   "outputs": [
-    {
-     "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": [
-    "# 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",
-    "stuff_prompt_override = \"\"\"Given this text extracts:\n",
-    "-----\n",
-    "{context}\n",
-    "-----\n",
-    "Please answer the following question:\n",
-    "{query}\"\"\"\n",
-    "prompt = PromptTemplate(\n",
-    "    template=stuff_prompt_override, input_variables=[\"context\", \"query\"]\n",
-    ")\n",
-    "\n",
-    "# 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)"
+    "Below, we show how to incorporate the re-ordered documents into a simple question-answering chain:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "d4696a97",
+   "execution_count": 5,
+   "id": "8bbea705-d5b9-4ed5-9957-e12547283622",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "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"
+     ]
+    }
+   ],
+   "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",
+    "\n",
+    "llm = OpenAI()\n",
+    "\n",
+    "prompt_template = \"\"\"\n",
+    "Given these texts:\n",
+    "-----\n",
+    "{context}\n",
+    "-----\n",
+    "Please answer the following question:\n",
+    "{query}\n",
+    "\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(\n",
+    "    template=prompt_template,\n",
+    "    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)"
+   ]
   }
  ],
  "metadata": {
@@ -195,7 +205,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how_to/multi_vector.ipynb

@@ -5,33 +5,36 @@
    "id": "d9172545",
    "metadata": {},
    "source": [
-    "# How to use the MultiVector Retriever\n",
+    "# How to retrieve using multiple vectors per document\n",
     "\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",
+    "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",
     "\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).\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",
     "- 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",
-    "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."
+    "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"
    ]
   },
   {
    "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": [],
@@ -40,25 +43,22 @@
     "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"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "6d869496",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
+    "\n",
     "loaders = [\n",
-    "    TextLoader(\"../../paul_graham_essay.txt\"),\n",
-    "    TextLoader(\"../../state_of_the_union.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)"
+    "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",
+    ")"
    ]
   },
   {
@@ -68,52 +68,54 @@
    "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` does. Here we show what is going on under the hood."
+    "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."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "id": "0e7b6b45",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# The vectorstore to use to index the child chunks\n",
-    "vectorstore = Chroma(\n",
-    "    collection_name=\"full_documents\", embedding_function=OpenAIEmbeddings()\n",
-    ")\n",
+    "import uuid\n",
+    "\n",
+    "from langchain.retrievers.multi_vector import MultiVectorRetriever\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": "code",
-   "execution_count": 5,
-   "id": "72a36491",
+   "cell_type": "markdown",
+   "id": "d4feded4-856a-4282-91c3-53aabc62e6ff",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# The splitter to use to create smaller chunks\n",
-    "child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)"
+    "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": 6,
+   "execution_count": 3,
    "id": "5d23247d",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# The splitter to use to create smaller chunks\n",
+    "child_text_splitter = RecursiveCharacterTextSplitter(chunk_size=400)\n",
+    "\n",
     "sub_docs = []\n",
     "for i, doc in enumerate(docs):\n",
     "    _id = doc_ids[i]\n",
@@ -123,9 +125,17 @@
     "    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": 7,
+   "execution_count": 4,
    "id": "92ed5861",
    "metadata": {},
    "outputs": [],
@@ -134,31 +144,46 @@
     "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": 8,
+   "execution_count": 5,
    "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': '2fd77862-9ed5-4fad-bf76-e487b747b333', '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': '064eca46-a4c4-4789-8e3b-583f9597e54f', 'source': 'state_of_the_union.txt'})"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 5,
      "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": 9,
+   "execution_count": 6,
    "id": "3c9017f1",
    "metadata": {},
    "outputs": [
@@ -168,14 +193,13 @@
        "9875"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# Retriever returns larger chunks\n",
-    "len(retriever.get_relevant_documents(\"justice breyer\")[0].page_content)"
+    "len(retriever.invoke(\"justice breyer\")[0].page_content)"
    ]
   },
   {
@@ -183,12 +207,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) so if you want this instead you can just set the `search_type` property as follows:"
+    "The default search type the retriever performs on the vector database is a similarity search. LangChain vector stores also support searching via [Max Marginal Relevance](https://api.python.langchain.com/en/latest/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:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "id": "36739460-a737-4a8e-b70f-50bf8c8eaae7",
    "metadata": {},
    "outputs": [
@@ -198,7 +222,7 @@
        "9875"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -208,7 +232,7 @@
     "\n",
     "retriever.search_type = SearchType.mmr\n",
     "\n",
-    "len(retriever.get_relevant_documents(\"justice breyer\")[0].page_content)"
+    "len(retriever.invoke(\"justice breyer\")[0].page_content)"
    ]
   },
   {
@@ -216,14 +240,37 @@
    "id": "d6a7ae0d",
    "metadata": {},
    "source": [
-    "## Summary\n",
+    "## Associating summaries with a document for retrieval\n",
     "\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."
+    "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",
+    "```"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "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,
    "id": "1433dff4",
    "metadata": {},
    "outputs": [],
@@ -233,27 +280,26 @@
     "from langchain_core.documents import Document\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_openai import ChatOpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "35b30390",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "\n",
     "chain = (\n",
     "    {\"doc\": lambda x: x.page_content}\n",
     "    | ChatPromptTemplate.from_template(\"Summarize the following document:\\n\\n{doc}\")\n",
-    "    | ChatOpenAI(max_retries=0)\n",
+    "    | llm\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": 13,
+   "execution_count": 10,
    "id": "41a2a738",
    "metadata": {},
    "outputs": [],
@@ -261,9 +307,17 @@
     "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": 14,
+   "execution_count": 11,
    "id": "7ac5e4b1",
    "metadata": {},
    "outputs": [],
@@ -279,29 +333,13 @@
     "    byte_store=store,\n",
     "    id_key=id_key,\n",
     ")\n",
-    "doc_ids = [str(uuid.uuid4()) for _ in docs]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "0d93309f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "doc_ids = [str(uuid.uuid4()) for _ in docs]\n",
+    "\n",
     "summary_docs = [\n",
     "    Document(page_content=s, metadata={id_key: doc_ids[i]})\n",
     "    for i, s in enumerate(summaries)\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "6d5edf0d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "]\n",
+    "\n",
     "retriever.vectorstore.add_documents(summary_docs)\n",
     "retriever.docstore.mset(list(zip(doc_ids, docs)))"
    ]
@@ -320,50 +358,48 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "299232d6",
+   "cell_type": "markdown",
+   "id": "f0274892-29c1-4616-9040-d23f9d537526",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "sub_docs = vectorstore.similarity_search(\"justice breyer\")"
+    "Querying the vector store will return summaries:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "id": "10e404c0",
+   "execution_count": 12,
+   "id": "299232d6",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "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'})"
+       "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'})"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "sub_docs = retriever.vectorstore.similarity_search(\"justice breyer\")\n",
+    "\n",
     "sub_docs[0]"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "e4cce5c2",
+   "cell_type": "markdown",
+   "id": "e4f77ac5-2926-4f60-aad5-b2067900dff9",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "retrieved_docs = retriever.get_relevant_documents(\"justice breyer\")"
+    "Whereas the retriever will return the larger source document:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "id": "c8570dbb",
+   "execution_count": 13,
+   "id": "e4cce5c2",
    "metadata": {},
    "outputs": [
     {
@@ -372,12 +408,14 @@
        "9194"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "retrieved_docs = retriever.invoke(\"justice breyer\")\n",
+    "\n",
     "len(retrieved_docs[0].page_content)"
    ]
   },
@@ -388,42 +426,28 @@
    "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. These questions can then be embedded"
+    "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."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
-   "id": "5219b085",
+   "execution_count": 16,
+   "id": "03d85234-c33a-4a43-861d-47328e1ec2ea",
    "metadata": {},
    "outputs": [],
    "source": [
-    "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.output_parsers.openai_functions import JsonKeyOutputFunctionsParser\n",
+    "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",
     "\n",
     "chain = (\n",
     "    {\"doc\": lambda x: x.page_content}\n",
@@ -431,28 +455,36 @@
     "    | 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-4\").bind(\n",
-    "        functions=functions, function_call={\"name\": \"hypothetical_questions\"}\n",
+    "    | ChatOpenAI(max_retries=0, model=\"gpt-4o\").with_structured_output(\n",
+    "        HypotheticalQuestions\n",
     "    )\n",
-    "    | JsonKeyOutputFunctionsParser(key_name=\"questions\")\n",
+    "    | (lambda x: x.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": 24,
+   "execution_count": 17,
    "id": "11d30554",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[\"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?']"
+       "[\"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?\"]"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -462,22 +494,24 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "3eb2e48c",
+   "cell_type": "markdown",
+   "id": "dcffc572-7b20-4b77-857a-90ec360a8f7e",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "hypothetical_questions = chain.batch(docs, {\"max_concurrency\": 5})"
+    "We can batch then batch the chain over all documents and assemble our vector store and document store as before:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 18,
    "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",
@@ -491,82 +525,67 @@
     "    byte_store=store,\n",
     "    id_key=id_key,\n",
     ")\n",
-    "doc_ids = [str(uuid.uuid4()) for _ in docs]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "18831b3b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "doc_ids = [str(uuid.uuid4()) for _ in docs]\n",
+    "\n",
+    "\n",
+    "# Generate Document objects from hypothetical questions\n",
     "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",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "id": "224b24c5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "    )\n",
+    "\n",
+    "\n",
     "retriever.vectorstore.add_documents(question_docs)\n",
     "retriever.docstore.mset(list(zip(doc_ids, docs)))"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "7b442b90",
+   "cell_type": "markdown",
+   "id": "75cba8ab-a06f-4545-85fc-cf49d0204b5e",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "sub_docs = vectorstore.similarity_search(\"justice breyer\")"
+    "Note that querying the underlying vector store will retrieve hypothetical questions that are semantically similar to the input query:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
-   "id": "089b5ad0",
+   "execution_count": 19,
+   "id": "7b442b90",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[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'})]"
+       "[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'})]"
       ]
      },
-     "execution_count": 30,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "sub_docs = retriever.vectorstore.similarity_search(\"justice breyer\")\n",
+    "\n",
     "sub_docs"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "7594b24e",
+   "cell_type": "markdown",
+   "id": "63c32e43-5f4a-463b-a0c2-2101986f70e6",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "retrieved_docs = retriever.get_relevant_documents(\"justice breyer\")"
+    "And invoking the retriever will return the corresponding document:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
-   "id": "4c120c65",
+   "execution_count": 20,
+   "id": "7594b24e",
    "metadata": {},
    "outputs": [
     {
@@ -575,22 +594,15 @@
        "9194"
       ]
      },
-     "execution_count": 32,
+     "execution_count": 20,
      "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": {
@@ -609,7 +621,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,