send single batch of generations

The new Fireworks and FireworksChat implementations are awesome! Added
in this PR https://github.com/langchain-ai/langchain/pull/11117 thank
you @ZixinYang

However, I think stop words were not plumbed correctly. I've made some
simple changes to do that, and also updated the notebook to be a bit
clearer with what's needed to use both new models.


---------

Co-authored-by: Taqi Jaffri <tjaffri@docugami.com>

.github/CONTRIBUTING.md

@@ -9,19 +9,19 @@ to contributions, whether they be in the form of new features, improved infra, b
 ### 👩‍💻 Contributing Code
 
 To contribute to this project, please follow a ["fork and pull request"](https://docs.github.com/en/get-started/quickstart/contributing-to-projects) workflow.
-Please do not try to push directly to this repo unless you are maintainer.
+Please do not try to push directly to this repo unless you are a maintainer.
 
 Please follow the checked-in pull request template when opening pull requests. Note related issues and tag relevant
 maintainers.
 
-Pull requests cannot land without passing the formatting, linting and testing checks first. See
-[Common Tasks](#-common-tasks) for how to run these checks locally.
+Pull requests cannot land without passing the formatting, linting and testing checks first. See [Testing](#testing) and
+[Formatting and Linting](#formatting-and-linting) for how to run these checks locally.
 
 It's essential that we maintain great documentation and testing. If you:
 - Fix a bug
   - Add a relevant unit or integration test when possible. These live in `tests/unit_tests` and `tests/integration_tests`.
 - Make an improvement
-  - Update any affected example notebooks and documentation. These lives in `docs`.
+  - Update any affected example notebooks and documentation. These live in `docs`.
   - Update unit and integration tests when relevant.
 - Add a feature
   - Add a demo notebook in `docs/modules`.
@@ -43,8 +43,8 @@ If you start working on an issue, please assign it to yourself.
 If you are adding an issue, please try to keep it focused on a single, modular bug/improvement/feature.
 If two issues are related, or blocking, please link them rather than combining them.
 
-We will try to keep these issues as up to date as possible, though
-with the rapid rate of develop in this field some may get out of date.
+We will try to keep these issues as up-to-date as possible, though
+with the rapid rate of development in this field some may get out of date.
 If you notice this happening, please let us know.
 
 ### 🙋Getting Help
@@ -59,43 +59,85 @@ we do not want these to get in the way of getting good code into the codebase.
 
 ## 🚀 Quick Start
 
-> **Note:** You can run this repository locally (which is described below) or in a [development container](https://containers.dev/) (which is described in the [.devcontainer folder](https://github.com/hwchase17/langchain/tree/master/.devcontainer)).
+This quick start describes running the repository locally.
+For a [development container](https://containers.dev/), see the [.devcontainer folder](https://github.com/hwchase17/langchain/tree/master/.devcontainer).
 
-This project uses [Poetry](https://python-poetry.org/) v1.5.1 as a dependency manager. Check out Poetry's [documentation on how to install it](https://python-poetry.org/docs/#installation) on your system before proceeding.
+### Dependency Management: Poetry and other env/dependency managers
 
-❗Note: If you use `Conda` or `Pyenv` as your environment / package manager, avoid dependency conflicts by doing the following first:
-1. *Before installing Poetry*, create and activate a new Conda env (e.g. `conda create -n langchain python=3.9`)
-2. Install Poetry v1.5.1 (see above)
-3. Tell Poetry to use the virtualenv python environment (`poetry config virtualenvs.prefer-active-python true`)
-4. Continue with the following steps.
+This project uses [Poetry](https://python-poetry.org/) v1.5.1+ as a dependency manager.
+
+❗Note: *Before installing Poetry*, if you use `Conda`, create and activate a new Conda env (e.g. `conda create -n langchain python=3.9`)
+
+Install Poetry: **[documentation on how to install it](https://python-poetry.org/docs/#installation)**.
+
+❗Note: If you use `Conda` or `Pyenv` as your environment/package manager, after installing Poetry,
+tell Poetry to use the virtualenv python environment (`poetry config virtualenvs.prefer-active-python true`)
+
+### Core vs. Experimental
 
 There are two separate projects in this repository:
 - `langchain`: core langchain code, abstractions, and use cases
-- `langchain.experimental`: more experimental code
+- `langchain.experimental`: see the [Experimental README](../libs/experimental/README.md) for more information.
 
-Each of these has their OWN development environment.
-In order to run any of the commands below, please move into their respective directories.
-For example, to contribute to `langchain` run `cd libs/langchain` before getting started with the below.
+Each of these has their own development environment. Docs are run from the top-level makefile, but development
+is split across separate test & release flows.
 
-To install requirements:
+For this quickstart, start with langchain core:
+
+```bash
+cd libs/langchain
+```
+
+### Local Development Dependencies
+
+Install langchain development requirements (for running langchain, running examples, linting, formatting, tests, and coverage):
 
 ```bash
 poetry install --with test
 ```
 
-This will install all requirements for running the package, examples, linting, formatting, tests, and coverage.
+Then verify dependency installation:
 
-❗Note: If during installation you receive a `WheelFileValidationError` for `debugpy`, please make sure you are running Poetry v1.5.1. This bug was present in older versions of Poetry (e.g. 1.4.1) and has been resolved in newer releases. If you are still seeing this bug on v1.5.1, you may also try disabling "modern installation" (`poetry config installer.modern-installation false`) and re-installing requirements. See [this `debugpy` issue](https://github.com/microsoft/debugpy/issues/1246) for more details.
+```bash
+make test
+```
 
-Now, you should be able to run the common tasks in the following section. To double check, run `make test`, all tests should pass. If they don't you may need to pip install additional dependencies, such as `numexpr` and `openapi_schema_pydantic`.
+If the tests don't pass, you may need to pip install additional dependencies, such as `numexpr` and `openapi_schema_pydantic`.
 
-## ✅ Common Tasks
+If during installation you receive a `WheelFileValidationError` for `debugpy`, please make sure you are running
+Poetry v1.5.1+. This bug was present in older versions of Poetry (e.g. 1.4.1) and has been resolved in newer releases.
+If you are still seeing this bug on v1.5.1, you may also try disabling "modern installation"
+(`poetry config installer.modern-installation false`) and re-installing requirements.
+See [this `debugpy` issue](https://github.com/microsoft/debugpy/issues/1246) for more details.
 
-Type `make` for a list of common tasks.
+### Testing
 
-### Code Formatting
+_some test dependencies are optional; see section about optional dependencies_.
 
-Formatting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/) and [isort](https://pycqa.github.io/isort/).
+Unit tests cover modular logic that does not require calls to outside APIs.
+If you add new logic, please add a unit test.
+
+To run unit tests:
+
+```bash
+make test
+```
+
+To run unit tests in Docker:
+
+```bash
+make docker_tests
+```
+
+There are also [integration tests and code-coverage](../libs/langchain/tests/README.md) available.
+
+### Formatting and Linting
+
+Run these locally before submitting a PR; the CI system will check also.
+
+#### Code Formatting
+
+Formatting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/) and [ruff](https://docs.astral.sh/ruff/rules/).
 
 To run formatting for this project:
 
@@ -111,9 +153,9 @@ make format_diff
 
 This is especially useful when you have made changes to a subset of the project and want to ensure your changes are properly formatted without affecting the rest of the codebase.
 
-### Linting
+#### Linting
 
-Linting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/), [isort](https://pycqa.github.io/isort/), [flake8](https://flake8.pycqa.org/en/latest/), and [mypy](http://mypy-lang.org/).
+Linting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/), [ruff](https://docs.astral.sh/ruff/rules/), and [mypy](http://mypy-lang.org/).
 
 To run linting for this project:
 
@@ -131,10 +173,10 @@ This can be very helpful when you've made changes to only certain parts of the p
 
 We recognize linting can be annoying - if you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
 
-### Spellcheck
+#### Spellcheck
 
 Spellchecking for this project is done via [codespell](https://github.com/codespell-project/codespell).
-Note that `codespell` finds common typos, so could have false-positive (correctly spelled but rarely used) and false-negatives (not finding misspelled) words.
+Note that `codespell` finds common typos, so it could have false-positive (correctly spelled but rarely used) and false-negatives (not finding misspelled) words.
 
 To check spelling for this project:
 
@@ -157,24 +199,14 @@ If codespell is incorrectly flagging a word, you can skip spellcheck for that wo
 ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogyny,unsecure'
 ```
 
-### Coverage
-
-Code coverage (i.e. the amount of code that is covered by unit tests) helps identify areas of the code that are potentially more or less brittle.
-
-To get a report of current coverage, run the following:
-
-```bash
-make coverage
-```
-
-### Working with Optional Dependencies
+## Working with Optional Dependencies
 
 Langchain relies heavily on optional dependencies to keep the Langchain package lightweight.
 
 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.
 
-Users that do not have the dependency installed should be able to **import** your code without
+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:
@@ -188,57 +220,13 @@ To introduce the dependency to the pyproject.toml file correctly, please do the
   ```bash
   poetry lock --no-update
   ```
-4. Add a unit test that the very least attempts to import the new code. Ideally the unit
+4. Add a unit test that the very least attempts to import the new code. Ideally, the unit
 test makes use of lightweight fixtures to test the logic of the code.
 5. Please use the `@pytest.mark.requires(package_name)` decorator for any tests that require the dependency.
 
-### Testing
+## Adding a Jupyter Notebook
 
-See section about optional dependencies.
-
-#### Unit Tests
-
-Unit tests cover modular logic that does not require calls to outside APIs.
-
-To run unit tests:
-
-```bash
-make test
-```
-
-To run unit tests in Docker:
-
-```bash
-make docker_tests
-```
-
-If you add new logic, please add a unit test.
-
-
-
-#### Integration Tests
-
-Integration tests cover logic that requires making calls to outside APIs (often integration with other services).
-
-**warning** Almost no tests should be integration tests.
-
-  Tests that require making network connections make it difficult for other
-  developers to test the code.
-
-  Instead favor relying on `responses` library and/or mock.patch to mock
-  requests using small fixtures.
-
-To run integration tests:
-
-```bash
-make integration_tests
-```
-
-If you add support for a new external API, please add a new integration test.
-
-### Adding a Jupyter Notebook
-
-If you are adding a Jupyter notebook example, you'll want to install the optional `dev` dependencies.
+If you are adding a Jupyter Notebook example, you'll want to install the optional `dev` dependencies.
 
 To install dev dependencies:
 
@@ -259,6 +247,12 @@ When you run `poetry install`, the `langchain` package is installed as editable
 While the code is split between `langchain` and `langchain.experimental`, the documentation is one holistic thing.
 This covers how to get started contributing to documentation.
 
+From the top-level of this repo, install documentation dependencies:
+
+```bash
+poetry install
+```
+
 ### Contribute Documentation
 
 The docs directory contains Documentation and API Reference.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,11 +1,11 @@
 <!-- Thank you for contributing to LangChain!
 
 Replace this entire comment with:
-  - Description: a description of the change, 
-  - Issue: the issue # it fixes (if applicable),
-  - Dependencies: any dependencies required for this change,
-  - Tag maintainer: for a quicker response, tag the relevant maintainer (see below),
-  - Twitter handle: we announce bigger features on Twitter. If your PR gets announced and you'd like a mention, we'll gladly shout you out!
+  - **Description:** a description of the change, 
+  - **Issue:** the issue # it fixes (if applicable),
+  - **Dependencies:** any dependencies required for this change,
+  - **Tag maintainer:** for a quicker response, tag the relevant maintainer (see below),
+  - **Twitter handle:** we announce bigger features on Twitter. If your PR gets announced, and you'd like a mention, we'll gladly shout you out!
 
 Please make sure your PR is passing linting and testing before submitting. Run `make format`, `make lint` and `make test` to check this locally.
 
@@ -14,7 +14,7 @@ https://github.com/hwchase17/langchain/blob/master/.github/CONTRIBUTING.md
 
 If you're adding a new integration, please include:
   1. a test for the integration, preferably unit tests that do not rely on network access,
-  2. an example notebook showing its use. These live is docs/extras directory.
+  2. an example notebook showing its use. It lives in `docs/extras` directory.
 
-If no one reviews your PR within a few days, please @-mention one of @baskaryan, @eyurtsev, @hwchase17, @rlancemartin.
+If no one reviews your PR within a few days, please @-mention one of @baskaryan, @eyurtsev, @hwchase17.
  -->

.github/actions/poetry_setup/action.yml

@@ -27,7 +27,7 @@ runs:
   using: composite
   steps:
     - uses: actions/setup-python@v4
-      name: Setup python $${ inputs.python-version }}
+      name: Setup python ${{ inputs.python-version }}
       with:
         python-version: ${{ inputs.python-version }}
 
@@ -39,10 +39,35 @@ runs:
       with:
         path: |
           /opt/pipx/venvs/poetry
-          /opt/pipx_bin/poetry
         # This step caches the poetry installation, so make sure it's keyed on the poetry version as well.
         key: bin-poetry-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-${{ inputs.poetry-version }}
 
+    - name: Refresh shell hashtable and fixup softlinks
+      if: steps.cache-bin-poetry.outputs.cache-hit == 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      run: |
+        set -eux
+
+        # Refresh the shell hashtable, to ensure correct `which` output.
+        hash -r
+
+        # `actions/cache@v3` doesn't always seem able to correctly unpack softlinks.
+        # Delete and recreate the softlinks pipx expects to have.
+        rm /opt/pipx/venvs/poetry/bin/python
+        cd /opt/pipx/venvs/poetry/bin
+        ln -s "$(which "python$PYTHON_VERSION")" python
+        chmod +x python
+        cd /opt/pipx_bin/
+        ln -s /opt/pipx/venvs/poetry/bin/poetry poetry
+        chmod +x poetry
+
+        # Ensure everything got set up correctly.
+        /opt/pipx/venvs/poetry/bin/python --version
+        /opt/pipx_bin/poetry --version
+
     - name: Install poetry
       if: steps.cache-bin-poetry.outputs.cache-hit != 'true'
       shell: bash

.github/workflows/_lint.yml

@@ -87,7 +87,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
           working-directory: ${{ inputs.working-directory }}
-          cache-key: lint
+          cache-key: lint-with-extras
 
       - name: Check Poetry File
         shell: bash
@@ -102,9 +102,17 @@ jobs:
           poetry lock --check
 
       - name: Install dependencies
+        # Also installs dev/lint/test/typing dependencies, to ensure we have
+        # type hints for as many of our libraries as possible.
+        # This helps catch errors that require dependencies to be spotted, for example:
+        # https://github.com/langchain-ai/langchain/pull/10249/files#diff-935185cd488d015f026dcd9e19616ff62863e8cde8c0bee70318d3ccbca98341
+        #
+        # If you change this configuration, make sure to change the `cache-key`
+        # in the `poetry_setup` action above to stop using the old cache.
+        # It doesn't matter how you change it, any change will cause a cache-bust.
         working-directory: ${{ inputs.working-directory }}
         run: |
-          poetry install
+          poetry install --with dev,lint,test,typing
 
       - name: Install langchain editable
         working-directory: ${{ inputs.working-directory }}

.github/workflows/_pydantic_compatibility.yml

@@ -79,3 +79,15 @@ jobs:
       - name: Run pydantic compatibility tests
         shell: bash
         run: make test
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/_release.yml

@@ -31,13 +31,15 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
     steps:
       - uses: actions/checkout@v3
-      - name: Install poetry
-        run: pipx install "poetry==$POETRY_VERSION"
-      - name: Set up Python 3.10
-        uses: actions/setup-python@v4
+
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.10"
-          cache: "poetry"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
+          cache-key: release
+
       - name: Build project for distribution
         run: poetry build
       - name: Check Version

.github/workflows/_test.yml

@@ -43,3 +43,15 @@ jobs:
       - name: Run core tests
         shell: bash
         run: make test
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/doc_lint.yml

@@ -0,0 +1,22 @@
+---
+name: Documentation Lint
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    - name: Run import check
+      run: |
+        # We should not encourage imports directly from main init file
+        # Expect for hub
+        git grep 'from langchain import' docs/{extras,docs_skeleton,snippets} | grep -vE 'from langchain import (hub)' && exit 1 || exit 0

.github/workflows/langchain_ci.yml

@@ -6,6 +6,8 @@ on:
     branches: [ master ]
   pull_request:
     paths:
+      - '.github/actions/poetry_setup/action.yml'
+      - '.github/tools/**'
       - '.github/workflows/_lint.yml'
       - '.github/workflows/_test.yml'
       - '.github/workflows/_pydantic_compatibility.yml'
@@ -81,3 +83,15 @@ jobs:
 
       - name: Run extended tests
         run: make extended_tests
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/langchain_experimental_ci.yml

@@ -6,6 +6,8 @@ on:
     branches: [ master ]
   pull_request:
     paths:
+      - '.github/actions/poetry_setup/action.yml'
+      - '.github/tools/**'
       - '.github/workflows/_lint.yml'
       - '.github/workflows/_test.yml'
       - '.github/workflows/langchain_experimental_ci.yml'
@@ -81,3 +83,47 @@ jobs:
 
       - name: Run tests
         run: make test
+  extended-tests:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ${{ env.WORKDIR }}
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.9"
+          - "3.10"
+          - "3.11"
+    name: Python ${{ matrix.python-version }} extended tests
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: libs/experimental
+          cache-key: extended
+
+      - name: Install dependencies
+        shell: bash
+        run: |
+          echo "Running extended tests, installing dependencies with poetry..."
+          poetry install -E extended_testing
+
+      - name: Run extended tests
+        run: make extended_tests
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/scheduled_test.yml

@@ -34,12 +34,19 @@ jobs:
           working-directory: libs/langchain
           cache-key: scheduled
 
+      - name: 'Authenticate to Google Cloud'
+        id: 'auth'
+        uses: 'google-github-actions/auth@v1'
+        with:
+          credentials_json: '${{ secrets.GOOGLE_CREDENTIALS }}'
+
       - name: Install dependencies
         working-directory: libs/langchain
         shell: bash
         run: |
           echo "Running scheduled tests, installing dependencies with poetry..."
           poetry install --with=test_integration
+          poetry run pip install google-cloud-aiplatform
 
       - name: Run tests
         shell: bash
@@ -47,3 +54,15 @@ jobs:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
         run: |
           make scheduled_tests
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

Makefile

@@ -42,7 +42,8 @@ spell_fix:
 ######################
 
 help:
-	@echo '----'
+	@echo '===================='
+	@echo '-- DOCUMENTATION --'
 	@echo 'clean                        - run docs_clean and api_docs_clean'
 	@echo 'docs_build                   - build the documentation'
 	@echo 'docs_clean                   - clean the documentation build artifacts'
@@ -51,4 +52,5 @@ help:
 	@echo 'api_docs_clean               - clean the API Reference documentation build artifacts'
 	@echo 'api_docs_linkcheck           - run linkchecker on the API Reference documentation'
 	@echo 'spell_check               	- run codespell on the project'
-	@echo 'spell_fix               		- run codespell on the project and fix the errors'
+	@echo 'spell_fix               		- run codespell on the project and fix the errors'
+	@echo '-- TEST and LINT tasks are within libs/*/ per-package --'

docs/_scripts/model_feat_table.py

@@ -0,0 +1,150 @@
+import os
+from pathlib import Path
+
+from langchain import chat_models, llms
+from langchain.chat_models.base import BaseChatModel, SimpleChatModel
+from langchain.llms.base import BaseLLM, LLM
+
+INTEGRATIONS_DIR = (
+    Path(os.path.abspath(__file__)).parents[1] / "extras" / "integrations"
+)
+LLM_IGNORE = ("FakeListLLM", "OpenAIChat", "PromptLayerOpenAIChat")
+LLM_FEAT_TABLE_CORRECTION = {
+    "TextGen": {"_astream": False, "_agenerate": False},
+    "Ollama": {
+        "_stream": False,
+    },
+    "PromptLayerOpenAI": {"batch_generate": False, "batch_agenerate": False},
+}
+CHAT_MODEL_IGNORE = ("FakeListChatModel", "HumanInputChatModel")
+CHAT_MODEL_FEAT_TABLE_CORRECTION = {
+    "ChatMLflowAIGateway": {"_agenerate": False},
+    "PromptLayerChatOpenAI": {"_stream": False, "_astream": False},
+    "ChatKonko": {"_astream": False, "_agenerate": False},
+}
+
+LLM_TEMPLATE = """\
+---
+sidebar_position: 0
+sidebar_class_name: hidden
+---
+
+# LLMs
+
+import DocCardList from "@theme/DocCardList";
+
+## Features (natively supported)
+All LLMs implement the Runnable interface, which comes with default implementations of all methods, ie. `ainvoke`, `batch`, `abatch`, `stream`, `astream`. This gives all LLMs basic support for async, streaming and batch, which by default is implemented as below:
+- *Async* support defaults to calling the respective sync method in asyncio's default thread pool executor. This lets other async functions in your application make progress while the LLM is being executed, by moving this call to a background thread.
+- *Streaming* support defaults to returning an `Iterator` (or `AsyncIterator` in the case of async streaming) of a single value, the final result returned by the underlying LLM provider. This obviously doesn't give you token-by-token streaming, which requires native support from the LLM provider, but ensures your code that expects an iterator of tokens can work for any of our LLM integrations.
+- *Batch* support defaults to calling the underlying LLM in parallel for each input by making use of a thread pool executor (in the sync batch case) or `asyncio.gather` (in the async batch case). The concurrency can be controlled with the `max_concurrency` key in `RunnableConfig`.
+
+Each LLM integration can optionally provide native implementations for async, streaming or batch, which, for providers that support it, can be more efficient. The table shows, for each integration, which features have been implemented with native support.
+
+{table}
+
+<DocCardList />
+"""
+
+CHAT_MODEL_TEMPLATE = """\
+---
+sidebar_position: 1
+sidebar_class_name: hidden
+---
+
+# Chat models
+
+import DocCardList from "@theme/DocCardList";
+
+## Features (natively supported)
+All ChatModels implement the Runnable interface, which comes with default implementations of all methods, ie. `ainvoke`, `batch`, `abatch`, `stream`, `astream`. This gives all ChatModels basic support for async, streaming and batch, which by default is implemented as below:
+- *Async* support defaults to calling the respective sync method in asyncio's default thread pool executor. This lets other async functions in your application make progress while the ChatModel is being executed, by moving this call to a background thread.
+- *Streaming* support defaults to returning an `Iterator` (or `AsyncIterator` in the case of async streaming) of a single value, the final result returned by the underlying ChatModel provider. This obviously doesn't give you token-by-token streaming, which requires native support from the ChatModel provider, but ensures your code that expects an iterator of tokens can work for any of our ChatModel integrations.
+- *Batch* support defaults to calling the underlying ChatModel in parallel for each input by making use of a thread pool executor (in the sync batch case) or `asyncio.gather` (in the async batch case). The concurrency can be controlled with the `max_concurrency` key in `RunnableConfig`.
+
+Each ChatModel integration can optionally provide native implementations to truly enable async or streaming.
+The table shows, for each integration, which features have been implemented with native support.
+
+{table}
+
+<DocCardList />
+"""
+
+
+def get_llm_table():
+    llm_feat_table = {}
+    for cm in llms.__all__:
+        llm_feat_table[cm] = {}
+        cls = getattr(llms, cm)
+        if issubclass(cls, LLM):
+            for feat in ("_stream", "_astream", ("_acall", "_agenerate")):
+                if isinstance(feat, tuple):
+                    feat, name = feat
+                else:
+                    feat, name = feat, feat
+                llm_feat_table[cm][name] = getattr(cls, feat) != getattr(LLM, feat)
+        else:
+            for feat in [
+                "_stream",
+                "_astream",
+                ("_generate", "batch_generate"),
+                "_agenerate",
+                ("_agenerate", "batch_agenerate"),
+            ]:
+                if isinstance(feat, tuple):
+                    feat, name = feat
+                else:
+                    feat, name = feat, feat
+                llm_feat_table[cm][name] = getattr(cls, feat) != getattr(BaseLLM, feat)
+    final_feats = {
+        k: v
+        for k, v in {**llm_feat_table, **LLM_FEAT_TABLE_CORRECTION}.items()
+        if k not in LLM_IGNORE
+    }
+
+    header = [
+        "model",
+        "_agenerate",
+        "_stream",
+        "_astream",
+        "batch_generate",
+        "batch_agenerate",
+    ]
+    title = ["Model", "Invoke", "Async invoke", "Stream", "Async stream", "Batch", "Async batch"]
+    rows = [title, [":-"] + [":-:"] * (len(title) - 1)]
+    for llm, feats in sorted(final_feats.items()):
+        rows += [[llm, "✅"] + ["✅" if feats.get(h) else "❌" for h in header[1:]]]
+    return "\n".join(["|".join(row) for row in rows])
+
+
+def get_chat_model_table():
+    feat_table = {}
+    for cm in chat_models.__all__:
+        feat_table[cm] = {}
+        cls = getattr(chat_models, cm)
+        if issubclass(cls, SimpleChatModel):
+            comparison_cls = SimpleChatModel
+        else:
+            comparison_cls = BaseChatModel
+        for feat in ("_stream", "_astream", "_agenerate"):
+            feat_table[cm][feat] = getattr(cls, feat) != getattr(comparison_cls, feat)
+    final_feats = {
+        k: v
+        for k, v in {**feat_table, **CHAT_MODEL_FEAT_TABLE_CORRECTION}.items()
+        if k not in CHAT_MODEL_IGNORE
+    }
+    header = ["model", "_agenerate", "_stream", "_astream"]
+    title = ["Model", "Invoke", "Async invoke", "Stream", "Async stream"]
+    rows = [title, [":-"] + [":-:"] * (len(title) - 1)]
+    for llm, feats in sorted(final_feats.items()):
+        rows += [[llm, "✅"] + ["✅" if feats.get(h) else "❌" for h in header[1:]]]
+    return "\n".join(["|".join(row) for row in rows])
+
+
+if __name__ == "__main__":
+    llm_page = LLM_TEMPLATE.format(table=get_llm_table())
+    with open(INTEGRATIONS_DIR / "llms" / "index.mdx", "w") as f:
+        f.write(llm_page)
+    chat_model_page = CHAT_MODEL_TEMPLATE.format(table=get_chat_model_table())
+    with open(INTEGRATIONS_DIR / "chat" / "index.mdx", "w") as f:
+        f.write(chat_model_page)

docs/api_reference/create_api_rst.py

@@ -3,7 +3,7 @@ import importlib
 import inspect
 import typing
 from pathlib import Path
-from typing import TypedDict, Sequence, List, Dict, Literal, Union
+from typing import TypedDict, Sequence, List, Dict, Literal, Union, Optional
 from enum import Enum
 
 from pydantic import BaseModel
@@ -122,7 +122,8 @@ def _merge_module_members(
 
 
 def _load_package_modules(
-    package_directory: Union[str, Path]
+    package_directory: Union[str, Path],
+    submodule: Optional[str] = None
 ) -> Dict[str, ModuleMembers]:
     """Recursively load modules of a package based on the file system.
 
@@ -131,6 +132,7 @@ def _load_package_modules(
 
     Parameters:
         package_directory: Path to the package directory.
+        submodule: Optional name of submodule to load.
 
     Returns:
         list: A list of loaded module objects.
@@ -142,8 +144,13 @@ def _load_package_modules(
     )
     modules_by_namespace = {}
 
+    # Get the high level package name
     package_name = package_path.name
 
+    # If we are loading a submodule, add it in
+    if submodule is not None:
+        package_path = package_path / submodule
+
     for file_path in package_path.rglob("*.py"):
         if file_path.name.startswith("_"):
             continue
@@ -160,9 +167,16 @@ def _load_package_modules(
         top_namespace = namespace.split(".")[0]
 
         try:
-            module_members = _load_module_members(
-                f"{package_name}.{namespace}", namespace
-            )
+            # If submodule is present, we need to construct the paths in a slightly
+            # different way
+            if submodule is not None:
+                module_members = _load_module_members(
+                    f"{package_name}.{submodule}.{namespace}", f"{submodule}.{namespace}"
+                )
+            else:
+                module_members = _load_module_members(
+                    f"{package_name}.{namespace}", namespace
+                )
             # Merge module members if the namespace already exists
             if top_namespace in modules_by_namespace:
                 existing_module_members = modules_by_namespace[top_namespace]
@@ -269,6 +283,12 @@ Functions
 def main() -> None:
     """Generate the reference.rst file for each package."""
     lc_members = _load_package_modules(PKG_DIR)
+    # Put some packages at top level
+    tools = _load_package_modules(PKG_DIR, "tools")
+    lc_members['tools.render'] = tools['render']
+    agents = _load_package_modules(PKG_DIR, "agents")
+    lc_members['agents.output_parsers'] = agents['output_parsers']
+    lc_members['agents.format_scratchpad'] = agents['format_scratchpad']
     lc_doc = ".. _api_reference:\n\n" + _construct_doc("langchain", lc_members)
     with open(WRITE_FILE, "w") as f:
         f.write(lc_doc)

docs/api_reference/templates/redirects.html

@@ -5,9 +5,10 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <meta http-equiv="Refresh" content="0; url={{ redirect }}" />
-    <meta name="Description" content="scikit-learn: machine learning in Python">
+    <meta name="robots" content="follow, index">
+    <meta name="Description" content="Python API reference for LangChain.">
     <link rel="canonical" href="{{ redirect }}" />
-    <title>scikit-learn: machine learning in Python</title>
+    <title>LangChain Python API Reference Documentation.</title>
   </head>
   <body>
     <p>You will be automatically redirected to the <a href="{{ redirect }}">new location of this page</a>.</p>

docs/docs_skeleton/docs/community.md

@@ -17,38 +17,38 @@ Whether you’re new to LangChain, looking to go deeper, or just want to get mor
 
 LangChain is the product of over 5,000+ contributions by 1,500+ contributors, and there is ******still****** so much to do together. Here are some ways to get involved:
 
-- **[Open a pull request](https://github.com/langchain-ai/langchain/issues):** we’d appreciate all forms of contributions–new features, infrastructure improvements, better documentation, bug fixes, etc. If you have an improvement or an idea, we’d love to work on it with you.
+- **[Open a pull request](https://github.com/langchain-ai/langchain/issues):** We’d appreciate all forms of contributions–new features, infrastructure improvements, better documentation, bug fixes, etc. If you have an improvement or an idea, we’d love to work on it with you.
 - **[Read our contributor guidelines:](https://github.com/langchain-ai/langchain/blob/bbd22b9b761389a5e40fc45b0570e1830aabb707/.github/CONTRIBUTING.md)** We ask contributors to follow a ["fork and pull request"](https://docs.github.com/en/get-started/quickstart/contributing-to-projects) workflow, run a few local checks for formatting, linting, and testing before submitting, and follow certain documentation and testing conventions.
     - **First time contributor?** [Try one of these PRs with the “good first issue” tag](https://github.com/langchain-ai/langchain/contribute).
-- **Become an expert:** our experts help the community by answering product questions in Discord. If that’s a role you’d like to play, we’d be so grateful! (And we have some special experts-only goodies/perks we can tell you more about). Send us an email to introduce yourself at hello@langchain.dev and we’ll take it from there!
-- **Integrate with LangChain:** if your product integrates with LangChain–or aspires to–we want to help make sure the experience is as smooth as possible for you and end users. Send us an email at hello@langchain.dev and tell us what you’re working on.
+- **Become an expert:** Our experts help the community by answering product questions in Discord. If that’s a role you’d like to play, we’d be so grateful! (And we have some special experts-only goodies/perks we can tell you more about). Send us an email to introduce yourself at hello@langchain.dev and we’ll take it from there!
+- **Integrate with LangChain:** If your product integrates with LangChain–or aspires to–we want to help make sure the experience is as smooth as possible for you and end users. Send us an email at hello@langchain.dev and tell us what you’re working on.
     - **Become an Integration Maintainer:** Partner with our team to ensure your integration stays up-to-date and talk directly with users (and answer their inquiries) in our Discord. Introduce yourself at hello@langchain.dev if you’d like to explore this role.
 
 
 # 🌍 Meetups, Events, and Hackathons
 
 One of our favorite things about working in AI is how much enthusiasm there is for building together. We want to help make that as easy and impactful for you as possible! 
-- **Find a meetup, hackathon, or webinar:** you can find the one for you on our [global events calendar](https://mirror-feeling-d80.notion.site/0bc81da76a184297b86ca8fc782ee9a3?v=0d80342540df465396546976a50cfb3f).  
-    - **Submit an event to our calendar:** email us at events@langchain.dev with a link to your event page! We can also help you spread the word with our local communities.
-- **Host a meetup:** If you want to bring a group of builders together, we want to help! We can publicize your event on our event calendar/Twitter, share with our local communities in Discord, send swag, or potentially hook you up with a sponsor. Email us at events@langchain.dev to tell us about your event!
-- **Become a meetup sponsor:** we often hear from groups of builders that want to get together, but are blocked or limited on some dimension (space to host, budget for snacks, prizes to distribute, etc.). If you’d like to help, send us an email to events@langchain.dev we can share more about how it works!
-- **Speak at an event:** meetup hosts are always looking for great speakers, presenters, and panelists. If you’d like to do that at an event, send us an email to hello@langchain.dev with more information about yourself, what you want to talk about, and what city you’re based in and we’ll try to match you with an upcoming event!
+- **Find a meetup, hackathon, or webinar:** You can find the one for you on our [global events calendar](https://mirror-feeling-d80.notion.site/0bc81da76a184297b86ca8fc782ee9a3?v=0d80342540df465396546976a50cfb3f).  
+    - **Submit an event to our calendar:** Email us at events@langchain.dev with a link to your event page! We can also help you spread the word with our local communities.
+- **Host a meetup:** If you want to bring a group of builders together, we want to help! We can publicize your event on our event calendar/Twitter, share it with our local communities in Discord, send swag, or potentially hook you up with a sponsor. Email us at events@langchain.dev to tell us about your event!
+- **Become a meetup sponsor:** We often hear from groups of builders that want to get together, but are blocked or limited on some dimension (space to host, budget for snacks, prizes to distribute, etc.). If you’d like to help, send us an email to events@langchain.dev we can share more about how it works!
+- **Speak at an event:** Meetup hosts are always looking for great speakers, presenters, and panelists. If you’d like to do that at an event, send us an email to hello@langchain.dev with more information about yourself, what you want to talk about, and what city you’re based in and we’ll try to match you with an upcoming event!
 - **Tell us about your LLM community:** If you host or participate in a community that would welcome support from LangChain and/or our team, send us an email at hello@langchain.dev and let us know how we can help.
 
 # 📣 Help Us Amplify Your Work
 
 If you’re working on something you’re proud of, and think the LangChain community would benefit from knowing about it, we want to help you show it off.
 
-- **Post about your work and mention us:** we love hanging out on Twitter to see what people in the space are talking about and working on. If you tag [@langchainai](https://twitter.com/LangChainAI), we’ll almost certainly see it and can show you some love.
-- **Publish something on our blog:** if you’re writing about your experience building with LangChain, we’d love to post (or crosspost) it on our blog! E-mail hello@langchain.dev with a draft of your post! Or even an idea for something you want to write about.
+- **Post about your work and mention us:** We love hanging out on Twitter to see what people in the space are talking about and working on. If you tag [@langchainai](https://twitter.com/LangChainAI), we’ll almost certainly see it and can show you some love.
+- **Publish something on our blog:** If you’re writing about your experience building with LangChain, we’d love to post (or crosspost) it on our blog! E-mail hello@langchain.dev with a draft of your post! Or even an idea for something you want to write about.
 - **Get your product onto our [integrations hub](https://integrations.langchain.com/):** Many developers take advantage of our seamless integrations with other products, and come to our integrations hub to find out who those are. If you want to get your product up there, tell us about it (and how it works with LangChain) at hello@langchain.dev.
 
 # ☀️ Stay in the loop
 
 Here’s where our team hangs out, talks shop, spotlights cool work, and shares what we’re up to. We’d love to see you there too.
 
-- **[Twitter](https://twitter.com/LangChainAI):** we post about what we’re working on and what cool things we’re seeing in the space. If you tag @langchainai in your post, we’ll almost certainly see it, and can show you some love!
+- **[Twitter](https://twitter.com/LangChainAI):** We post about what we’re working on and what cool things we’re seeing in the space. If you tag @langchainai in your post, we’ll almost certainly see it, and can show you some love!
 - **[Discord](https://discord.gg/6adMQxSpJS):** connect with >30k developers who are building with LangChain
-- **[GitHub](https://github.com/langchain-ai/langchain):** open pull requests, contribute to a discussion, and/or contribute
+- **[GitHub](https://github.com/langchain-ai/langchain):** Open pull requests, contribute to a discussion, and/or contribute
 - **[Subscribe to our bi-weekly Release Notes](https://6w1pwbss0py.typeform.com/to/KjZB1auB):** a twice/month email roundup of the coolest things going on in our orbit
-- **Slack:** if you’re building an application in production at your company, we’d love to get into a Slack channel together. Fill out [this form](https://airtable.com/appwQzlErAS2qiP0L/shrGtGaVBVAz7NcV2) and we’ll get in touch about setting one up.
+- **Slack:** If you’re building an application in production at your company, we’d love to get into a Slack channel together. Fill out [this form](https://airtable.com/appwQzlErAS2qiP0L/shrGtGaVBVAz7NcV2) and we’ll get in touch about setting one up.

docs/docs_skeleton/docs/expression_language/index.mdx

@@ -0,0 +1,33 @@
+---
+sidebar_class_name: hidden
+---
+
+# LangChain Expression Language (LCEL)
+
+LangChain Expression Language or LCEL is a declarative way to easily compose chains together.
+There are several benefits to writing chains in this manner (as opposed to writing normal code):
+
+**Async, Batch, and Streaming Support**
+Any chain constructed this way will automatically have full sync, async, batch, and streaming support.
+This makes it easy to prototype a chain in a Jupyter notebook using the sync interface, and then expose it as an async streaming interface.
+
+**Fallbacks**
+The non-determinism of LLMs makes it important to be able to handle errors gracefully.
+With LCEL you can easily attach fallbacks to any chain.
+
+**Parallelism**
+Since LLM applications involve (sometimes long) API calls, it often becomes important to run things in parallel.
+With LCEL syntax, any components that can be run in parallel automatically are.
+
+**Seamless LangSmith Tracing Integration**
+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](https://smith.langchain.com) for maximal observability and debuggability.
+
+#### [Interface](/docs/expression_language/interface)
+The base interface shared by all LCEL objects
+
+#### [How to](/docs/expression_language/how_to)
+How to use core features of LCEL
+
+#### [Cookbook](/docs/expression_language/cookbook)
+Examples of common LCEL usage patterns

docs/docs_skeleton/docs/get_started/introduction.mdx

@@ -4,21 +4,21 @@ sidebar_position: 0
 
 # Introduction
 
-**LangChain** is a framework for developing applications powered by language models. It enables applications that are:
-- **Data-aware**: connect a language model to other sources of data
-- **Agentic**: allow a language model to interact with its environment
+**LangChain** is a framework for developing applications powered by language models. It enables applications that:
+- **Are context-aware**: connect a language model to sources of context (prompt instructions, few shot examples, content to ground its response in, etc.)
+- **Reason**: rely on a language model to reason (about how to answer based on provided context, what actions to take, etc.)
 
 The main value props of LangChain are:
 1. **Components**: abstractions for working with language models, along with a collection of implementations for each abstraction. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
 2. **Off-the-shelf chains**: a structured assembly of components for accomplishing specific higher-level tasks
 
-Off-the-shelf chains make it easy to get started. For more complex applications and nuanced use-cases, components make it easy to customize existing chains or build new ones.
+Off-the-shelf chains make it easy to get started. For complex applications, components make it easy to customize existing chains and build new ones.
 
 ## Get started
 
-[Here’s](/docs/get_started/installation.html) how to install LangChain, set up your environment, and start building.
+[Here’s](/docs/get_started/installation) how to install LangChain, set up your environment, and start building.
 
-We recommend following our [Quickstart](/docs/get_started/quickstart.html) guide to familiarize yourself with the framework by building your first LangChain application.
+We recommend following our [Quickstart](/docs/get_started/quickstart) guide to familiarize yourself with the framework by building your first LangChain application.
 
 _**Note**: These docs are for the LangChain [Python package](https://github.com/hwchase17/langchain). For documentation on [LangChain.js](https://github.com/hwchase17/langchainjs), the JS/TS version, [head here](https://js.langchain.com/docs)._
 
@@ -40,25 +40,24 @@ Persist application state between runs of a chain
 Log and stream intermediate steps of any chain
 
 ## Examples, ecosystem, and resources
-### [Use cases](/docs/use_cases/)
+### [Use cases](/docs/use_cases/question_answering/)
 Walkthroughs and best-practices for common end-to-end use cases, like:
+- [Document question answering](/docs/use_cases/question_answering/)
 - [Chatbots](/docs/use_cases/chatbots/)
-- [Answering questions using sources](/docs/use_cases/question_answering/)
-- [Analyzing structured data](/docs/use_cases/tabular.html)
+- [Analyzing structured data](/docs/use_cases/qa_structured/sql/)
 - and much more...
 
 ### [Guides](/docs/guides/)
 Learn best practices for developing with LangChain.
 
-### [Ecosystem](/docs/ecosystem/)
-LangChain is part of a rich ecosystem of tools that integrate with our framework and build on top of it. Check out our growing list of [integrations](/docs/integrations/) and [dependent repos](/docs/ecosystem/dependents).
+### [Ecosystem](/docs/integrations/providers/)
+LangChain is part of a rich ecosystem of tools that integrate with our framework and build on top of it. Check out our growing list of [integrations](/docs/integrations/providers/) and [dependent repos](/docs/additional_resources/dependents).
 
 ### [Additional resources](/docs/additional_resources/)
-Our community is full of prolific developers, creative builders, and fantastic teachers. Check out [YouTube tutorials](/docs/additional_resources/youtube.html) for great tutorials from folks in the community, and [Gallery](https://github.com/kyrolabs/awesome-langchain) for a list of awesome LangChain projects, compiled by the folks at [KyroLabs](https://kyrolabs.com).
+Our community is full of prolific developers, creative builders, and fantastic teachers. Check out [YouTube tutorials](/docs/additional_resources/youtube) for great tutorials from folks in the community, and [Gallery](https://github.com/kyrolabs/awesome-langchain) for a list of awesome LangChain projects, compiled by the folks at [KyroLabs](https://kyrolabs.com).
 
-<h3><span style={{color:"#2e8555"}}> Support </span></h3>
-
-Join us on [GitHub](https://github.com/hwchase17/langchain) or [Discord](https://discord.gg/6adMQxSpJS) to ask questions, share feedback, meet other developers building with LangChain, and dream about the future of LLM’s.
+### [Community](/docs/community)
+Head to the [Community navigator](/docs/community) to find places to ask questions, share feedback, meet other developers, and dream about the future of LLM’s.
 
 ## API reference
 

docs/docs_skeleton/docs/get_started/quickstart.mdx

@@ -25,13 +25,12 @@ import OpenAISetup from "@snippets/get_started/quickstart/openai_setup.mdx"
 Now we can start building our language model application. LangChain provides many modules that can be used to build language model applications.
 Modules can be used as stand-alones in simple applications and they can be combined for more complex use cases.
 
-The core building block of LangChain applications is the LLMChain.
-This combines three things:
+The most common and most important chain that LangChain helps create contains three things:
 - LLM: The language model is the core reasoning engine here. In order to work with LangChain, you need to understand the different types of language models and how to work with them.
 - Prompt Templates: This provides instructions to the language model. This controls what the language model outputs, so understanding how to construct prompts and different prompting strategies is crucial.
 - Output Parsers: These translate the raw response from the LLM to a more workable format, making it easy to use the output downstream.
 
-In this getting started guide we will cover those three components by themselves, and then cover the LLMChain which combines all of them.
+In this getting started guide we will cover those three components by themselves, and then go over how to combine all of them.
 Understanding these concepts will set you up well for being able to use and customize LangChain applications.
 Most LangChain applications allow you to configure the LLM and/or the prompt used, so knowing how to take advantage of this will be a big enabler.
 
@@ -59,8 +58,8 @@ LangChain provides several objects to easily distinguish between different roles
 If none of those roles sound right, there is also a `ChatMessage` class where you can specify the role manually.
 For more information on how to use these different messages most effectively, see our prompting guide.
 
-LangChain exposes a standard interface for both, but it's useful to understand this difference in order to construct prompts for a given language model.
-The standard interface that LangChain exposes has two methods:
+LangChain provides a standard interface for both, but it's useful to understand this difference in order to construct prompts for a given language model.
+The standard interface that LangChain provides has two methods:
 - `predict`: Takes in a string, returns a string
 - `predict_messages`: Takes in a list of messages, returns a message.
 
@@ -119,7 +118,7 @@ Let's take a look at this below:
 
 <PromptTemplateChatModel/>
 
-ChatPromptTemplates can also include other things besides ChatMessageTemplates - see the [section on prompts](/docs/modules/model_io/prompts) for more detail.
+ChatPromptTemplates can also be constructed in other ways - see the [section on prompts](/docs/modules/model_io/prompts) for more detail.
 
 ## Output parsers
 
@@ -138,10 +137,10 @@ import OutputParser from "@snippets/get_started/quickstart/output_parser.mdx"
 
 <OutputParser/>
 
-## LLMChain
+## PromptTemplate + LLM + OutputParser
 
 We can now combine all these into one chain.
-This chain will take input variables, pass those to a prompt template to create a prompt, pass the prompt to an LLM, and then pass the output through an (optional) output parser.
+This chain will take input variables, pass those to a prompt template to create a prompt, pass the prompt to a language model, and then pass the output through an (optional) output parser.
 This is a convenient way to bundle up a modular piece of logic.
 Let's see it in action!
 
@@ -149,14 +148,19 @@ import LLMChain from "@snippets/get_started/quickstart/llm_chain.mdx"
 
 <LLMChain/>
 
+Note that we are using the `|` syntax to join these components together.
+This `|` syntax is called the LangChain Expression Language.
+To learn more about this syntax, read the documentation [here](/docs/expression_language).
+
 ## Next steps
 
 This is it!
-We've now gone over how to create the core building block of LangChain applications - the LLMChains.
+We've now gone over how to create the core building block of LangChain applications.
 There is a lot more nuance in all these components (LLMs, prompts, output parsers) and a lot more different components to learn about as well.
 To continue on your journey:
 
 - [Dive deeper](/docs/modules/model_io) into LLMs, prompts, and output parsers
 - Learn the other [key components](/docs/modules)
+- Read up on [LangChain Expression Language](/docs/expression_language) to learn how to chain these components together
 - Check out our [helpful guides](/docs/guides) for detailed walkthroughs on particular topics
 - Explore [end-to-end use cases](/docs/use_cases)

docs/docs_skeleton/docs/guides/evaluation/comparison/index.mdx

@@ -16,6 +16,10 @@ Here's a summary of the key methods and properties of a comparison evaluator:
 - `requires_input`: This property indicates whether this evaluator requires an input string.
 - `requires_reference`: This property specifies whether this evaluator requires a reference label.
 
+:::note LangSmith Support
+The [run_on_dataset](https://api.python.langchain.com/en/latest/api_reference.html#module-langchain.smith) evaluation method is designed to evaluate only a single model at a time, and thus, doesn't support these evaluators.
+:::
+
 Detailed information about creating custom evaluators and the available built-in comparison evaluators is provided in the following sections.
 
 import DocCardList from "@theme/DocCardList";

docs/docs_skeleton/docs/guides/evaluation/index.mdx

@@ -1,7 +1,3 @@
----
-sidebar_position: 6
----
-
 import DocCardList from "@theme/DocCardList";
 
 # Evaluation

docs/docs_skeleton/docs/guides/expression_language/index.mdx

@@ -1,9 +0,0 @@
-# LangChain Expression Language
-
-import DocCardList from "@theme/DocCardList";
-
-LangChain Expression Language is a declarative way to easily compose chains together.
-Any chain constructed this way will automatically have full sync, async, and streaming support.
-See guides below for how to interact with chains constructed this way as well as cookbook examples.
-
-<DocCardList />

docs/docs_skeleton/docs/guides/langsmith/index.md

@@ -2,11 +2,21 @@
 
 import DocCardList from "@theme/DocCardList";
 
-LangSmith helps you trace and evaluate your language model applications and intelligent agents to help you
+[LangSmith](https://smith.langchain.com) helps you trace and evaluate your language model applications and intelligent agents to help you
 move from prototype to production.
 
 Check out the [interactive walkthrough](/docs/guides/langsmith/walkthrough) below to get started.
 
-For more information, please refer to the [LangSmith documentation](https://docs.smith.langchain.com/)
+For more information, please refer to the [LangSmith documentation](https://docs.smith.langchain.com/).
+
+For tutorials and other end-to-end examples demonstrating ways to integrate LangSmith in your workflow,
+check out the [LangSmith Cookbook](https://github.com/langchain-ai/langsmith-cookbook). Some of the guides therein include:
+
+- Leveraging user feedback in your JS application ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/feedback-examples/nextjs/README.md)).
+- Building an automated feedback pipeline ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/feedback-examples/algorithmic-feedback/algorithmic_feedback.ipynb)).
+- How to evaluate and audit your RAG workflows ([link](https://github.com/langchain-ai/langsmith-cookbook/tree/main/testing-examples/qa-correctness)).
+- How to fine-tune a LLM on real usage data ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/fine-tuning-examples/export-to-openai/fine-tuning-on-chat-runs.ipynb)).
+- How to use the [LangChain Hub](https://smith.langchain.com/hub) to version your prompts ([link](https://github.com/langchain-ai/langsmith-cookbook/blob/main/hub-examples/retrieval-qa-chain/retrieval-qa.ipynb))
+
 
 <DocCardList />

docs/docs_skeleton/docs/guides/safety/amazon_comprehend_chain.ipynb

@@ -22,6 +22,16 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "b39ac41a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install -U langchain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
    "id": "3f8518ad-c762-413c-b8c9-f1c211fc311d",
    "metadata": {
     "tags": []
@@ -30,12 +40,7 @@
    "source": [
     "import boto3\n",
     "\n",
-    "comprehend_client = boto3.client('comprehend', \n",
-    "                                 region_name='us-east-1', \n",
-    "                                 aws_access_key_id=\"ASIA6BR6ZDLNQLMEGWHM\",\n",
-    "                                 aws_secret_access_key=\"Y79nefFoOfvgrog6sojSe55xTuKqDJY53BgfrtlG\",\n",
-    "                                 aws_session_token=\"IQoJb3JpZ2luX2VjEIP//////////wEaCXVzLWVhc3QtMSJGMEQCIBvUl0Wj5Gu5GrHB+i5fHkaVc2V1381M7UNRX8EggHORAiB+dG/uKJ4loHn2oAcXIEy6+lfU7wygl4zw/vUo2VItFiqfAghMEAIaDDk2NTQyNTU2ODQ3NSIMfbh8uyoO1XONSkuEKvwBTMxeDCi//9U9LGIwZZzIiHOudQAqR2wlIGZKcw//abSeHNBE1AoDT8ibcqk7EuIt9fwnj1WYiLGmSIWd9/kSZShiKdYg0UpNWyr1/LdeutV5byFAjT21RnWTgSMr0QeSCU698PFusvO1Coph8C75pcqTVYsxi/HypJT8OfB5iCxKgfzx0qD4X6hScpIAEYZhgQXHFBAeubqMkVPYEqSob6fSm1vEI8LkU8HG1N2M2p8TzGCQWo5uBgtNkipxve++bkR+xjiNLIpAN3P1xF2/W/lYlz+4xGsi90aZqIVh/tOvAjg7Yx1Dd5Ir2C0fZc7wbtabzVFlJZ7GFcpcMOX0o6cGOp4BismuW2CJRBmFFpoparqraQaiQBY/VDbQg9KQc/Y6o0oCxkESLUdY6ino3yrheT3W832eAg0RwrmEaQqT8kKGyJFimUxrAF/otNQhySLKuSXLooguammJiQAtgK1EhmuLBUBoLcngxQ31kDqw13g7Ccwuo68fnI/QzQLj5MX+V5VLCSp9VrOzi9XSjmeF/TJQARdZeL3CSeu2pATQc80=\"\n",
-    "                                )"
+    "comprehend_client = boto3.client('comprehend', region_name='us-east-1')"
    ]
   },
   {
@@ -48,7 +53,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "74550d74-3c01-4ba7-ad32-ca66d955d001",
    "metadata": {
     "tags": []
@@ -100,7 +105,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain import PromptTemplate, LLMChain\n",
+    "from langchain.prompts import PromptTemplate\nfrom langchain.chains import LLMChain\n",
     "from langchain.llms.fake import FakeListLLM\n",
     "from langchain_experimental.comprehend_moderation.base_moderation_exceptions import ModerationPiiError\n",
     "\n",
@@ -112,7 +117,8 @@
     "\n",
     "responses = [\n",
     "    \"Final Answer: A credit card number looks like 1289-2321-1123-2387. A fake SSN number looks like 323-22-9980. John Doe's phone number is (999)253-9876.\", \n",
-    "    \"Final Answer: This is a really shitty way of constructing a birdhouse. This is fucking insane to think that any birds would actually create their motherfucking nests here.\"\n",
+    "    # replace with your own expletive\n",
+    "    \"Final Answer: This is a really <expletive> way of constructing a birdhouse. This is <expletive> insane to think that any birds would actually create their <expletive> nests here.\"\n",
     "]\n",
     "llm = FakeListLLM(responses=responses)\n",
     "\n",
@@ -128,9 +134,9 @@
     ")\n",
     "\n",
     "try:\n",
-    "    response = chain.invoke({\"question\": \"A sample SSN number looks like this 123-456-7890. Can you give me some more samples?\"})\n",
+    "    response = chain.invoke({\"question\": \"A sample SSN number looks like this . Can you give me some more samples?\"})\n",
     "except ModerationPiiError as e:\n",
-    "    print(e.message)\n",
+    "    print(str(e))\n",
     "else:\n",
     "    print(response['output'])\n"
    ]
@@ -160,36 +166,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "d6e8900a-44ef-4967-bde8-b88af282139d",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "from langchain_experimental.comprehend_moderation import BaseModerationActions, BaseModerationFilters\n",
+    "from langchain_experimental.comprehend_moderation import (BaseModerationConfig, \n",
+    "                                 ModerationIntentConfig, \n",
+    "                                 ModerationPiiConfig, \n",
+    "                                 ModerationToxicityConfig\n",
+    ")\n",
     "\n",
-    "moderation_config = { \n",
-    "        \"filters\":[ \n",
-    "                BaseModerationFilters.PII, \n",
-    "                BaseModerationFilters.TOXICITY,\n",
-    "                BaseModerationFilters.INTENT\n",
-    "        ],\n",
-    "        \"pii\":{ \n",
-    "                \"action\": BaseModerationActions.ALLOW, \n",
-    "                \"threshold\":0.5, \n",
-    "                \"labels\":[\"SSN\"],\n",
-    "                \"mask_character\": \"X\"\n",
-    "        },\n",
-    "        \"toxicity\":{ \n",
-    "                \"action\": BaseModerationActions.STOP, \n",
-    "                \"threshold\":0.5\n",
-    "        },\n",
-    "        \"intent\":{ \n",
-    "                \"action\": BaseModerationActions.STOP, \n",
-    "                \"threshold\":0.5\n",
-    "        }\n",
-    "}"
+    "pii_config = ModerationPiiConfig(\n",
+    "    labels=[\"SSN\"],\n",
+    "    redact=True,\n",
+    "    mask_character=\"X\"\n",
+    ")\n",
+    "\n",
+    "toxicity_config = ModerationToxicityConfig(\n",
+    "    threshold=0.5\n",
+    ")\n",
+    "\n",
+    "intent_config = ModerationIntentConfig(\n",
+    "    threshold=0.5\n",
+    ")\n",
+    "\n",
+    "moderation_config = BaseModerationConfig(\n",
+    "    filters=[pii_config, toxicity_config, intent_config]\n",
+    ")"
    ]
   },
   {
@@ -197,16 +203,20 @@
    "id": "3634376b-5938-43df-9ed6-70ca7e99290f",
    "metadata": {},
    "source": [
-    "At the core of the configuration you have three filters specified in the `filters` key:\n",
+    "At the core of the the configuration there are three configuration models to be used\n",
     "\n",
-    "1. `BaseModerationFilters.PII`\n",
-    "2. `BaseModerationFilters.TOXICITY`\n",
-    "3. `BaseModerationFilters.INTENT`\n",
+    "- `ModerationPiiConfig` used for configuring the behavior of the PII validations. Following are the parameters it can be initialized with\n",
+    "  - `labels` the PII entity labels. Defaults to an empty list which means that the PII validation will consider all PII entities.\n",
+    "  - `threshold` the confidence threshold for the detected entities, defaults to 0.5 or 50%\n",
+    "  - `redact` a boolean flag to enforce whether redaction should be performed on the text, defaults to `False`. When `False`, the PII validation will error out when it detects any PII entity, when set to `True` it simply redacts the PII values in the text.\n",
+    "  - `mask_character` the character used for masking, defaults to asterisk (*)\n",
+    "- `ModerationToxicityConfig` used for configuring the behavior of the toxicity validations. Following are the parameters it can be initialized with\n",
+    "  - `labels` the Toxic entity labels. Defaults to an empty list which means that the toxicity validation will consider all toxic entities. all\n",
+    "  - `threshold` the confidence threshold for the detected entities, defaults to 0.5 or 50% \n",
+    "- `ModerationIntentConfig` used for configuring the behavior of the intent validation\n",
+    "  - `threshold` the confidence threshold for the the intent classification, defaults to 0.5 or 50% \n",
     "\n",
-    "And an `action` key that defines two possible actions for each moderation function:\n",
-    "\n",
-    "1. `BaseModerationActions.ALLOW` - `allows` the prompt to pass through but masks detected PII in case of PII check. The default behavior is to run and redact all PII entities. If there is an entity specified in the `labels` field, then only those entities will go through the PII check and masked.\n",
-    "2. `BaseModerationActions.STOP` - `stops` the prompt from passing through to the next step in case any PII, Toxicity, or incorrect Intent is detected. The action of `BaseModerationActions.STOP` will raise a Python `Exception` essentially stopping the chain in progress.\n",
+    "Finally, you use the `BaseModerationConfig` to define the order in which each of these checks are to be performed. The `BaseModerationConfig` takes an optional `filters` parameter which can be a list of one or more than one of the above validation checks, as seen in the previous code block. The  `BaseModerationConfig` can also be initialized with any `filters` in which case it will use all the checks with default configuration (more on this explained later).\n",
     "\n",
     "Using the configuration in the previous cell will perform PII checks and will allow the prompt to pass through however it will mask any SSN numbers present in either the prompt or the LLM output.\n"
    ]
@@ -244,7 +254,8 @@
     "\n",
     "responses = [\n",
     "    \"Final Answer: A credit card number looks like 1289-2321-1123-2387. A fake SSN number looks like 323-22-9980. John Doe's phone number is (999)253-9876.\", \n",
-    "    \"Final Answer: This is a really shitty way of constructing a birdhouse. This is fucking insane to think that any birds would actually create their motherfucking nests here.\"\n",
+    "    # replace with your own expletive\n",
+    "    \"Final Answer: This is a really <expletive> way of constructing a birdhouse. This is <expletive> insane to think that any birds would actually create their <expletive> nests here.\"\n",
     "]\n",
     "llm = FakeListLLM(responses=responses)\n",
     "\n",
@@ -369,27 +380,23 @@
    },
    "outputs": [],
    "source": [
-    "moderation_config = { \n",
-    "        \"filters\": [ \n",
-    "                BaseModerationFilters.PII, \n",
-    "                BaseModerationFilters.TOXICITY\n",
-    "        ],\n",
-    "        \"pii\":{ \n",
-    "                \"action\": BaseModerationActions.STOP, \n",
-    "                \"threshold\":0.5, \n",
-    "                \"labels\":[\"SSN\"], \n",
-    "                \"mask_character\": \"X\" \n",
-    "        },\n",
-    "        \"toxicity\":{ \n",
-    "                \"action\": BaseModerationActions.STOP, \n",
-    "                \"threshold\":0.5 \n",
-    "        }\n",
-    "}\n",
+    "pii_config = ModerationPiiConfig(\n",
+    "    labels=[\"SSN\"],\n",
+    "    redact=True,\n",
+    "    mask_character=\"X\"\n",
+    ")\n",
+    "\n",
+    "toxicity_config = ModerationToxicityConfig(\n",
+    "    threshold=0.5\n",
+    ")\n",
+    "\n",
+    "moderation_config = BaseModerationConfig(\n",
+    "    filters=[pii_config, toxicity_config]\n",
+    ")\n",
     "\n",
     "comp_moderation_with_config = AmazonComprehendModerationChain(\n",
     "        moderation_config=moderation_config, # specify the configuration\n",
     "        client=comprehend_client,            # optionally pass the Boto3 Client\n",
-    "        force_base_exception=True,           # Force BaseModerationError\n",
     "        unique_id='john.doe@email.com',      # A unique ID\n",
     "        moderation_callback=my_callback,     # BaseModerationCallbackHandler\n",
     "        verbose=True\n",
@@ -405,7 +412,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain import PromptTemplate, LLMChain\n",
+    "from langchain.prompts import PromptTemplate\nfrom langchain.chains import LLMChain\n",
     "from langchain.llms.fake import FakeListLLM\n",
     "\n",
     "template = \"\"\"Question: {question}\n",
@@ -416,7 +423,8 @@
     "\n",
     "responses = [\n",
     "    \"Final Answer: A credit card number looks like 1289-2321-1123-2387. A fake SSN number looks like 323-22-9980. John Doe's phone number is (999)253-9876.\", \n",
-    "    \"Final Answer: This is a really shitty way of constructing a birdhouse. This is fucking insane to think that any birds would actually create their motherfucking nests here.\"\n",
+    "    # replace with your own expletive\n",
+    "    \"Final Answer: This is a really <expletive> way of constructing a birdhouse. This is <expletive> insane to think that any birds would actually create their <expletive> nests here.\"\n",
     "]\n",
     "\n",
     "llm = FakeListLLM(responses=responses)\n",
@@ -450,7 +458,7 @@
     "## `moderation_config` and moderation execution order\n",
     "---\n",
     "\n",
-    "If `AmazonComprehendModerationChain` is not initialized with any `moderation_config` then the default action is `STOP` and default order of moderation check is as follows.\n",
+    "If `AmazonComprehendModerationChain` is not initialized with any `moderation_config` then it is initialized with the default values of `BaseModerationConfig`. If no `filters` are used then the sequence of moderation check is as follows.\n",
     "\n",
     "```\n",
     "AmazonComprehendModerationChain\n",
@@ -470,32 +478,25 @@
     "                        └── Return Prompt\n",
     "```\n",
     "\n",
-    "If any of the check raises exception then the subsequent checks will not be performed. If a `callback` is provided in this case, then it will be called for each of the checks that have been performed. For example, in the case above, if the Chain fails due to presence of PII then the Toxicity and Intent checks will not be performed.\n",
+    "If any of the check raises a validation exception then the subsequent checks will not be performed. If a `callback` is provided in this case, then it will be called for each of the checks that have been performed. For example, in the case above, if the Chain fails due to presence of PII then the Toxicity and Intent checks will not be performed.\n",
     "\n",
-    "You can override the execution order by passing `moderation_config` and simply specifying the desired order in the `filters` key of the configuration. In case you use `moderation_config` then the order of the checks as specified in the `filters` key will be maintained. For example, in the configuration below, first Toxicity check will be performed, then PII, and finally Intent validation will be performed. In this case, `AmazonComprehendModerationChain` will perform the desired checks in the specified order with default values of each model `kwargs`.\n",
+    "You can override the execution order by passing `moderation_config` and simply specifying the desired order in the `filters` parameter of the `BaseModerationConfig`. In case you specify the filters, then the order of the checks as specified in the `filters` parameter will be maintained. For example, in the configuration below, first Toxicity check will be performed, then PII, and finally Intent validation will be performed. In this case, `AmazonComprehendModerationChain` will perform the desired checks in the specified order with default values of each model `kwargs`.\n",
     "\n",
     "```python\n",
-    "moderation_config = { \n",
-    "        \"filters\":[ BaseModerationFilters.TOXICITY, \n",
-    "                    BaseModerationFilters.PII, \n",
-    "                    BaseModerationFilters.INTENT]\n",
-    "   }\n",
+    "pii_check = ModerationPiiConfig()\n",
+    "toxicity_check = ModerationToxicityConfig()\n",
+    "intent_check = ModerationIntentConfig()\n",
+    "\n",
+    "moderation_config = BaseModerationConfig(filters=[toxicity_check, pii_check, intent_check])\n",
     "```\n",
     "\n",
-    "Model `kwargs` are specified by the `pii`, `toxicity`, and `intent` keys within the `moderation_config` dictionary. For example, in the `moderation_config` below, the default order of moderation is overriden and the `pii` & `toxicity` model `kwargs` have been overriden. For `intent` the chain's default `kwargs` will be used.\n",
+    "You can have also use more than one configuration for a specific moderation check, for example in the sample below, two consecutive PII checks are performed. First the configuration checks for any SSN, if found it would raise an error. If any SSN isn't found then it will next check if any NAME and CREDIT_DEBIT_NUMBER is present in the prompt and will mask it.\n",
     "\n",
     "```python\n",
-    " moderation_config = { \n",
-    "        \"filters\":[ BaseModerationFilters.TOXICITY, \n",
-    "                    BaseModerationFilters.PII, \n",
-    "                    BaseModerationFilters.INTENT],\n",
-    "        \"pii\":{ \"action\": BaseModerationActions.ALLOW, \n",
-    "                \"threshold\":0.5, \n",
-    "                \"labels\":[\"SSN\"], \n",
-    "                \"mask_character\": \"X\" },\n",
-    "        \"toxicity\":{ \"action\": BaseModerationActions.STOP, \n",
-    "                     \"threshold\":0.5 }\n",
-    "   }\n",
+    "pii_check_1 = ModerationPiiConfig(labels=[\"SSN\"])\n",
+    "pii_check_2 = ModerationPiiConfig(labels=[\"NAME\", \"CREDIT_DEBIT_NUMBER\"], redact=True)\n",
+    "\n",
+    "moderation_config = BaseModerationConfig(filters=[pii_check_1, pii_check_2])\n",
     "```\n",
     "\n",
     "1. For a list of PII labels see Amazon Comprehend Universal PII entity types - https://docs.aws.amazon.com/comprehend/latest/dg/how-pii.html#how-pii-types\n",
@@ -545,7 +546,8 @@
    },
    "outputs": [],
    "source": [
-    "%env HUGGINGFACEHUB_API_TOKEN=\"<HUGGINGFACEHUB_API_TOKEN>\""
+    "import os\n",
+    "os.environ[\"HUGGINGFACEHUB_API_TOKEN\"] = \"<YOUR HF TOKEN HERE>\""
    ]
   },
   {
@@ -558,7 +560,7 @@
    "outputs": [],
    "source": [
     "# See https://huggingface.co/models?pipeline_tag=text-generation&sort=downloads for some other options\n",
-    "repo_id = \"google/flan-t5-xxl\"  \n"
+    "repo_id = \"google/flan-t5-xxl\"  "
    ]
   },
   {
@@ -570,15 +572,12 @@
    },
    "outputs": [],
    "source": [
-    "from langchain import HuggingFaceHub\n",
-    "from langchain import PromptTemplate, LLMChain\n",
+    "from langchain.llms import HuggingFaceHub\n",
+    "from langchain.prompts import PromptTemplate\nfrom langchain.chains import LLMChain\n",
     "\n",
-    "template = \"\"\"Question: {question}\n",
-    "\n",
-    "Answer:\"\"\"\n",
+    "template = \"\"\"Question: {question}\"\"\"\n",
     "\n",
     "prompt = PromptTemplate(template=template, input_variables=[\"question\"])\n",
-    "\n",
     "llm = HuggingFaceHub(\n",
     "    repo_id=repo_id, model_kwargs={\"temperature\": 0.5, \"max_length\": 256}\n",
     ")\n",
@@ -602,22 +601,32 @@
    },
    "outputs": [],
    "source": [
-    "moderation_config = { \n",
-    "        \"filters\":[ BaseModerationFilters.PII, BaseModerationFilters.TOXICITY, BaseModerationFilters.INTENT ],\n",
-    "        \"pii\":{\"action\": BaseModerationActions.ALLOW, \"threshold\":0.5, \"labels\":[\"SSN\",\"CREDIT_DEBIT_NUMBER\"], \"mask_character\": \"X\"},\n",
-    "        \"toxicity\":{\"action\": BaseModerationActions.STOP, \"threshold\":0.5},\n",
-    "        \"intent\":{\"action\": BaseModerationActions.ALLOW, \"threshold\":0.5,},\n",
-    "   }\n",
+    "pii_config = ModerationPiiConfig(\n",
+    "    labels=[\"SSN\", \"CREDIT_DEBIT_NUMBER\"],\n",
+    "    redact=True,\n",
+    "    mask_character=\"X\"\n",
+    ")\n",
     "\n",
-    "# without any callback\n",
+    "toxicity_config = ModerationToxicityConfig(\n",
+    "    threshold=0.5\n",
+    ")\n",
+    "\n",
+    "intent_config = ModerationIntentConfig(\n",
+    "    threshold=0.8\n",
+    ")\n",
+    "\n",
+    "moderation_config = BaseModerationConfig(\n",
+    "    filters=[pii_config, toxicity_config, intent_config]\n",
+    ")\n",
+    "# with callback\n",
     "amazon_comp_moderation = AmazonComprehendModerationChain(moderation_config=moderation_config, \n",
     "                                                         client=comprehend_client,\n",
+    "                                                         moderation_callback=my_callback,\n",
     "                                                         verbose=True)\n",
     "\n",
-    "# with callback\n",
+    "# without callback\n",
     "amazon_comp_moderation_out = AmazonComprehendModerationChain(moderation_config=moderation_config, \n",
     "                                                         client=comprehend_client,\n",
-    "                                                         moderation_callback=my_callback,\n",
     "                                                         verbose=True)"
    ]
   },
@@ -648,7 +657,10 @@
     ")\n",
     "\n",
     "try:\n",
-    "    response = chain.invoke({\"question\": \"My AnyCompany Financial Services, LLC credit card account 1111-0000-1111-0008 has 24$ due by July 31st. Can you give me some more credit car number samples?\"})\n",
+    "    response = chain.invoke({\"question\": \"\"\"What is John Doe's address, phone number and SSN from the following text?\n",
+    "\n",
+    "John Doe, a resident of 1234 Elm Street in Springfield, recently celebrated his birthday on January 1st. Turning 43 this year, John reflected on the years gone by. He often shares memories of his younger days with his close friends through calls on his phone, (555) 123-4567. Meanwhile, during a casual evening, he received an email at johndoe@example.com reminding him of an old acquaintance's reunion. As he navigated through some old documents, he stumbled upon a paper that listed his SSN as 123-45-6789, reminding him to store it in a safer place.\n",
+    "\"\"\"})\n",
     "except Exception as e:\n",
     "    print(str(e))\n",
     "else:\n",
@@ -685,7 +697,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain import SagemakerEndpoint\n",
+    "from langchain.llms import SagemakerEndpoint\n",
     "from langchain.llms.sagemaker_endpoint import LLMContentHandler\n",
     "from langchain.chains import LLMChain\n",
     "from langchain.prompts import load_prompt, PromptTemplate\n",
@@ -741,15 +753,26 @@
    },
    "outputs": [],
    "source": [
-    "moderation_config = { \n",
-    "        \"filters\":[ BaseModerationFilters.PII, BaseModerationFilters.TOXICITY ],\n",
-    "        \"pii\":{\"action\": BaseModerationActions.ALLOW, \"threshold\":0.5, \"labels\":[\"SSN\"], \"mask_character\": \"X\"},\n",
-    "        \"toxicity\":{\"action\": BaseModerationActions.STOP, \"threshold\":0.5},\n",
-    "        \"intent\":{\"action\": BaseModerationActions.ALLOW, \"threshold\":0.5,},\n",
-    "   }\n",
+    "pii_config = ModerationPiiConfig(\n",
+    "    labels=[\"SSN\"],\n",
+    "    redact=True,\n",
+    "    mask_character=\"X\"\n",
+    ")\n",
+    "\n",
+    "toxicity_config = ModerationToxicityConfig(\n",
+    "    threshold=0.5\n",
+    ")\n",
+    "\n",
+    "intent_config = ModerationIntentConfig(\n",
+    "    threshold=0.8\n",
+    ")\n",
+    "\n",
+    "moderation_config = BaseModerationConfig(\n",
+    "    filters=[pii_config, toxicity_config, intent_config]\n",
+    ")\n",
     "\n",
     "amazon_comp_moderation = AmazonComprehendModerationChain(moderation_config=moderation_config, \n",
-    "                                                         client=comprehend_client ,\n",
+    "                                                         client=comprehend_client,\n",
     "                                                         verbose=True)"
    ]
   },
@@ -780,7 +803,10 @@
     ")\n",
     "\n",
     "try:\n",
-    "    response = chain.invoke({\"question\": \"My AnyCompany Financial Services, LLC credit card account 1111-0000-1111-0008 has 24$ due by July 31st. Can you give me some more samples?\"})\n",
+    "    response = chain.invoke({\"question\": \"\"\"What is John Doe's address, phone number and SSN from the following text?\n",
+    "\n",
+    "John Doe, a resident of 1234 Elm Street in Springfield, recently celebrated his birthday on January 1st. Turning 43 this year, John reflected on the years gone by. He often shares memories of his younger days with his close friends through calls on his phone, (555) 123-4567. Meanwhile, during a casual evening, he received an email at johndoe@example.com reminding him of an old acquaintance's reunion. As he navigated through some old documents, he stumbled upon a paper that listed his SSN as 123-45-6789, reminding him to store it in a safer place.\n",
+    "\"\"\"})\n",
     "except Exception as e:\n",
     "    print(str(e))\n",
     "else:\n",

docs/docs_skeleton/docs/guides/safety/index.mdx

@@ -1,6 +1,8 @@
-# Preventing harmful outputs
+# Moderation
 
 One of the key concerns with using LLMs is that they may generate harmful or unethical text. This is an area of active research in the field. Here we present some built-in chains inspired by this research, which are intended to make the outputs of LLMs safer.
 
 - [Moderation chain](/docs/guides/safety/moderation): Explicitly check if any output text is harmful and flag it.
 - [Constitutional chain](/docs/guides/safety/constitutional_chain): Prompt the model with a set of principles which should guide it's behavior.
+- [Logical Fallacy chain](/docs/guides/safety/logical_fallacy_chain): Checks the model output against logical fallacies to correct any deviation.
+- [Amazon Comprehend moderation chain](/docs/guides/safety/amazon_comprehend_chain): Use [Amazon Comprehend](https://aws.amazon.com/comprehend/) to detect and handle PII and toxicity.

docs/docs_skeleton/docs/guides/safety/logical_fallacy_chain.mdx

@@ -0,0 +1,85 @@
+# Removing logical fallacies from model output
+Logical fallacies are flawed reasoning or false arguments that can undermine the validity of a model's outputs. Examples include circular reasoning, false
+dichotomies, ad hominem attacks, etc.  Machine learning models are optimized to perform well on specific metrics like accuracy, perplexity, or loss. However, 
+optimizing for metrics alone does not guarantee logically sound reasoning.
+
+Language models can learn to exploit flaws in reasoning to generate plausible-sounding but logically invalid arguments.  When models rely on fallacies, their outputs become unreliable and untrustworthy, even if they achieve high scores on metrics. Users cannot depend on such outputs. Propagating logical fallacies can spread misinformation, confuse users, and lead to harmful real-world consequences when models are deployed in products or services.
+
+Monitoring and testing specifically for logical flaws is challenging unlike other quality issues. It requires reasoning about arguments rather than pattern matching.
+
+Therefore, it is crucial that model developers proactively address logical fallacies after optimizing metrics. Specialized techniques like causal modeling, robustness testing, and bias mitigation can help avoid flawed reasoning.  Overall, allowing logical flaws to persist makes models less safe and ethical. Eliminating fallacies ensures model outputs remain logically valid and aligned with human reasoning. This maintains user trust and mitigates risks.
+
+
+
+```python
+# Imports
+from langchain.llms import OpenAI
+from langchain.prompts import PromptTemplate
+from langchain.chains.llm import LLMChain
+from langchain_experimental.fallacy_removal.base import FallacyChain
+```
+
+```python
+# Example of a model output being returned with a logical fallacy
+misleading_prompt = PromptTemplate(
+    template="""You have to respond by using only logical fallacies inherent in your answer explanations.
+
+Question: {question}
+
+Bad answer:""",
+    input_variables=["question"],
+)
+
+llm = OpenAI(temperature=0)
+
+misleading_chain = LLMChain(llm=llm, prompt=misleading_prompt)
+
+misleading_chain.run(question="How do I know the earth is round?")
+```
+
+<CodeOutputBlock lang="python">
+
+```
+    'The earth is round because my professor said it is, and everyone believes my professor'
+```
+
+</CodeOutputBlock>
+
+
+```python
+fallacies = FallacyChain.get_fallacies(["correction"])
+fallacy_chain = FallacyChain.from_llm(
+    chain=misleading_chain,
+    logical_fallacies=fallacies,
+    llm=llm,
+    verbose=True,
+)
+
+fallacy_chain.run(question="How do I know the earth is round?")
+```
+
+<CodeOutputBlock lang="python">
+
+```
+
+
+    > Entering new FallacyChain chain...
+    Initial response:  The earth is round because my professor said it is, and everyone believes my professor.
+
+    Applying correction...
+
+    Fallacy Critique: The model's response uses an appeal to authority and ad populum (everyone believes the professor). Fallacy Critique Needed.
+
+    Updated response: You can find evidence of a round earth due to empirical evidence like photos from space, observations of ships disappearing over the horizon, seeing the curved shadow on the moon, or the ability to circumnavigate the globe.
+
+
+    > Finished chain.
+
+
+
+
+
+    'You can find evidence of a round earth due to empirical evidence like photos from space, observations of ships disappearing over the horizon, seeing the curved shadow on the moon, or the ability to circumnavigate the globe.'
+```
+
+</CodeOutputBlock>

docs/docs_skeleton/docs/modules/agents/agent_types/chat_conversation_agent.mdx

@@ -1,13 +0,0 @@
-# Conversational
-
-This walkthrough demonstrates how to use an agent optimized for conversation. Other agents are often optimized for using tools to figure out the best response, which is not ideal in a conversational setting where you may want the agent to be able to chat with the user as well.
-
-import Example from "@snippets/modules/agents/agent_types/conversational_agent.mdx"
-
-<Example/>
-
-import ChatExample from "@snippets/modules/agents/agent_types/chat_conversation_agent.mdx"
-
-## Using a chat model
-
-<ChatExample/>

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

@@ -2,15 +2,13 @@
 sidebar_position: 0
 ---
 
-# Agent types
-
-## Action agents
+# Agent Types
 
 Agents use an LLM to determine which actions to take and in what order.
 An action can either be using a tool and observing its output, or returning a response to the user.
 Here are the agents available in LangChain.
 
-### [Zero-shot ReAct](/docs/modules/agents/agent_types/react.html)
+## [Zero-shot ReAct](/docs/modules/agents/agent_types/react.html)
 
 This agent uses the [ReAct](https://arxiv.org/pdf/2210.03629) framework to determine which tool to use
 based solely on the tool's description. Any number of tools can be provided.
@@ -18,33 +16,33 @@ This agent requires that a description is provided for each tool.
 
 **Note**: This is the most general purpose action agent.
 
-### [Structured input ReAct](/docs/modules/agents/agent_types/structured_chat.html)
+## [Structured input ReAct](/docs/modules/agents/agent_types/structured_chat.html)
 
 The structured tool chat agent is capable of using multi-input tools.
 Older agents are configured to specify an action input as a single string, but this agent can use a tools' argument
 schema to create a structured action input. This is useful for more complex tool usage, like precisely
 navigating around a browser.
 
-### [OpenAI Functions](/docs/modules/agents/agent_types/openai_functions_agent.html)
+## [OpenAI Functions](/docs/modules/agents/agent_types/openai_functions_agent.html)
 
 Certain OpenAI models (like gpt-3.5-turbo-0613 and gpt-4-0613) have been explicitly fine-tuned to detect when a
 function should be called and respond with the inputs that should be passed to the function.
 The OpenAI Functions Agent is designed to work with these models.
 
-### [Conversational](/docs/modules/agents/agent_types/chat_conversation_agent.html)
+## [Conversational](/docs/modules/agents/agent_types/chat_conversation_agent.html)
 
 This agent is designed to be used in conversational settings.
 The prompt is designed to make the agent helpful and conversational.
 It uses the ReAct framework to decide which tool to use, and uses memory to remember the previous conversation interactions.
 
-### [Self ask with search](/docs/modules/agents/agent_types/self_ask_with_search.html)
+## [Self-ask with search](/docs/modules/agents/agent_types/self_ask_with_search.html)
 
 This agent utilizes a single tool that should be named `Intermediate Answer`.
 This tool should be able to lookup factual answers to questions. This agent
-is equivalent to the original [self ask with search paper](https://ofir.io/self-ask.pdf),
+is equivalent to the original [self-ask with search paper](https://ofir.io/self-ask.pdf),
 where a Google search API was provided as the tool.
 
-### [ReAct document store](/docs/modules/agents/agent_types/react_docstore.html)
+## [ReAct document store](/docs/modules/agents/agent_types/react_docstore.html)
 
 This agent uses the ReAct framework to interact with a docstore. Two tools must
 be provided: a `Search` tool and a `Lookup` tool (they must be named exactly as so).
@@ -52,6 +50,3 @@ The `Search` tool should search for a document, while the `Lookup` tool should l
 a term in the most recently found document.
 This agent is equivalent to the
 original [ReAct paper](https://arxiv.org/pdf/2210.03629.pdf), specifically the Wikipedia example.
-
-## [Plan-and-execute agents](/docs/modules/agents/agent_types/plan_and_execute.html)
-Plan and execute agents accomplish an objective by first planning what to do, then executing the sub tasks. This idea is largely inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) and then the ["Plan-and-Solve" paper](https://arxiv.org/abs/2305.04091).

docs/docs_skeleton/docs/modules/agents/agent_types/openai_functions_agent.mdx

@@ -1,11 +0,0 @@
-# OpenAI functions
-
-Certain OpenAI models (like gpt-3.5-turbo-0613 and gpt-4-0613) have been fine-tuned to detect when a function should be called and respond with the inputs that should be passed to the function.
-In an API call, you can describe functions and have the model intelligently choose to output a JSON object containing arguments to call those functions.
-The goal of the OpenAI Function APIs is to more reliably return valid and useful function calls than a generic text completion or chat API.
-
-The OpenAI Functions Agent is designed to work with these models.
-
-import Example from "@snippets/modules/agents/agent_types/openai_functions_agent.mdx";
-
-<Example/>

docs/docs_skeleton/docs/modules/agents/agent_types/plan_and_execute.mdx

@@ -1,11 +0,0 @@
-# Plan and execute
-
-Plan and execute agents accomplish an objective by first planning what to do, then executing the sub tasks. This idea is largely inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) and then the ["Plan-and-Solve" paper](https://arxiv.org/abs/2305.04091).
-
-The planning is almost always done by an LLM.
-
-The execution is usually done by a separate agent (equipped with tools).
-
-import Example from "@snippets/modules/agents/agent_types/plan_and_execute.mdx"
-
-<Example/>

docs/docs_skeleton/docs/modules/agents/agent_types/react.mdx

@@ -1,15 +0,0 @@
-# ReAct
-
-This walkthrough showcases using an agent to implement the [ReAct](https://react-lm.github.io/) logic.
-
-import Example from "@snippets/modules/agents/agent_types/react.mdx"
-
-<Example/>
-
-## Using chat models
-
-You can also create ReAct agents that use chat models instead of LLMs as the agent driver.
-
-import ChatExample from "@snippets/modules/agents/agent_types/react_chat.mdx"
-
-<ChatExample/>

docs/docs_skeleton/docs/modules/agents/agent_types/structured_chat.mdx

@@ -1,10 +0,0 @@
-# Structured tool chat
-
-The structured tool chat agent is capable of using multi-input tools.
-
-Older agents are configured to specify an action input as a single string, but this agent can use the provided tools' `args_schema` to populate the action input.
-
-
-import Example from "@snippets/modules/agents/agent_types/structured_chat.mdx"
-
-<Example/>

docs/docs_skeleton/docs/modules/agents/how_to/custom_llm_agent.mdx

@@ -1,13 +1,13 @@
-# Custom LLM Agent
+# Custom LLM agent
 
 This notebook goes through how to create your own custom LLM agent.
 
 An LLM agent consists of three parts:
 
-- PromptTemplate: This is the prompt template that can be used to instruct the language model on what to do
+- `PromptTemplate`: This is the prompt template that can be used to instruct the language model on what to do
 - LLM: This is the language model that powers the agent
 - `stop` sequence: Instructs the LLM to stop generating as soon as this string is found
-- OutputParser: This determines how to parse the LLMOutput into an AgentAction or AgentFinish object
+- `OutputParser`: This determines how to parse the LLM output into an `AgentAction` or `AgentFinish` object
 
 import Example from "@snippets/modules/agents/how_to/custom_llm_agent.mdx"
 

docs/docs_skeleton/docs/modules/agents/how_to/custom_llm_chat_agent.mdx

@@ -4,10 +4,10 @@ This notebook goes through how to create your own custom agent based on a chat m
 
 An LLM chat agent consists of three parts:
 
-- PromptTemplate: This is the prompt template that can be used to instruct the language model on what to do
-- ChatModel: This is the language model that powers the agent
+- `PromptTemplate`: This is the prompt template that can be used to instruct the language model on what to do
+- `ChatModel`: This is the language model that powers the agent
 - `stop` sequence: Instructs the LLM to stop generating as soon as this string is found
-- OutputParser: This determines how to parse the LLMOutput into an AgentAction or AgentFinish object
+- `OutputParser`: This determines how to parse the LLM output into an `AgentAction` or `AgentFinish` object
 
 import Example from "@snippets/modules/agents/how_to/custom_llm_chat_agent.mdx"
 

docs/docs_skeleton/docs/modules/agents/index.mdx

@@ -7,20 +7,27 @@ The core idea of agents is to use an LLM to choose a sequence of actions to take
 In chains, a sequence of actions is hardcoded (in code).
 In agents, a language model is used as a reasoning engine to determine which actions to take and in which order.
 
+Some important terminology (and schema) to know:
+
+1. `AgentAction`: This is a dataclass that represents the action an agent should take. It has a `tool` property (which is the name of the tool that should be invoked) and a `tool_input` property (the input to that tool)
+2. `AgentFinish`: This is a dataclass that signifies that the agent has finished and should return to the user. It has a `return_values` parameter, which is a dictionary to return. It often only has one key - `output` - that is a string, and so often it is just this key that is returned.
+3. `intermediate_steps`: These represent previous agent actions and corresponding outputs that are passed around. These are important to pass to future iteration so the agent knows what work it has already done. This is typed as a `List[Tuple[AgentAction, Any]]`. Note that observation is currently left as type `Any` to be maximally flexible. In practice, this is often a string.
+
 There are several key components here:
 
 ## Agent
 
-This is the class responsible for deciding what step to take next.
+This is the chain responsible for deciding what step to take next.
 This is powered by a language model and a prompt.
-This prompt can include things like:
+The inputs to this chain are:
 
-1. The personality of the agent (useful for having it respond in a certain way)
-2. Background context for the agent (useful for giving it more context on the types of tasks it's being asked to do)
-3. Prompting strategies to invoke better reasoning (the most famous/widely used being [ReAct](https://arxiv.org/abs/2210.03629))
+1. List of available tools
+2. User input
+3. Any previously executed steps (`intermediate_steps`)
 
-LangChain provides a few different types of agents to get started.
-Even then, you will likely want to customize those agents with parts (1) and (2).
+This chain then returns either the next action to take or the final response to send to the user (`AgentAction` or `AgentFinish`).
+
+Different agents have different prompting styles for reasoning, different ways of encoding input, and different ways of parsing the output.
 For a full list of agent types see [agent types](/docs/modules/agents/agent_types/)
 
 ## Tools
@@ -74,12 +81,22 @@ The `AgentExecutor` class is the main agent runtime supported by LangChain.
 However, there are other, more experimental runtimes we also support.
 These include:
 
-- [Plan-and-execute Agent](/docs/modules/agents/agent_types/plan_and_execute.html)
-- [Baby AGI](/docs/use_cases/autonomous_agents/baby_agi.html)
-- [Auto GPT](/docs/use_cases/autonomous_agents/autogpt.html)
+- [Plan-and-execute Agent](/docs/use_cases/more/agents/autonomous_agents/plan_and_execute)
+- [Baby AGI](/docs/use_cases/more/agents/autonomous_agents/baby_agi)
+- [Auto GPT](/docs/use_cases/more/agents/autonomous_agents/autogpt)
 
 ## Get started
 
 import GetStarted from "@snippets/modules/agents/get_started.mdx"
 
 <GetStarted/>
+
+## Next Steps
+
+Awesome! You've now run your first end-to-end agent.
+To dive deeper, you can:
+
+- Check out all the different [agent types](/docs/modules/agents/agent_types/) supported
+- Learn all the controls for [AgentExecutor](/docs/modules/agents/how_to/)
+- See a full list of all the off-the-shelf [toolkits](/docs/modules/agents/toolkits/) we provide
+- Explore all the individual [tools](/docs/modules/agents/tools/) supported

docs/docs_skeleton/docs/modules/chains/document/index.mdx

@@ -3,7 +3,7 @@ sidebar_position: 2
 ---
 # Documents
 
-These are the core chains for working with Documents. They are useful for summarizing documents, answering questions over documents, extracting information from documents, and more.
+These are the core chains for working with documents. They are useful for summarizing documents, answering questions over documents, extracting information from documents, and more.
 
 These chains all implement a common interface:
 

docs/docs_skeleton/docs/modules/chains/document/refine.mdx

@@ -3,10 +3,10 @@ sidebar_position: 1
 ---
 # Refine
 
-The refine documents chain constructs a response by looping over the input documents and iteratively updating its answer. For each document, it passes all non-document inputs, the current document, and the latest intermediate answer to an LLM chain to get a new answer.
+The Refine documents chain constructs a response by looping over the input documents and iteratively updating its answer. For each document, it passes all non-document inputs, the current document, and the latest intermediate answer to an LLM chain to get a new answer.
 
 Since the Refine chain only passes a single document to the LLM at a time, it is well-suited for tasks that require analyzing more documents than can fit in the model's context.
 The obvious tradeoff is that this chain will make far more LLM calls than, for example, the Stuff documents chain.
 There are also certain tasks which are difficult to accomplish iteratively. For example, the Refine chain can perform poorly when documents frequently cross-reference one another or when a task requires detailed information from many documents.
 
-![refine_diagram](/img/refine.jpg)
+![refine_diagram](/img/refine.jpg)

docs/docs_skeleton/docs/modules/chains/foundational/llm_chain.mdx

@@ -1,11 +1,11 @@
 # LLM
 
-An LLMChain is a simple chain that adds some functionality around language models. It is used widely throughout LangChain, including in other chains and agents.
+An `LLMChain` is a simple chain that adds some functionality around language models. It is used widely throughout LangChain, including in other chains and agents.
 
-An LLMChain consists of a PromptTemplate and a language model (either an LLM or chat model). It formats the prompt template using the input key values provided (and also memory key values, if available), passes the formatted string to LLM and returns the LLM output.
+An `LLMChain` consists of a `PromptTemplate` and a language model (either an LLM or chat model). It formats the prompt template using the input key values provided (and also memory key values, if available), passes the formatted string to LLM and returns the LLM output.
 
 ## Get started
 
 import Example from "@snippets/modules/chains/foundational/llm_chain.mdx"
 
-<Example/>
+<Example/>

docs/docs_skeleton/docs/modules/chains/foundational/sequential_chains.mdx

@@ -2,9 +2,9 @@
 
 
 
-The next step after calling a language model is make a series of calls to a language model. This is particularly useful when you want to take the output from one call and use it as the input to another.
+The next step after calling a language model is to make a series of calls to a language model. This is particularly useful when you want to take the output from one call and use it as the input to another.
 
-In this notebook we will walk through some examples for how to do this, using sequential chains. Sequential chains allow you to connect multiple chains and compose them into pipelines that execute some specific scenario.. There are two types of sequential chains:
+In this notebook we will walk through some examples of how to do this, using sequential chains. Sequential chains allow you to connect multiple chains and compose them into pipelines that execute some specific scenario. There are two types of sequential chains:
 
 - `SimpleSequentialChain`: The simplest form of sequential chains, where each step has a singular input/output, and the output of one step is the input to the next.
 - `SequentialChain`: A more general form of sequential chains, allowing for multiple inputs/outputs.

docs/docs_skeleton/docs/modules/chains/index.mdx

@@ -19,8 +19,6 @@ For more specifics check out:
 - [How-to](/docs/modules/chains/how_to/) for walkthroughs of different chain features
 - [Foundational](/docs/modules/chains/foundational/) to get acquainted with core building block chains
 - [Document](/docs/modules/chains/document/) to learn how to incorporate documents into chains
-- [Popular](/docs/modules/chains/popular/) chains for the most common use cases
-- [Additional](/docs/modules/chains/additional/) to see some of the more advanced chains and integrations that you can use out of the box
 
 ## Why do we need chains?
 
@@ -30,4 +28,4 @@ Chains allow us to combine multiple components together to create a single, cohe
 
 import GetStarted from "@snippets/modules/chains/get_started.mdx"
 
-<GetStarted/>
+<GetStarted/>

docs/docs_skeleton/docs/modules/data_connection/document_loaders/index.mdx

@@ -11,7 +11,7 @@ Use document loaders to load data from a source as `Document`'s. A `Document` is
 and associated metadata. For example, there are document loaders for loading a simple `.txt` file, for loading the text
 contents of any web page, or even for loading a transcript of a YouTube video.
 
-Document loaders expose a "load" method for loading data as documents from a configured source. They optionally
+Document loaders provide a "load" method for loading data as documents from a configured source. They optionally
 implement a "lazy load" as well for lazily loading data into memory.
 
 ## Get started

docs/docs_skeleton/docs/modules/data_connection/document_transformers/text_splitters/character_text_splitter.mdx

@@ -2,8 +2,8 @@
 
 This is the simplest method. This splits based on characters (by default "\n\n") and measure chunk length by number of characters.
 
-1. How the text is split: by single character
-2. How the chunk size is measured: by number of characters
+1. How the text is split: by single character.
+2. How the chunk size is measured: by number of characters.
 
 import Example from "@snippets/modules/data_connection/document_transformers/text_splitters/character_text_splitter.mdx"
 

docs/docs_skeleton/docs/modules/data_connection/document_transformers/text_splitters/code_splitter.mdx

@@ -1,6 +1,6 @@
 # Split code
 
-CodeTextSplitter allows you to split your code with multiple language support. Import enum `Language` and specify the language. 
+CodeTextSplitter allows you to split your code with multiple languages supported. Import enum `Language` and specify the language. 
 
 import Example from "@snippets/modules/data_connection/document_transformers/text_splitters/code_splitter.mdx"
 

docs/docs_skeleton/docs/modules/data_connection/document_transformers/text_splitters/recursive_text_splitter.mdx

@@ -2,8 +2,8 @@
 
 This text splitter is the recommended one for generic text. It is parameterized by a list of characters. It tries to split on them in order until the chunks are small enough. The default list is `["\n\n", "\n", " ", ""]`. This has the effect of trying to keep all paragraphs (and then sentences, and then words) together as long as possible, as those would generically seem to be the strongest semantically related pieces of text.
 
-1. How the text is split: by list of characters
-2. How the chunk size is measured: by number of characters
+1. How the text is split: by list of characters.
+2. How the chunk size is measured: by number of characters.
 
 import Example from "@snippets/modules/data_connection/document_transformers/text_splitters/recursive_text_splitter.mdx"
 

docs/docs_skeleton/docs/modules/data_connection/index.mdx

@@ -18,9 +18,9 @@ This encompasses several key modules.
 **[Document loaders](/docs/modules/data_connection/document_loaders/)**
 
 Load documents from many different sources.
-LangChain provides over a 100 different document loaders as well as integrations with other major providers in the space,
+LangChain provides over 100 different document loaders as well as integrations with other major providers in the space,
 like AirByte and Unstructured.
-We provide integrations to load all types of documents (html, PDF, code) from all types of locations (private s3 buckets, public websites).
+We provide integrations to load all types of documents (HTML, PDF, code) from all types of locations (private s3 buckets, public websites).
 
 **[Document transformers](/docs/modules/data_connection/document_transformers/)**
 
@@ -32,18 +32,18 @@ LangChain provides several different algorithms for doing this, as well as logic
 **[Text embedding models](/docs/modules/data_connection/text_embedding/)**
 
 Another key part of retrieval has become creating embeddings for documents.
-Embeddings capture the semantic meaning of text, allowing you to quickly and
+Embeddings capture the semantic meaning of the text, allowing you to quickly and
 efficiently find other pieces of text that are similar.
 LangChain provides integrations with over 25 different embedding providers and methods,
 from open-source to proprietary API,
 allowing you to choose the one best suited for your needs.
-LangChain exposes a standard interface, allowing you to easily swap between models.
+LangChain provides a standard interface, allowing you to easily swap between models.
 
 **[Vector stores](/docs/modules/data_connection/vectorstores/)**
 
 With the rise of embeddings, there has emerged a need for databases to support efficient storage and searching of these embeddings.
 LangChain provides integrations with over 50 different vectorstores, from open-source local ones to cloud-hosted proprietary ones,
-allowing you choose the one best suited for your needs.
+allowing you to choose the one best suited for your needs.
 LangChain exposes a standard interface, allowing you to easily swap between vector stores.
 
 **[Retrievers](/docs/modules/data_connection/retrievers/)**
@@ -55,7 +55,7 @@ However, we have also added a collection of algorithms on top of this to increas
 These include:
 
 - [Parent Document Retriever](/docs/modules/data_connection/retrievers/parent_document_retriever): This allows you to create multiple embeddings per parent document, allowing you to look up smaller chunks but return larger context.
-- [Self Query Retriever](/docs/modules/data_connection/retrievers/self_query): User questions often contain reference to something that isn't just semantic, but rather expresses some logic that can best be represented as a metadata filter. Self-query allows you to parse out the *semantic* part of a query from other *metadata filters* present in the query
+- [Self Query Retriever](/docs/modules/data_connection/retrievers/self_query): User questions often contain a reference to something that isn't just semantic but rather expresses some logic that can best be represented as a metadata filter. Self-query allows you to parse out the *semantic* part of a query from other *metadata filters* present in the query.
 - [Ensemble Retriever](/docs/modules/data_connection/retrievers/ensemble): Sometimes you may want to retrieve documents from multiple different sources, or using multiple different algorithms. The ensemble retriever allows you to easily do this.
 - And more!
 

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

@@ -5,10 +5,10 @@ One challenge with retrieval is that usually you don't know the specific queries
 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.
 
 To use the Contextual Compression Retriever, you'll need:
-- a base Retriever
+- a base retriever
 - a Document Compressor
 
-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.
+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.
 
 ![](https://drive.google.com/uc?id=1CtNgWODXZudxAWSRiWgSGEoTNrUFT98v)
 

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

@@ -8,7 +8,7 @@ Head to [Integrations](/docs/integrations/retrievers/) for documentation on buil
 :::
 
 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) it. Vector stores can be used
+A retriever does not need to be able to store documents, only to return (or retrieve) them. Vector stores can be used
 as the backbone of a retriever, but there are other types of retrievers as well.
 
 ## Get started

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

@@ -1,6 +1,6 @@
 # Self-querying
 
-A self-querying retriever is one that, as the name suggests, has the ability to query itself. Specifically, given any natural language query, the retriever uses a query-constructing LLM chain to write a structured query and then applies that structured query to it's underlying VectorStore. This allows the retriever to not only use the user-input query for semantic similarity comparison with the contents of stored documented, but to also extract filters from the user query on the metadata of stored documents and to execute those filters.
+A self-querying retriever is one that, as the name suggests, has the ability to query itself. Specifically, given any natural language query, the retriever uses a query-constructing LLM chain to write a structured query and then applies that structured query to its underlying VectorStore. This allows the retriever to not only use the user-input query for semantic similarity comparison with the contents of stored documents but to also extract filters from the user query on the metadata of stored documents and to execute those filters.
 
 ![](https://drive.google.com/uc?id=1OQUN-0MJcDUxmPXofgS7MqReEs720pqS)
 

docs/docs_skeleton/docs/modules/data_connection/retrievers/time_weighted_vectorstore.mdx

@@ -8,7 +8,7 @@ The algorithm for scoring them is:
 semantic_similarity + (1.0 - decay_rate) ^ hours_passed
 ```
 
-Notably, `hours_passed` refers to the hours passed since the object in the retriever **was last accessed**, not since it was created. This means that frequently accessed objects remain "fresh."
+Notably, `hours_passed` refers to the hours passed since the object in the retriever **was last accessed**, not since it was created. This means that frequently accessed objects remain "fresh".
 
 import Example from "@snippets/modules/data_connection/retrievers/how_to/time_weighted_vectorstore.mdx"
 

docs/docs_skeleton/docs/modules/data_connection/retrievers/vectorstore.mdx

@@ -1,9 +1,9 @@
 # Vector store-backed retriever
 
-A vector store retriever is a retriever that uses a vector store to retrieve documents. It is a lightweight wrapper around the Vector Store class to make it conform to the Retriever interface.
+A vector store retriever is a retriever that uses a vector store to retrieve documents. It is a lightweight wrapper around the vector store class to make it conform to the retriever interface.
 It uses the search methods implemented by a vector store, like similarity search and MMR, to query the texts in the vector store.
 
-Once you construct a Vector store, it's very easy to construct a retriever. Let's walk through an example.
+Once you construct a vector store, it's very easy to construct a retriever. Let's walk through an example.
 
 import Example from "@snippets/modules/data_connection/retrievers/how_to/vectorstore.mdx"
 

docs/docs_skeleton/docs/modules/data_connection/text_embedding/index.mdx

@@ -11,7 +11,7 @@ The Embeddings class is a class designed for interfacing with text embedding mod
 
 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 exposes 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).
+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).
 
 ## Get started
 

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

@@ -16,7 +16,7 @@ for you.
 
 ## Get started
 
-This walkthrough showcases basic functionality related to VectorStores. A key part of working with vector stores is creating the vector to put in them, which is usually created via embeddings. Therefore, it is recommended that you familiarize yourself with the [text embedding model](/docs/modules/data_connection/text_embedding/) interfaces before diving into this.
+This walkthrough showcases basic functionality related to vector stores. A key part of working with vector stores is creating the vector to put in them, which is usually created via embeddings. Therefore, it is recommended that you familiarize yourself with the [text embedding model](/docs/modules/data_connection/text_embedding/) interfaces before diving into this.
 
 import GetStarted from "@snippets/modules/data_connection/vectorstores/get_started.mdx"
 

docs/docs_skeleton/docs/modules/memory/chat_messages/index.mdx

@@ -8,10 +8,10 @@ Head to [Integrations](/docs/integrations/memory/) for documentation on built-in
 :::
 
 One of the core utility classes underpinning most (if not all) memory modules is the `ChatMessageHistory` class.
-This is a super lightweight wrapper which exposes convenience methods for saving Human messages, AI messages, and then fetching them all.
+This is a super lightweight wrapper that provides convenience methods for saving HumanMessages, AIMessages, and then fetching them all.
 
 You may want to use this class directly if you are managing memory outside of a chain.
 
 import GetStarted from "@snippets/modules/memory/chat_messages/get_started.mdx"
 
-<GetStarted/>
+<GetStarted/>

docs/docs_skeleton/docs/modules/memory/index.mdx

@@ -32,7 +32,7 @@ Even if these are not all used directly, they need to be stored in some form.
 One of the key parts of the LangChain memory module is a series of integrations for storing these chat messages,
 from in-memory lists to persistent databases.
 
-- [Chat message storage](/docs/modules/memory/chat_messages/): How to work with Chat Messages, and the various integrations offered
+- [Chat message storage](/docs/modules/memory/chat_messages/): How to work with Chat Messages, and the various integrations offered.
 
 ### Querying: Data structures and algorithms on top of chat messages
 Keeping a list of chat messages is fairly straight-forward.

docs/docs_skeleton/docs/modules/memory/types/buffer.mdx

@@ -1,6 +1,6 @@
-# Conversation buffer memory
+# Conversation Buffer
 
-This notebook shows how to use `ConversationBufferMemory`. This memory allows for storing of messages and then extracts the messages in a variable.
+This notebook shows how to use `ConversationBufferMemory`. This memory allows for storing messages and then extracts the messages in a variable.
 
 We can first extract it as a string.
 

docs/docs_skeleton/docs/modules/memory/types/buffer_window.mdx

@@ -1,6 +1,6 @@
-# Conversation buffer window memory
+# Conversation Buffer Window
 
-`ConversationBufferWindowMemory` keeps a list of the interactions of the conversation over time. It only uses the last K interactions. This can be useful for keeping a sliding window of the most recent interactions, so the buffer does not get too large
+`ConversationBufferWindowMemory` keeps a list of the interactions of the conversation over time. It only uses the last K interactions. This can be useful for keeping a sliding window of the most recent interactions, so the buffer does not get too large.
 
 Let's first explore the basic functionality of this type of memory.
 

docs/docs_skeleton/docs/modules/memory/types/entity_summary_memory.mdx

@@ -1,6 +1,6 @@
-# Entity memory
+# Entity
 
-Entity Memory remembers given facts about specific entities in a conversation. It extracts information on entities (using an LLM) and builds up its knowledge about that entity over time (also using an LLM).
+Entity memory remembers given facts about specific entities in a conversation. It extracts information on entities (using an LLM) and builds up its knowledge about that entity over time (also using an LLM).
 
 Let's first walk through using this functionality.
 

docs/docs_skeleton/docs/modules/memory/types/index.mdx

@@ -1,8 +1,8 @@
 ---
 sidebar_position: 2
 ---
-# Memory Types
+# Memory types
 
 There are many different types of memory.
-Each have their own parameters, their own return types, and are useful in different scenarios.
+Each has their own parameters, their own return types, and is useful in different scenarios.
 Please see their individual page for more detail on each one.

docs/docs_skeleton/docs/modules/memory/types/summary.mdx

@@ -1,4 +1,4 @@
-# Conversation summary memory
+# Conversation Summary
 Now let's take a look at using a slightly more complex type of memory - `ConversationSummaryMemory`. This type of memory creates a summary of the conversation over time. This can be useful for condensing information from the conversation over time.
 Conversation summary memory summarizes the conversation as it happens and stores the current summary in memory. This memory can then be used to inject the summary of the conversation so far into a prompt/chain. This memory is most useful for longer conversations, where keeping the past message history in the prompt verbatim would take up too many tokens.
 

docs/docs_skeleton/docs/modules/memory/types/vectorstore_retriever_memory.mdx

@@ -1,6 +1,6 @@
-# Vector store-backed memory
+# Backed by a Vector Store
 
-`VectorStoreRetrieverMemory` stores memories in a VectorDB and queries the top-K most "salient" docs every time it is called.
+`VectorStoreRetrieverMemory` stores memories in a vector store and queries the top-K most "salient" docs every time it is called.
 
 This differs from most of the other Memory classes in that it doesn't explicitly track the order of interactions.
 

docs/docs_skeleton/docs/modules/model_io/models/chat/chat_model_caching.mdx

@@ -1,5 +1,5 @@
 # Caching
-LangChain provides an optional caching layer for Chat Models. This is useful for two reasons:
+LangChain provides an optional caching layer for chat models. This is useful for two reasons:
 
 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.
 It can speed up your application by reducing the number of API calls you make to the LLM provider.

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

@@ -8,8 +8,8 @@ Head to [Integrations](/docs/integrations/chat/) for documentation on built-in i
 :::
 
 Chat models are a variation on language models.
-While chat models use language models under the hood, the interface they expose is a bit different.
-Rather than expose a "text in, text out" API, they expose an interface where "chat messages" are the inputs and outputs.
+While chat models use language models under the hood, the interface they use is a bit different.
+Rather than using a "text in, text out" API, they use an interface where "chat messages" are the inputs and outputs.
 
 Chat model APIs are fairly new, so we are still figuring out the correct abstractions.
 

docs/docs_skeleton/docs/modules/model_io/models/chat/prompts.mdx

@@ -1,6 +1,6 @@
 # Prompts
 
-Prompts for Chat models are built around messages, instead of just plain text.
+Prompts for chat models are built around messages, instead of just plain text.
 
 import Prompts from "@snippets/modules/model_io/models/chat/how_to/prompts.mdx"
 

docs/docs_skeleton/docs/modules/model_io/models/chat/streaming.mdx

@@ -1,6 +1,6 @@
 # Streaming
 
-Some Chat models provide a streaming response. This means that instead of waiting for the entire response to be returned, you can start processing it as soon as it's available. This is useful if you want to display the response to the user as it's being generated, or if you want to process the response as it's being generated.
+Some chat models provide a streaming response. This means that instead of waiting for the entire response to be returned, you can start processing it as soon as it's available. This is useful if you want to display the response to the user as it's being generated, or if you want to process the response as it's being generated.
 
 import StreamingChatModel from "@snippets/modules/model_io/models/chat/how_to/streaming.mdx"
 

docs/docs_skeleton/docs/modules/model_io/models/index.mdx

@@ -8,16 +8,16 @@ LangChain provides interfaces and integrations for two types of models:
 - [LLMs](/docs/modules/model_io/models/llms/): Models that take a text string as input and return a text string
 - [Chat models](/docs/modules/model_io/models/chat/): Models that are backed by a language model but take a list of Chat Messages as input and return a Chat Message
 
-## LLMs vs Chat Models
+## LLMs vs chat models
 
-LLMs and Chat Models are subtly but importantly different. LLMs in LangChain refer to pure text completion models.
+LLMs and chat models are subtly but importantly different. LLMs in LangChain refer to pure text completion models.
 The APIs they wrap take a string prompt as input and output a string completion. OpenAI's GPT-3 is implemented as an LLM.
 Chat models are often backed by LLMs but tuned specifically for having conversations.
-And, crucially, their provider APIs expose a different interface than pure text completion models. Instead of a single string,
+And, crucially, their provider APIs use a different interface than pure text completion models. Instead of a single string,
 they take a list of chat messages as input. Usually these messages are labeled with the speaker (usually one of "System",
-"AI", and "Human"). And they return a ("AI") chat message as output. GPT-4 and Anthropic's Claude are both implemented as Chat Models.
+"AI", and "Human"). And they return an AI chat message as output. GPT-4 and Anthropic's Claude are both implemented as chat models.
 
-To make it possible to swap LLMs and Chat Models, both implement the Base Language Model interface. This exposes common
+To make it possible to swap LLMs and chat models, both implement the Base Language Model interface. This includes common
 methods "predict", which takes a string and returns a string, and "predict messages", which takes messages and returns a message.
-If you are using a specific model it's recommended you use the methods specific to that model class (i.e., "predict" for LLMs and "predict messages" for Chat Models),
+If you are using a specific model it's recommended you use the methods specific to that model class (i.e., "predict" for LLMs and "predict messages" for chat models),
 but if you're creating an application that should work with different types of models the shared interface can be helpful.

docs/docs_skeleton/docs/modules/model_io/output_parsers/index.mdx

@@ -12,7 +12,7 @@ Output parsers are classes that help structure language model responses. There a
 
 And then one optional one:
 
-- "Parse with prompt": A method which takes in a string (assumed to be the response from a language model) and a prompt (assumed to the prompt that generated such a response) and parses it into some structure. The prompt is largely provided in the event the OutputParser wants to retry or fix the output in some way, and needs information from the prompt to do so.
+- "Parse with prompt": A method which takes in a string (assumed to be the response from a language model) and a prompt (assumed to be the prompt that generated such a response) and parses it into some structure. The prompt is largely provided in the event the OutputParser wants to retry or fix the output in some way, and needs information from the prompt to do so.
 
 ## Get started
 

docs/docs_skeleton/docs/use_cases/question_answering/_category_.yml

@@ -0,0 +1,2 @@
+position: 0
+collapsed: false

docs/docs_skeleton/docs/use_cases/question_answering/how_to/chat_vector_db.mdx

@@ -5,7 +5,7 @@ sidebar_position: 2
 # Store and reference chat history
 The ConversationalRetrievalQA chain builds on RetrievalQAChain to provide a chat history component.
 
-It first combines the chat history (either explicitly passed in or retrieved from the provided memory) and the question into a standalone question, then looks up relevant documents from the retriever, and finally passes those documents and the question to a question answering chain to return a response.
+It first combines the chat history (either explicitly passed in or retrieved from the provided memory) and the question into a standalone question, then looks up relevant documents from the retriever, and finally passes those documents and the question to a question-answering chain to return a response.
 
 To create one, you will need a retriever. In the below example, we will create one from a vector store, which can be created from embeddings.
 

docs/docs_skeleton/docs/use_cases/web_scraping/index.mdx

@@ -1,9 +0,0 @@
----
-sidebar_position: 3
----
-
-# Web Scraping
-
-Web scraping has historically been a challenging endeavor due to the ever-changing nature of website structures, making it tedious for developers to maintain their scraping scripts. Traditional methods often rely on specific HTML tags and patterns which, when altered, can disrupt data extraction processes.
-
-Enter the LLM-based method for parsing HTML: By leveraging the capabilities of LLMs, and especially OpenAI Functions in LangChain's extraction chain, developers can instruct the model to extract only the desired data in a specified format. This method not only streamlines the extraction process but also significantly reduces the time spent on manual debugging and script modifications. Its adaptability means that even if websites undergo significant design changes, the extraction remains consistent and robust. This level of resilience translates to reduced maintenance efforts, cost savings, and ensures a higher quality of extracted data. Compared to its predecessors, LLM-based approach wins out the web scraping domain by transforming a historically cumbersome task into a more automated and efficient process.

docs/docs_skeleton/docusaurus.config.js

@@ -71,9 +71,9 @@ const config = {
               test: /\.ipynb$/,
               loader: "raw-loader",
               resolve: {
-                fullySpecified: false
-              }
-            }
+                fullySpecified: false,
+              },
+            },
           ],
         },
       }),
@@ -158,16 +158,16 @@ const config = {
             position: "left",
           },
           {
-            type: 'docSidebar',
-            position: 'left',
-            sidebarId: 'use_cases',
-            label: 'Use cases',
+            type: "docSidebar",
+            position: "left",
+            sidebarId: "use_cases",
+            label: "Use cases",
           },
           {
-            type: 'docSidebar',
-            position: 'left',
-            sidebarId: 'integrations',
-            label: 'Integrations',
+            type: "docSidebar",
+            position: "left",
+            sidebarId: "integrations",
+            label: "Integrations",
           },
           {
             href: "https://api.python.langchain.com",
@@ -187,9 +187,9 @@ const config = {
           // Please keep GitHub link to the right for consistency.
           {
             href: "https://github.com/hwchase17/langchain",
-            position: 'right',
-            className: 'header-github-link',
-            'aria-label': 'GitHub repository',
+            position: "right",
+            className: "header-github-link",
+            "aria-label": "GitHub repository",
           },
         ],
       },
@@ -239,6 +239,14 @@ const config = {
         copyright: `Copyright © ${new Date().getFullYear()} LangChain, Inc.`,
       },
     }),
+
+  scripts: [
+    "/js/google_analytics.js",
+    {
+      src: "https://www.googletagmanager.com/gtag/js?id=G-9B66JQQH2F",
+      async: true,
+    },
+  ],
 };
 
 module.exports = config;

docs/docs_skeleton/sidebars.js

@@ -44,6 +44,16 @@ module.exports = {
         id: "modules/index"
       },
     },
+    {
+      type: "category",
+      label: "LangChain Expression Language",
+      collapsed: true,
+      items: [{ type: "autogenerated", dirName: "expression_language" } ],
+      link: {
+        type: 'doc',
+        id: "expression_language/index"
+      },
+    },
     {
       type: "category",
       label: "Guides",
@@ -52,27 +62,20 @@ module.exports = {
       link: {
         type: 'generated-index',
         description: 'Design guides for key parts of the development process',
-      slug: "guides",
-      },
-    },
-    {
-      type: "category",
-      label: "Ecosystem",
-      collapsed: true,
-      items: [{ type: "autogenerated", dirName: "ecosystem" }],
-      link: {
-        type: 'generated-index',
-      slug: "ecosystem",
+        slug: "guides",
       },
     },
     {
       type: "category",
       label: "Additional resources",
       collapsed: true,
-      items: [{ type: "autogenerated", dirName: "additional_resources" }, { type: "link", label: "Gallery", href: "https://github.com/kyrolabs/awesome-langchain" }],
+      items: [
+        { type: "autogenerated", dirName: "additional_resources" },
+        { type: "link", label: "Gallery", href: "https://github.com/kyrolabs/awesome-langchain" }
+      ],
       link: {
         type: 'generated-index',
-      slug: "additional_resources",
+        slug: "additional_resources",
       },
     },
     'community'
@@ -80,25 +83,42 @@ module.exports = {
   integrations: [
     {
       type: "category",
-      label: "Integrations",
+      label: "Providers",
       collapsible: false,
-      items: [{ type: "autogenerated", dirName: "integrations" }],
+      items: [
+        { type: "autogenerated", dirName: "integrations/platforms" },
+        { type: "category", label: "More", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/providers" }]},
+      ],
       link: {
         type: 'generated-index',
-      slug: "integrations",
+        slug: "integrations/providers",
+      },
+    },
+    {
+      type: "category",
+      label: "Components",
+      collapsible: false,
+      items: [
+        { type: "category", label: "LLMs", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/llms" }], link: { type: 'doc', id: "integrations/llms/index"}},
+        { type: "category", label: "Chat models", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/chat" }], link: { type: 'doc', id: "integrations/chat/index"}},
+        { type: "category", label: "Document loaders", collapsed: true, items: [{type:"autogenerated", dirName: "integrations/document_loaders" }], link: {type: "generated-index", slug: "integrations/document_loaders" }},
+        { type: "category", label: "Document transformers", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/document_transformers" }], link: {type: "generated-index", slug: "integrations/document_transformers" }},
+        { type: "category", label: "Text embedding models", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/text_embedding" }], link: {type: "generated-index", slug: "integrations/text_embedding" }},
+        { type: "category", label: "Vector stores", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/vectorstores" }], link: {type: "generated-index", slug: "integrations/vectorstores" }},
+        { type: "category", label: "Retrievers", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/retrievers" }], link: {type: "generated-index", slug: "integrations/retrievers" }},
+        { type: "category", label: "Tools", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/tools" }], link: {type: "generated-index", slug: "integrations/tools" }},
+        { type: "category", label: "Agents and toolkits", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/toolkits" }], link: {type: "generated-index", slug: "integrations/toolkits" }},
+        { type: "category", label: "Memory", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/memory" }], link: {type: "generated-index", slug: "integrations/memory" }},
+        { type: "category", label: "Callbacks", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/callbacks" }], link: {type: "generated-index", slug: "integrations/callbacks" }},
+        { type: "category", label: "Chat loaders", collapsed: true, items: [{type: "autogenerated", dirName: "integrations/chat_loaders" }], link: {type: "generated-index", slug: "integrations/chat_loaders" }},
+      ],
+      link: {
+        type: 'generated-index',
+      slug: "integrations/components",
       },
     },
   ],
   use_cases: [
-    {
-      type: "category",
-      label: "Use cases",
-      collapsible: false,
-      items: [{ type: "autogenerated", dirName: "use_cases" }],
-      link: {
-        type: 'generated-index',
-      slug: "use_cases",
-      },
-    },
+    {type: "autogenerated", dirName: "use_cases" }
   ],
 };

docs/docs_skeleton/src/pages/index.js

@@ -11,5 +11,5 @@ import React from "react";
 import { Redirect } from "@docusaurus/router";
 
 export default function Home() {
-  return <Redirect to="docs/get_started/introduction.html" />;
+  return <Redirect to="docs/get_started/introduction" />;
 }

docs/docs_skeleton/static/js/google_analytics.js

@@ -0,0 +1,7 @@
+window.dataLayer = window.dataLayer || [];
+function gtag() {
+  dataLayer.push(arguments);
+}
+gtag("js", new Date());
+
+gtag("config", "G-9B66JQQH2F");

docs/docs_skeleton/vercel.json

@@ -1,5 +1,101 @@
 {
   "redirects": [
+    {
+      "source": "/docs/modules/agents/agents/examples/mrkl_chat(.html?)",
+      "destination": "/docs/modules/agents/"
+    },
+    {
+      "source": "/docs/use_cases(/?)",
+      "destination": "/docs/use_cases/question_answering/"
+    },
+    {
+      "source": "/docs/integrations(/?)",
+      "destination": "/docs/integrations/providers/"
+    },
+    {
+      "source": "/docs/integrations/platforms(/?)",
+      "destination": "/docs/integrations/providers/"
+    },
+    {
+      "source": "/docs/integrations/platforms(/?)",
+      "destination": "/docs/integrations/providers/"
+    },
+    {
+      "source": "/docs/expression_language/cookbook/routing",
+      "destination": "/docs/expression_language/how_to/routing"
+    },
+    {
+      "source":  "/docs/integrations/providers/amazon_api_gateway",
+      "destination": "/docs/integrations/platforms/aws"
+    },
+    {
+      "source":  "/docs/integrations/providers/azure_blob_storage",
+      "destination": "/docs/integrations/platforms/microsoft"
+    },
+    {
+      "source":  "/docs/integrations/providers/google_vertexai_matchingengine",
+      "destination": "/docs/integrations/platforms/google"
+    },
+    {
+      "source":  "/docs/integrations/providers/aws_s3",
+      "destination": "/docs/integrations/platforms/aws"
+    },
+    {
+      "source":  "/docs/integrations/providers/azure_openai",
+      "destination": "/docs/integrations/platforms/microsoft"
+    },
+    {
+      "source":  "/docs/integrations/providers/azure_blob_storage",
+      "destination": "/docs/integrations/platforms/microsoft"
+    },
+    {
+      "source":  "/docs/integrations/providers/azure_cognitive_search_",
+      "destination": "/docs/integrations/platforms/microsoft"
+    },
+    {
+      "source":  "/docs/integrations/providers/bedrock",
+      "destination": "/docs/integrations/platforms/aws"
+    },
+    {
+      "source":  "/docs/integrations/providers/google_bigquery",
+      "destination": "/docs/integrations/platforms/google"
+    },
+    {
+      "source":  "/docs/integrations/providers/google_cloud_storage",
+      "destination": "/docs/integrations/platforms/google"
+    },
+    {
+      "source":  "/docs/integrations/providers/google_drive",
+      "destination": "/docs/integrations/platforms/google"
+    },
+    {
+      "source":  "/docs/integrations/providers/google_search",
+      "destination": "/docs/integrations/platforms/google"
+    },
+    {
+      "source":  "/docs/integrations/providers/microsoft_onedrive",
+      "destination": "/docs/integrations/platforms/microsoft"
+    },
+    {
+      "source":  "/docs/integrations/providers/microsoft_powerpoint",
+      "destination": "/docs/integrations/platforms/microsoft"
+    },
+    {
+      "source":  "/docs/integrations/providers/microsoft_word",
+      "destination": "/docs/integrations/platforms/microsoft"
+    },
+    {
+      "source":  "/docs/integrations/providers/sagemaker_endpoint",
+      "destination": "/docs/integrations/platforms/aws"
+    },
+    {
+      "source":  "/docs/integrations/providers/sagemaker_tracking",
+      "destination": "/docs/integrations/callbacks/sagemaker_tracking"
+    },
+    {
+      "source":  "/docs/integrations/providers/openai",
+      "destination": "/docs/integrations/platforms/openai"
+    },
     {
       "source": "/docs/modules/data_connection/caching_embeddings(/?)",
       "destination": "/docs/modules/data_connection/text_embedding/caching_embeddings"
@@ -362,7 +458,7 @@
     },
     {
       "source": "/docs/integrations/openai",
-      "destination": "/docs/integrations/providers/openai"
+      "destination": "/docs/integrations/platforms/openai"
     },
     {
       "source": "/docs/integrations/opensearch",
@@ -1076,6 +1172,10 @@
       "source": "/docs/modules/agents/tools/integrations/zapier",
       "destination": "/docs/integrations/tools/zapier"
     },
+    {
+      "source": "/docs/integrations/tools/sqlite",
+      "destination": "/docs/use_cases/qa_structured/sqlite"
+    },
     {
       "source": "/en/latest/modules/callbacks/filecallbackhandler.html",
       "destination": "/docs/modules/callbacks/how_to/filecallbackhandler"
@@ -1872,6 +1972,18 @@
       "source": "/docs/modules/data_connection/document_loaders/integrations/youtube_transcript",
       "destination": "/docs/integrations/document_loaders/youtube_transcript"
     },
+    {
+      "source": "/docs/integrations/document_loaders/Etherscan",
+      "destination": "/docs/integrations/document_loaders/etherscan"
+    },
+    {
+      "source": "/docs/integrations/document_loaders/merge_doc_loader",
+      "destination": "/docs/integrations/document_loaders/merge_doc"
+    },
+    {
+      "source": "/docs/integrations/document_loaders/recursive_url_loader",
+      "destination": "/docs/integrations/document_loaders/recursive_url"
+    },
     {
       "source": "/en/latest/modules/indexes/text_splitters/examples/markdown_header_metadata.html",
       "destination": "/docs/modules/data_connection/document_transformers/text_splitters/markdown_header_metadata"
@@ -2216,6 +2328,10 @@
       "source": "/docs/modules/data_connection/text_embedding/integrations/tensorflowhub",
       "destination": "/docs/integrations/text_embedding/tensorflowhub"
     },
+    {
+      "source": "/docs/integrations/text_embedding/Awa",
+      "destination": "/docs/integrations/text_embedding/awadb"
+    },
     {
       "source": "/en/latest/modules/indexes/vectorstores/examples/analyticdb.html",
       "destination": "/docs/integrations/vectorstores/analyticdb"
@@ -2952,6 +3068,46 @@
       "source": "/docs/modules/model_io/models/llms/integrations/writer",
       "destination": "/docs/integrations/llms/writer"
     },
+    {
+      "source": "/docs/integrations/llms/amazon_api_gateway_example",
+      "destination": "/docs/integrations/llms/amazon_api_gateway"
+    },
+    {
+      "source": "/docs/integrations/llms/azureml_endpoint_example",
+      "destination": "/docs/integrations/llms/azure_ml"
+    },
+    {
+      "source": "/docs/integrations/llms/azure_openai_example",
+      "destination": "/docs/integrations/llms/azure_openai"
+    },
+    {
+      "source": "/docs/integrations/llms/cerebriumai_example",
+      "destination": "/docs/integrations/llms/cerebriumai"
+    },
+    {
+      "source": "/docs/integrations/llms/deepinfra_example",
+      "destination": "/docs/integrations/llms/deepinfra"
+    },
+    {
+      "source": "/docs/integrations/llms/Fireworks",
+      "destination": "/docs/integrations/llms/fireworks"
+    },
+    {
+      "source": "/docs/integrations/llms/forefrontai_example",
+      "destination": "/docs/integrations/llms/forefrontai"
+    },
+    {
+      "source": "/docs/integrations/llms/gooseai_example",
+      "destination": "/docs/integrations/llms/gooseai"
+    },
+    {
+      "source": "/docs/integrations/llms/petals_example",
+      "destination": "/docs/integrations/llms/petals"
+    },
+    {
+      "source": "/docs/integrations/llms/pipelineai_example",
+      "destination": "/docs/integrations/llms/pipelineai"
+    },
     {
       "source": "/en/latest/modules/prompts.html",
       "destination": "/docs/modules/model_io/prompts"
@@ -3138,7 +3294,11 @@
     },
     {
       "source": "/en/latest/use_cases/tabular.html",
-      "destination": "/docs/use_cases/tabular"
+      "destination": "/docs/use_cases/qa_structured"
+    },
+    {
+      "source": "/docs/use_cases/sql(/?)",
+      "destination": "/docs/use_cases/qa_structured/sql"
     },
     {
       "source": "/en/latest/youtube.html",
@@ -3330,7 +3490,7 @@
     },
     {
       "source": "/docs/modules/chains/popular/sqlite",
-      "destination": "/docs/use_cases/tabular/sqlite"
+      "destination": "/docs/use_cases/qa_structured/sql"
     },
     {
       "source": "/docs/modules/chains/popular/openai_functions",
@@ -3436,6 +3596,14 @@
       "source": "/docs/modules/chains/additional/graph_kuzu_qa",
       "destination": "/docs/use_cases/more/graph/graph_kuzu_qa"
     },
+    {
+      "source": "/docs/use_cases/graph/graph_falkordb_qa",
+      "destination": "/docs/use_cases/more/graph/graph_falkordb_qa"
+    },
+    {
+      "source": "/docs/modules/chains/additional/graph_falkordb_qa",
+      "destination": "/docs/use_cases/more/graph/graph_falkordb_qa"
+    },
     {
       "source": "/docs/use_cases/graph/graph_nebula_qa",
       "destination": "/docs/use_cases/more/graph/graph_nebula_qa"
@@ -3534,7 +3702,7 @@
     },
     {
       "source": "/docs/modules/chains/additional/elasticsearch_database",
-      "destination": "/docs/use_cases/tabular/elasticsearch_database"
+      "destination": "/docs/use_cases/qa_structured/integrations/elasticsearch"
     },
     {
       "source": "/docs/modules/chains/additional/tagging",
@@ -3547,6 +3715,18 @@
     {
       "source": "/en/latest/integrations/:path*",
       "destination": "/docs/integrations/providers/:path*"
+    },
+    {
+      "source": "/docs/guides/expression_language(/?)",
+      "destination": "/docs/expression_language/"
+    },
+    {
+      "source": "/docs/guides/expression_language/:path*",
+      "destination": "/docs/expression_language/:path*"
+    },
+    {
+      "source": "/docs/ecosystem/dependents",
+      "destination": "/docs/additional_resources/dependents"
     }
   ]
 }

docs/extras/_templates/integration.mdx

@@ -1,4 +1,3 @@
-
 [comment: Please, a reference example here "docs/integrations/arxiv.md"]::
 [comment: Use this template to create a new .md file in "docs/integrations/"]::
 
@@ -7,26 +6,25 @@
 [comment: Only one Tile/H1 is allowed!]::
 
 >
- 
 [comment: Description: After reading this description, a reader should decide if this integration is good enough to try/follow reading OR]::
 [comment: go to read the next integration doc. ]::
 [comment: Description should include a link to the source for follow reading.]::
 
 ## Installation and Setup
 
-[comment: Installation and Setup: All necessary additional package installations and set ups for Tokens, etc]::
+[comment: Installation and Setup: All necessary additional package installations and setups for Tokens, etc]::
 
 ```bash
 pip install package_name_REPLACE_ME
 ```
 
 [comment: OR this text:]::
-There isn't any special setup for it.
 
+There isn't any special setup for it.
 
 [comment: The next H2/## sections with names of the integration modules, like "LLM", "Text Embedding Models", etc]::
 [comment: see "Modules" in the "index.html" page]::
-[comment: Each H2 section should include a link to an example(s) and a python code with import of the integration class]::
+[comment: Each H2 section should include a link to an example(s) and a Python code with the import of the integration class]::
 [comment: Below are several example sections. Remove all unnecessary sections. Add all necessary sections not provided here.]::
 
 ## LLM
@@ -37,7 +35,6 @@ See a [usage example](/docs/integrations/llms/INCLUDE_REAL_NAME).
 from langchain.llms import integration_class_REPLACE_ME
 ```
 
-
 ## Text Embedding Models
 
 See a [usage example](/docs/integrations/text_embedding/INCLUDE_REAL_NAME)
@@ -46,8 +43,7 @@ See a [usage example](/docs/integrations/text_embedding/INCLUDE_REAL_NAME)
 from langchain.embeddings import integration_class_REPLACE_ME
 ```
 
-
-## Chat Models
+## Chat models
 
 See a [usage example](/docs/integrations/chat/INCLUDE_REAL_NAME)
 

docs/extras/additional_resources/dependents.mdx

@@ -51,7 +51,7 @@ Dependents stats for `langchain-ai/langchain`
 |[e2b-dev/e2b](https://github.com/e2b-dev/e2b) | 5365 |
 |[mage-ai/mage-ai](https://github.com/mage-ai/mage-ai) | 5352 |
 |[wenda-LLM/wenda](https://github.com/wenda-LLM/wenda) | 5192 |
-|[LangChain-Chinese-Getting-Started-Guide](https://github.com/liaokongVFX/LangChain-Chinese-Getting-Started-Guide) | 5129 |
+|[liaokongVFX/LangChain-Chinese-Getting-Started-Guide](https://github.com/liaokongVFX/LangChain-Chinese-Getting-Started-Guide) | 5129 |
 |[zilliztech/GPTCache](https://github.com/zilliztech/GPTCache) | 4993 |
 |[GreyDGL/PentestGPT](https://github.com/GreyDGL/PentestGPT) | 4831 |
 |[zauberzeug/nicegui](https://github.com/zauberzeug/nicegui) | 4824 |

docs/extras/additional_resources/youtube.mdx

@@ -1,6 +1,6 @@
 # YouTube videos
 
-⛓ icon marks a new addition [last update 2023-06-20]
+⛓ icon marks a new addition [last update 2023-09-05]
 
 ### [Official LangChain YouTube channel](https://www.youtube.com/@LangChain)
 
@@ -86,20 +86,20 @@
 - [`Llama Index`: Chat with Documentation using URL Loader](https://youtu.be/XJRoDEctAwA) by [Merk](https://www.youtube.com/@merksworld)
 - [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)
-- ⛓ [Using ChatGPT with YOUR OWN Data. This is magical. (LangChain OpenAI API)](https://youtu.be/9AXP7tCI9PI) by [TechLead](https://www.youtube.com/@TechLead)
-- ⛓ [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 [Toolfinder AI](https://www.youtube.com/@toolfinderai)
-- ⛓ [`PrivateGPT`: Chat to your FILES OFFLINE and FREE [Installation and Tutorial]](https://youtu.be/G7iLllmx4qc) by [Prompt Engineering](https://www.youtube.com/@engineerprompt)
-- ⛓ [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)
-
+- [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)
+- [Using ChatGPT with YOUR OWN Data. This is magical. (LangChain OpenAI API)](https://youtu.be/9AXP7tCI9PI) by [TechLead](https://www.youtube.com/@TechLead)
+- [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 [Toolfinder AI](https://www.youtube.com/@toolfinderai)
+- [`PrivateGPT`: Chat to your FILES OFFLINE and FREE [Installation and Tutorial]](https://youtu.be/G7iLllmx4qc) by [Prompt Engineering](https://www.youtube.com/@engineerprompt)
+- [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)
+- ⛓ [LangChain HowTo and Guides YouTube playlist](https://www.youtube.com/playlist?list=PL8motc6AQftk1Bs42EW45kwYbyJ4jOdiZ) by [Sam Witteveen](https://www.youtube.com/@samwitteveenai/)
 
 
 ### [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)

docs/extras/expression_language/cookbook/agent.ipynb

@@ -0,0 +1,203 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e89f490d",
+   "metadata": {},
+   "source": [
+    "# Agents\n",
+    "\n",
+    "You can pass a Runnable into an agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "af4381de",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import XMLAgent, tool, AgentExecutor\n",
+    "from langchain.chat_models import ChatAnthropic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "24cc8134",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = ChatAnthropic(model=\"claude-2\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "67c0b0e4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@tool\n",
+    "def search(query: str) -> str:\n",
+    "    \"\"\"Search things about current events.\"\"\"\n",
+    "    return \"32 degrees\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7203b101",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tool_list = [search]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b68e756d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Get prompt to use\n",
+    "prompt = XMLAgent.get_default_prompt()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "61ab3e9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Logic for going from intermediate steps to a string to pass into model\n",
+    "# This is pretty tied to the prompt\n",
+    "def convert_intermediate_steps(intermediate_steps):\n",
+    "    log = \"\"\n",
+    "    for action, observation in intermediate_steps:\n",
+    "        log += (\n",
+    "            f\"<tool>{action.tool}</tool><tool_input>{action.tool_input}\"\n",
+    "            f\"</tool_input><observation>{observation}</observation>\"\n",
+    "        )\n",
+    "    return log\n",
+    "\n",
+    "\n",
+    "# Logic for converting tools to string to go in prompt\n",
+    "def convert_tools(tools):\n",
+    "    return \"\\n\".join([f\"{tool.name}: {tool.description}\" for tool in tools])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "260f5988",
+   "metadata": {},
+   "source": [
+    "Building an agent from a runnable usually involves a few things:\n",
+    "\n",
+    "1. Data processing for the intermediate steps. These need to represented in a way that the language model can recognize them. This should be pretty tightly coupled to the instructions in the prompt\n",
+    "\n",
+    "2. The prompt itself\n",
+    "\n",
+    "3. The model, complete with stop tokens if needed\n",
+    "\n",
+    "4. The output parser - should be in sync with how the prompt specifies things to be formatted."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e92f1d6f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = (\n",
+    "    {\n",
+    "        \"question\": lambda x: x[\"question\"],\n",
+    "        \"intermediate_steps\": lambda x: convert_intermediate_steps(x[\"intermediate_steps\"])\n",
+    "    }\n",
+    "    | prompt.partial(tools=convert_tools(tool_list))\n",
+    "    | model.bind(stop=[\"</tool_input>\", \"</final_answer>\"])\n",
+    "    | XMLAgent.get_default_output_parser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6ce6ec7a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fb5cb2e3",
+   "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 <tool>search</tool>\n",
+      "<tool_input>weather in new york\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m\n",
+      "\n",
+      "<final_answer>The weather in New York is 32 degrees\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'whats the weather in New york?',\n",
+       " 'output': 'The weather in New York is 32 degrees'}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.invoke({\"question\": \"whats the weather in New york?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bce86dd8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/expression_language/cookbook/code_writing.ipynb

@@ -0,0 +1,119 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f09fd305",
+   "metadata": {},
+   "source": [
+    "# Code writing\n",
+    "\n",
+    "Example of how to use LCEL to write Python code."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "bd7c259a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.utilities import PythonREPL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "73795d2d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Write some python code to solve the user's problem. \n",
+    "\n",
+    "Return only python code in Markdown format, e.g.:\n",
+    "\n",
+    "```python\n",
+    "....\n",
+    "```\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [(\"system\", template), (\"human\", \"{input}\")]\n",
+    ")\n",
+    "\n",
+    "model = ChatOpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "42859e8a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _sanitize_output(text: str):\n",
+    "    _, after = text.split(\"```python\")\n",
+    "    return after.split(\"```\")[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5ded1a86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = prompt | model | StrOutputParser() | _sanitize_output | PythonREPL().run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "208c2b75",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Python REPL can execute arbitrary code. Use with caution.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'4\\n'"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"input\": \"whats 2 plus 2\"})"
+   ]
+  }
+ ],
+ "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/extras/expression_language/cookbook/index.mdx

@@ -0,0 +1,11 @@
+---
+sidebar_position: 2
+---
+
+# Cookbook
+
+import DocCardList from "@theme/DocCardList";
+
+Example code for accomplishing common tasks with the LangChain Expression Language (LCEL). These examples show how to compose different Runnable (the core LCEL interface) components to achieve various tasks. If you're just getting acquainted with LCEL, the [Prompt + LLM](/docs/expression_language/cookbook/prompt_llm_parser) page is a good place to start.
+
+<DocCardList />

docs/extras/expression_language/cookbook/memory.ipynb

@@ -0,0 +1,180 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5062941a",
+   "metadata": {},
+   "source": [
+    "# Adding memory\n",
+    "\n",
+    "This shows how to add memory to an arbitrary chain. Right now, you can use the memory classes but need to hook it up manually"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7998efd8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.memory import ConversationBufferMemory\n",
+    "from langchain.schema.runnable import RunnableMap\n",
+    "from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "prompt = ChatPromptTemplate.from_messages([\n",
+    "    (\"system\", \"You are a helpful chatbot\"),\n",
+    "    MessagesPlaceholder(variable_name=\"history\"),\n",
+    "    (\"human\", \"{input}\")\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fa0087f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(return_messages=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "06b531ae",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': []}"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d9437af6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = RunnableMap({\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"memory\": memory.load_memory_variables\n",
+    "}) | {\n",
+    "    \"input\": lambda x: x[\"input\"],\n",
+    "    \"history\": lambda x: x[\"memory\"][\"history\"]\n",
+    "} | prompt | model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bed1e260",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='Hello Bob! How can I assist you today?', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inputs = {\"input\": \"hi im bob\"}\n",
+    "response = chain.invoke(inputs)\n",
+    "response"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "890475b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory.save_context(inputs, {\"output\": response.content})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e8fcb77f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': [HumanMessage(content='hi im bob', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Hello Bob! How can I assist you today?', additional_kwargs={}, example=False)]}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d837d5c3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='Your name is Bob.', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inputs = {\"input\": \"whats my name\"}\n",
+    "response = chain.invoke(inputs)\n",
+    "response"
+   ]
+  }
+ ],
+ "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/extras/expression_language/cookbook/moderation.ipynb

@@ -0,0 +1,133 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4927a727-b4c8-453c-8c83-bd87b4fcac14",
+   "metadata": {},
+   "source": [
+    "# Adding moderation\n",
+    "\n",
+    "This shows how to add in moderation (or other safeguards) around your LLM application."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "4f5f6449-940a-4f5c-97c0-39b71c3e2a68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chains import OpenAIModerationChain\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "fcb8312b-7e7a-424f-a3ec-76738c9a9d21",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "moderate = OpenAIModerationChain()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "b24b9148-f6b0-4091-8ea8-d3fb281bd950",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = OpenAI()\n",
+    "prompt = ChatPromptTemplate.from_messages([\n",
+    "    (\"system\", \"repeat after me: {input}\")\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "1c8ed87c-9ca6-4559-bf60-d40e94a0af08",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = prompt | model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "5256b9bd-381a-42b0-bfa8-7e6d18f853cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nYou are stupid.'"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"input\": \"you are stupid\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "fe6e3b33-dc9a-49d5-b194-ba750c58a628",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "moderated_chain = chain | moderate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "d8ba0cbd-c739-4d23-be9f-6ae092bd5ffb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'input': '\\n\\nYou are stupid',\n",
+       " 'output': \"Text was found that violates OpenAI's content policy.\"}"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "moderated_chain.invoke({\"input\": \"you are stupid\"})"
+   ]
+  }
+ ],
+ "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/extras/expression_language/cookbook/multiple_chains.ipynb

@@ -0,0 +1,240 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "877102d1-02ea-4fa3-8ec7-a08e242b95b3",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 2\n",
+    "title: Multiple chains\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0f2bf8d3",
+   "metadata": {},
+   "source": [
+    "Runnables can easily be used to string together multiple Chains"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d65d4e9e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'El país donde se encuentra la ciudad de Honolulu, donde nació Barack Obama, el 44º Presidente de los Estados Unidos, es Estados Unidos. Honolulu se encuentra en la isla de Oahu, en el estado de Hawái.'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from operator import itemgetter\n",
+    "\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.schema import StrOutputParser\n",
+    "\n",
+    "prompt1 = ChatPromptTemplate.from_template(\"what is the city {person} is from?\")\n",
+    "prompt2 = ChatPromptTemplate.from_template(\"what country is the city {city} in? respond in {language}\")\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "chain1 = prompt1 | model | StrOutputParser()\n",
+    "\n",
+    "chain2 = {\"city\": chain1, \"language\": itemgetter(\"language\")} | prompt2 | model | StrOutputParser()\n",
+    "\n",
+    "chain2.invoke({\"person\": \"obama\", \"language\": \"spanish\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "878f8176",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.runnable import RunnableMap, RunnablePassthrough\n",
+    "\n",
+    "prompt1 = ChatPromptTemplate.from_template(\"generate a {attribute} color. Return the name of the color and nothing else:\")\n",
+    "prompt2 = ChatPromptTemplate.from_template(\"what is a fruit of color: {color}. Return the name of the fruit and nothing else:\")\n",
+    "prompt3 = ChatPromptTemplate.from_template(\"what is a country with a flag that has the color: {color}. Return the name of the country and nothing else:\")\n",
+    "prompt4 = ChatPromptTemplate.from_template(\"What is the color of {fruit} and the flag of {country}?\")\n",
+    "\n",
+    "model_parser = model | StrOutputParser()\n",
+    "\n",
+    "color_generator = {\"attribute\": RunnablePassthrough()} | prompt1 | {\"color\": model_parser}\n",
+    "color_to_fruit = prompt2 | model_parser\n",
+    "color_to_country = prompt3 | model_parser\n",
+    "question_generator = color_generator | {\"fruit\": color_to_fruit, \"country\": color_to_country} | prompt4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d621a870",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ChatPromptValue(messages=[HumanMessage(content='What is the color of strawberry and the flag of China?', additional_kwargs={}, example=False)])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "question_generator.invoke(\"warm\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b4a9812b-bead-4fd9-ae27-0b8be57e5dc1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='The color of an apple is typically red or green. The flag of China is predominantly red with a large yellow star in the upper left corner and four smaller yellow stars surrounding it.', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt = question_generator.invoke(\"warm\")\n",
+    "model.invoke(prompt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d75a313-f1c8-4e94-9a17-24e0bf4a2bdc",
+   "metadata": {},
+   "source": [
+    "### Branching and Merging\n",
+    "\n",
+    "You may want the output of one component to be processed by 2 or more other components. [RunnableMaps](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.base.RunnableMap.html) let you split or fork the chain so multiple components can process the input in parallel. Later, other components can join or merge the results to synthesize a final response. This type of chain creates a computation graph that looks like the following:\n",
+    "\n",
+    "```text\n",
+    "     Input\n",
+    "      / \\\n",
+    "     /   \\\n",
+    " Branch1 Branch2\n",
+    "     \\   /\n",
+    "      \\ /\n",
+    "      Combine\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "247fa0bd-4596-4063-8cb3-1d7fc119d982",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "planner = (\n",
+    "    ChatPromptTemplate.from_template(\n",
+    "        \"Generate an argument about: {input}\"\n",
+    "    )\n",
+    "    | ChatOpenAI()\n",
+    "    | StrOutputParser()\n",
+    "    | {\"base_response\": RunnablePassthrough()}\n",
+    ")\n",
+    "\n",
+    "arguments_for = (\n",
+    "    ChatPromptTemplate.from_template(\n",
+    "        \"List the pros or positive aspects of {base_response}\"\n",
+    "    )\n",
+    "    | ChatOpenAI()\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "arguments_against =  (\n",
+    "    ChatPromptTemplate.from_template(\n",
+    "        \"List the cons or negative aspects of {base_response}\"\n",
+    "    )\n",
+    "    | ChatOpenAI()\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "final_responder = (\n",
+    "    ChatPromptTemplate.from_messages(\n",
+    "        [\n",
+    "            (\"ai\", \"{original_response}\"),\n",
+    "            (\"human\", \"Pros:\\n{results_1}\\n\\nCons:\\n{results_2}\"),\n",
+    "            (\"system\", \"Generate a final response given the critique\"),\n",
+    "        ]\n",
+    "    )\n",
+    "    | ChatOpenAI()\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "chain = (\n",
+    "    planner \n",
+    "    | {\n",
+    "        \"results_1\": arguments_for,\n",
+    "        \"results_2\": arguments_against,\n",
+    "        \"original_response\": itemgetter(\"base_response\"),\n",
+    "    }\n",
+    "    | final_responder\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "2564f310-0674-4bb1-9c4e-d7848ca73511",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'While Scrum has its potential cons and challenges, many organizations have successfully embraced and implemented this project management framework to great effect. The cons mentioned above can be mitigated or overcome with proper training, support, and a commitment to continuous improvement. It is also important to note that not all cons may be applicable to every organization or project.\\n\\nFor example, while Scrum may be complex initially, with proper training and guidance, teams can quickly grasp the concepts and practices. The lack of predictability can be mitigated by implementing techniques such as velocity tracking and release planning. The limited documentation can be addressed by maintaining a balance between lightweight documentation and clear communication among team members. The dependency on team collaboration can be improved through effective communication channels and regular team-building activities.\\n\\nScrum can be scaled and adapted to larger projects by using frameworks like Scrum of Scrums or LeSS (Large Scale Scrum). Concerns about speed versus quality can be addressed by incorporating quality assurance practices, such as continuous integration and automated testing, into the Scrum process. Scope creep can be managed by having a well-defined and prioritized product backlog, and a strong product owner can be developed through training and mentorship.\\n\\nResistance to change can be overcome by providing proper education and communication to stakeholders and involving them in the decision-making process. Ultimately, the cons of Scrum can be seen as opportunities for growth and improvement, and with the right mindset and support, they can be effectively managed.\\n\\nIn conclusion, while Scrum may have its challenges and potential cons, the benefits and advantages it offers in terms of collaboration, flexibility, adaptability, transparency, and customer satisfaction make it a widely adopted and successful project management framework. With proper implementation and continuous improvement, organizations can leverage Scrum to drive innovation, efficiency, and project success.'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"input\": \"scrum\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "poetry-venv",
+   "language": "python",
+   "name": "poetry-venv"
+  },
+  "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/extras/expression_language/cookbook/prompt_llm_parser.ipynb

@@ -0,0 +1,431 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "abf7263d-3a62-4016-b5d5-b157f92f2070",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 0\n",
+    "title: Prompt + LLM\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a434f2b-9405-468c-9dfd-254d456b57a6",
+   "metadata": {},
+   "source": [
+    "The most common and valuable composition is taking:\n",
+    "\n",
+    "``PromptTemplate`` / ``ChatPromptTemplate`` -> ``LLM`` / ``ChatModel`` -> ``OutputParser``\n",
+    "\n",
+    "Almost any other chains you build will use this building block."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93aa2c87",
+   "metadata": {},
+   "source": [
+    "## PromptTemplate + LLM\n",
+    "\n",
+    "The simplest composition is just combing a prompt and model to create a chain that takes user input, adds it to a prompt, passes it to a model, and returns the raw model input.\n",
+    "\n",
+    "Note, you can mix and match PromptTemplate/ChatPromptTemplates and LLMs/ChatModels as you like here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "466b65b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_template(\"tell me a joke about {foo}\")\n",
+    "model = ChatOpenAI()\n",
+    "chain = prompt | model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e3d0a6cd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"Why don't bears wear shoes?\\n\\nBecause they have bear feet!\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7eb9ef50",
+   "metadata": {},
+   "source": [
+    "Often times we want to attach kwargs that'll be passed to each model call. Here's a few examples of that:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b1d8f88",
+   "metadata": {},
+   "source": [
+    "### Attaching Stop Sequences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "562a06bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = prompt | model.bind(stop=[\"\\n\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "43f5d04c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='Why did the bear never wear shoes?', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f3eaf88a",
+   "metadata": {},
+   "source": [
+    "### Attaching Function Call information"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f94b71b2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "functions = [\n",
+    "    {\n",
+    "      \"name\": \"joke\",\n",
+    "      \"description\": \"A joke\",\n",
+    "      \"parameters\": {\n",
+    "        \"type\": \"object\",\n",
+    "        \"properties\": {\n",
+    "          \"setup\": {\n",
+    "            \"type\": \"string\",\n",
+    "            \"description\": \"The setup for the joke\"\n",
+    "          },\n",
+    "          \"punchline\": {\n",
+    "            \"type\": \"string\",\n",
+    "            \"description\": \"The punchline for the joke\"\n",
+    "          }\n",
+    "        },\n",
+    "        \"required\": [\"setup\", \"punchline\"]\n",
+    "      }\n",
+    "    }\n",
+    "  ]\n",
+    "chain = prompt | model.bind(function_call= {\"name\": \"joke\"}, functions= functions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "decf7710",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='', additional_kwargs={'function_call': {'name': 'joke', 'arguments': '{\\n  \"setup\": \"Why don\\'t bears wear shoes?\",\\n  \"punchline\": \"Because they have bear feet!\"\\n}'}}, example=False)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bears\"}, config={})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9098c5ed",
+   "metadata": {},
+   "source": [
+    "## PromptTemplate + LLM + OutputParser\n",
+    "\n",
+    "We can also add in an output parser to easily trasform the raw LLM/ChatModel output into a more workable format"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "cc194c78",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "\n",
+    "chain = prompt | model | StrOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "77acf448",
+   "metadata": {},
+   "source": [
+    "Notice that this now returns a string - a much more workable format for downstream tasks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e3d69a18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Why don't bears wear shoes?\\n\\nBecause they have bear feet!\""
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c01864e5",
+   "metadata": {},
+   "source": [
+    "### Functions Output Parser\n",
+    "\n",
+    "When you specify the function to return, you may just want to parse that directly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "ad0dd88e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser\n",
+    "\n",
+    "chain = (\n",
+    "    prompt \n",
+    "    | model.bind(function_call= {\"name\": \"joke\"}, functions= functions) \n",
+    "    | JsonOutputFunctionsParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "1e7aa8eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'setup': \"Why don't bears like fast food?\",\n",
+       " 'punchline': \"Because they can't catch it!\"}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "d4aa1a01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser\n",
+    "\n",
+    "chain = (\n",
+    "    prompt \n",
+    "    | model.bind(function_call= {\"name\": \"joke\"}, functions= functions) \n",
+    "    | JsonKeyOutputFunctionsParser(key_name=\"setup\")\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "8b6df9ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Why don't bears wear shoes?\""
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "023fbccb-ef7d-489e-a9ba-f98e17283d51",
+   "metadata": {},
+   "source": [
+    "## Simplifying input\n",
+    "\n",
+    "To make invocation even simpler, we can add a `RunnableMap` to take care of creating the prompt input dict for us:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9601c0f0-71f9-4bd4-a672-7bd04084b018",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.runnable import RunnableMap, RunnablePassthrough\n",
+    "\n",
+    "map_ = RunnableMap({\"foo\": RunnablePassthrough()})\n",
+    "chain = (\n",
+    "    map_ \n",
+    "    | prompt\n",
+    "    | model.bind(function_call= {\"name\": \"joke\"}, functions= functions) \n",
+    "    | JsonKeyOutputFunctionsParser(key_name=\"setup\")\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "7ec4f154-fda5-4847-9220-41aa902fdc33",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Why don't bears wear shoes?\""
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"bears\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "def00bfe-0f83-4805-8c8f-8a53f99fa8ea",
+   "metadata": {},
+   "source": [
+    "Since we're composing our map with another Runnable, we can even use some syntactic sugar and just use a dict:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "7bf3846a-02ee-41a3-ba1b-a708827d4f3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = (\n",
+    "    {\"foo\": RunnablePassthrough()} \n",
+    "    | prompt\n",
+    "    | model.bind(function_call= {\"name\": \"joke\"}, functions= functions) \n",
+    "    | JsonKeyOutputFunctionsParser(key_name=\"setup\")\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "e566d6a1-538d-4cb5-a210-a63e082e4c74",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Why don't bears like fast food?\""
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"bears\")"
+   ]
+  }
+ ],
+ "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/extras/expression_language/cookbook/retrieval.ipynb

@@ -0,0 +1,461 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "abe47592-909c-4844-bf44-9e55c2fb4bfa",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 1\n",
+    "title: RAG\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91c5ef3d",
+   "metadata": {},
+   "source": [
+    "Let's look at adding in a retrieval step to a prompt and LLM, which adds up to a \"retrieval-augmented generation\" chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7f25d9e9-d192-42e9-af50-5660a4bfb0d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install langchain openai faiss-cpu tiktoken"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "33be32af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from operator import itemgetter\n",
+    "\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain.vectorstores import FAISS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "bfc47ec1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vectorstore = FAISS.from_texts([\"harrison worked at kensho\"], embedding=OpenAIEmbeddings())\n",
+    "retriever = vectorstore.as_retriever()\n",
+    "\n",
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "model = ChatOpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "eae31755",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = (\n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()} \n",
+    "    | prompt \n",
+    "    | model \n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "f3040b0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Harrison worked at Kensho.'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke(\"where did harrison work?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e1d20c7c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\n",
+    "Answer in the following language: {language}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "chain = {\n",
+    "    \"context\": itemgetter(\"question\") | retriever, \n",
+    "    \"question\": itemgetter(\"question\"), \n",
+    "    \"language\": itemgetter(\"language\")\n",
+    "} | prompt | model | StrOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "7ee8b2d4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Harrison ha lavorato a Kensho.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"question\": \"where did harrison work\", \"language\": \"italian\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f007669c",
+   "metadata": {},
+   "source": [
+    "## Conversational Retrieval Chain\n",
+    "\n",
+    "We can easily add in conversation history. This primarily means adding in chat_message_history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3f30c348",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.runnable import RunnableMap\n",
+    "from langchain.schema import format_document"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "64ab1dbf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.prompt import PromptTemplate\n",
+    "\n",
+    "_template = \"\"\"Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.\n",
+    "\n",
+    "Chat History:\n",
+    "{chat_history}\n",
+    "Follow Up Input: {question}\n",
+    "Standalone question:\"\"\"\n",
+    "CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7d628c97",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "ANSWER_PROMPT = ChatPromptTemplate.from_template(template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f60a5d0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template=\"{page_content}\")\n",
+    "def _combine_documents(docs, document_prompt = DEFAULT_DOCUMENT_PROMPT, document_separator=\"\\n\\n\"):\n",
+    "    doc_strings = [format_document(doc, document_prompt) for doc in docs]\n",
+    "    return document_separator.join(doc_strings)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7d007db6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Tuple, List\n",
+    "def _format_chat_history(chat_history: List[Tuple]) -> str:\n",
+    "    buffer = \"\"\n",
+    "    for dialogue_turn in chat_history:\n",
+    "        human = \"Human: \" + dialogue_turn[0]\n",
+    "        ai = \"Assistant: \" + dialogue_turn[1]\n",
+    "        buffer += \"\\n\" + \"\\n\".join([human, ai])\n",
+    "    return buffer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "5c32cc89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_inputs = RunnableMap(\n",
+    "    {\n",
+    "        \"standalone_question\": {\n",
+    "            \"question\": lambda x: x[\"question\"],\n",
+    "            \"chat_history\": lambda x: _format_chat_history(x['chat_history'])\n",
+    "        } | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),\n",
+    "    }\n",
+    ")\n",
+    "_context = {\n",
+    "    \"context\": itemgetter(\"standalone_question\") | retriever | _combine_documents,\n",
+    "    \"question\": lambda x: x[\"standalone_question\"]\n",
+    "}\n",
+    "conversational_qa_chain = _inputs | _context | ANSWER_PROMPT | ChatOpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "135c8205",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='Harrison was employed at Kensho.', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversational_qa_chain.invoke({\n",
+    "    \"question\": \"where did harrison work?\",\n",
+    "    \"chat_history\": [],\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "424e7e7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='Harrison worked at Kensho.', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "conversational_qa_chain.invoke({\n",
+    "    \"question\": \"where did he work?\",\n",
+    "    \"chat_history\": [(\"Who wrote this notebook?\", \"Harrison\")],\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5543183",
+   "metadata": {},
+   "source": [
+    "### With Memory and returning source documents\n",
+    "\n",
+    "This shows how to use memory with the above. For memory, we need to manage that outside at the memory. For returning the retrieved documents, we just need to pass them through all the way."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "e31dd17c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationBufferMemory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "d4bffe94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory = ConversationBufferMemory(return_messages=True, output_key=\"answer\", input_key=\"question\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "733be985",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First we add a step to load memory\n",
+    "# This needs to be a RunnableMap because its the first input\n",
+    "loaded_memory = RunnableMap(\n",
+    "    {\n",
+    "        \"question\": itemgetter(\"question\"),\n",
+    "        \"memory\": memory.load_memory_variables,\n",
+    "    }\n",
+    ")\n",
+    "# Next we add a step to expand memory into the variables\n",
+    "expanded_memory = {\n",
+    "    \"question\": itemgetter(\"question\"),\n",
+    "    \"chat_history\": lambda x: x[\"memory\"][\"history\"]\n",
+    "}\n",
+    "\n",
+    "# Now we calculate the standalone question\n",
+    "standalone_question = {\n",
+    "    \"standalone_question\": {\n",
+    "        \"question\": lambda x: x[\"question\"],\n",
+    "        \"chat_history\": lambda x: _format_chat_history(x['chat_history'])\n",
+    "    } | CONDENSE_QUESTION_PROMPT | ChatOpenAI(temperature=0) | StrOutputParser(),\n",
+    "}\n",
+    "# Now we retrieve the documents\n",
+    "retrieved_documents = {\n",
+    "    \"docs\": itemgetter(\"standalone_question\") | retriever,\n",
+    "    \"question\": lambda x: x[\"standalone_question\"]\n",
+    "}\n",
+    "# Now we construct the inputs for the final prompt\n",
+    "final_inputs = {\n",
+    "    \"context\": lambda x: _combine_documents(x[\"docs\"]),\n",
+    "    \"question\": itemgetter(\"question\")\n",
+    "}\n",
+    "# And finally, we do the part that returns the answers\n",
+    "answer = {\n",
+    "    \"answer\": final_inputs | ANSWER_PROMPT | ChatOpenAI(),\n",
+    "    \"docs\": itemgetter(\"docs\"),\n",
+    "}\n",
+    "# And now we put it all together!\n",
+    "final_chain = loaded_memory | expanded_memory | standalone_question | retrieved_documents | answer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "806e390c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'answer': AIMessage(content='Harrison was employed at Kensho.', additional_kwargs={}, example=False),\n",
+       " 'docs': [Document(page_content='harrison worked at kensho', metadata={})]}"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inputs = {\"question\": \"where did harrison work?\"}\n",
+    "result = final_chain.invoke(inputs)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "977399fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Note that the memory does not save automatically\n",
+    "# This will be improved in the future\n",
+    "# For now you need to save it yourself\n",
+    "memory.save_context(inputs, {\"answer\": result[\"answer\"].content})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "f94f7de4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'history': [HumanMessage(content='where did harrison work?', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Harrison was employed at Kensho.', additional_kwargs={}, example=False)]}"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "memory.load_memory_variables({})"
+   ]
+  }
+ ],
+ "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/extras/expression_language/cookbook/sql_db.ipynb

@@ -0,0 +1,227 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "c14da114-1a4a-487d-9cff-e0e8c30ba366",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 3\n",
+    "title: Querying a SQL DB\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "506e9636",
+   "metadata": {},
+   "source": [
+    "We can replicate our SQLDatabaseChain with Runnables."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7a927516",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "\n",
+    "template = \"\"\"Based on the table schema below, write a SQL query that would answer the user's question:\n",
+    "{schema}\n",
+    "\n",
+    "Question: {question}\n",
+    "SQL Query:\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3f51f386",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.utilities import SQLDatabase"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c3449d6-684b-416e-ba16-90a035835a88",
+   "metadata": {},
+   "source": [
+    "We'll need the Chinook sample DB for this example. There's many places to download it from, e.g. https://database.guide/2-sample-databases-sqlite/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "2ccca6fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db = SQLDatabase.from_uri(\"sqlite:///./Chinook.db\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "05ba88ee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_schema(_):\n",
+    "    return db.get_table_info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "a4eda902",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_query(query):\n",
+    "    return db.run(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "5046cb17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from operator import itemgetter\n",
+    "\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnableLambda, RunnableMap\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "inputs = {\n",
+    "    \"schema\": RunnableLambda(get_schema),\n",
+    "    \"question\": itemgetter(\"question\")\n",
+    "}\n",
+    "sql_response = (\n",
+    "        RunnableMap(inputs)\n",
+    "        | prompt\n",
+    "        | model.bind(stop=[\"\\nSQLResult:\"])\n",
+    "        | StrOutputParser()\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "a5552039",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'SELECT COUNT(*) FROM Employee'"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sql_response.invoke({\"question\": \"How many employees are there?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "d6fee130",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Based on the table schema below, question, sql query, and sql response, write a natural language response:\n",
+    "{schema}\n",
+    "\n",
+    "Question: {question}\n",
+    "SQL Query: {query}\n",
+    "SQL Response: {response}\"\"\"\n",
+    "prompt_response = ChatPromptTemplate.from_template(template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "923aa634",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "full_chain = (\n",
+    "    RunnableMap({\n",
+    "        \"question\": itemgetter(\"question\"),\n",
+    "        \"query\": sql_response,\n",
+    "    }) \n",
+    "    | {\n",
+    "        \"schema\": RunnableLambda(get_schema),\n",
+    "        \"question\": itemgetter(\"question\"),\n",
+    "        \"query\": itemgetter(\"query\"),\n",
+    "        \"response\": lambda x: db.run(x[\"query\"])    \n",
+    "    } \n",
+    "    | prompt_response \n",
+    "    | model\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "e94963d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='There are 8 employees.', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"How many employees are there?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f358d7b-a721-4db3-9f92-f06913428afc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/expression_language/cookbook/tools.ipynb

@@ -0,0 +1,122 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "29781123",
+   "metadata": {},
+   "source": [
+    "# Using tools\n",
+    "\n",
+    "You can use any Tools with Runnables easily."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5c579dd-2e22-41b0-a789-346dfdecb5a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install duckduckgo-search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9232d2a9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.tools import DuckDuckGoSearchRun"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a0c64d2c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = DuckDuckGoSearchRun()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "391969b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"turn the following user input into a search query for a search engine:\n",
+    "\n",
+    "{input}\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "model = ChatOpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e3d9d20d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = prompt | model | StrOutputParser() | search"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "55f2967d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'What sports games are on TV today & tonight? Watch and stream live sports on TV today, tonight, tomorrow. Today\\'s 2023 sports TV schedule includes football, basketball, baseball, hockey, motorsports, soccer and more. Watch on TV or stream online on ESPN, FOX, FS1, CBS, NBC, ABC, Peacock, Paramount+, fuboTV, local channels and many other networks. MLB Games Tonight: How to Watch on TV, Streaming & Odds - Thursday, September 7. Seattle Mariners\\' Julio Rodriguez greets teammates in the dugout after scoring against the Oakland Athletics in a ... Circle - Country Music and Lifestyle. Live coverage of all the MLB action today is available to you, with the information provided below. The Brewers will look to pick up a road win at PNC Park against the Pirates on Wednesday at 12:35 PM ET. Check out the latest odds and with BetMGM Sportsbook. Use bonus code \"GNPLAY\" for special offers! MLB Games Tonight: How to Watch on TV, Streaming & Odds - Tuesday, September 5. Houston Astros\\' Kyle Tucker runs after hitting a double during the fourth inning of a baseball game against the Los Angeles Angels, Sunday, Aug. 13, 2023, in Houston. (AP Photo/Eric Christian Smith) (APMedia) The Houston Astros versus the Texas Rangers is one of ... The second half of tonight\\'s college football schedule still has some good games remaining to watch on your television.. We\\'ve already seen an exciting one when Colorado upset TCU. And we saw some ...'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"input\": \"I'd like to figure out what games are tonight\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a16949cf-00ea-43c6-a6aa-797ad4f6918d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "poetry-venv",
+   "language": "python",
+   "name": "poetry-venv"
+  },
+  "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/extras/expression_language/how_to/binding.ipynb

@@ -0,0 +1,194 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "711752cb-4f15-42a3-9838-a0c67f397771",
+   "metadata": {},
+   "source": [
+    "# Bind runtime args\n",
+    "\n",
+    "Sometimes we want to invoke a Runnable within a Runnable sequence 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 `Runnable.bind()` to easily pass these arguments in.\n",
+    "\n",
+    "Suppose we have a simple prompt + model sequence:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f3fdf86d-155f-4587-b7cd-52d363970c1d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EQUATION: x^3 + 7 = 12\n",
+      "\n",
+      "SOLUTION:\n",
+      "Subtracting 7 from both sides of the equation, we get:\n",
+      "x^3 = 12 - 7\n",
+      "x^3 = 5\n",
+      "\n",
+      "Taking the cube root of both sides, we get:\n",
+      "x = ∛5\n",
+      "\n",
+      "Therefore, the solution to the equation x^3 + 7 = 12 is x = ∛5.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.schema import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"Write out the following equation using algebraic symbols then solve it. Use the format\\n\\nEQUATION:...\\nSOLUTION:...\\n\\n\"),\n",
+    "        (\"human\", \"{equation_statement}\")\n",
+    "    ]\n",
+    ")\n",
+    "model = ChatOpenAI(temperature=0)\n",
+    "runnable = {\"equation_statement\": RunnablePassthrough()} | prompt | model | StrOutputParser()\n",
+    "\n",
+    "print(runnable.invoke(\"x raised to the third plus seven equals 12\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "929c9aba-a4a0-462c-adac-2cfc2156e117",
+   "metadata": {},
+   "source": [
+    "and want to call the model with certain `stop` words:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "32e0484a-78c5-4570-a00b-20d597245a96",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "EQUATION: x^3 + 7 = 12\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "runnable = (\n",
+    "    {\"equation_statement\": RunnablePassthrough()} \n",
+    "    | prompt \n",
+    "    | model.bind(stop=\"SOLUTION\") \n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "print(runnable.invoke(\"x raised to the third plus seven equals 12\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4bd641f-6b58-4ca9-a544-f69095428f16",
+   "metadata": {},
+   "source": [
+    "## Attaching OpenAI functions\n",
+    "\n",
+    "One particularly useful application of binding is to attach OpenAI functions to a compatible OpenAI model:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "f66a0fe4-fde0-4706-8863-d60253f211c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "functions = [\n",
+    "    {\n",
+    "      \"name\": \"solver\",\n",
+    "      \"description\": \"Formulates and solves an equation\",\n",
+    "      \"parameters\": {\n",
+    "        \"type\": \"object\",\n",
+    "        \"properties\": {\n",
+    "          \"equation\": {\n",
+    "            \"type\": \"string\",\n",
+    "            \"description\": \"The algebraic expression of the equation\"\n",
+    "          },\n",
+    "          \"solution\": {\n",
+    "            \"type\": \"string\",\n",
+    "            \"description\": \"The solution to the equation\"\n",
+    "          }\n",
+    "        },\n",
+    "        \"required\": [\"equation\", \"solution\"]\n",
+    "      }\n",
+    "    }\n",
+    "  ]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "f381f969-df8e-48a3-bf5c-d0397cfecde0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='', additional_kwargs={'function_call': {'name': 'solver', 'arguments': '{\\n\"equation\": \"x^3 + 7 = 12\",\\n\"solution\": \"x = ∛5\"\\n}'}}, example=False)"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Need gpt-4 to solve this one correctly\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"Write out the following equation using algebraic symbols then solve it.\"),\n",
+    "        (\"human\", \"{equation_statement}\")\n",
+    "    ]\n",
+    ")\n",
+    "model = ChatOpenAI(model=\"gpt-4\", temperature=0).bind(function_call={\"name\": \"solver\"}, functions=functions)\n",
+    "runnable = (\n",
+    "    {\"equation_statement\": RunnablePassthrough()} \n",
+    "    | prompt \n",
+    "    | model\n",
+    ")\n",
+    "runnable.invoke(\"x raised to the third plus seven equals 12\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2cdeeb4c-0c1f-43da-bd58-4f591d9e0671",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "poetry-venv",
+   "language": "python",
+   "name": "poetry-venv"
+  },
+  "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/extras/expression_language/how_to/fallbacks.ipynb

@@ -0,0 +1,285 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "19c9cbd6",
+   "metadata": {},
+   "source": [
+    "# Add fallbacks\n",
+    "\n",
+    "There are many possible points of failure in an LLM application, whether that be issues with LLM API's, poor model outputs, issues with other integrations, etc. Fallbacks help you gracefully handle and isolate these issues.\n",
+    "\n",
+    "Crucially, fallbacks can be applied not only on the LLM level but on the whole runnable level."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a6bb9ba9",
+   "metadata": {},
+   "source": [
+    "## Handling LLM API Errors\n",
+    "\n",
+    "This is maybe the most common use case for fallbacks. A request to an LLM API can fail for a variety of reasons - the API could be down, you could have hit rate limits, any number of things. Therefore, using fallbacks can help protect against these types of things.\n",
+    "\n",
+    "IMPORTANT: By default, a lot of the LLM wrappers catch errors and retry. You will most likely want to turn those off when working with fallbacks. Otherwise the first wrapper will keep on retrying and not failing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d3e893bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI, ChatAnthropic"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4847c82d",
+   "metadata": {},
+   "source": [
+    "First, let's mock out what happens if we hit a RateLimitError from OpenAI"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "dfdd8bf5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from unittest.mock import patch\n",
+    "from openai.error import RateLimitError"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e6fdffc1",
+   "metadata": {},
+   "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",
+    "llm = openai_llm.with_fallbacks([anthropic_llm])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "584461ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hit error\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Let's use just the OpenAI LLm first, to show that we run into an error\n",
+    "with patch('openai.ChatCompletion.create', side_effect=RateLimitError()):\n",
+    "    try:\n",
+    "         print(openai_llm.invoke(\"Why did the chicken cross the road?\"))\n",
+    "    except:\n",
+    "        print(\"Hit error\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "4fc1e673",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=' I don\\'t actually know why the chicken crossed the road, but here are some possible humorous answers:\\n\\n- To get to the other side!\\n\\n- It was too chicken to just stand there. \\n\\n- It wanted a change of scenery.\\n\\n- It wanted to show the possum it could be done.\\n\\n- It was on its way to a poultry farmers\\' convention.\\n\\nThe joke plays on the double meaning of \"the other side\" - literally crossing the road to the other side, or the \"other side\" meaning the afterlife. So it\\'s an anti-joke, with a silly or unexpected pun as the answer.' additional_kwargs={} example=False\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Now let's try with fallbacks to Anthropic\n",
+    "with patch('openai.ChatCompletion.create', side_effect=RateLimitError()):\n",
+    "    try:\n",
+    "         print(llm.invoke(\"Why did the the chicken cross the road?\"))\n",
+    "    except:\n",
+    "        print(\"Hit error\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f00bea25",
+   "metadata": {},
+   "source": [
+    "We can use our \"LLM with Fallbacks\" as we would a normal LLM."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4f8eaaa0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "content=\" I don't actually know why the kangaroo crossed the road, but I'm happy to take a guess! Maybe the kangaroo was trying to get to the other side to find some tasty grass to eat. Or maybe it was trying to get away from a predator or other danger. Kangaroos do need to cross roads and other open areas sometimes as part of their normal activities. Whatever the reason, I'm sure the kangaroo looked both ways before hopping across!\" additional_kwargs={} example=False\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"You're a nice assistant who always includes a compliment in your response\"),\n",
+    "        (\"human\", \"Why did the {animal} cross the road\"),\n",
+    "    ]\n",
+    ")\n",
+    "chain = prompt | llm\n",
+    "with patch('openai.ChatCompletion.create', side_effect=RateLimitError()):\n",
+    "    try:\n",
+    "         print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
+    "    except:\n",
+    "        print(\"Hit error\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef9f0f39-0b9f-4723-a394-f61c98c75d41",
+   "metadata": {},
+   "source": [
+    "### Specifying errors to handle\n",
+    "\n",
+    "We can also specify the errors to handle if we want to be more specific about when the fallback is invoked:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e4069ca4-1c16-4915-9a8c-b2732869ae27",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hit error\n"
+     ]
+    }
+   ],
+   "source": [
+    "llm = openai_llm.with_fallbacks([anthropic_llm], exceptions_to_handle=(KeyboardInterrupt,))\n",
+    "\n",
+    "chain = prompt | llm\n",
+    "with patch('openai.ChatCompletion.create', side_effect=RateLimitError()):\n",
+    "    try:\n",
+    "         print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
+    "    except:\n",
+    "        print(\"Hit error\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d62241b",
+   "metadata": {},
+   "source": [
+    "## Fallbacks for Sequences\n",
+    "\n",
+    "We can also create fallbacks for sequences, that are sequences themselves. Here we do that with two different models: ChatOpenAI and then normal OpenAI (which does not use a chat model). Because OpenAI is NOT a chat model, you likely want a different prompt."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "6d0b8056",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First let's create a chain with a ChatModel\n",
+    "# We add in a string output parser here so the outputs between the two are the same type\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "\n",
+    "chat_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"You're a nice assistant who always includes a compliment in your response\"),\n",
+    "        (\"human\", \"Why did the {animal} cross the road\"),\n",
+    "    ]\n",
+    ")\n",
+    "# Here we're going to use a bad model name to easily create a chain that will error\n",
+    "chat_model = ChatOpenAI(model_name=\"gpt-fake\")\n",
+    "bad_chain = chat_prompt | chat_model | StrOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "8d1fc2a5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Now lets create a chain with the normal OpenAI model\n",
+    "from langchain.llms import OpenAI\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "\n",
+    "prompt_template = \"\"\"Instructions: You should always include a compliment in your response.\n",
+    "\n",
+    "Question: Why did the {animal} cross the road?\"\"\"\n",
+    "prompt = PromptTemplate.from_template(prompt_template)\n",
+    "llm = OpenAI()\n",
+    "good_chain = prompt | llm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "283bfa44",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nAnswer: The turtle crossed the road to get to the other side, and I have to say he had some impressive determination.'"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# We can now create a final chain which combines the two\n",
+    "chain = bad_chain.with_fallbacks([good_chain])\n",
+    "chain.invoke({\"animal\": \"turtle\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/expression_language/how_to/functions.ipynb

@@ -0,0 +1,171 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fbc4bf6e",
+   "metadata": {},
+   "source": [
+    "# Run arbitrary functions\n",
+    "\n",
+    "You can use arbitrary functions in the pipeline\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 input and unpacks it into multiple argument."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6bb221b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.runnable import RunnableLambda\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from operator import itemgetter\n",
+    "\n",
+    "def length_function(text):\n",
+    "    return len(text)\n",
+    "\n",
+    "def _multiple_length_function(text1, text2):\n",
+    "    return len(text1) * len(text2)\n",
+    "\n",
+    "def multiple_length_function(_dict):\n",
+    "    return _multiple_length_function(_dict[\"text1\"], _dict[\"text2\"])\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_template(\"what is {a} + {b}\")\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "chain1 = prompt | model\n",
+    "\n",
+    "chain = {\n",
+    "    \"a\": itemgetter(\"foo\") | RunnableLambda(length_function),\n",
+    "    \"b\": {\"text1\": itemgetter(\"foo\"), \"text2\": itemgetter(\"bar\")} | RunnableLambda(multiple_length_function)\n",
+    "} | prompt | model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "5488ec85",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='3 + 9 equals 12.', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bar\", \"bar\": \"gah\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4728ddd9-914d-42ce-ae9b-72c9ce8ec940",
+   "metadata": {},
+   "source": [
+    "## Accepting a Runnable Config\n",
+    "\n",
+    "Runnable lambdas can optionally accept a [RunnableConfig](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.config.RunnableConfig.html?highlight=runnableconfig#langchain.schema.runnable.config.RunnableConfig), which they can use to pass callbacks, tags, and other configuration information to nested runs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "80b3b5f6-5d58-44b9-807e-cce9a46bf49f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.runnable import RunnableConfig\n",
+    "from langchain.schema.output_parser import StrOutputParser"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ff0daf0c-49dd-4d21-9772-e5fa133c5f36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "def parse_or_fix(text: str, config: RunnableConfig):\n",
+    "    fixing_chain = (\n",
+    "        ChatPromptTemplate.from_template(\n",
+    "            \"Fix the following text:\\n\\n```text\\n{input}\\n```\\nError: {error}\"\n",
+    "            \" Don't narrate, just respond with the fixed data.\"\n",
+    "        )\n",
+    "        | ChatOpenAI()\n",
+    "        | StrOutputParser()\n",
+    "    )\n",
+    "    for _ in range(3):\n",
+    "        try:\n",
+    "            return json.loads(text)\n",
+    "        except Exception as e:\n",
+    "            text = fixing_chain.invoke({\"input\": text, \"error\": e}, config)\n",
+    "    return \"Failed to parse\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1a5e709e-9d75-48c7-bb9c-503251990505",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tokens Used: 65\n",
+      "\tPrompt Tokens: 56\n",
+      "\tCompletion Tokens: 9\n",
+      "Successful Requests: 1\n",
+      "Total Cost (USD): $0.00010200000000000001\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.callbacks import get_openai_callback\n",
+    "\n",
+    "with get_openai_callback() as cb:\n",
+    "    RunnableLambda(parse_or_fix).invoke(\"{foo: bar}\", {\"tags\": [\"my-tag\"], \"callbacks\": [cb]})\n",
+    "    print(cb)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29f55c38",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/expression_language/how_to/index.mdx

@@ -2,8 +2,8 @@
 sidebar_position: 1
 ---
 
-# Grouped by provider
+# How to
 
 import DocCardList from "@theme/DocCardList";
 
-<DocCardList />
+<DocCardList />

docs/extras/expression_language/how_to/map.ipynb

@@ -0,0 +1,199 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b022ab74-794d-4c54-ad47-ff9549ddb9d2",
+   "metadata": {},
+   "source": [
+    "# Use RunnableMaps\n",
+    "\n",
+    "RunnableMaps make it easy to execute multiple Runnables in parallel, and to return the output of these Runnables as a map."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "7e1873d6-d4b6-43ac-96a1-edcf178201e0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'joke': AIMessage(content=\"Why don't bears wear shoes? \\n\\nBecause they have bear feet!\", additional_kwargs={}, example=False),\n",
+       " 'poem': AIMessage(content=\"In woodland depths, bear prowls with might,\\nSilent strength, nature's sovereign, day and night.\", additional_kwargs={}, example=False)}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.schema.runnable import RunnableMap\n",
+    "\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "joke_chain = ChatPromptTemplate.from_template(\"tell me a joke about {topic}\") | model\n",
+    "poem_chain = ChatPromptTemplate.from_template(\"write a 2-line poem about {topic}\") | model\n",
+    "\n",
+    "map_chain = RunnableMap({\"joke\": joke_chain, \"poem\": poem_chain,})\n",
+    "\n",
+    "map_chain.invoke({\"topic\": \"bear\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df867ae9-1cec-4c9e-9fef-21969b206af5",
+   "metadata": {},
+   "source": [
+    "## Manipulating outputs/inputs\n",
+    "Maps can be useful for manipulating the output of one Runnable to match the input format of the next Runnable in a sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "267d1460-53c1-4fdb-b2c3-b6a1eb7fccff",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Harrison worked at Kensho.'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain.vectorstores import FAISS\n",
+    "\n",
+    "vectorstore = FAISS.from_texts([\"harrison worked at kensho\"], embedding=OpenAIEmbeddings())\n",
+    "retriever = vectorstore.as_retriever()\n",
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "retrieval_chain = (\n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()} \n",
+    "    | prompt \n",
+    "    | model \n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "retrieval_chain.invoke(\"where did harrison work?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "392cd4c4-e7ed-4ab8-934d-f7a4eca55ee1",
+   "metadata": {},
+   "source": [
+    "Here the input to prompt is expected to be a map with keys \"context\" and \"question\". The user input is just the question. So we need to get the context using our retriever and passthrough the user input under the \"question\" key.\n",
+    "\n",
+    "Note that when composing a RunnableMap when another Runnable we don't even need to wrap our dictuionary in the RunnableMap class — the type conversion is handled for us."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "833da249-c0d4-4e5b-b3f8-cab549f0f7e1",
+   "metadata": {},
+   "source": [
+    "## Parallelism\n",
+    "\n",
+    "RunnableMaps are also useful for running independent processes in parallel, since each Runnable in the map is executed in parallel. For example, we can see our earlier `joke_chain`, `poem_chain` and `map_chain` all have about the same runtime, even though `map_chain` executes both of the other two."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "38e47834-45af-4281-991f-86f150001510",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "958 ms ± 402 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "\n",
+    "joke_chain.invoke({\"topic\": \"bear\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d0cd40de-b37e-41fa-a2f6-8aaa49f368d6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.22 s ± 508 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "\n",
+    "poem_chain.invoke({\"topic\": \"bear\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "799894e1-8e18-4a73-b466-f6aea6af3920",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.15 s ± 119 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "\n",
+    "map_chain.invoke({\"topic\": \"bear\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/expression_language/how_to/routing.ipynb

@@ -0,0 +1,354 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4b47436a",
+   "metadata": {},
+   "source": [
+    "# Route between multiple Runnables\n",
+    "\n",
+    "This notebook covers how to do routing in the LangChain Expression Language.\n",
+    "\n",
+    "Routing allows you to create non-deterministic chains where the output of a previous step defines the next step. Routing helps provide structure and consistency around interactions with LLMs.\n",
+    "\n",
+    "There are two ways to perform routing:\n",
+    "\n",
+    "1. Using a `RunnableBranch`.\n",
+    "2. Writing custom factory function that takes the input of a previous step and returns a **runnable**. Importantly, this should return a **runnable** and NOT actually execute.\n",
+    "\n",
+    "We'll illustrate both methods using a two step sequence where the first step classifies an input question as being about `LangChain`, `Anthropic`, or `Other`, then routes to a corresponding prompt chain."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f885113d",
+   "metadata": {},
+   "source": [
+    "## Using a RunnableBranch\n",
+    "\n",
+    "A `RunnableBranch` is initialized with a list of (condition, runnable) pairs and a default runnable. It selects which branch by passing each condition the input it's invoked with. It selects the first condition to evaluate to True, and runs the corresponding runnable to that condition with the input. \n",
+    "\n",
+    "If no provided conditions match, it runs the default runnable.\n",
+    "\n",
+    "Here's an example of what it looks like in action:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1aa13c1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain.chat_models import ChatAnthropic\n",
+    "from langchain.schema.output_parser import StrOutputParser"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ed84c59a",
+   "metadata": {},
+   "source": [
+    "First, let's create a chain that will identify incoming questions as being about `LangChain`, `Anthropic`, or `Other`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "3ec03886",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = PromptTemplate.from_template(\"\"\"Given the user question below, classify it as either being about `LangChain`, `Anthropic`, or `Other`.\n",
+    "                                     \n",
+    "Do not respond with more than one word.\n",
+    "\n",
+    "<question>\n",
+    "{question}\n",
+    "</question>\n",
+    "\n",
+    "Classification:\"\"\") | ChatAnthropic() | StrOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "87ae7c1c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' Anthropic'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"question\": \"how do I call Anthropic?\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8aa0a365",
+   "metadata": {},
+   "source": [
+    "Now, let's create three sub chains:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d479962a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "langchain_chain = PromptTemplate.from_template(\"\"\"You are an expert in langchain. \\\n",
+    "Always answer questions starting with \"As Harrison Chase told me\". \\\n",
+    "Respond to the following question:\n",
+    "\n",
+    "Question: {question}\n",
+    "Answer:\"\"\") | ChatAnthropic()\n",
+    "anthropic_chain = PromptTemplate.from_template(\"\"\"You are an expert in anthropic. \\\n",
+    "Always answer questions starting with \"As Dario Amodei told me\". \\\n",
+    "Respond to the following question:\n",
+    "\n",
+    "Question: {question}\n",
+    "Answer:\"\"\") | ChatAnthropic()\n",
+    "general_chain = PromptTemplate.from_template(\"\"\"Respond to the following question:\n",
+    "\n",
+    "Question: {question}\n",
+    "Answer:\"\"\") | ChatAnthropic()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "593eab06",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.runnable import RunnableBranch\n",
+    "\n",
+    "branch = RunnableBranch(\n",
+    "  (lambda x: \"anthropic\" in x[\"topic\"].lower(), anthropic_chain),\n",
+    "  (lambda x: \"langchain\" in x[\"topic\"].lower(), langchain_chain),\n",
+    "  general_chain\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "752c732e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "full_chain = {\n",
+    "    \"topic\": chain,\n",
+    "    \"question\": lambda x: x[\"question\"]\n",
+    "} | branch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "29231bb8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\" As Dario Amodei told me, here are some ways to use Anthropic:\\n\\n- Sign up for an account on Anthropic's website to access tools like Claude, Constitutional AI, and Writer. \\n\\n- Use Claude for tasks like email generation, customer service chat, and QA. Claude can understand natural language prompts and provide helpful responses.\\n\\n- Use Constitutional AI if you need an AI assistant that is harmless, honest, and helpful. It is designed to be safe and aligned with human values.\\n\\n- Use Writer to generate natural language content for things like marketing copy, stories, reports, and more. Give it a topic and prompt and it will create high-quality written content.\\n\\n- Check out Anthropic's documentation and blog for tips, tutorials, examples, and announcements about new capabilities as they continue to develop their AI technology.\\n\\n- Follow Anthropic on social media or subscribe to their newsletter to stay up to date on new features and releases.\\n\\n- For most people, the easiest way to leverage Anthropic's technology is through their website - just create an account to get started!\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"how do I use Anthropic?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c67d8733",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' As Harrison Chase told me, here is how you use LangChain:\\n\\nLangChain is an AI assistant that can have conversations, answer questions, and generate text. To use LangChain, you simply type or speak your input and LangChain will respond. \\n\\nYou can ask LangChain questions, have discussions, get summaries or explanations about topics, and request it to generate text on a subject. Some examples of interactions:\\n\\n- Ask general knowledge questions and LangChain will try to answer factually. For example \"What is the capital of France?\"\\n\\n- Have conversations on topics by taking turns speaking. You can prompt the start of a conversation by saying something like \"Let\\'s discuss machine learning\"\\n\\n- Ask for summaries or high-level explanations on subjects. For example \"Can you summarize the main themes in Shakespeare\\'s Hamlet?\" \\n\\n- Give creative writing prompts or requests to have LangChain generate text in different styles. For example \"Write a short children\\'s story about a mouse\" or \"Generate a poem in the style of Robert Frost about nature\"\\n\\n- Correct LangChain if it makes an inaccurate statement and provide the right information. This helps train it.\\n\\nThe key is interacting naturally and giving it clear prompts and requests', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"how do I use LangChain?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "935ad949",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' 2 + 2 = 4', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"whats 2 + 2\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6d8d042c",
+   "metadata": {},
+   "source": [
+    "## Using a custom function\n",
+    "\n",
+    "You can also use a custom function to route between different outputs. Here's an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "687492da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def route(info):\n",
+    "    if \"anthropic\" in info[\"topic\"].lower():\n",
+    "        return anthropic_chain\n",
+    "    elif \"langchain\" in info[\"topic\"].lower():\n",
+    "        return langchain_chain\n",
+    "    else:\n",
+    "        return general_chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "02a33c86",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema.runnable import RunnableLambda\n",
+    "\n",
+    "full_chain = {\n",
+    "    \"topic\": chain,\n",
+    "    \"question\": lambda x: x[\"question\"]\n",
+    "} | RunnableLambda(route)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "c2e977a4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' As Dario Amodei told me, to use Anthropic IPC you first need to import it:\\n\\n```python\\nfrom anthroipc import ic\\n```\\n\\nThen you can create a client and connect to the server:\\n\\n```python \\nclient = ic.connect()\\n```\\n\\nAfter that, you can call methods on the client and get responses:\\n\\n```python\\nresponse = client.ask(\"What is the meaning of life?\")\\nprint(response)\\n```\\n\\nYou can also register callbacks to handle events: \\n\\n```python\\ndef on_poke(event):\\n  print(\"Got poked!\")\\n\\nclient.on(\\'poke\\', on_poke)\\n```\\n\\nAnd that\\'s the basics of using the Anthropic IPC client library for Python! Let me know if you have any other questions!', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"how do I use Anthroipc?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "48913dc6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' As Harrison Chase told me, to use LangChain you first need to sign up for an API key at platform.langchain.com. Once you have your API key, you can install the Python library and write a simple Python script to call the LangChain API. Here is some sample code to get started:\\n\\n```python\\nimport langchain\\n\\napi_key = \"YOUR_API_KEY\"\\n\\nlangchain.set_key(api_key)\\n\\nresponse = langchain.ask(\"What is the capital of France?\")\\n\\nprint(response.response)\\n```\\n\\nThis will send the question \"What is the capital of France?\" to the LangChain API and print the response. You can customize the request by providing parameters like max_tokens, temperature, etc. The LangChain Python library documentation has more details on the available options. The key things are getting an API key and calling langchain.ask() with your question text. Let me know if you have any other questions!', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"how do I use LangChain?\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "a14d0dca",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=' 4', additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "full_chain.invoke({\"question\": \"whats 2 + 2\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "46802d04",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/extras/expression_language/interface.ipynb

@@ -1,12 +1,21 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "366a0e68-fd67-4fe5-a292-5c33733339ea",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 0\n",
+    "title: Interface\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "9a9acd2e",
    "metadata": {},
    "source": [
-    "# Interface\n",
-    "\n",
     "In an effort to make it as easy as possible to create custom chains, we've implemented a [\"Runnable\"](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.Runnable.html#langchain.schema.runnable.Runnable) protocol that most components implement. This is a standard interface with a few different methods, which makes it easy to define custom chains as well as making it possible to invoke them in a standard way. The standard interface exposed includes:\n",
     "\n",
     "- `stream`: stream back chunks of the response\n",
@@ -62,7 +71,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "id": "d1850a1f",
    "metadata": {},
    "outputs": [],
@@ -72,7 +81,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 4,
    "id": "56d0669f",
    "metadata": {},
    "outputs": [],
@@ -170,6 +179,36 @@
     "chain.batch([{\"topic\": \"bears\"}, {\"topic\": \"cats\"}])"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "2434ab15",
+   "metadata": {},
+   "source": [
+    "You can set the number of concurrent requests by using the `max_concurrency` parameter"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a08522f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[AIMessage(content=\"Why don't bears wear shoes?\\n\\nBecause they have bear feet!\", additional_kwargs={}, example=False),\n",
+       " AIMessage(content=\"Why don't cats play poker in the wild?\\n\\nToo many cheetahs!\", additional_kwargs={}, example=False)]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.batch([{\"topic\": \"bears\"}, {\"topic\": \"cats\"}], config={\"max_concurrency\": 5})"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "b960cbfe",
@@ -399,7 +438,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/extras/guides/debugging.md

@@ -2,7 +2,7 @@
 
 If you're building with LLMs, at some point something will break, and you'll need to debug. A model call will fail, or the model output will be misformatted, or there will be some nested model calls and it won't be clear where along the way an incorrect output was created.
 
-Here's a few different tools and functionalities to aid in debugging.
+Here are a few different tools and functionalities to aid in debugging.
 
 
 
@@ -18,9 +18,9 @@ For anyone building production-grade LLM applications, we highly recommend using
 
 If you're prototyping in Jupyter Notebooks or running Python scripts, it can be helpful to print out the intermediate steps of a Chain run. 
 
-There's a number of ways to enable printing at varying degrees of verbosity.
+There are a number of ways to enable printing at varying degrees of verbosity.
 
-Let's suppose we have a simple agent and want to visualize the actions it takes and tool outputs it receives. Without any debugging, here's what we see:
+Let's suppose we have a simple agent, and want to visualize the actions it takes and tool outputs it receives. Without any debugging, here's what we see:
 
 
 ```python

docs/extras/guides/deployments/template_repos.mdx

@@ -14,7 +14,7 @@ It also contains instructions for how to deploy this app on the Streamlit platfo
 
 ## [Gradio (on Hugging Face)](https://github.com/hwchase17/langchain-gradio-template)
 
-This repo serves as a template for how deploy a LangChain with Gradio.
+This repo serves as a template for how to deploy a LangChain with Gradio.
 It implements a chatbot interface, with a "Bring-Your-Own-Token" approach (nice for not wracking up big bills).
 It also contains instructions for how to deploy this app on the Hugging Face platform.
 This is heavily influenced by James Weaver's [excellent examples](https://huggingface.co/JavaFXpert).
@@ -27,7 +27,7 @@ Chainlit [doc](https://docs.chainlit.io/langchain) on the integration with LangC
 
 ## [Beam](https://github.com/slai-labs/get-beam/tree/main/examples/langchain-question-answering)
 
-This repo serves as a template for how deploy a LangChain with [Beam](https://beam.cloud).
+This repo serves as a template for how to deploy a LangChain with [Beam](https://beam.cloud).
 
 It implements a Question Answering app and contains instructions for deploying the app as a serverless REST API.
 
@@ -47,17 +47,17 @@ A minimal example on how to deploy LangChain to [Kinsta](https://kinsta.com) usi
 
 A minimal example of how to deploy LangChain to [Fly.io](https://fly.io/) using Flask.
 
-## [Digitalocean App Platform](https://github.com/homanp/digitalocean-langchain)
+## [DigitalOcean App Platform](https://github.com/homanp/digitalocean-langchain)
 
-A minimal example on how to deploy LangChain to DigitalOcean App Platform.
+A minimal example of how to deploy LangChain to DigitalOcean App Platform.
 
 ## [CI/CD Google Cloud Build + Dockerfile + Serverless Google Cloud Run](https://github.com/g-emarco/github-assistant)
 
-Boilerplate LangChain project on how to deploy to Google Cloud Run using Docker with Cloud Build CI/CD pipeline
+Boilerplate LangChain project on how to deploy to Google Cloud Run using Docker with Cloud Build CI/CD pipeline.
 
 ## [Google Cloud Run](https://github.com/homanp/gcp-langchain)
 
-A minimal example on how to deploy LangChain to Google Cloud Run.
+A minimal example of how to deploy LangChain to Google Cloud Run.
 
 ## [SteamShip](https://github.com/steamship-core/steamship-langchain/)
 
@@ -82,4 +82,4 @@ These templates serve as examples of how to build, deploy, and share LangChain a
 
 ## [AzureML Online Endpoint](https://github.com/Azure/azureml-examples/blob/main/sdk/python/endpoints/online/llm/langchain/1_langchain_basic_deploy.ipynb)
 
-A minimal example of how to deploy LangChain to an Azure Machine Learning Online Endpoint. 
+A minimal example of how to deploy LangChain to an Azure Machine Learning Online Endpoint. 

docs/extras/guides/evaluation/comparison/custom.ipynb

@@ -1,280 +1,281 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "657d2c8c-54b4-42a3-9f02-bdefa0ed6728",
-   "metadata": {},
-   "source": [
-    "# Custom Pairwise Evaluator\n",
-    "\n",
-    "You can make your own pairwise string evaluators by inheriting from `PairwiseStringEvaluator` class and overwriting the `_evaluate_string_pairs` method (and the `_aevaluate_string_pairs` method if you want to use the evaluator asynchronously).\n",
-    "\n",
-    "In this example, you will make a simple custom evaluator that just returns whether the first prediction has more whitespace tokenized 'words' than the second.\n",
-    "\n",
-    "You can check out the reference docs for the [PairwiseStringEvaluator interface](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.schema.PairwiseStringEvaluator.html#langchain.evaluation.schema.PairwiseStringEvaluator) for more info.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "93f3a653-d198-4291-973c-8d1adba338b2",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from typing import Optional, Any\n",
-    "from langchain.evaluation import PairwiseStringEvaluator\n",
-    "\n",
-    "\n",
-    "class LengthComparisonPairwiseEvalutor(PairwiseStringEvaluator):\n",
-    "    \"\"\"\n",
-    "    Custom evaluator to compare two strings.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    def _evaluate_string_pairs(\n",
-    "        self,\n",
-    "        *,\n",
-    "        prediction: str,\n",
-    "        prediction_b: str,\n",
-    "        reference: Optional[str] = None,\n",
-    "        input: Optional[str] = None,\n",
-    "        **kwargs: Any,\n",
-    "    ) -> dict:\n",
-    "        score = int(len(prediction.split()) > len(prediction_b.split()))\n",
-    "        return {\"score\": score}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "7d4a77c3-07a7-4076-8e7f-f9bca0d6c290",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'score': 1}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "evaluator = LengthComparisonPairwiseEvalutor()\n",
-    "\n",
-    "evaluator.evaluate_string_pairs(\n",
-    "    prediction=\"The quick brown fox jumped over the lazy dog.\",\n",
-    "    prediction_b=\"The quick brown fox jumped over the dog.\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d90f128f-6f49-42a1-b05a-3aea568ee03b",
-   "metadata": {},
-   "source": [
-    "## LLM-Based Example\n",
-    "\n",
-    "That example was simple to illustrate the API, but it wasn't very useful in practice. Below, use an LLM with some custom instructions to form a simple preference scorer similar to the built-in [PairwiseStringEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain.html#langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain). We will use `ChatAnthropic` for the evaluator chain."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "b4b43098-4d96-417b-a8a9-b3e75779cfe8",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "# %pip install anthropic\n",
-    "# %env ANTHROPIC_API_KEY=YOUR_API_KEY"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "b6e978ab-48f1-47ff-9506-e13b1a50be6e",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from typing import Optional, Any\n",
-    "from langchain.evaluation import PairwiseStringEvaluator\n",
-    "from langchain.chat_models import ChatAnthropic\n",
-    "from langchain.chains import LLMChain\n",
-    "\n",
-    "\n",
-    "class CustomPreferenceEvaluator(PairwiseStringEvaluator):\n",
-    "    \"\"\"\n",
-    "    Custom evaluator to compare two strings using a custom LLMChain.\n",
-    "    \"\"\"\n",
-    "\n",
-    "    def __init__(self) -> None:\n",
-    "        llm = ChatAnthropic(model=\"claude-2\", temperature=0)\n",
-    "        self.eval_chain = LLMChain.from_string(\n",
-    "            llm,\n",
-    "            \"\"\"Which option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/C\n",
-    "\n",
-    "Input: How do I get the path of the parent directory in python 3.8?\n",
-    "Option A: You can use the following code:\n",
-    "```python\n",
-    "import os\n",
-    "\n",
-    "os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n",
-    "```\n",
-    "Option B: You can use the following code:\n",
-    "```python\n",
-    "from pathlib import Path\n",
-    "Path(__file__).absolute().parent\n",
-    "```\n",
-    "Reasoning: Both options return the same result. However, since option B is more concise and easily understand, it is preferred.\n",
-    "Preference: B\n",
-    "\n",
-    "Which option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/C\n",
-    "Input: {input}\n",
-    "Option A: {prediction}\n",
-    "Option B: {prediction_b}\n",
-    "Reasoning:\"\"\",\n",
-    "        )\n",
-    "\n",
-    "    @property\n",
-    "    def requires_input(self) -> bool:\n",
-    "        return True\n",
-    "\n",
-    "    @property\n",
-    "    def requires_reference(self) -> bool:\n",
-    "        return False\n",
-    "\n",
-    "    def _evaluate_string_pairs(\n",
-    "        self,\n",
-    "        *,\n",
-    "        prediction: str,\n",
-    "        prediction_b: str,\n",
-    "        reference: Optional[str] = None,\n",
-    "        input: Optional[str] = None,\n",
-    "        **kwargs: Any,\n",
-    "    ) -> dict:\n",
-    "        result = self.eval_chain(\n",
-    "            {\n",
-    "                \"input\": input,\n",
-    "                \"prediction\": prediction,\n",
-    "                \"prediction_b\": prediction_b,\n",
-    "                \"stop\": [\"Which option is preferred?\"],\n",
-    "            },\n",
-    "            **kwargs,\n",
-    "        )\n",
-    "\n",
-    "        response_text = result[\"text\"]\n",
-    "        reasoning, preference = response_text.split(\"Preference:\", maxsplit=1)\n",
-    "        preference = preference.strip()\n",
-    "        score = 1.0 if preference == \"A\" else (0.0 if preference == \"B\" else None)\n",
-    "        return {\"reasoning\": reasoning.strip(), \"value\": preference, \"score\": score}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "5cbd8b1d-2cb0-4f05-b435-a1a00074d94a",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "evaluator = CustomPreferenceEvaluator()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "2c0a7fb7-b976-4443-9f0e-e707a6dfbdf7",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'reasoning': 'Option B is preferred over option A for importing from a relative directory, because it is more straightforward and concise.\\n\\nOption A uses the importlib module, which allows importing a module by specifying the full name as a string. While this works, it is less clear compared to option B.\\n\\nOption B directly imports from the relative path using dot notation, which clearly shows that it is a relative import. This is the recommended way to do relative imports in Python.\\n\\nIn summary, option B is more accurate and helpful as it uses the standard Python relative import syntax.',\n",
-       " 'value': 'B',\n",
-       " 'score': 0.0}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "evaluator.evaluate_string_pairs(\n",
-    "    input=\"How do I import from a relative directory?\",\n",
-    "    prediction=\"use importlib! importlib.import_module('.my_package', '.')\",\n",
-    "    prediction_b=\"from .sibling import foo\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "f13a1346-7dbe-451d-b3a3-99e8fc7b753b",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CustomPreferenceEvaluator requires an input string.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Setting requires_input to return True adds additional validation to avoid returning a grade when insufficient data is provided to the chain.\n",
-    "\n",
-    "try:\n",
-    "    evaluator.evaluate_string_pairs(\n",
-    "        prediction=\"use importlib! importlib.import_module('.my_package', '.')\",\n",
-    "        prediction_b=\"from .sibling import foo\",\n",
-    "    )\n",
-    "except ValueError as e:\n",
-    "    print(e)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e7829cc3-ebd1-4628-ae97-15166202e9cc",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "657d2c8c-54b4-42a3-9f02-bdefa0ed6728",
+            "metadata": {},
+            "source": [
+                "# Custom Pairwise Evaluator\n",
+                "[![Open In Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/extras/guides/evaluation/comparison/custom.ipynb)\n",
+                "\n",
+                "You can make your own pairwise string evaluators by inheriting from `PairwiseStringEvaluator` class and overwriting the `_evaluate_string_pairs` method (and the `_aevaluate_string_pairs` method if you want to use the evaluator asynchronously).\n",
+                "\n",
+                "In this example, you will make a simple custom evaluator that just returns whether the first prediction has more whitespace tokenized 'words' than the second.\n",
+                "\n",
+                "You can check out the reference docs for the [PairwiseStringEvaluator interface](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.schema.PairwiseStringEvaluator.html#langchain.evaluation.schema.PairwiseStringEvaluator) for more info.\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "id": "93f3a653-d198-4291-973c-8d1adba338b2",
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [],
+            "source": [
+                "from typing import Optional, Any\n",
+                "from langchain.evaluation import PairwiseStringEvaluator\n",
+                "\n",
+                "\n",
+                "class LengthComparisonPairwiseEvalutor(PairwiseStringEvaluator):\n",
+                "    \"\"\"\n",
+                "    Custom evaluator to compare two strings.\n",
+                "    \"\"\"\n",
+                "\n",
+                "    def _evaluate_string_pairs(\n",
+                "        self,\n",
+                "        *,\n",
+                "        prediction: str,\n",
+                "        prediction_b: str,\n",
+                "        reference: Optional[str] = None,\n",
+                "        input: Optional[str] = None,\n",
+                "        **kwargs: Any,\n",
+                "    ) -> dict:\n",
+                "        score = int(len(prediction.split()) > len(prediction_b.split()))\n",
+                "        return {\"score\": score}"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "7d4a77c3-07a7-4076-8e7f-f9bca0d6c290",
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "{'score': 1}"
+                        ]
+                    },
+                    "execution_count": 2,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "evaluator = LengthComparisonPairwiseEvalutor()\n",
+                "\n",
+                "evaluator.evaluate_string_pairs(\n",
+                "    prediction=\"The quick brown fox jumped over the lazy dog.\",\n",
+                "    prediction_b=\"The quick brown fox jumped over the dog.\",\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "d90f128f-6f49-42a1-b05a-3aea568ee03b",
+            "metadata": {},
+            "source": [
+                "## LLM-Based Example\n",
+                "\n",
+                "That example was simple to illustrate the API, but it wasn't very useful in practice. Below, use an LLM with some custom instructions to form a simple preference scorer similar to the built-in [PairwiseStringEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain.html#langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain). We will use `ChatAnthropic` for the evaluator chain."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "id": "b4b43098-4d96-417b-a8a9-b3e75779cfe8",
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [],
+            "source": [
+                "# %pip install anthropic\n",
+                "# %env ANTHROPIC_API_KEY=YOUR_API_KEY"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "id": "b6e978ab-48f1-47ff-9506-e13b1a50be6e",
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [],
+            "source": [
+                "from typing import Optional, Any\n",
+                "from langchain.evaluation import PairwiseStringEvaluator\n",
+                "from langchain.chat_models import ChatAnthropic\n",
+                "from langchain.chains import LLMChain\n",
+                "\n",
+                "\n",
+                "class CustomPreferenceEvaluator(PairwiseStringEvaluator):\n",
+                "    \"\"\"\n",
+                "    Custom evaluator to compare two strings using a custom LLMChain.\n",
+                "    \"\"\"\n",
+                "\n",
+                "    def __init__(self) -> None:\n",
+                "        llm = ChatAnthropic(model=\"claude-2\", temperature=0)\n",
+                "        self.eval_chain = LLMChain.from_string(\n",
+                "            llm,\n",
+                "            \"\"\"Which option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/C\n",
+                "\n",
+                "Input: How do I get the path of the parent directory in python 3.8?\n",
+                "Option A: You can use the following code:\n",
+                "```python\n",
+                "import os\n",
+                "\n",
+                "os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n",
+                "```\n",
+                "Option B: You can use the following code:\n",
+                "```python\n",
+                "from pathlib import Path\n",
+                "Path(__file__).absolute().parent\n",
+                "```\n",
+                "Reasoning: Both options return the same result. However, since option B is more concise and easily understand, it is preferred.\n",
+                "Preference: B\n",
+                "\n",
+                "Which option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/C\n",
+                "Input: {input}\n",
+                "Option A: {prediction}\n",
+                "Option B: {prediction_b}\n",
+                "Reasoning:\"\"\",\n",
+                "        )\n",
+                "\n",
+                "    @property\n",
+                "    def requires_input(self) -> bool:\n",
+                "        return True\n",
+                "\n",
+                "    @property\n",
+                "    def requires_reference(self) -> bool:\n",
+                "        return False\n",
+                "\n",
+                "    def _evaluate_string_pairs(\n",
+                "        self,\n",
+                "        *,\n",
+                "        prediction: str,\n",
+                "        prediction_b: str,\n",
+                "        reference: Optional[str] = None,\n",
+                "        input: Optional[str] = None,\n",
+                "        **kwargs: Any,\n",
+                "    ) -> dict:\n",
+                "        result = self.eval_chain(\n",
+                "            {\n",
+                "                \"input\": input,\n",
+                "                \"prediction\": prediction,\n",
+                "                \"prediction_b\": prediction_b,\n",
+                "                \"stop\": [\"Which option is preferred?\"],\n",
+                "            },\n",
+                "            **kwargs,\n",
+                "        )\n",
+                "\n",
+                "        response_text = result[\"text\"]\n",
+                "        reasoning, preference = response_text.split(\"Preference:\", maxsplit=1)\n",
+                "        preference = preference.strip()\n",
+                "        score = 1.0 if preference == \"A\" else (0.0 if preference == \"B\" else None)\n",
+                "        return {\"reasoning\": reasoning.strip(), \"value\": preference, \"score\": score}"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "id": "5cbd8b1d-2cb0-4f05-b435-a1a00074d94a",
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [],
+            "source": [
+                "evaluator = CustomPreferenceEvaluator()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 7,
+            "id": "2c0a7fb7-b976-4443-9f0e-e707a6dfbdf7",
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "{'reasoning': 'Option B is preferred over option A for importing from a relative directory, because it is more straightforward and concise.\\n\\nOption A uses the importlib module, which allows importing a module by specifying the full name as a string. While this works, it is less clear compared to option B.\\n\\nOption B directly imports from the relative path using dot notation, which clearly shows that it is a relative import. This is the recommended way to do relative imports in Python.\\n\\nIn summary, option B is more accurate and helpful as it uses the standard Python relative import syntax.',\n",
+                            " 'value': 'B',\n",
+                            " 'score': 0.0}"
+                        ]
+                    },
+                    "execution_count": 7,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "evaluator.evaluate_string_pairs(\n",
+                "    input=\"How do I import from a relative directory?\",\n",
+                "    prediction=\"use importlib! importlib.import_module('.my_package', '.')\",\n",
+                "    prediction_b=\"from .sibling import foo\",\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 13,
+            "id": "f13a1346-7dbe-451d-b3a3-99e8fc7b753b",
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "CustomPreferenceEvaluator requires an input string.\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# Setting requires_input to return True adds additional validation to avoid returning a grade when insufficient data is provided to the chain.\n",
+                "\n",
+                "try:\n",
+                "    evaluator.evaluate_string_pairs(\n",
+                "        prediction=\"use importlib! importlib.import_module('.my_package', '.')\",\n",
+                "        prediction_b=\"from .sibling import foo\",\n",
+                "    )\n",
+                "except ValueError as e:\n",
+                "    print(e)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "e7829cc3-ebd1-4628-ae97-15166202e9cc",
+            "metadata": {},
+            "outputs": [],
+            "source": []
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3 (ipykernel)",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.2"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
 }

docs/extras/guides/evaluation/comparison/pairwise_embedding_distance.ipynb

@@ -1,232 +1,233 @@
 {
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {
-    "tags": []
-   },
-   "source": [
-    "# Pairwise Embedding Distance \n",
-    "\n",
-    "One way to measure the similarity (or dissimilarity) between two predictions on a shared or similar input is to embed the predictions and compute a vector distance between the two embeddings.<a name=\"cite_ref-1\"></a>[<sup>[1]</sup>](#cite_note-1)\n",
-    "\n",
-    "You can load the `pairwise_embedding_distance` evaluator to do this.\n",
-    "\n",
-    "**Note:** This returns a **distance** score, meaning that the lower the number, the **more** similar the outputs are, according to their embedded representation.\n",
-    "\n",
-    "Check out the reference docs for the [PairwiseEmbeddingDistanceEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain.html#langchain.evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain) for more info."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.evaluation import load_evaluator\n",
-    "\n",
-    "evaluator = load_evaluator(\"pairwise_embedding_distance\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'score': 0.0966466944859925}"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "evaluator.evaluate_string_pairs(\n",
-    "    prediction=\"Seattle is hot in June\", prediction_b=\"Seattle is cool in June.\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'score': 0.03761174337464557}"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "evaluator.evaluate_string_pairs(\n",
-    "    prediction=\"Seattle is warm in June\", prediction_b=\"Seattle is cool in June.\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Select the Distance Metric\n",
-    "\n",
-    "By default, the evalutor uses cosine distance. You can choose a different distance metric if you'd like. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<EmbeddingDistance.COSINE: 'cosine'>,\n",
-       " <EmbeddingDistance.EUCLIDEAN: 'euclidean'>,\n",
-       " <EmbeddingDistance.MANHATTAN: 'manhattan'>,\n",
-       " <EmbeddingDistance.CHEBYSHEV: 'chebyshev'>,\n",
-       " <EmbeddingDistance.HAMMING: 'hamming'>]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from langchain.evaluation import EmbeddingDistance\n",
-    "\n",
-    "list(EmbeddingDistance)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "evaluator = load_evaluator(\n",
-    "    \"pairwise_embedding_distance\", distance_metric=EmbeddingDistance.EUCLIDEAN\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Select Embeddings to Use\n",
-    "\n",
-    "The constructor uses `OpenAI` embeddings by default, but you can configure this however you want. Below, use huggingface local embeddings"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "from langchain.embeddings import HuggingFaceEmbeddings\n",
-    "\n",
-    "embedding_model = HuggingFaceEmbeddings()\n",
-    "hf_evaluator = load_evaluator(\"pairwise_embedding_distance\", embeddings=embedding_model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'score': 0.5486443280477362}"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "hf_evaluator.evaluate_string_pairs(\n",
-    "    prediction=\"Seattle is hot in June\", prediction_b=\"Seattle is cool in June.\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'score': 0.21018880025138598}"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "hf_evaluator.evaluate_string_pairs(\n",
-    "    prediction=\"Seattle is warm in June\", prediction_b=\"Seattle is cool in June.\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<a name=\"cite_note-1\"></a><i>1. Note: When it comes to semantic similarity, this often gives better results than older string distance metrics (such as those in the `PairwiseStringDistanceEvalChain`), though it tends to be less reliable than evaluators that use the LLM directly (such as the `PairwiseStringEvalChain`) </i>"
-   ]
-  }
- ],
- "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.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
+    "cells": [
+        {
+            "attachments": {},
+            "cell_type": "markdown",
+            "metadata": {
+                "tags": []
+            },
+            "source": [
+                "# Pairwise Embedding Distance \n",
+                "[![Open In Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/extras/guides/evaluation/comparison/pairwise_embedding_distance.ipynb)\n",
+                "\n",
+                "One way to measure the similarity (or dissimilarity) between two predictions on a shared or similar input is to embed the predictions and compute a vector distance between the two embeddings.<a name=\"cite_ref-1\"></a>[<sup>[1]</sup>](#cite_note-1)\n",
+                "\n",
+                "You can load the `pairwise_embedding_distance` evaluator to do this.\n",
+                "\n",
+                "**Note:** This returns a **distance** score, meaning that the lower the number, the **more** similar the outputs are, according to their embedded representation.\n",
+                "\n",
+                "Check out the reference docs for the [PairwiseEmbeddingDistanceEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain.html#langchain.evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain) for more info."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [],
+            "source": [
+                "from langchain.evaluation import load_evaluator\n",
+                "\n",
+                "evaluator = load_evaluator(\"pairwise_embedding_distance\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "{'score': 0.0966466944859925}"
+                        ]
+                    },
+                    "execution_count": 2,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "evaluator.evaluate_string_pairs(\n",
+                "    prediction=\"Seattle is hot in June\", prediction_b=\"Seattle is cool in June.\"\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "{'score': 0.03761174337464557}"
+                        ]
+                    },
+                    "execution_count": 3,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "evaluator.evaluate_string_pairs(\n",
+                "    prediction=\"Seattle is warm in June\", prediction_b=\"Seattle is cool in June.\"\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Select the Distance Metric\n",
+                "\n",
+                "By default, the evalutor uses cosine distance. You can choose a different distance metric if you'd like. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "[<EmbeddingDistance.COSINE: 'cosine'>,\n",
+                            " <EmbeddingDistance.EUCLIDEAN: 'euclidean'>,\n",
+                            " <EmbeddingDistance.MANHATTAN: 'manhattan'>,\n",
+                            " <EmbeddingDistance.CHEBYSHEV: 'chebyshev'>,\n",
+                            " <EmbeddingDistance.HAMMING: 'hamming'>]"
+                        ]
+                    },
+                    "execution_count": 4,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "from langchain.evaluation import EmbeddingDistance\n",
+                "\n",
+                "list(EmbeddingDistance)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [],
+            "source": [
+                "evaluator = load_evaluator(\n",
+                "    \"pairwise_embedding_distance\", distance_metric=EmbeddingDistance.EUCLIDEAN\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Select Embeddings to Use\n",
+                "\n",
+                "The constructor uses `OpenAI` embeddings by default, but you can configure this however you want. Below, use huggingface local embeddings"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [],
+            "source": [
+                "from langchain.embeddings import HuggingFaceEmbeddings\n",
+                "\n",
+                "embedding_model = HuggingFaceEmbeddings()\n",
+                "hf_evaluator = load_evaluator(\"pairwise_embedding_distance\", embeddings=embedding_model)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 10,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "{'score': 0.5486443280477362}"
+                        ]
+                    },
+                    "execution_count": 10,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "hf_evaluator.evaluate_string_pairs(\n",
+                "    prediction=\"Seattle is hot in June\", prediction_b=\"Seattle is cool in June.\"\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 12,
+            "metadata": {
+                "tags": []
+            },
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "{'score': 0.21018880025138598}"
+                        ]
+                    },
+                    "execution_count": 12,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "hf_evaluator.evaluate_string_pairs(\n",
+                "    prediction=\"Seattle is warm in June\", prediction_b=\"Seattle is cool in June.\"\n",
+                ")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "<a name=\"cite_note-1\"></a><i>1. Note: When it comes to semantic similarity, this often gives better results than older string distance metrics (such as those in the `PairwiseStringDistanceEvalChain`), though it tends to be less reliable than evaluators that use the LLM directly (such as the `PairwiseStringEvalChain`) </i>"
+            ]
+        }
+    ],
+    "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.2"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 4
+}