Merge branch 'harrison/docs-revamp-mirror' of github.com:hwchase17/langchain into harrison/docs-revamp-mirror

Made a stupid typo in the last PR which got already merged😅

revamp getting started (#15070)

Harrison/agents rewrite (#15028)

havent marked the class as deprecated yet, will likely want to do all in
one go (with other classes)

---------

Co-authored-by: Nuno Campos <nuno@langchain.dev>

ModelIO revamp (#15230)

Retrieval Docs Revamp (#15238)

[core, langchain] modelio code improvements (#15277)

[langchain] agents code changes (#15278)

<!-- Thank you for contributing to LangChain!

Please title your PR "<package>: <description>", where <package> is
whichever of langchain, community, core, experimental, etc. is being
modified.

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,
- **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!

move stuff

.github/CONTRIBUTING.md

@@ -3,31 +3,17 @@
 Hi there! Thank you for even being interested in contributing to LangChain.
 As an open-source project in a rapidly developing field, we are extremely open to contributions, whether they involve new features, improved infrastructure, better documentation, or bug fixes.
 
+To learn about how to contribute, please follow the [guides here](https://python.langchain.com/docs/contributing/)
+
 ## 🗺️ Guidelines
 
-### 👩‍💻 Contributing Code
+### 👩‍💻 Ways to contribute
 
-To contribute to this project, please follow the ["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 a maintainer.
+There are many ways to contribute to LangChain. Here are some common ways people contribute:
 
-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 [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 live in `docs`.
-  - Update unit and integration tests when relevant.
-- Add a feature
-  - Add a demo notebook in `docs/modules`.
-  - Add unit and integration tests.
-
-We are a small, progress-oriented team. If there's something you'd like to add or change, opening a pull request is the
-best way to get our attention.
+- [**Documentation**](https://python.langchain.com/docs/contributing/documentation): Help improve our docs, including this one!
+- [**Code**](https://python.langchain.com/docs/contributing/code): Help us write code, fix bugs, or improve our infrastructure.
+- [**Integrations**](https://python.langchain.com/docs/contributing/integration): Help us integrate with your favorite vendors and tools.
 
 ### 🚩GitHub Issues
 
@@ -54,268 +40,6 @@ In a similar vein, we do enforce certain linting, formatting, and documentation
 If you are finding these difficult (or even just annoying) to work with, feel free to contact a maintainer for help -
 we do not want these to get in the way of getting good code into the codebase.
 
-## 🚀 Quick Start
+### Contributor Documentation
 
-This quick start guide explains how to run the repository locally.
-For a [development container](https://containers.dev/), see the [.devcontainer folder](https://github.com/langchain-ai/langchain/tree/master/.devcontainer).
-
-### Dependency Management: Poetry and other env/dependency managers
-
-This project utilizes [Poetry](https://python-poetry.org/) v1.6.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
-
-This repository contains two separate projects:
-- `langchain`: core langchain code, abstractions, and use cases.
-- `langchain.experimental`: see the [Experimental README](https://github.com/langchain-ai/langchain/tree/master/libs/experimental/README.md) for more information.
-
-Each of these has its own development environment. Docs are run from the top-level makefile, but development
-is split across separate test & release flows.
-
-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
-```
-
-Then verify dependency installation:
-
-```bash
-make test
-```
-
-If the tests don't pass, you may need to pip install additional dependencies, such as `numexpr` and `openapi_schema_pydantic`.
-
-If during installation you receive a `WheelFileValidationError` for `debugpy`, please make sure you are running
-Poetry v1.6.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.6.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.
-
-### Testing
-
-_some test dependencies are optional; see section about optional dependencies_.
-
-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](https://github.com/langchain-ai/langchain/tree/master/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 [ruff](https://docs.astral.sh/ruff/rules/).
-
-To run formatting for docs, cookbook and templates:
-
-```bash
-make format
-```
-
-To run formatting for a library, run the same command from the relevant library directory:
-
-```bash
-cd libs/{LIBRARY}
-make format
-```
-
-Additionally, you can run the formatter only on the files that have been modified in your current branch as compared to the master branch using the format_diff command:
-
-```bash
-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 for this project is done via a combination of [ruff](https://docs.astral.sh/ruff/rules/) and [mypy](http://mypy-lang.org/).
-
-To run linting for docs, cookbook and templates:
-
-```bash
-make lint
-```
-
-To run linting for a library, run the same command from the relevant library directory:
-
-```bash
-cd libs/{LIBRARY}
-make lint
-```
-
-In addition, you can run the linter only on the files that have been modified in your current branch as compared to the master branch using the lint_diff command:
-
-```bash
-make lint_diff
-```
-
-This can be very helpful when you've made changes to only certain parts of the project and want to ensure your changes meet the linting standards without having to check the entire codebase.
-
-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
-
-Spellchecking for this project is done via [codespell](https://github.com/codespell-project/codespell).
-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:
-
-```bash
-make spell_check
-```
-
-To fix spelling in place:
-
-```bash
-make spell_fix
-```
-
-If codespell is incorrectly flagging a word, you can skip spellcheck for that word by adding it to the codespell config in the `pyproject.toml` file.
-
-```python
-[tool.codespell]
-...
-# Add here:
-ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogyny,unsecure'
-```
-
-## 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 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:
-
-1. Add the dependency to the main group as an optional dependency
-  ```bash
-  poetry add --optional [package_name]
-  ```
-2. Open pyproject.toml and add the dependency to the `extended_testing` extra
-3. Relock the poetry file to update the extra.
-  ```bash
-  poetry lock --no-update
-  ```
-4. Add a unit test that the very least attempts to import the new code. Ideally, the unit
-test makes use of lightweight fixtures to test the logic of the code.
-5. Please use the `@pytest.mark.requires(package_name)` decorator for any tests that require the dependency.
-
-## Adding a Jupyter Notebook
-
-If you are adding a Jupyter Notebook example, you'll want to install the optional `dev` dependencies.
-
-To install dev dependencies:
-
-```bash
-poetry install --with dev
-```
-
-Launch a notebook:
-
-```bash
-poetry run jupyter notebook
-```
-
-When you run `poetry install`, the `langchain` package is installed as editable in the virtualenv, so your new logic can be imported into the notebook.
-
-## Documentation
-
-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.
-
-Documentation is built using [Docusaurus 2](https://docusaurus.io/).
-
-API Reference are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
-For that reason, we ask that you add good documentation to all classes and methods.
-
-Similar to linting, we recognize documentation 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.
-
-### Build Documentation Locally
-
-In the following commands, the prefix `api_` indicates that those are operations for the API Reference.
-
-Before building the documentation, it is always a good idea to clean the build directory:
-
-```bash
-make docs_clean
-make api_docs_clean
-```
-
-Next, you can build the documentation as outlined below:
-
-```bash
-make docs_build
-make api_docs_build
-```
-
-Finally, run the link checker to ensure all links are valid:
-
-```bash
-make docs_linkcheck
-make api_docs_linkcheck
-```
-
-### Verify Documentation changes
-
-After pushing documentation changes to the repository, you can preview and verify that the changes are
-what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page.
-This will take you to a preview of the documentation changes.
-This preview is created by [Vercel](https://vercel.com/docs/getting-started-with-vercel).
-
-## 🏭 Release Process
-
-As of now, LangChain has an ad hoc release process: releases are cut with high frequency by
-a developer and published to [PyPI](https://pypi.org/project/langchain/).
-
-LangChain follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
-even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
-
-### 🌟 Recognition
-
-If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
-If you have a Twitter account you would like us to mention, please let us know in the PR or through another means.
+To learn about how to contribute, please follow the [guides here](https://python.langchain.com/docs/contributing/)

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -27,4 +27,4 @@ body:
     attributes:
       label: Your contribution
       description: |
-        Is there any way that you could help, e.g. by submitting a PR? Make sure to read the CONTRIBUTING.MD [readme](https://github.com/langchain-ai/langchain/blob/master/.github/CONTRIBUTING.md)
+        Is there any way that you could help, e.g. by submitting a PR? Make sure to read the [Contributing Guide](https://python.langchain.com/docs/contributing/)

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,20 +1,20 @@
 <!-- Thank you for contributing to LangChain!
 
+Please title your PR "<package>: <description>", where <package> is whichever of langchain, community, core, experimental, etc. is being modified.
+
 Replace this entire comment with:
   - **Description:** a description of the change, 
-  - **Issue:** the issue # it fixes (if applicable),
+  - **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.
+Please make sure your PR is passing linting and testing before submitting. Run `make format`, `make lint` and `make test` from the root of the package you've modified to check this locally.
 
-See contribution guidelines for more information on how to write/run tests, lint, etc: 
-https://github.com/langchain-ai/langchain/blob/master/.github/CONTRIBUTING.md
+See contribution guidelines for more information on how to write/run tests, lint, etc: https://python.langchain.com/docs/contributing/
 
 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. It lives in `docs/extras` directory.
+  2. an example notebook showing its use. It lives in `docs/docs/integrations` directory.
 
 If no one reviews your PR within a few days, please @-mention one of @baskaryan, @eyurtsev, @hwchase17.
  -->

.github/scripts/check_diff.py

@@ -0,0 +1,51 @@
+import json
+import sys
+import os
+
+LANGCHAIN_DIRS = {
+    "libs/core",
+    "libs/langchain",
+    "libs/experimental",
+    "libs/community",
+}
+
+if __name__ == "__main__":
+    files = sys.argv[1:]
+    dirs_to_run = set()
+
+    for file in files:
+        if any(
+            file.startswith(dir_)
+            for dir_ in (
+                ".github/workflows",
+                ".github/tools",
+                ".github/actions",
+                "libs/core",
+                ".github/scripts/check_diff.py",
+            )
+        ):
+            dirs_to_run.update(LANGCHAIN_DIRS)
+        elif "libs/community" in file:
+            dirs_to_run.update(
+                ("libs/community", "libs/langchain", "libs/experimental")
+            )
+        elif "libs/partners" in file:
+            partner_dir = file.split("/")[2]
+            if os.path.isdir(f"libs/partners/{partner_dir}"):
+                dirs_to_run.update(
+                    (
+                        f"libs/partners/{partner_dir}",
+                        "libs/langchain",
+                        "libs/experimental",
+                    )
+                )
+            # Skip if the directory was deleted
+        elif "libs/langchain" in file:
+            dirs_to_run.update(("libs/langchain", "libs/experimental"))
+        elif "libs/experimental" in file:
+            dirs_to_run.add("libs/experimental")
+        elif file.startswith("libs/"):
+            dirs_to_run.update(LANGCHAIN_DIRS)
+        else:
+            pass
+    print(json.dumps(list(dirs_to_run)))

.github/workflows/_all_ci.yml

@@ -1,20 +1,25 @@
 ---
-name: libs/langchain CI
+name: langchain CI
 
 on:
-  push:
-    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'
-      - '.github/workflows/langchain_ci.yml'
-      - 'libs/*'
-      - 'libs/langchain/**'
-  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
+  workflow_call:
+    inputs:
+      working-directory:
+        required: true
+        type: string
+        description: "From which folder this pipeline executes"
+  workflow_dispatch:
+    inputs:
+      working-directory:
+        required: true
+        type: choice
+        default: 'libs/langchain'
+        options:
+        - libs/langchain
+        - libs/core
+        - libs/experimental
+        - libs/community
+
 
 # If another push to the same PR or branch happens while this workflow is still running,
 # cancel the earlier run in favor of the next run.
@@ -23,47 +28,39 @@ on:
 # a limited number of job runners to be active at the same time, so it's better to cancel
 # pointless jobs early so that more useful jobs can run sooner.
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
+  group: ${{ github.workflow }}-${{ github.ref }}-${{ inputs.working-directory }}
   cancel-in-progress: true
 
 env:
   POETRY_VERSION: "1.6.1"
-  WORKDIR: "libs/langchain"
 
 jobs:
   lint:
-    uses:
-      ./.github/workflows/_lint.yml
+    uses: ./.github/workflows/_lint.yml
     with:
-      working-directory: libs/langchain
+      working-directory: ${{ inputs.working-directory }}
     secrets: inherit
 
   test:
-    uses:
-      ./.github/workflows/_test.yml
+    uses: ./.github/workflows/_test.yml
     with:
-      working-directory: libs/langchain
+      working-directory: ${{ inputs.working-directory }}
     secrets: inherit
 
   compile-integration-tests:
-    uses:
-      ./.github/workflows/_compile_integration_test.yml
+    uses: ./.github/workflows/_compile_integration_test.yml
     with:
-      working-directory: libs/langchain
+      working-directory: ${{ inputs.working-directory }}
     secrets: inherit
 
-  pydantic-compatibility:
-    uses:
-      ./.github/workflows/_pydantic_compatibility.yml
+  dependencies:
+    uses: ./.github/workflows/_dependencies.yml
     with:
-      working-directory: libs/langchain
+      working-directory: ${{ inputs.working-directory }}
     secrets: inherit
 
   extended-tests:
     runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ${{ env.WORKDIR }}
     strategy:
       matrix:
         python-version:
@@ -72,6 +69,10 @@ jobs:
           - "3.10"
           - "3.11"
     name: Python ${{ matrix.python-version }} extended tests
+    defaults:
+      run:
+        working-directory: ${{ inputs.working-directory }}
+    if: ${{ ! startsWith(inputs.working-directory, 'libs/partners/') }}
     steps:
       - uses: actions/checkout@v4
 
@@ -80,14 +81,14 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: libs/langchain
+          working-directory: ${{ inputs.working-directory }}
           cache-key: extended
 
       - name: Install dependencies
         shell: bash
         run: |
           echo "Running extended tests, installing dependencies with poetry..."
-          poetry install -E extended_testing
+          poetry install -E extended_testing --with test
 
       - name: Run extended tests
         run: make extended_tests

.github/workflows/_compile_integration_test.yml

@@ -38,7 +38,7 @@ jobs:
 
       - name: Install integration dependencies
         shell: bash
-        run: poetry install --with=test_integration
+        run: poetry install --with=test_integration,test
 
       - name: Check integration tests compile
         shell: bash

.github/workflows/_dependencies.yml

@@ -1,4 +1,4 @@
-name: pydantic v1/v2 compatibility
+name: dependencies
 
 on:
   workflow_call:
@@ -7,6 +7,10 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
+      langchain-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain library folder"
 
 env:
   POETRY_VERSION: "1.6.1"
@@ -24,7 +28,7 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
-    name: Pydantic v1/v2 compatibility - Python ${{ matrix.python-version }}
+    name: dependencies - Python ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@v4
 
@@ -40,6 +44,22 @@ jobs:
         shell: bash
         run: poetry install
 
+      - name: Check imports with base dependencies
+        shell: bash
+        run: poetry run make check_imports
+
+      - name: Install test dependencies
+        shell: bash
+        run: poetry install --with test
+
+      - name: Install langchain editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-location }}
+        env:
+          LANGCHAIN_LOCATION: ${{ inputs.langchain-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_LOCATION"
+
       - name: Install the opposite major version of pydantic
         # If normal tests use pydantic v1, here we'll use v2, and vice versa.
         shell: bash

.github/workflows/_integration_test.yml

@@ -0,0 +1,60 @@
+name: Integration tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      working-directory:
+        required: true
+        type: string
+
+env:
+  POETRY_VERSION: "1.6.1"
+
+jobs:
+  build:
+    defaults:
+      run:
+        working-directory: ${{ inputs.working-directory }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.8"
+          - "3.11"
+    name: Python ${{ matrix.python-version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - 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: ${{ inputs.working-directory }}
+          cache-key: core
+
+      - name: Install dependencies
+        shell: bash
+        run: poetry install --with test,test_integration
+
+      - name: Run integration tests
+        shell: bash
+        env:
+          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
+          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
+        run: |
+          make integration_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/_lint.yml

@@ -68,7 +68,7 @@ jobs:
         # It doesn't matter how you change it, any change will cause a cache-bust.
         working-directory: ${{ inputs.working-directory }}
         run: |
-          poetry install --with dev,lint,test,typing
+          poetry install --with lint,typing
 
       - name: Install langchain editable
         working-directory: ${{ inputs.working-directory }}
@@ -76,7 +76,7 @@ jobs:
         env:
           LANGCHAIN_LOCATION: ${{ inputs.langchain-location }}
         run: |
-          pip install -e "$LANGCHAIN_LOCATION"
+          poetry run pip install -e "$LANGCHAIN_LOCATION"
 
       - name: Get .mypy_cache to speed up mypy
         uses: actions/cache@v3
@@ -85,9 +85,37 @@ jobs:
         with:
           path: |
             ${{ env.WORKDIR }}/.mypy_cache
-          key: mypy-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', env.WORKDIR)) }}
+          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', env.WORKDIR)) }}
+
 
       - name: Analysing the code with our lint
         working-directory: ${{ inputs.working-directory }}
         run: |
-          make lint
+          make lint_package
+
+      - name: Install test 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 --with test
+
+      - name: Get .mypy_cache_test to speed up mypy
+        uses: actions/cache@v3
+        env:
+          SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
+        with:
+          path: |
+            ${{ env.WORKDIR }}/.mypy_cache_test
+          key: mypy-test-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', env.WORKDIR)) }}
+
+      - name: Analysing the code with our lint
+        working-directory: ${{ inputs.working-directory }}
+        run: |
+          make lint_tests

.github/workflows/_release.yml

@@ -7,6 +7,12 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
+  workflow_dispatch:
+    inputs:
+      working-directory:
+        required: true
+        type: string
+        default: 'libs/langchain'
 
 env:
   PYTHON_VERSION: "3.10"
@@ -76,6 +82,8 @@ jobs:
       - test-pypi-publish
     runs-on: ubuntu-latest
     steps:
+      - uses: actions/checkout@v4
+
       # We explicitly *don't* set up caching here. This ensures our tests are
       # maximally sensitive to catching breakage.
       #
@@ -88,12 +96,17 @@ jobs:
       # - Tests pass, because the dependency is present even though it wasn't specified.
       # - The package is published, and it breaks on the missing dependency when
       #   used in the real world.
-      - uses: actions/setup-python@v4
+
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
 
-      - name: Test published package
+      - name: Import published package
         shell: bash
+        working-directory: ${{ inputs.working-directory }}
         env:
           PKG_NAME: ${{ needs.build.outputs.pkg-name }}
           VERSION: ${{ needs.build.outputs.version }}
@@ -105,9 +118,8 @@ jobs:
         #   (https://test.pypi.org/simple). This will include the PKG_NAME==VERSION
         #   package because VERSION will not have been uploaded to regular PyPI yet.
         #
-        # TODO: add more in-depth pre-publish tests after testing that importing works
         run: |
-          pip install \
+          poetry run pip install \
             --extra-index-url https://test.pypi.org/simple/ \
             "$PKG_NAME==$VERSION"
 
@@ -115,7 +127,38 @@ jobs:
           # since that's how Python imports packages with dashes in the name.
           IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
 
-          python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
+          poetry run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
+
+      - name: Import test dependencies
+        run: poetry install --with test,test_integration
+        working-directory: ${{ inputs.working-directory }}
+
+      # Overwrite the local version of the package with the test PyPI version.
+      - name: Import published package (again)
+        working-directory: ${{ inputs.working-directory }}
+        shell: bash
+        env:
+          PKG_NAME: ${{ needs.build.outputs.pkg-name }}
+          VERSION: ${{ needs.build.outputs.version }}
+        run: |
+          poetry run pip install \
+            --extra-index-url https://test.pypi.org/simple/ \
+            "$PKG_NAME==$VERSION"
+
+      - name: Run unit tests
+        run: make tests
+        working-directory: ${{ inputs.working-directory }}
+
+      - name: Run integration tests
+        if: ${{ startsWith(inputs.working-directory, 'libs/partners/') }}
+        env:
+          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
+          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
+        run: make integration_tests
+        working-directory: ${{ inputs.working-directory }}
+
 
   publish:
     needs:

.github/workflows/_test.yml

@@ -7,6 +7,10 @@ on:
         required: true
         type: string
         description: "From which folder this pipeline executes"
+      langchain-location:
+        required: false
+        type: string
+        description: "Relative path to the langchain library folder"
 
 env:
   POETRY_VERSION: "1.6.1"
@@ -38,11 +42,20 @@ jobs:
 
       - name: Install dependencies
         shell: bash
-        run: poetry install
+        run: poetry install --with test
+
+      - name: Install langchain editable
+        working-directory: ${{ inputs.working-directory }}
+        if: ${{ inputs.langchain-location }}
+        env:
+          LANGCHAIN_LOCATION: ${{ inputs.langchain-location }}
+        run: |
+          poetry run pip install -e "$LANGCHAIN_LOCATION"
 
       - name: Run core tests
         shell: bash
-        run: make test
+        run: |
+          make test
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/check_diffs.yml

@@ -0,0 +1,47 @@
+---
+name: Check library diffs
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    paths:
+      - ".github/actions/**"
+      - ".github/tools/**"
+      - ".github/workflows/**"
+      - "libs/**"
+
+# If another push to the same PR or branch happens while this workflow is still running,
+# cancel the earlier run in favor of the next run.
+#
+# There's no point in testing an outdated version of the code. GitHub only allows
+# a limited number of job runners to be active at the same time, so it's better to cancel
+# pointless jobs early so that more useful jobs can run sooner.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.10'
+      - id: files
+        uses: Ana06/get-changed-files@v2.2.0
+      - id: set-matrix
+        run: echo "dirs-to-run=$(python .github/scripts/check_diff.py ${{ steps.files.outputs.all }})" >> $GITHUB_OUTPUT
+    outputs:
+      dirs-to-run: ${{ steps.set-matrix.outputs.dirs-to-run }}
+  ci:
+    needs: [ build ]
+    strategy:
+      matrix:
+        working-directory: ${{ fromJson(needs.build.outputs.dirs-to-run) }}
+    uses: ./.github/workflows/_all_ci.yml
+    with:
+      working-directory: ${{ matrix.working-directory }}
+
+

.github/workflows/langchain_cli_ci.yml

@@ -1,47 +0,0 @@
----
-name: libs/cli CI
-
-on:
-  push:
-    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'
-      - '.github/workflows/langchain_cli_ci.yml'
-      - 'libs/cli/**'
-      - 'libs/*'
-  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
-
-# If another push to the same PR or branch happens while this workflow is still running,
-# cancel the earlier run in favor of the next run.
-#
-# There's no point in testing an outdated version of the code. GitHub only allows
-# a limited number of job runners to be active at the same time, so it's better to cancel
-# pointless jobs early so that more useful jobs can run sooner.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  POETRY_VERSION: "1.6.1"
-  WORKDIR: "libs/cli"
-
-jobs:
-  lint:
-    uses:
-      ./.github/workflows/_lint.yml
-    with:
-      working-directory: libs/cli
-      langchain-location: ../langchain
-    secrets: inherit
-
-  test:
-    uses:
-      ./.github/workflows/_test.yml
-    with:
-      working-directory: libs/cli
-    secrets: inherit

.github/workflows/langchain_community_release.yml

@@ -0,0 +1,13 @@
+---
+name: libs/community Release
+
+on:
+  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
+
+jobs:
+  release:
+    uses:
+      ./.github/workflows/_release.yml
+    with:
+      working-directory: libs/community
+    secrets: inherit

.github/workflows/langchain_core_release.yml

@@ -0,0 +1,13 @@
+---
+name: libs/core Release
+
+on:
+  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
+
+jobs:
+  release:
+    uses:
+      ./.github/workflows/_release.yml
+    with:
+      working-directory: libs/core
+    secrets: inherit

.github/workflows/langchain_experimental_ci.yml

@@ -1,137 +0,0 @@
----
-name: libs/experimental CI
-
-on:
-  push:
-    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'
-      - 'libs/*'
-      - 'libs/experimental/**'
-  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
-
-# If another push to the same PR or branch happens while this workflow is still running,
-# cancel the earlier run in favor of the next run.
-#
-# There's no point in testing an outdated version of the code. GitHub only allows
-# a limited number of job runners to be active at the same time, so it's better to cancel
-# pointless jobs early so that more useful jobs can run sooner.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  POETRY_VERSION: "1.6.1"
-  WORKDIR: "libs/experimental"
-
-jobs:
-  lint:
-    uses:
-      ./.github/workflows/_lint.yml
-    with:
-      working-directory: libs/experimental
-      langchain-location: ../langchain
-    secrets: inherit
-
-  test:
-    uses:
-      ./.github/workflows/_test.yml
-    with:
-      working-directory: libs/experimental
-    secrets: inherit
-
-  compile-integration-tests:
-    uses:
-      ./.github/workflows/_compile_integration_test.yml
-    with:
-      working-directory: libs/experimental
-    secrets: inherit
-
-  # It's possible that langchain-experimental works fine with the latest *published* langchain,
-  # but is broken with the langchain on `master`.
-  #
-  # We want to catch situations like that *before* releasing a new langchain, hence this test.
-  test-with-latest-langchain:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ${{ env.WORKDIR }}
-    strategy:
-      matrix:
-        python-version:
-          - "3.8"
-          - "3.9"
-          - "3.10"
-          - "3.11"
-    name: test with unpublished langchain - Python ${{ matrix.python-version }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - 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: ${{ env.WORKDIR }}
-          cache-key: unpublished-langchain
-
-      - name: Install dependencies
-        shell: bash
-        run: |
-          echo "Running tests with unpublished langchain, installing dependencies with poetry..."
-          poetry install
-
-          echo "Editably installing langchain outside of poetry, to avoid messing up lockfile..."
-          poetry run pip install -e ../langchain
-
-      - 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@v4
-
-      - 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/langchain_openai_release.yml

@@ -0,0 +1,13 @@
+---
+name: libs/core Release
+
+on:
+  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
+
+jobs:
+  release:
+    uses:
+      ./.github/workflows/_release.yml
+    with:
+      working-directory: libs/core
+    secrets: inherit

.github/workflows/scheduled_test.yml

@@ -52,13 +52,7 @@ jobs:
         shell: bash
         run: |
           echo "Running scheduled tests, installing dependencies with poetry..."
-          poetry install --with=test_integration
-          poetry run pip install google-cloud-aiplatform
-          poetry run pip install "boto3>=1.28.57"
-          if [[ ${{ matrix.python-version }} != "3.8" ]]
-          then
-            poetry run pip install fireworks-ai
-          fi
+          poetry install --with=test_integration,test
 
       - name: Run tests
         shell: bash
@@ -68,7 +62,9 @@ jobs:
           AZURE_OPENAI_API_VERSION: ${{ secrets.AZURE_OPENAI_API_VERSION }}
           AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}
           AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}
-          AZURE_OPENAI_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_DEPLOYMENT_NAME }}
+          AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_CHAT_DEPLOYMENT_NAME }}
+          AZURE_OPENAI_LLM_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_LLM_DEPLOYMENT_NAME }}
+          AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME }}
           FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
         run: |
           make scheduled_tests

.github/workflows/templates_ci.yml

@@ -33,5 +33,4 @@ jobs:
       ./.github/workflows/_lint.yml
     with:
       working-directory: templates
-      langchain-location: ../libs/langchain
     secrets: inherit

.gitignore

@@ -167,8 +167,7 @@ docs/node_modules/
 docs/.docusaurus/
 docs/.cache-loader/
 docs/_dist
-docs/api_reference/api_reference.rst
-docs/api_reference/experimental_api_reference.rst
+docs/api_reference/*api_reference.rst
 docs/api_reference/_build
 docs/api_reference/*/
 !docs/api_reference/_static/

.readthedocs.yaml

@@ -13,6 +13,7 @@ build:
       - python -mvirtualenv $READTHEDOCS_VIRTUALENV_PATH
       - python -m pip install --upgrade --no-cache-dir pip setuptools
       - python -m pip install --upgrade --no-cache-dir sphinx readthedocs-sphinx-ext
+      - python -m pip install ./libs/partners/*
       - python -m pip install --exists-action=w --no-cache-dir -r docs/api_reference/requirements.txt
       - python docs/api_reference/create_api_rst.py
       - cat docs/api_reference/conf.py

LICENSE

@@ -1,6 +1,6 @@
-The MIT License
+MIT License
 
-Copyright (c) Harrison Chase
+Copyright (c) LangChain, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -41,9 +41,10 @@ spell_fix:
 # LINTING AND FORMATTING
 ######################
 
-lint:
+lint lint_package lint_tests:
 	poetry run ruff docs templates cookbook
 	poetry run ruff format docs templates cookbook --diff
+	poetry run ruff --select I docs templates cookbook
 
 format format_diff:
 	poetry run ruff format docs templates cookbook

README.md

@@ -3,8 +3,7 @@
 ⚡ Building applications with LLMs through composability ⚡
 
 [![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain)](https://github.com/langchain-ai/langchain/releases)
-[![CI](https://github.com/langchain-ai/langchain/actions/workflows/langchain_ci.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/langchain_ci.yml)
-[![Experimental CI](https://github.com/langchain-ai/langchain/actions/workflows/langchain_experimental_ci.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/langchain_experimental_ci.yml)
+[![CI](https://github.com/langchain-ai/langchain/actions/workflows/check_diffs.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/check_diffs.yml)
 [![Downloads](https://static.pepy.tech/badge/langchain/month)](https://pepy.tech/project/langchain)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
@@ -30,7 +29,7 @@ pip install langchain
 
 With conda:
 ```bash
-pip install langsmith && conda install langchain -c conda-forge
+conda install langchain -c conda-forge
 ```
 
 ## 🤔 What is LangChain?
@@ -45,7 +44,10 @@ This framework consists of several parts.
 - **[LangServe](https://github.com/langchain-ai/langserve)**: A library for deploying LangChain chains as a REST API.
 - **[LangSmith](https://smith.langchain.com)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
 
-**This repo contains the `langchain` ([here](libs/langchain)), `langchain-experimental` ([here](libs/experimental)), and `langchain-cli` ([here](libs/cli)) Python packages, as well as [LangChain Templates](templates).**
+The LangChain libraries themselves are made up of several different packages.
+- **[`langchain-core`](libs/core)**: Base abstractions and LangChain Expression Language.
+- **[`langchain-community`](libs/community)**: Third party integrations.
+- **[`langchain`](libs/langchain)**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
 
 ![LangChain Stack](docs/static/img/langchain_stack.png)
 
@@ -93,7 +95,7 @@ Agents involve an LLM making decisions about which Actions to take, taking that
 Please see [here](https://python.langchain.com) for full documentation, which includes:
 
 - [Getting started](https://python.langchain.com/docs/get_started/introduction): installation, setting up the environment, simple examples
-- Overview of the [interfaces](https://python.langchain.com/docs/expression_language/), [modules](https://python.langchain.com/docs/modules/) and [integrations](https://python.langchain.com/docs/integrations/providers)
+- Overview of the [interfaces](https://python.langchain.com/docs/expression_language/), [modules](https://python.langchain.com/docs/modules/), and [integrations](https://python.langchain.com/docs/integrations/providers)
 - [Use case](https://python.langchain.com/docs/use_cases/qa_structured/sql) walkthroughs and best practice [guides](https://python.langchain.com/docs/guides/adapters/openai)
 - [LangSmith](https://python.langchain.com/docs/langsmith/), [LangServe](https://python.langchain.com/docs/langserve), and [LangChain Template](https://python.langchain.com/docs/templates/) overviews
 - [Reference](https://api.python.langchain.com): full API docs
@@ -103,4 +105,8 @@ Please see [here](https://python.langchain.com) for full documentation, which in
 
 As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
 
-For detailed information on how to contribute, see [here](.github/CONTRIBUTING.md).
+For detailed information on how to contribute, see [here](https://python.langchain.com/docs/contributing/).
+
+## 🌟 Contributors
+
+[![langchain contributors](https://contrib.rocks/image?repo=langchain-ai/langchain&max=2000)](https://github.com/langchain-ai/langchain/graphs/contributors)

cookbook/LLaMA2_sql_chat.ipynb

@@ -164,8 +164,8 @@
     ")\n",
     "\n",
     "# Chain to query\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "sql_response = (\n",
     "    RunnablePassthrough.assign(schema=get_schema)\n",
@@ -217,7 +217,7 @@
     "    [\n",
     "        (\n",
     "            \"system\",\n",
-    "            \"Given an input question and SQL response, convert it to a natural langugae answer. No pre-amble.\",\n",
+    "            \"Given an input question and SQL response, convert it to a natural language answer. No pre-amble.\",\n",
     "        ),\n",
     "        (\"human\", template),\n",
     "    ]\n",
@@ -293,7 +293,7 @@
     "memory = ConversationBufferMemory(return_messages=True)\n",
     "\n",
     "# Chain to query with memory\n",
-    "from langchain.schema.runnable import RunnableLambda\n",
+    "from langchain_core.runnables import RunnableLambda\n",
     "\n",
     "sql_chain = (\n",
     "    RunnablePassthrough.assign(\n",
@@ -345,7 +345,7 @@
     "    [\n",
     "        (\n",
     "            \"system\",\n",
-    "            \"Given an input question and SQL response, convert it to a natural langugae answer. No pre-amble.\",\n",
+    "            \"Given an input question and SQL response, convert it to a natural language answer. No pre-amble.\",\n",
     "        ),\n",
     "        (\"human\", template),\n",
     "    ]\n",

cookbook/Multi_modal_RAG.ipynb

@@ -46,7 +46,7 @@
     "\n",
     "---\n",
     "\n",
-    "A seperate cookbook highlights `Option 1` [here](https://github.com/langchain-ai/langchain/blob/master/cookbook/multi_modal_RAG_chroma.ipynb).\n",
+    "A separate cookbook highlights `Option 1` [here](https://github.com/langchain-ai/langchain/blob/master/cookbook/multi_modal_RAG_chroma.ipynb).\n",
     "\n",
     "And option `Option 2` is appropriate for cases when a multi-modal LLM cannot be used for answer synthesis (e.g., cost, etc).\n",
     "\n",
@@ -200,7 +200,7 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
     "\n",
     "\n",
     "# Generate summaries of text elements\n",
@@ -270,7 +270,7 @@
     "import base64\n",
     "import os\n",
     "\n",
-    "from langchain.schema.messages import HumanMessage\n",
+    "from langchain_core.messages import HumanMessage\n",
     "\n",
     "\n",
     "def encode_image(image_path):\n",
@@ -355,9 +355,9 @@
     "\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.retrievers.multi_vector import MultiVectorRetriever\n",
-    "from langchain.schema.document import Document\n",
     "from langchain.storage import InMemoryStore\n",
     "from langchain.vectorstores import Chroma\n",
+    "from langchain_core.documents import Document\n",
     "\n",
     "\n",
     "def create_multi_vector_retriever(\n",
@@ -442,7 +442,7 @@
     "import re\n",
     "\n",
     "from IPython.display import HTML, display\n",
-    "from langchain.schema.runnable import RunnableLambda, RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
     "from PIL import Image\n",
     "\n",
     "\n",

cookbook/Semi_Structured_RAG.ipynb

@@ -237,7 +237,7 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser"
+    "from langchain_core.output_parsers import StrOutputParser"
    ]
   },
   {
@@ -320,9 +320,9 @@
     "\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.retrievers.multi_vector import MultiVectorRetriever\n",
-    "from langchain.schema.document import Document\n",
     "from langchain.storage import InMemoryStore\n",
     "from langchain.vectorstores import Chroma\n",
+    "from langchain_core.documents import Document\n",
     "\n",
     "# The vectorstore to use to index the child chunks\n",
     "vectorstore = Chroma(collection_name=\"summaries\", embedding_function=OpenAIEmbeddings())\n",
@@ -374,7 +374,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "# Prompt template\n",
     "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",

cookbook/Semi_structured_and_multi_modal_RAG.ipynb

@@ -213,7 +213,7 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser"
+    "from langchain_core.output_parsers import StrOutputParser"
    ]
   },
   {
@@ -375,9 +375,9 @@
     "\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.retrievers.multi_vector import MultiVectorRetriever\n",
-    "from langchain.schema.document import Document\n",
     "from langchain.storage import InMemoryStore\n",
     "from langchain.vectorstores import Chroma\n",
+    "from langchain_core.documents import Document\n",
     "\n",
     "# The vectorstore to use to index the child chunks\n",
     "vectorstore = Chroma(collection_name=\"summaries\", embedding_function=OpenAIEmbeddings())\n",
@@ -646,7 +646,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "# Prompt template\n",
     "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",

cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb

@@ -211,7 +211,7 @@
    "source": [
     "from langchain.chat_models import ChatOllama\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser"
+    "from langchain_core.output_parsers import StrOutputParser"
    ]
   },
   {
@@ -378,9 +378,9 @@
     "\n",
     "from langchain.embeddings import GPT4AllEmbeddings\n",
     "from langchain.retrievers.multi_vector import MultiVectorRetriever\n",
-    "from langchain.schema.document import Document\n",
     "from langchain.storage import InMemoryStore\n",
     "from langchain.vectorstores import Chroma\n",
+    "from langchain_core.documents import Document\n",
     "\n",
     "# The vectorstore to use to index the child chunks\n",
     "vectorstore = Chroma(\n",
@@ -532,7 +532,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "# Prompt template\n",
     "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",

cookbook/advanced_rag_eval.ipynb

@@ -162,7 +162,7 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
     "\n",
     "# Prompt\n",
     "prompt_text = \"\"\"You are an assistant tasked with summarizing tables and text for retrieval. \\\n",
@@ -202,7 +202,7 @@
     "import os\n",
     "from io import BytesIO\n",
     "\n",
-    "from langchain.schema.messages import HumanMessage\n",
+    "from langchain_core.messages import HumanMessage\n",
     "from PIL import Image\n",
     "\n",
     "\n",
@@ -273,8 +273,8 @@
     "from base64 import b64decode\n",
     "\n",
     "from langchain.retrievers.multi_vector import MultiVectorRetriever\n",
-    "from langchain.schema.document import Document\n",
     "from langchain.storage import InMemoryStore\n",
+    "from langchain_core.documents import Document\n",
     "\n",
     "\n",
     "def create_multi_vector_retriever(\n",
@@ -475,7 +475,7 @@
    "source": [
     "from operator import itemgetter\n",
     "\n",
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "# Prompt\n",
     "template = \"\"\"Answer the question based only on the following context, which can include text and tables:\n",
@@ -521,7 +521,7 @@
     "import re\n",
     "\n",
     "from langchain.schema import Document\n",
-    "from langchain.schema.runnable import RunnableLambda\n",
+    "from langchain_core.runnables import RunnableLambda\n",
     "\n",
     "\n",
     "def looks_like_base64(sb):\n",

cookbook/agent_vectorstore.ipynb

@@ -13,7 +13,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "9b22020a",
    "metadata": {},
@@ -146,7 +145,6 @@
    "source": []
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "c0a6c031",
    "metadata": {},
@@ -280,7 +278,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "787a9b5e",
    "metadata": {},
@@ -289,7 +286,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "9161ba91",
    "metadata": {},
@@ -411,7 +407,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "49a0cbbe",
    "metadata": {},
@@ -525,7 +520,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

cookbook/code-analysis-deeplake.ipynb

@@ -648,7 +648,7 @@
     {
      "data": {
       "text/plain": [
-       "OpenAIEmbeddings(client=<class 'openai.api_resources.embedding.Embedding'>, model='text-embedding-ada-002', deployment='text-embedding-ada-002', openai_api_version='', openai_api_base='', openai_api_type='', openai_proxy='', embedding_ctx_length=8191, openai_api_key='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', openai_organization='', allowed_special=set(), disallowed_special='all', chunk_size=1000, max_retries=6, request_timeout=None, headers=None, tiktoken_model_name=None, show_progress_bar=False, model_kwargs={})"
+       "OpenAIEmbeddings(client=<class 'openai.api_resources.embedding.Embedding'>, model='text-embedding-ada-002', deployment='text-embedding-ada-002', openai_api_version='', openai_api_base='', openai_api_type='', openai_proxy='', embedding_ctx_length=8191, openai_api_key='', openai_organization='', allowed_special=set(), disallowed_special='all', chunk_size=1000, max_retries=6, request_timeout=None, headers=None, tiktoken_model_name=None, show_progress_bar=False, model_kwargs={})"
       ]
      },
      "execution_count": 13,

cookbook/custom_agent_with_tool_retrieval.ipynb

@@ -7,8 +7,6 @@
    "source": [
     "# Custom agent with tool retrieval\n",
     "\n",
-    "This notebook builds off of [this notebook](/docs/modules/agents/how_to/custom_llm_agent) and assumes familiarity with how agents work.\n",
-    "\n",
     "The novel idea introduced in this notebook is the idea of using retrieval to select the set of tools to use to answer an agent query. This is useful when you have many many tools to select from. You cannot put the description of all the tools in the prompt (because of context length issues) so instead you dynamically select the N tools you do want to consider using at run time.\n",
     "\n",
     "In this notebook we will create a somewhat contrived example. We will have one legitimate tool (search) and then 99 fake tools which are just nonsense. We will then add a step in the prompt template that takes the user input and retrieves tool relevant to the query."
@@ -489,7 +487,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.1"
   },
   "vscode": {
    "interpreter": {

cookbook/extraction_openai_tools.ipynb

@@ -23,7 +23,7 @@
     "\n",
     "from langchain.chains.openai_tools import create_extraction_chain_pydantic\n",
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.pydantic_v1 import BaseModel"
+    "from langchain_core.pydantic_v1 import BaseModel"
    ]
   },
   {
@@ -151,11 +151,11 @@
     "\n",
     "from langchain.output_parsers.openai_tools import PydanticToolsParser\n",
     "from langchain.utils.openai_functions import convert_pydantic_to_openai_tool\n",
-    "from langchain.schema.runnable import Runnable\n",
-    "from langchain.pydantic_v1 import BaseModel\n",
+    "from langchain_core.runnables import Runnable\n",
+    "from langchain_core.pydantic_v1 import BaseModel\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.messages import SystemMessage\n",
-    "from langchain.schema.language_model import BaseLanguageModel\n",
+    "from langchain_core.messages import SystemMessage\n",
+    "from langchain_core.language_models import BaseLanguageModel\n",
     "\n",
     "_EXTRACTION_TEMPLATE = \"\"\"Extract and save the relevant entities mentioned \\\n",
     "in the following passage together with their properties.\n",

cookbook/learned_prompt_optimization.ipynb

@@ -51,7 +51,7 @@
     "\n",
     "from langchain.llms import OpenAI\n",
     "\n",
-    "llm = OpenAI(model=\"text-davinci-003\")"
+    "llm = OpenAI(model=\"gpt-3.5-turbo-instruct\")"
    ]
   },
   {

cookbook/llm_bash.ipynb

@@ -69,8 +69,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.chains.llm_bash.prompt import BashOutputParser\n",
     "from langchain.prompts.prompt import PromptTemplate\n",
+    "from langchain_experimental.llm_bash.prompt import BashOutputParser\n",
     "\n",
     "_PROMPT_TEMPLATE = \"\"\"If someone asks you to perform a task, your job is to come up with a series of bash commands that will perform the task. There is no need to put \"#!/bin/bash\" in your answer. Make sure to reason step by step, using this format:\n",
     "Question: \"copy the files in the directory named 'target' into a new directory at the same level as target called 'myNewDirectory'\"\n",

cookbook/multi_modal_QA.ipynb

@@ -92,7 +92,7 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.schema.messages import HumanMessage, SystemMessage"
+    "from langchain_core.messages import HumanMessage, SystemMessage"
    ]
   },
   {

cookbook/multi_modal_RAG_chroma.ipynb

@@ -42,7 +42,7 @@
     "* We will use Open Clip multi-modal embeddings.\n",
     "* We will use [Chroma](https://www.trychroma.com/) with support for multi-modal.\n",
     "\n",
-    "A seperate cookbook highlights `Options 2 and 3` [here](https://github.com/langchain-ai/langchain/blob/master/cookbook/Multi_modal_RAG.ipynb).\n",
+    "A separate cookbook highlights `Options 2 and 3` [here](https://github.com/langchain-ai/langchain/blob/master/cookbook/Multi_modal_RAG.ipynb).\n",
     "\n",
     "![chroma_multimodal.png](attachment:1920fda3-1808-407c-9820-f518c9c6f566.png)\n",
     "\n",
@@ -316,9 +316,9 @@
     "from operator import itemgetter\n",
     "\n",
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.schema.messages import HumanMessage, SystemMessage\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnableLambda, RunnablePassthrough\n",
+    "from langchain_core.messages import HumanMessage, SystemMessage\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
     "\n",
     "\n",
     "def prompt_func(data_dict):\n",

cookbook/multi_modal_output_agent.ipynb

@@ -31,7 +31,7 @@
    "source": [
     "import re\n",
     "\n",
-    "from IPython.display import Image\n",
+    "from IPython.display import Image, display\n",
     "from steamship import Block, Steamship"
    ]
   },
@@ -180,7 +180,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

cookbook/openai_v1_cookbook.ipynb

@@ -29,7 +29,7 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.schema.messages import HumanMessage, SystemMessage"
+    "from langchain_core.messages import HumanMessage, SystemMessage"
    ]
   },
   {
@@ -252,7 +252,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.agent import AgentFinish\n",
+    "from langchain_core.agents import AgentFinish\n",
     "\n",
     "\n",
     "def execute_agent(agent, tools, input):\n",
@@ -457,8 +457,8 @@
     "\n",
     "from langchain.output_parsers.openai_tools import PydanticToolsParser\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.pydantic_v1 import BaseModel, Field\n",
     "from langchain.utils.openai_functions import convert_pydantic_to_openai_tool\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
     "\n",
     "\n",
     "class GetCurrentWeather(BaseModel):\n",

cookbook/plan_and_execute_agent.ipynb

@@ -29,11 +29,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents.tools import Tool\n",
     "from langchain.chains import LLMMathChain\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.llms import OpenAI\n",
     "from langchain.utilities import DuckDuckGoSearchAPIWrapper\n",
+    "from langchain_core.tools import Tool\n",
     "from langchain_experimental.plan_and_execute import (\n",
     "    PlanAndExecute,\n",
     "    load_agent_executor,\n",

cookbook/qianfan_baidu_elasticesearch_RAG.ipynb

@@ -37,7 +37,8 @@
    "source": [
     "#!pip install qianfan\n",
     "#!pip install bce-python-sdk\n",
-    "#!pip install elasticsearch == 7.11.0"
+    "#!pip install elasticsearch == 7.11.0\n",
+    "#!pip install sentence-transformers"
    ]
   },
   {
@@ -54,8 +55,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import sentence_transformers\n",
     "from baidubce.auth.bce_credentials import BceCredentials\n",
     "from baidubce.bce_client_configuration import BceClientConfiguration\n",
+    "from langchain.chains.retrieval_qa import RetrievalQA\n",
     "from langchain.document_loaders.baiducloud_bos_directory import BaiduBOSDirectoryLoader\n",
     "from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n",
     "from langchain.llms.baidu_qianfan_endpoint import QianfanLLMEndpoint\n",
@@ -161,15 +164,22 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "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",
-   "version": "3.9.17"
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
   },
-  "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
     "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
@@ -177,5 +187,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

cookbook/rag_fusion.ipynb

@@ -87,7 +87,7 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.schema.output_parser import StrOutputParser"
+    "from langchain_core.output_parsers import StrOutputParser"
    ]
   },
   {

cookbook/retrieval_in_sql.ipynb

@@ -133,7 +133,7 @@
     "from tqdm import tqdm\n",
     "\n",
     "for i in tqdm(range(len(title_embeddings))):\n",
-    "    title = titles[i].replace(\"'\", \"''\")\n",
+    "    title = song_titles[i].replace(\"'\", \"''\")\n",
     "    embedding = title_embeddings[i]\n",
     "    sql_command = (\n",
     "        f'UPDATE \"Track\" SET \"embeddings\" = ARRAY{embedding} WHERE \"Name\" ='\n",
@@ -268,8 +268,8 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "db = SQLDatabase.from_uri(\n",
     "    CONNECTION_STRING\n",
@@ -324,7 +324,7 @@
    "source": [
     "import re\n",
     "\n",
-    "from langchain.schema.runnable import RunnableLambda\n",
+    "from langchain_core.runnables import RunnableLambda\n",
     "\n",
     "\n",
     "def replace_brackets(match):\n",
@@ -681,9 +681,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.18"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

cookbook/rewrite.ipynb

@@ -33,9 +33,9 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnablePassthrough\n",
-    "from langchain.utilities import DuckDuckGoSearchAPIWrapper"
+    "from langchain.utilities import DuckDuckGoSearchAPIWrapper\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough"
    ]
   },
   {

cookbook/selecting_llms_based_on_context_length.ipynb

@@ -19,8 +19,8 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.prompt import PromptValue"
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompt_values import PromptValue"
    ]
   },
   {

cookbook/stepback-qa.ipynb

@@ -25,8 +25,8 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnableLambda"
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnableLambda"
    ]
   },
   {

cookbook/tree_of_thought.ipynb

@@ -26,7 +26,7 @@
    "source": [
     "from langchain.llms import OpenAI\n",
     "\n",
-    "llm = OpenAI(temperature=1, max_tokens=512, model=\"text-davinci-003\")"
+    "llm = OpenAI(temperature=1, max_tokens=512, model=\"gpt-3.5-turbo-instruct\")"
    ]
   },
   {

cookbook/wikibase_agent.ipynb

@@ -187,7 +187,7 @@
     "    for key in path:\n",
     "        try:\n",
     "            current = current[key]\n",
-    "        except:\n",
+    "        except KeyError:\n",
     "            return None\n",
     "    return current\n",
     "\n",

docs/.local_build.sh

@@ -9,13 +9,15 @@ SCRIPT_DIR="$(cd "$(dirname "$0")"; pwd)"
 cd "${SCRIPT_DIR}"
 
 mkdir -p ../_dist
-cp -r . ../_dist
+rsync -ruv --exclude node_modules --exclude api_reference --exclude .venv --exclude .docusaurus . ../_dist
 cd ../_dist
 poetry run python scripts/model_feat_table.py
-poetry run nbdoc_build --srcdir docs
 cp ../cookbook/README.md src/pages/cookbook.mdx
-cp ../.github/CONTRIBUTING.md docs/contributing.md
+mkdir -p docs/templates
+cp ../templates/docs/INDEX.md docs/templates/index.md
+poetry run python scripts/copy_templates.py
 wget https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md -O docs/langserve.md
-poetry run python scripts/generate_api_reference_links.py
-yarn install
-yarn start
+
+yarn
+
+quarto preview docs

docs/README.md

@@ -1,49 +1,3 @@
-# Website
+# LangChain Documentation
 
-This website is built using [Docusaurus 2](https://docusaurus.io/), a modern static website generator.
-
-### Installation
-
-```
-$ yarn
-```
-
-### Local Development
-
-```
-$ yarn start
-```
-
-This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.
-
-### Build
-
-```
-$ yarn build
-```
-
-This command generates static content into the `build` directory and can be served using any static contents hosting service.
-
-### Deployment
-
-Using SSH:
-
-```
-$ USE_SSH=true yarn deploy
-```
-
-Not using SSH:
-
-```
-$ GIT_USER=<Your GitHub username> yarn deploy
-```
-
-If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.
-
-### Continuous Integration
-
-Some common defaults for linting/formatting have been set for you. If you integrate your project with an open-source Continuous Integration system (e.g. Travis CI, CircleCI), you may check for issues using the following command.
-
-```
-$ yarn ci
-```
+For more information on contributing to our documentation, see the [Documentation Contributing Guide](https://python.langchain.com/docs/contributing/documentation)

docs/api_reference/conf.py

@@ -72,8 +72,8 @@ def setup(app):
 # -- Project information -----------------------------------------------------
 
 project = "🦜🔗 LangChain"
-copyright = "2023, Harrison Chase"
-author = "Harrison Chase"
+copyright = "2023, LangChain, Inc."
+author = "LangChain, Inc."
 
 version = data["tool"]["poetry"]["version"]
 release = version
@@ -136,18 +136,25 @@ html_theme_path = ["themes"]
 # redirects dictionary maps from old links to new links
 html_additional_pages = {}
 redirects = {
-    "index": "api_reference",
+    "index": "langchain_api_reference",
 }
 for old_link in redirects:
     html_additional_pages[old_link] = "redirects.html"
 
+partners_dir = Path(__file__).parent.parent.parent / "libs/partners"
+partners = [
+    (p.name, p.name.replace("-", "_") + "_api_reference")
+    for p in partners_dir.iterdir()
+]
+
 html_context = {
     "display_github": True,  # Integrate GitHub
-    "github_user": "hwchase17",  # Username
+    "github_user": "langchain-ai",  # Username
     "github_repo": "langchain",  # Repo name
     "github_version": "master",  # Version
     "conf_py_path": "/docs/api_reference",  # Path in the checkout to the docs root
     "redirects": redirects,
+    "partners": partners,
 }
 
 # Add any paths that contain custom static files (such as style sheets) here,

docs/api_reference/create_api_rst.py

@@ -1,21 +1,18 @@
 """Script for auto-generating api_reference.rst."""
 import importlib
 import inspect
+import os
 import typing
 from enum import Enum
 from pathlib import Path
 from typing import Dict, List, Literal, Optional, Sequence, TypedDict, Union
 
+import toml
 from pydantic import BaseModel
 
 ROOT_DIR = Path(__file__).parents[2].absolute()
 HERE = Path(__file__).parent
 
-PKG_DIR = ROOT_DIR / "libs" / "langchain" / "langchain"
-EXP_DIR = ROOT_DIR / "libs" / "experimental" / "langchain_experimental"
-WRITE_FILE = HERE / "api_reference.rst"
-EXP_WRITE_FILE = HERE / "experimental_api_reference.rst"
-
 
 ClassKind = Literal["TypedDict", "Regular", "Pydantic", "enum"]
 
@@ -194,11 +191,15 @@ def _load_package_modules(
     return modules_by_namespace
 
 
-def _construct_doc(pkg: str, members_by_namespace: Dict[str, ModuleMembers]) -> str:
+def _construct_doc(
+    package_namespace: str,
+    members_by_namespace: Dict[str, ModuleMembers],
+    package_version: str,
+) -> str:
     """Construct the contents of the reference.rst file for the given package.
 
     Args:
-        pkg: The package name
+        package_namespace: The package top level namespace
         members_by_namespace: The members of the package, dict organized by top level
                               module contains a list of classes and functions
                               inside of the top level namespace.
@@ -208,7 +209,7 @@ def _construct_doc(pkg: str, members_by_namespace: Dict[str, ModuleMembers]) ->
     """
     full_doc = f"""\
 =======================
-``{pkg}`` API Reference
+``{package_namespace}`` {package_version}
 =======================
 
 """
@@ -220,13 +221,13 @@ def _construct_doc(pkg: str, members_by_namespace: Dict[str, ModuleMembers]) ->
         functions = _members["functions"]
         if not (classes or functions):
             continue
-        section = f":mod:`{pkg}.{module}`"
+        section = f":mod:`{package_namespace}.{module}`"
         underline = "=" * (len(section) + 1)
         full_doc += f"""\
 {section}
 {underline}
 
-.. automodule:: {pkg}.{module}
+.. automodule:: {package_namespace}.{module}
     :no-members:
     :no-inherited-members:
 
@@ -236,7 +237,7 @@ def _construct_doc(pkg: str, members_by_namespace: Dict[str, ModuleMembers]) ->
             full_doc += f"""\
 Classes
 --------------
-.. currentmodule:: {pkg}
+.. currentmodule:: {package_namespace}
 
 .. autosummary::
     :toctree: {module}
@@ -268,7 +269,7 @@ Classes
             full_doc += f"""\
 Functions
 --------------
-.. currentmodule:: {pkg}
+.. currentmodule:: {package_namespace}
 
 .. autosummary::
     :toctree: {module}
@@ -280,46 +281,71 @@ Functions
     return full_doc
 
 
-def _document_langchain_experimental() -> None:
-    """Document the langchain_experimental package."""
-    # Generate experimental_api_reference.rst
-    exp_members = _load_package_modules(EXP_DIR)
-    exp_doc = ".. _experimental_api_reference:\n\n" + _construct_doc(
-        "langchain_experimental", exp_members
-    )
-    with open(EXP_WRITE_FILE, "w") as f:
-        f.write(exp_doc)
+def _build_rst_file(package_name: str = "langchain") -> None:
+    """Create a rst file for building of documentation.
+
+    Args:
+        package_name: Can be either "langchain" or "core" or "experimental".
+    """
+    package_dir = _package_dir(package_name)
+    package_members = _load_package_modules(package_dir)
+    package_version = _get_package_version(package_dir)
+    with open(_out_file_path(package_name), "w") as f:
+        f.write(
+            _doc_first_line(package_name)
+            + _construct_doc(
+                _package_namespace(package_name), package_members, package_version
+            )
+        )
 
 
-def _document_langchain_core() -> None:
-    """Document the main langchain package."""
-    # load top level module members
-    lc_members = _load_package_modules(PKG_DIR)
-
-    # Add additional packages
-    tools = _load_package_modules(PKG_DIR, "tools")
-    agents = _load_package_modules(PKG_DIR, "agents")
-    schema = _load_package_modules(PKG_DIR, "schema")
-
-    lc_members.update(
-        {
-            "agents.output_parsers": agents["output_parsers"],
-            "agents.format_scratchpad": agents["format_scratchpad"],
-            "tools.render": tools["render"],
-            "schema.runnable": schema["runnable"],
-        }
+def _package_namespace(package_name: str) -> str:
+    return (
+        package_name
+        if package_name == "langchain"
+        else f"langchain_{package_name.replace('-', '_')}"
     )
 
-    lc_doc = ".. _api_reference:\n\n" + _construct_doc("langchain", lc_members)
 
-    with open(WRITE_FILE, "w") as f:
-        f.write(lc_doc)
+def _package_dir(package_name: str = "langchain") -> Path:
+    """Return the path to the directory containing the documentation."""
+    if package_name in ("langchain", "experimental", "community", "core", "cli"):
+        return ROOT_DIR / "libs" / package_name / _package_namespace(package_name)
+    else:
+        return (
+            ROOT_DIR
+            / "libs"
+            / "partners"
+            / package_name
+            / _package_namespace(package_name)
+        )
+
+
+def _get_package_version(package_dir: Path) -> str:
+    with open(package_dir.parent / "pyproject.toml", "r") as f:
+        pyproject = toml.load(f)
+    return pyproject["tool"]["poetry"]["version"]
+
+
+def _out_file_path(package_name: str = "langchain") -> Path:
+    """Return the path to the file containing the documentation."""
+    return HERE / f"{package_name.replace('-', '_')}_api_reference.rst"
+
+
+def _doc_first_line(package_name: str = "langchain") -> str:
+    """Return the path to the file containing the documentation."""
+    return f".. {package_name.replace('-', '_')}_api_reference:\n\n"
 
 
 def main() -> None:
-    """Generate the reference.rst file for each package."""
-    _document_langchain_core()
-    _document_langchain_experimental()
+    """Generate the api_reference.rst file for each package."""
+    for dir in os.listdir(ROOT_DIR / "libs"):
+        if dir in ("cli", "partners"):
+            continue
+        else:
+            _build_rst_file(package_name=dir)
+    for dir in os.listdir(ROOT_DIR / "libs" / "partners"):
+        _build_rst_file(package_name=dir)
 
 
 if __name__ == "__main__":

docs/api_reference/requirements.txt

@@ -1,5 +1,7 @@
--e libs/langchain
 -e libs/experimental
+-e libs/langchain
+-e libs/core
+-e libs/community
 pydantic<2
 autodoc_pydantic==1.8.0
 myst_parser
@@ -12,4 +14,4 @@ sphinx-panels
 toml
 myst_nb
 sphinx_copybutton
-pydata-sphinx-theme==0.13.1
+pydata-sphinx-theme==0.13.1

docs/api_reference/themes/scikit-learn-modern/layout.html

@@ -63,13 +63,6 @@
             <a href="#" role="button" class="btn sk-btn-rellink py-1 disabled"">Next</a>
           {%- endif %}
         </div>
-        {%- if pagename != "install" %}
-        <div class="alert alert-warning p-1 mb-2" role="alert">
-          <p class="text-center mb-0">
-          <strong>LangChain {{ release }}</strong><br/>
-          </p>
-        </div>
-        {%- endif %}
             {%- if meta and meta['parenttoc']|tobool %}
             <div class="sk-sidebar-toc">
             {% set nav = get_nav_object(maxdepth=3, collapse=True, numbered=True) %}

docs/api_reference/themes/scikit-learn-modern/nav.html

@@ -32,19 +32,33 @@
     <div class="sk-navbar-collapse collapse navbar-collapse" id="navbarSupportedContent">
       <ul class="navbar-nav mr-auto">
         <li class="nav-item">
-          <a class="sk-nav-link nav-link" href="{{ pathto('api_reference') }}">API</a>
+          <a class="sk-nav-link nav-link" href="{{ pathto('langchain_api_reference') }}">LangChain</a>
+        </li>
+        <li class="nav-item">
+          <a class="sk-nav-link nav-link" href="{{ pathto('core_api_reference') }}">Core</a>
+        </li>
+        <li class="nav-item">
+          <a class="sk-nav-link nav-link" href="{{ pathto('community_api_reference') }}">Community</a>
         </li>
         <li class="nav-item">
           <a class="sk-nav-link nav-link" href="{{ pathto('experimental_api_reference') }}">Experimental</a>
         </li>
+        {%- for title, pathname in partners %}
         <li class="nav-item">
-          <a class="sk-nav-link nav-link" target="_blank" rel="noopener noreferrer" href="https://python.langchain.com/">Python Docs</a>
-        </li>
-        {%- for title, link, link_attrs in drop_down_navigation %}
-        <li class="nav-item">
-          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="{{ link }}" {{ link_attrs }}>{{ title }}</a>
+          <a class="sk-nav-link nav-link nav-more-item-mobile-items" href="{{ pathto(pathname) }}">{{ title }}</a>
         </li>
         {%- endfor %}
+        <li class="nav-item dropdown nav-more-item-dropdown">
+          <a class="sk-nav-link nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Partner libs</a>
+          <div class="dropdown-menu" aria-labelledby="navbarDropdown">
+            {%- for title, pathname in partners %}
+              <a class="sk-nav-dropdown-item dropdown-item" href="{{ pathto(pathname) }}">{{ title }}</a>
+            {%- endfor %}
+          </div>
+        </li>
+        <li class="nav-item">
+          <a class="sk-nav-link nav-link" target="_blank" rel="noopener noreferrer" href="https://python.langchain.com/">Docs</a>
+        </li>
       </ul>
       {%- if pagename != "search"%}
       <div id="searchbox" role="search">

docs/docs/additional_resources/tutorials.mdx

@@ -6,7 +6,12 @@ Below are links to tutorials and courses on LangChain. For written guides on com
 
 ---------------------
 
-### [LangChain on Wikipedia](https://en.wikipedia.org/wiki/LangChain)
+### [LangChain](https://en.wikipedia.org/wiki/LangChain) on Wikipedia
+
+### Books
+
+#### ⛓[Generative AI with LangChain](https://www.amazon.com/Generative-AI-LangChain-language-ChatGPT/dp/1835083463/ref=sr_1_1?crid=1GMOMH0G7GLR&keywords=generative+ai+with+langchain&qid=1703247181&sprefix=%2Caps%2C298&sr=8-1) by [Ben Auffrath](https://www.amazon.com/stores/Ben-Auffarth/author/B08JQKSZ7D?ref=ap_rdr&store_ref=ap_rdr&isDramIntegrated=true&shoppingPortalEnabled=true), ©️ 2023 Packt Publishing
+
 
 ### DeepLearning.AI courses
  by [Harrison Chase](https://en.wikipedia.org/wiki/LangChain) and [Andrew Ng](https://en.wikipedia.org/wiki/Andrew_Ng)

docs/docs/community.md

@@ -18,7 +18,7 @@ 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.
-- **[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.
+- **[Read our contributor guidelines:](./contributing/)** 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.

docs/docs/contributing/code.mdx

@@ -0,0 +1,250 @@
+---
+sidebar_position: 1
+---
+# Contribute Code
+
+To contribute to this project, please follow the ["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 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 [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 live in `docs`.
+  - Update unit and integration tests when relevant.
+- Add a feature
+  - Add a demo notebook in `docs/docs/`.
+  - Add unit and integration tests.
+
+We are a small, progress-oriented team. If there's something you'd like to add or change, opening a pull request is the
+best way to get our attention.
+
+## 🚀 Quick Start
+
+This quick start guide explains how to run the repository locally.
+For a [development container](https://containers.dev/), see the [.devcontainer folder](https://github.com/langchain-ai/langchain/tree/master/.devcontainer).
+
+### Dependency Management: Poetry and other env/dependency managers
+
+This project utilizes [Poetry](https://python-poetry.org/) v1.6.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`)
+
+### Different packages
+
+This repository contains multiple packages:
+- `langchain-core`: Base interfaces for key abstractions as well as logic for combining them in chains (LangChain Expression Language).
+- `langchain-community`: Third-party integrations of various components.
+- `langchain`: Chains, agents, and retrieval logic that makes up the cognitive architecture of your applications.
+- `langchain-experimental`: Components and chains that are experimental, either in the sense that the techniques are novel and still being tested, or they require giving the LLM more access than would be possible in most production systems.
+- Partner integrations: Partner packages in `libs/partners` that are independently version controlled.
+
+Each of these has its own development environment. Docs are run from the top-level makefile, but development
+is split across separate test & release flows.
+
+For this quickstart, start with langchain-community:
+
+```bash
+cd libs/community
+```
+
+### Local Development Dependencies
+
+Install langchain-community development requirements (for running langchain, running examples, linting, formatting, tests, and coverage):
+
+```bash
+poetry install --with lint,typing,test,test_integration
+```
+
+Then verify dependency installation:
+
+```bash
+make test
+```
+
+If during installation you receive a `WheelFileValidationError` for `debugpy`, please make sure you are running
+Poetry v1.6.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.6.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.
+
+### Testing
+
+_In `langchain`, `langchain-community`, and `langchain-experimental`, some test dependencies are optional; see section about optional dependencies_.
+
+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](./testing) available.
+
+### Only develop langchain_core or langchain_experimental
+
+If you are only developing `langchain_core` or `langchain_experimental`, you can simply install the dependencies for the respective projects and run tests:
+
+```bash
+cd libs/core
+poetry install --with test
+make test
+```
+
+Or:
+
+```bash
+cd libs/experimental
+poetry install --with test
+make test
+```
+
+### 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 [ruff](https://docs.astral.sh/ruff/rules/).
+
+To run formatting for docs, cookbook and templates:
+
+```bash
+make format
+```
+
+To run formatting for a library, run the same command from the relevant library directory:
+
+```bash
+cd libs/{LIBRARY}
+make format
+```
+
+Additionally, you can run the formatter only on the files that have been modified in your current branch as compared to the master branch using the format_diff command:
+
+```bash
+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 for this project is done via a combination of [ruff](https://docs.astral.sh/ruff/rules/) and [mypy](http://mypy-lang.org/).
+
+To run linting for docs, cookbook and templates:
+
+```bash
+make lint
+```
+
+To run linting for a library, run the same command from the relevant library directory:
+
+```bash
+cd libs/{LIBRARY}
+make lint
+```
+
+In addition, you can run the linter only on the files that have been modified in your current branch as compared to the master branch using the lint_diff command:
+
+```bash
+make lint_diff
+```
+
+This can be very helpful when you've made changes to only certain parts of the project and want to ensure your changes meet the linting standards without having to check the entire codebase.
+
+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
+
+Spellchecking for this project is done via [codespell](https://github.com/codespell-project/codespell).
+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:
+
+```bash
+make spell_check
+```
+
+To fix spelling in place:
+
+```bash
+make spell_fix
+```
+
+If codespell is incorrectly flagging a word, you can skip spellcheck for that word by adding it to the codespell config in the `pyproject.toml` file.
+
+```python
+[tool.codespell]
+...
+# Add here:
+ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogyny,unsecure'
+```
+
+## Working with Optional Dependencies
+
+`langchain`, `langchain-community`, and `langchain-experimental` rely on optional dependencies to keep these packages lightweight.
+
+`langchain-core` and partner packages **do not use** optional dependencies in this way.
+
+You only need to add a new dependency if a **unit test** relies on the package.
+If your package is only required for **integration tests**, then you can skip these
+steps and leave all pyproject.toml and poetry.lock files alone.
+
+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 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:
+
+1. Add the dependency to the main group as an optional dependency
+  ```bash
+  poetry add --optional [package_name]
+  ```
+2. Open pyproject.toml and add the dependency to the `extended_testing` extra
+3. Relock the poetry file to update the extra.
+  ```bash
+  poetry lock --no-update
+  ```
+4. Add a unit test that the very least attempts to import the new code. Ideally, the unit
+test makes use of lightweight fixtures to test the logic of the code.
+5. Please use the `@pytest.mark.requires(package_name)` decorator for any tests that require the dependency.
+
+## Adding a Jupyter Notebook
+
+If you are adding a Jupyter Notebook example, you'll want to install the optional `dev` dependencies.
+
+To install dev dependencies:
+
+```bash
+poetry install --with dev
+```
+
+Launch a notebook:
+
+```bash
+poetry run jupyter notebook
+```
+
+When you run `poetry install`, the `langchain` package is installed as editable in the virtualenv, so your new logic can be imported into the notebook.

docs/docs/contributing/documentation.mdx

@@ -0,0 +1,67 @@
+---
+sidebar_position: 3
+---
+# Contribute Documentation
+
+The docs directory contains Documentation and API Reference.
+
+Documentation is built using [Quarto](https://quarto.org) and [Docusaurus 2](https://docusaurus.io/).
+
+API Reference are largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code and are hosted by [Read the Docs](https://readthedocs.org/).
+For that reason, we ask that you add good documentation to all classes and methods.
+
+Similar to linting, we recognize documentation 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.
+
+## Build Documentation Locally
+
+### Install dependencies
+
+- [Quarto](https://quarto.org) - package that converts Jupyter notebooks (`.ipynb` files) into mdx files for serving in Docusaurus.
+- `poetry install` from the monorepo root
+
+### Building
+
+In the following commands, the prefix `api_` indicates that those are operations for the API Reference.
+
+Before building the documentation, it is always a good idea to clean the build directory:
+
+```bash
+make docs_clean
+make api_docs_clean
+```
+
+Next, you can build the documentation as outlined below:
+
+```bash
+make docs_build
+make api_docs_build
+```
+
+Finally, run the link checker to ensure all links are valid:
+
+```bash
+make docs_linkcheck
+make api_docs_linkcheck
+```
+
+### Linting and Formatting
+
+The docs are linted from the monorepo root. To lint the docs, run the following from there:
+
+```bash
+poetry install --with lint,typing
+make lint
+```
+
+If you have formatting-related errors, you can fix them automatically with:
+
+```bash
+make format
+``` 
+
+## Verify Documentation changes
+
+After pushing documentation changes to the repository, you can preview and verify that the changes are
+what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page.
+This will take you to a preview of the documentation changes.
+This preview is created by [Vercel](https://vercel.com/docs/getting-started-with-vercel).

docs/docs/contributing/index.mdx

@@ -0,0 +1,42 @@
+---
+sidebar_position: 0
+---
+# Welcome Contributors
+
+Hi there! Thank you for even being interested in contributing to LangChain.
+As an open-source project in a rapidly developing field, we are extremely open to contributions, whether they involve new features, improved infrastructure, better documentation, or bug fixes.
+
+## 🗺️ Guidelines
+
+### 👩‍💻 Ways to contribute
+
+There are many ways to contribute to LangChain. Here are some common ways people contribute:
+
+- [**Documentation**](./documentation): Help improve our docs, including this one!
+- [**Code**](./code): Help us write code, fix bugs, or improve our infrastructure.
+- [**Integrations**](./integrations): Help us integrate with your favorite vendors and tools.
+
+### 🚩GitHub Issues
+
+Our [issues](https://github.com/langchain-ai/langchain/issues) page is kept up to date with bugs, improvements, and feature requests.
+
+There is a taxonomy of labels to help with sorting and discovery of issues of interest. Please use these to help organize issues.
+
+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 development in this field some may get out of date.
+If you notice this happening, please let us know.
+
+### 🙋Getting Help
+
+Our goal is to have the simplest developer setup possible. Should you experience any difficulty getting setup, please
+contact a maintainer! Not only do we want to help get you unblocked, but we also want to make sure that the process is
+smooth for future contributors.
+
+In a similar vein, we do enforce certain linting, formatting, and documentation standards in the codebase.
+If you are finding these difficult (or even just annoying) to work with, feel free to contact a maintainer for help -
+we do not want these to get in the way of getting good code into the codebase.

docs/docs/contributing/integrations.mdx

@@ -0,0 +1,145 @@
+---
+sidebar_position: 5
+---
+# Contribute Integrations
+
+To begin, make sure you have all the dependencies outlined in guide on [Contributing Code](./code).
+
+There are a few different places you can contribute integrations for LangChain:
+
+- **Community**: For lighter-weight integrations that are primarily maintained by LangChain and the Open Source Community.
+- **Partner Packages**: For independent packages that are co-maintained by LangChain and a partner.
+
+For the most part, new integrations should be added to the Community package. Partner packages require more maintenance as separate packages, so please confirm with the LangChain team before creating a new partner package.
+
+In the following sections, we'll walk through how to contribute to each of these packages from a fake company, `Parrot Link AI`.
+
+## Community Package
+
+The `langchain-community` package is in `libs/community` and contains most integrations.
+
+It is installed by users with `pip install langchain-community`, and exported members can be imported with code like 
+
+```python
+from langchain_community.chat_models import ParrotLinkLLM
+from langchain_community.llms import ChatParrotLink
+from langchain_community.vectorstores import ParrotLinkVectorStore
+```
+
+The community package relies on manually-installed dependent packages, so you will see errors if you try to import a package that is not installed. In our fake example, if you tried to import `ParrotLinkLLM` without installing `parrot-link-sdk`, you will see an `ImportError` telling you to install it when trying to use it.
+
+Let's say we wanted to implement a chat model for Parrot Link AI. We would create a new file in `libs/community/langchain_community/chat_models/parrot_link.py` with the following code:
+
+```python
+from langchain_core.language_models.chat_models import BaseChatModel
+
+class ChatParrotLink(BaseChatModel):
+    """ChatParrotLink chat model.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_parrot_link import ChatParrotLink
+
+            model = ChatParrotLink()
+    """
+
+    ...
+```
+
+And we would write tests in:
+
+- Unit tests: `libs/community/tests/unit_tests/chat_models/test_parrot_link.py`
+- Integration tests: `libs/community/tests/integration_tests/chat_models/test_parrot_link.py`
+
+And add documentation to:
+- `docs/docs/integrations/chat/parrot_link.ipynb`
+
+- `docs/docs/
+## Partner Packages
+
+Partner packages are in `libs/partners/*` and are installed by users with `pip install langchain-{partner}`, and exported members can be imported with code like 
+
+```python
+from langchain_{partner} import X
+```
+
+### Set up a new package
+
+To set up a new partner package, use the latest version of the LangChain CLI. You can install or update it with:
+
+```bash
+pip install -U langchain-cli
+```
+
+Let's say you want to create a new partner package working for a company called Parrot Link AI.
+
+Then, run the following command to create a new partner package:
+
+```bash
+cd libs/partners
+langchain-cli integration new
+> Name: parrot-link
+> Name of integration in PascalCase [ParrotLink]: ParrotLink
+```
+
+This will create a new package in `libs/partners/parrot-link` with the following structure:
+
+```
+libs/partners/parrot-link/
+  langchain_parrot_link/ # folder containing your package
+    ...
+  tests/
+    ...
+  docs/ # bootstrapped docs notebooks, must be moved to /docs in monorepo root
+    ...
+  scripts/ # scripts for CI
+    ...
+  LICENSE
+  README.md # fill out with information about your package
+  Makefile # default commands for CI
+  pyproject.toml # package metadata, mostly managed by Poetry
+  poetry.lock # package lockfile, managed by Poetry
+  .gitignore
+```
+
+### Implement your package
+
+First, add any dependencies your package needs, such as your company's SDK:
+
+```bash
+poetry add parrot-link-sdk
+```
+
+If you need separate dependencies for type checking, you can add them to the `typing` group with:
+
+```bash
+poetry add --group typing types-parrot-link-sdk
+```
+
+Then, implement your package in `libs/partners/parrot-link/langchain_parrot_link`.
+
+By default, this will include stubs for a Chat Model, an LLM, and/or a Vector Store. You should delete any of the files you won't use and remove them from `__init__.py`.
+
+### Write Unit and Integration Tests
+
+Some basic tests are generated in the tests/ directory. You should add more tests to cover your package's functionality.
+
+For information on running and implementing tests, see the [Testing guide](./testing).
+
+### Write documentation
+
+Documentation is generated from Jupyter notebooks in the `docs/` directory. You should move the generated notebooks to the relevant `docs/docs/integrations` directory in the monorepo root.
+
+### Additional steps
+
+Contributor steps:
+
+- [ ] Add secret names to manual integrations workflow in `.github/workflows/_integration_test.yml`
+- [ ] Add secrets to release workflow (for pre-release testing) in `.github/workflows/_release.yml`
+
+Maintainer steps (Contributors should **not** do these):
+
+- [ ] set up pypi and test pypi projects
+- [ ] add credential secrets to Github Actions
+- [ ] add package to conda-forge

docs/docs/contributing/packages.mdx

@@ -0,0 +1,56 @@
+---
+sidebar_label: Package Versioning
+sidebar_position: 4
+---
+
+# 📕 Package Versioning
+
+As of now, LangChain has an ad hoc release process: releases are cut with high frequency by
+a maintainer and published to [PyPI](https://pypi.org/). 
+The different packages are versioned slightly differently.
+
+## `langchain-core`
+
+`langchain-core` is currently on version `0.1.x`. 
+
+As `langchain-core` contains the base abstractions and runtime for the whole LangChain ecosystem, we will communicate any breaking changes with advance notice and version bumps. The exception for this is anything in `langchain_core.beta`. The reason for `langchain_core.beta` is that given the rate of change of the field, being able to move quickly is still a priority, and this module is our attempt to do so.
+
+Minor version increases will occur for:
+
+- Breaking changes for any public interfaces NOT in `langchain_core.beta`
+
+Patch version increases will occur for:
+
+- Bug fixes
+- New features
+- Any changes to private interfaces
+- Any changes to `langchain_core.beta`
+
+## `langchain`
+
+`langchain` is currently on version `0.0.x`
+
+All changes will be accompanied by a patch version increase. Any changes to public interfaces are nearly always done in a backwards compatible way and will be communicated ahead of time when they are not backwards compatible.
+
+We are targeting January 2024 for a release of `langchain` v0.1, at which point `langchain` will adopt the same versioning policy as `langchain-core`.
+
+## `langchain-community`
+
+`langchain-community` is currently on version `0.0.x`
+
+All changes will be accompanied by a patch version increase.
+
+## `langchain-experimental`
+
+`langchain-experimental` is currently on version `0.0.x`
+
+All changes will be accompanied by a patch version increase.
+
+## Partner Packages
+
+Partner packages are versioned independently.
+
+# 🌟 Recognition
+
+If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
+If you have a Twitter account you would like us to mention, please let us know in the PR or through another means.

docs/docs/contributing/testing.mdx

@@ -0,0 +1,147 @@
+---
+sidebar_position: 2
+---
+
+# Testing
+
+All of our packages have unit tests and integration tests, and we favor unit tests over integration tests.
+
+Unit tests run on every pull request, so they should be fast and reliable.
+
+Integration tests run once a day, and they require more setup, so they should be reserved for confirming interface points with external services.
+
+## Unit Tests
+
+Unit tests cover modular logic that does not require calls to outside APIs.
+If you add new logic, please add a unit test.
+
+To install dependencies for unit tests:
+
+```bash
+poetry install --with test
+```
+
+To run unit tests:
+
+```bash
+make test
+```
+
+To run unit tests in Docker:
+
+```bash
+make docker_tests
+```
+
+To run a specific test:
+
+```bash
+TEST_FILE=tests/unit_tests/test_imports.py make test
+```
+
+## Integration Tests
+
+Integration tests cover logic that requires making calls to outside APIs (often integration with other services).
+If you add support for a new external API, please add a new integration test.
+
+**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 install dependencies for integration tests:
+
+```bash
+poetry install --with test,test_integration
+```
+
+To run integration tests:
+
+```bash
+make integration_tests
+```
+
+### Prepare
+
+The integration tests use several search engines and databases. The tests
+aim to verify the correct behavior of the engines and databases according to
+their specifications and requirements.
+
+To run some integration tests, such as tests located in
+`tests/integration_tests/vectorstores/`, you will need to install the following
+software:
+
+- Docker
+- Python 3.8.1 or later
+
+Any new dependencies should be added by running:
+
+```bash
+# add package and install it after adding:
+poetry add tiktoken@latest --group "test_integration" && poetry install --with test_integration
+```
+
+Before running any tests, you should start a specific Docker container that has all the
+necessary dependencies installed. For instance, we use the `elasticsearch.yml` container
+for `test_elasticsearch.py`:
+
+```bash
+cd tests/integration_tests/vectorstores/docker-compose
+docker-compose -f elasticsearch.yml up
+```
+
+For environments that requires more involving preparation, look for `*.sh`. For instance,
+`opensearch.sh` builds a required docker image and then launch opensearch.
+
+
+### Prepare environment variables for local testing:
+
+- copy `tests/integration_tests/.env.example` to `tests/integration_tests/.env`
+- set variables in `tests/integration_tests/.env` file, e.g `OPENAI_API_KEY`
+
+Additionally, it's important to note that some integration tests may require certain
+environment variables to be set, such as `OPENAI_API_KEY`. Be sure to set any required
+environment variables before running the tests to ensure they run correctly.
+
+### Recording HTTP interactions with pytest-vcr
+
+Some of the integration tests in this repository involve making HTTP requests to
+external services. To prevent these requests from being made every time the tests are
+run, we use pytest-vcr to record and replay HTTP interactions.
+
+When running tests in a CI/CD pipeline, you may not want to modify the existing
+cassettes. You can use the --vcr-record=none command-line option to disable recording
+new cassettes. Here's an example:
+
+```bash
+pytest --log-cli-level=10 tests/integration_tests/vectorstores/test_pinecone.py --vcr-record=none
+pytest tests/integration_tests/vectorstores/test_elasticsearch.py --vcr-record=none
+
+```
+
+### Run some tests with coverage:
+
+```bash
+pytest tests/integration_tests/vectorstores/test_elasticsearch.py --cov=langchain --cov-report=html
+start "" htmlcov/index.html || open htmlcov/index.html
+
+```
+
+## 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.
+
+Coverage requires the dependencies for integration tests:
+
+```bash
+poetry install --with test_integration
+```
+
+To get a report of current coverage, run the following:
+
+```bash
+make coverage
+```

docs/docs/expression_language/cookbook/code_writing.ipynb

@@ -21,7 +21,7 @@
     "from langchain.prompts import (\n",
     "    ChatPromptTemplate,\n",
     ")\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_experimental.utilities import PythonREPL"
    ]
   },

docs/docs/expression_language/cookbook/embedding_router.ipynb

@@ -22,9 +22,9 @@
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnableLambda, RunnablePassthrough\n",
     "from langchain.utils.math import cosine_similarity\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
     "\n",
     "physics_template = \"\"\"You are a very smart physics professor. \\\n",
     "You are great at answering questions about physics in a concise and easy to understand manner. \\\n",

docs/docs/expression_language/cookbook/index.mdx

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 2
+sidebar_position: 3
 ---
 
 # Cookbook

docs/docs/expression_language/cookbook/memory.ipynb

@@ -22,7 +22,7 @@
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.memory import ConversationBufferMemory\n",
     "from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
-    "from langchain.schema.runnable import RunnableLambda, RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
     "\n",
     "model = ChatOpenAI()\n",
     "prompt = ChatPromptTemplate.from_messages(\n",

docs/docs/expression_language/cookbook/multiple_chains.ipynb

@@ -69,7 +69,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "prompt1 = ChatPromptTemplate.from_template(\n",
     "    \"generate a {attribute} color. Return the name of the color and nothing else:\"\n",
@@ -146,7 +146,7 @@
    "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",
+    "You may want the output of one component to be processed by 2 or more other components. [RunnableParallels](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableParallel.html#langchain_core.runnables.base.RunnableParallel) 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",

docs/docs/expression_language/cookbook/prompt_llm_parser.ipynb

@@ -191,7 +191,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
     "\n",
     "chain = prompt | model | StrOutputParser()"
    ]
@@ -317,7 +317,7 @@
    "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:"
+    "To make invocation even simpler, we can add a `RunnableParallel` to take care of creating the prompt input dict for us:"
    ]
   },
   {
@@ -327,9 +327,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnableMap, RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n",
     "\n",
-    "map_ = RunnableMap(foo=RunnablePassthrough())\n",
+    "map_ = RunnableParallel(foo=RunnablePassthrough())\n",
     "chain = (\n",
     "    map_\n",
     "    | prompt\n",

docs/docs/expression_language/cookbook/prompt_size.ipynb

@@ -209,7 +209,10 @@
    "id": "637f994a-5134-402a-bcf0-4de3911eaf49",
    "metadata": {},
    "source": [
-    ":::tip [LangSmith trace](https://smith.langchain.com/public/60909eae-f4f1-43eb-9f96-354f5176f66f/r)\n",
+    ":::tip\n",
+    "\n",
+    "[LangSmith trace](https://smith.langchain.com/public/60909eae-f4f1-43eb-9f96-354f5176f66f/r)\n",
+    "\n",
     ":::"
    ]
   },
@@ -374,7 +377,10 @@
    "id": "5a7e498b-dc68-4267-a35c-90ceffa91c46",
    "metadata": {},
    "source": [
-    ":::tip [LangSmith trace](https://smith.langchain.com/public/3b27d47f-e4df-4afb-81b1-0f88b80ca97e/r)\n",
+    ":::tip\n",
+    "\n",
+    "[LangSmith trace](https://smith.langchain.com/public/3b27d47f-e4df-4afb-81b1-0f88b80ca97e/r)\n",
+    "\n",
     ":::"
    ]
   }

docs/docs/expression_language/cookbook/retrieval.ipynb

@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 1,
    "id": "33be32af",
    "metadata": {},
    "outputs": [],
@@ -41,14 +41,14 @@
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.embeddings import OpenAIEmbeddings\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnableLambda, RunnablePassthrough\n",
-    "from langchain.vectorstores import FAISS"
+    "from langchain.vectorstores import FAISS\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "id": "bfc47ec1",
    "metadata": {},
    "outputs": [],
@@ -70,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "eae31755",
    "metadata": {},
    "outputs": [],
@@ -85,7 +85,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 4,
    "id": "f3040b0c",
    "metadata": {},
    "outputs": [
@@ -95,7 +95,7 @@
        "'Harrison worked at Kensho.'"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -106,7 +106,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "e1d20c7c",
    "metadata": {},
    "outputs": [],
@@ -134,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "7ee8b2d4",
    "metadata": {},
    "outputs": [
@@ -144,7 +144,7 @@
        "'Harrison ha lavorato a Kensho.'"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -165,18 +165,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 21,
    "id": "3f30c348",
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain.schema import format_document\n",
-    "from langchain.schema.runnable import RunnableMap"
+    "from langchain_core.messages import AIMessage, HumanMessage, get_buffer_string\n",
+    "from langchain_core.runnables import RunnableParallel"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "64ab1dbf",
    "metadata": {},
    "outputs": [],
@@ -194,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "id": "7d628c97",
    "metadata": {},
    "outputs": [],
@@ -209,7 +210,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "id": "f60a5d0f",
    "metadata": {},
    "outputs": [],
@@ -226,33 +227,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "7d007db6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from typing import List, Tuple\n",
-    "\n",
-    "\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,
+   "execution_count": 11,
    "id": "5c32cc89",
    "metadata": {},
    "outputs": [],
    "source": [
-    "_inputs = RunnableMap(\n",
+    "_inputs = RunnableParallel(\n",
     "    standalone_question=RunnablePassthrough.assign(\n",
-    "        chat_history=lambda x: _format_chat_history(x[\"chat_history\"])\n",
+    "        chat_history=lambda x: get_buffer_string(x[\"chat_history\"])\n",
     "    )\n",
     "    | CONDENSE_QUESTION_PROMPT\n",
     "    | ChatOpenAI(temperature=0)\n",
@@ -267,17 +249,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 12,
    "id": "135c8205",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='Harrison was employed at Kensho.', additional_kwargs={}, example=False)"
+       "AIMessage(content='Harrison was employed at Kensho.')"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -293,17 +275,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 22,
    "id": "424e7e7a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='Harrison worked at Kensho.', additional_kwargs={}, example=False)"
+       "AIMessage(content='Harrison worked at Kensho.')"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -312,7 +294,10 @@
     "conversational_qa_chain.invoke(\n",
     "    {\n",
     "        \"question\": \"where did he work?\",\n",
-    "        \"chat_history\": [(\"Who wrote this notebook?\", \"Harrison\")],\n",
+    "        \"chat_history\": [\n",
+    "            HumanMessage(content=\"Who wrote this notebook?\"),\n",
+    "            AIMessage(content=\"Harrison\"),\n",
+    "        ],\n",
     "    }\n",
     ")"
    ]
@@ -329,7 +314,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 14,
    "id": "e31dd17c",
    "metadata": {},
    "outputs": [],
@@ -341,7 +326,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 15,
    "id": "d4bffe94",
    "metadata": {},
    "outputs": [],
@@ -353,7 +338,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 16,
    "id": "733be985",
    "metadata": {},
    "outputs": [],
@@ -367,7 +352,7 @@
     "standalone_question = {\n",
     "    \"standalone_question\": {\n",
     "        \"question\": lambda x: x[\"question\"],\n",
-    "        \"chat_history\": lambda x: _format_chat_history(x[\"chat_history\"]),\n",
+    "        \"chat_history\": lambda x: get_buffer_string(x[\"chat_history\"]),\n",
     "    }\n",
     "    | CONDENSE_QUESTION_PROMPT\n",
     "    | ChatOpenAI(temperature=0)\n",
@@ -394,18 +379,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 17,
    "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={})]}"
+       "{'answer': AIMessage(content='Harrison was employed at Kensho.'),\n",
+       " 'docs': [Document(page_content='harrison worked at kensho')]}"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -418,7 +403,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 18,
    "id": "977399fd",
    "metadata": {},
    "outputs": [],
@@ -431,18 +416,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 19,
    "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)]}"
+       "{'history': [HumanMessage(content='where did harrison work?'),\n",
+       "  AIMessage(content='Harrison was employed at Kensho.')]}"
       ]
      },
-     "execution_count": 21,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -450,6 +435,38 @@
    "source": [
     "memory.load_memory_variables({})"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "88f2b7cd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'answer': AIMessage(content='Harrison actually worked at Kensho.'),\n",
+       " 'docs': [Document(page_content='harrison worked at kensho')]}"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inputs = {\"question\": \"but where did he really work?\"}\n",
+    "result = final_chain.invoke(inputs)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "207a2782",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -468,7 +485,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/cookbook/sql_db.ipynb

@@ -94,8 +94,8 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnablePassthrough\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "model = ChatOpenAI()\n",
     "\n",
@@ -152,8 +152,7 @@
    "outputs": [],
    "source": [
     "full_chain = (\n",
-    "    RunnablePassthrough.assign(query=sql_response)\n",
-    "    | RunnablePassthrough.assign(\n",
+    "    RunnablePassthrough.assign(query=sql_response).assign(\n",
     "        schema=get_schema,\n",
     "        response=lambda x: db.run(x[\"query\"]),\n",
     "    )\n",

docs/docs/expression_language/cookbook/tools.ipynb

@@ -29,8 +29,8 @@
    "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"
+    "from langchain.tools import DuckDuckGoSearchRun\n",
+    "from langchain_core.output_parsers import StrOutputParser"
    ]
   },
   {

docs/docs/expression_language/get_started.ipynb

@@ -0,0 +1,494 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "366a0e68-fd67-4fe5-a292-5c33733339ea",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 0\n",
+    "title: Get started\n",
+    "keywords: [chain.invoke]\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "befa7fd1",
+   "metadata": {},
+   "source": [
+    "LCEL makes it easy to build complex chains from basic components, and supports out of the box functionality such as streaming, parallelism, and logging."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9a9acd2e",
+   "metadata": {},
+   "source": [
+    "## Basic example: prompt + model + output parser\n",
+    "\n",
+    "The most basic and common use case is chaining a prompt template and a model together. To see how this works, let's create a chain that takes a topic and generates a joke:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "466b65b3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Why did the ice cream go to therapy?\\n\\nBecause it had too many toppings and couldn't find its cone-fidence!\""
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_template(\"tell me a short joke about {topic}\")\n",
+    "model = ChatOpenAI()\n",
+    "output_parser = StrOutputParser()\n",
+    "\n",
+    "chain = prompt | model | output_parser\n",
+    "\n",
+    "chain.invoke({\"topic\": \"ice cream\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "81c502c5-85ee-4f36-aaf4-d6e350b7792f",
+   "metadata": {},
+   "source": [
+    "Notice this line of this code, where we piece together then different components into a single chain using LCEL:\n",
+    "\n",
+    "```\n",
+    "chain = prompt | model | output_parser\n",
+    "```\n",
+    "\n",
+    "The `|` symbol is similar to a [unix pipe operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)), which chains together the different components feeds the output from one component as input into the next component. \n",
+    "\n",
+    "In this chain the user input is passed to the prompt template, then the prompt template output is passed to the model, then the model output is passed to the output parser. Let's take a look at each component individually to really understand what's going on. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aa1b77fa",
+   "metadata": {},
+   "source": [
+    "### 1. Prompt\n",
+    "\n",
+    "`prompt` is a `BasePromptTemplate`, which means it takes in a dictionary of template variables and produces a `PromptValue`. A `PromptValue` is a wrapper around a completed prompt that can be passed to either an `LLM` (which takes a string as input) or `ChatModel` (which takes a sequence of messages as input). It can work with either language model type because it defines logic both for producing `BaseMessage`s and for producing a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b8656990",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ChatPromptValue(messages=[HumanMessage(content='tell me a short joke about ice cream')])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt_value = prompt.invoke({\"topic\": \"ice cream\"})\n",
+    "prompt_value"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "e6034488",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[HumanMessage(content='tell me a short joke about ice cream')]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt_value.to_messages()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "60565463",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Human: tell me a short joke about ice cream'"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt_value.to_string()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "577f0f76",
+   "metadata": {},
+   "source": [
+    "### 2. Model\n",
+    "\n",
+    "The `PromptValue` is then passed to `model`. In this case our `model` is a `ChatModel`, meaning it will output a `BaseMessage`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "33cf5f72",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"Why did the ice cream go to therapy? \\n\\nBecause it had too many toppings and couldn't find its cone-fidence!\")"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "message = model.invoke(prompt_value)\n",
+    "message"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "327e7db8",
+   "metadata": {},
+   "source": [
+    "If our `model` was an `LLM`, it would output a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "8feb05da",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n\\nRobot: Why did the ice cream go to therapy? Because it had a rocky road.'"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.llms import OpenAI\n",
+    "\n",
+    "llm = OpenAI(model=\"gpt-3.5-turbo-instruct\")\n",
+    "llm.invoke(prompt_value)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91847478",
+   "metadata": {},
+   "source": [
+    "### 3. Output parser\n",
+    "\n",
+    "And lastly we pass our `model` output to the `output_parser`, which is a `BaseOutputParser` meaning it takes either a string or a \n",
+    "`BaseMessage` as input. The `StrOutputParser` specifically simple converts any input into a string."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "533e59a8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Why did the ice cream go to therapy? \\n\\nBecause it had too many toppings and couldn't find its cone-fidence!\""
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "output_parser.invoke(message)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9851e842",
+   "metadata": {},
+   "source": [
+    "### 4. Entire Pipeline\n",
+    "\n",
+    "To follow the steps along:\n",
+    "\n",
+    "1. We pass in user input on the desired topic as `{\"topic\": \"ice cream\"}`\n",
+    "2. The `prompt` component takes the user input, which is then used to construct a PromptValue after using the `topic` to construct the prompt. \n",
+    "3. The `model` component takes the generated prompt, and passes into the OpenAI LLM model for evaluation. The generated output from the model is a `ChatMessage` object. \n",
+    "4. Finally, the `output_parser` component takes in a `ChatMessage`, and transforms this into a Python string, which is returned from the invoke method. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4873109",
+   "metadata": {},
+   "source": [
+    "```mermaid\n",
+    "graph LR\n",
+    "    A(Input: topic=ice cream) --> |Dict| B(PromptTemplate)\n",
+    "    B -->|PromptValue| C(ChatModel)    \n",
+    "    C -->|ChatMessage| D(StrOutputParser)\n",
+    "    D --> |String| F(Result)\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe63534d",
+   "metadata": {},
+   "source": [
+    ":::info\n",
+    "\n",
+    "Note that if you’re curious about the output of any components, you can always test out a smaller version of the chain such as `prompt`  or `prompt | model` to see the intermediate results:\n",
+    "\n",
+    ":::"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11089b6f-23f8-474f-97ec-8cae8d0ca6d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input = {\"topic\": \"ice cream\"}\n",
+    "\n",
+    "prompt.invoke(input)\n",
+    "# > ChatPromptValue(messages=[HumanMessage(content='tell me a short joke about ice cream')])\n",
+    "\n",
+    "(prompt | model).invoke(input)\n",
+    "# > AIMessage(content=\"Why did the ice cream go to therapy?\\nBecause it had too many toppings and couldn't cone-trol itself!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc7d3b9d-e400-4c9b-9188-f29dac73e6bb",
+   "metadata": {},
+   "source": [
+    "## RAG Search Example\n",
+    "\n",
+    "For our next example, we want to run a retrieval-augmented generation chain to add some context when responding to questions. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "662426e8-4316-41dc-8312-9b58edc7e0c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Requires:\n",
+    "# pip install langchain docarray tiktoken\n",
+    "\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.vectorstores import DocArrayInMemorySearch\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n",
+    "\n",
+    "vectorstore = DocArrayInMemorySearch.from_texts(\n",
+    "    [\"harrison worked at kensho\", \"bears like to eat honey\"],\n",
+    "    embedding=OpenAIEmbeddings(),\n",
+    ")\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",
+    "model = ChatOpenAI()\n",
+    "output_parser = StrOutputParser()\n",
+    "\n",
+    "setup_and_retrieval = RunnableParallel(\n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    ")\n",
+    "chain = setup_and_retrieval | prompt | model | output_parser\n",
+    "\n",
+    "chain.invoke(\"where did harrison work?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f0999140-6001-423b-970b-adf1dfdb4dec",
+   "metadata": {},
+   "source": [
+    "In this case, the composed chain is: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5b88e9bb-f04a-4a56-87ec-19a0e6350763",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = setup_and_retrieval | prompt | model | output_parser"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e929e15-40a5-4569-8969-384f636cab87",
+   "metadata": {},
+   "source": [
+    "To explain this, we first can see that the prompt template above takes in `context` and `question` as values to be substituted in the prompt. Before building the prompt template, we want to retrieve relevant documents to the search and include them as part of the context. \n",
+    "\n",
+    "As a preliminary step, we’ve setup the retriever using an in memory store, which can retrieve documents based on a query. This is a runnable component as well that can be chained together with other components, but you can also try to run it separately:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7319ef6-613b-4638-ad7d-4a2183702c1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "retriever.invoke(\"where did harrison work?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6833844-f1c4-444c-a3d2-31b3c6b31d46",
+   "metadata": {},
+   "source": [
+    "We then use the `RunnableParallel` to prepare the expected inputs into the prompt by using the entries for the retrieved documents as well as the original user question, using the retriever for document search, and RunnablePassthrough to pass the user’s question:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dcbca26b-d6b9-4c24-806c-1ec8fdaab4ed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "setup_and_retrieval = RunnableParallel(\n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68c721c1-048b-4a64-9d78-df54fe465992",
+   "metadata": {},
+   "source": [
+    "To review, the complete chain is:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1d5115a7-7b8e-458b-b936-26cc87ee81c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "setup_and_retrieval = RunnableParallel(\n",
+    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    ")\n",
+    "chain = setup_and_retrieval | prompt | model | output_parser"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c6f5f74-b387-48a0-bedd-1fae202cd10a",
+   "metadata": {},
+   "source": [
+    "With the flow being:\n",
+    "\n",
+    "1. The first steps create a `RunnableParallel` object with two entries.  The first entry, `context` will include the document results fetched by the retriever. The second entry, `question` will contain the user’s original question. To pass on the question, we use `RunnablePassthrough` to copy this entry. \n",
+    "2. Feed the dictionary from the step above to the `prompt` component. It then takes the user input which is `question` as well as the retrieved document which is `context` to construct a prompt and output a PromptValue.  \n",
+    "3. The `model` component takes the generated prompt, and passes into the OpenAI LLM model for evaluation. The generated output from the model is a `ChatMessage` object. \n",
+    "4. Finally, the `output_parser` component takes in a `ChatMessage`, and transforms this into a Python string, which is returned from the invoke method.\n",
+    "\n",
+    "```mermaid\n",
+    "graph LR\n",
+    "    A(Question) --> B(RunnableParallel)\n",
+    "    B -->|Question| C(Retriever)\n",
+    "    B -->|Question| D(RunnablePassThrough)\n",
+    "    C -->|context=retrieved docs| E(PromptTemplate)\n",
+    "    D -->|question=Question| E\n",
+    "    E -->|PromptValue| F(ChatModel)    \n",
+    "    F -->|ChatMessage| G(StrOutputParser)\n",
+    "    G --> |String| H(Result)\n",
+    "```\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c2438df-164e-4bbe-b5f4-461695e45b0f",
+   "metadata": {},
+   "source": [
+    "## Next steps\n",
+    "\n",
+    "We recommend reading our [Why use LCEL](/docs/expression_language/why) section next to see a side-by-side comparison of the code needed to produce common functionality with and without LCEL."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/expression_language/how_to/binding.ipynb

@@ -22,7 +22,7 @@
     "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"
+    "from langchain_core.runnables import RunnablePassthrough"
    ]
   },
   {

docs/docs/expression_language/how_to/configure.ipynb

@@ -43,6 +43,7 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.runnables import ConfigurableField\n",
     "\n",
     "model = ChatOpenAI(temperature=0).configurable_fields(\n",
     "    temperature=ConfigurableField(\n",
@@ -264,7 +265,7 @@
    "source": [
     "from langchain.chat_models import ChatAnthropic, ChatOpenAI\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain.schema.runnable import ConfigurableField"
+    "from langchain_core.runnables import ConfigurableField"
    ]
   },
   {
@@ -594,7 +595,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/fallbacks.ipynb

@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "d3e893bf",
    "metadata": {},
    "outputs": [],
@@ -44,19 +44,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "dfdd8bf5",
    "metadata": {},
    "outputs": [],
    "source": [
     "from unittest.mock import patch\n",
     "\n",
-    "from openai.error import RateLimitError"
+    "import httpx\n",
+    "from openai import RateLimitError\n",
+    "\n",
+    "request = httpx.Request(\"GET\", \"/\")\n",
+    "response = httpx.Response(200, request=request)\n",
+    "error = RateLimitError(\"rate limit\", response=response, body=\"\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "id": "e6fdffc1",
    "metadata": {},
    "outputs": [],
@@ -69,7 +74,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 4,
    "id": "584461ab",
    "metadata": {},
    "outputs": [
@@ -83,10 +88,10 @@
    ],
    "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",
+    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
     "    try:\n",
     "        print(openai_llm.invoke(\"Why did the chicken cross the road?\"))\n",
-    "    except:\n",
+    "    except RateLimitError:\n",
     "        print(\"Hit error\")"
    ]
   },
@@ -106,10 +111,10 @@
    ],
    "source": [
     "# Now let's try with fallbacks to Anthropic\n",
-    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
+    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
     "    try:\n",
     "        print(llm.invoke(\"Why did the chicken cross the road?\"))\n",
-    "    except:\n",
+    "    except RateLimitError:\n",
     "        print(\"Hit error\")"
    ]
   },
@@ -148,10 +153,10 @@
     "    ]\n",
     ")\n",
     "chain = prompt | llm\n",
-    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
+    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
     "    try:\n",
     "        print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
-    "    except:\n",
+    "    except RateLimitError:\n",
     "        print(\"Hit error\")"
    ]
   },
@@ -185,10 +190,10 @@
     ")\n",
     "\n",
     "chain = prompt | llm\n",
-    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
+    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
     "    try:\n",
     "        print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
-    "    except:\n",
+    "    except RateLimitError:\n",
     "        print(\"Hit error\")"
    ]
   },
@@ -211,7 +216,7 @@
    "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",
+    "from langchain_core.output_parsers import StrOutputParser\n",
     "\n",
     "chat_prompt = ChatPromptTemplate.from_messages(\n",
     "    [\n",
@@ -286,7 +291,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/functions.ipynb

@@ -1,5 +1,17 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "ce0e08fd",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 2\n",
+    "title: \"RunnableLambda: Run Custom Functions\"\n",
+    "keywords: [RunnableLambda, LCEL]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "fbc4bf6e",
@@ -7,14 +19,14 @@
    "source": [
     "# Run custom functions\n",
     "\n",
-    "You can use arbitrary functions in the pipeline\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,
+   "execution_count": 1,
    "id": "6bb221b3",
    "metadata": {},
    "outputs": [],
@@ -23,7 +35,7 @@
     "\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.schema.runnable import RunnableLambda\n",
+    "from langchain_core.runnables import RunnableLambda\n",
     "\n",
     "\n",
     "def length_function(text):\n",
@@ -56,17 +68,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "id": "5488ec85",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='3 + 9 equals 12.', additional_kwargs={}, example=False)"
+       "AIMessage(content='3 + 9 equals 12.')"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -82,23 +94,23 @@
    "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."
+    "Runnable lambdas can optionally accept a [RunnableConfig](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.config.RunnableConfig.html#langchain_core.runnables.config.RunnableConfig), which they can use to pass callbacks, tags, and other configuration information to nested runs."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 3,
    "id": "80b3b5f6-5d58-44b9-807e-cce9a46bf49f",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.output_parser import StrOutputParser\n",
-    "from langchain.schema.runnable import RunnableConfig"
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnableConfig"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 4,
    "id": "ff0daf0c-49dd-4d21-9772-e5fa133c5f36",
    "metadata": {},
    "outputs": [],
@@ -125,7 +137,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 5,
    "id": "1a5e709e-9d75-48c7-bb9c-503251990505",
    "metadata": {},
    "outputs": [
@@ -133,6 +145,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "{'foo': 'bar'}\n",
       "Tokens Used: 65\n",
       "\tPrompt Tokens: 56\n",
       "\tCompletion Tokens: 9\n",
@@ -145,9 +158,10 @@
     "from langchain.callbacks import get_openai_callback\n",
     "\n",
     "with get_openai_callback() as cb:\n",
-    "    RunnableLambda(parse_or_fix).invoke(\n",
+    "    output = RunnableLambda(parse_or_fix).invoke(\n",
     "        \"{foo: bar}\", {\"tags\": [\"my-tag\"], \"callbacks\": [cb]}\n",
     "    )\n",
+    "    print(output)\n",
     "    print(cb)"
    ]
   },
@@ -176,7 +190,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/generators.ipynb

@@ -17,6 +17,13 @@
     "Let's implement a custom output parser for comma-separated lists."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sync version"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -27,7 +34,7 @@
     "\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts.chat import ChatPromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
     "\n",
     "prompt = ChatPromptTemplate.from_template(\n",
     "    \"Write a comma-separated list of 5 animals similar to: {animal}\"\n",
@@ -57,7 +64,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -66,7 +73,7 @@
        "'lion, tiger, wolf, gorilla, panda'"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -152,12 +159,81 @@
     "list_chain.invoke({\"animal\": \"bear\"})"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Async version"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "from typing import AsyncIterator\n",
+    "\n",
+    "\n",
+    "async def asplit_into_list(\n",
+    "    input: AsyncIterator[str],\n",
+    ") -> AsyncIterator[List[str]]:  # async def\n",
+    "    buffer = \"\"\n",
+    "    async for (\n",
+    "        chunk\n",
+    "    ) in input:  # `input` is a `async_generator` object, so use `async for`\n",
+    "        buffer += chunk\n",
+    "        while \",\" in buffer:\n",
+    "            comma_index = buffer.index(\",\")\n",
+    "            yield [buffer[:comma_index].strip()]\n",
+    "            buffer = buffer[comma_index + 1 :]\n",
+    "    yield [buffer.strip()]\n",
+    "\n",
+    "\n",
+    "list_chain = str_chain | asplit_into_list"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['lion']\n",
+      "['tiger']\n",
+      "['wolf']\n",
+      "['gorilla']\n",
+      "['panda']\n"
+     ]
+    }
+   ],
+   "source": [
+    "async for chunk in list_chain.astream({\"animal\": \"bear\"}):\n",
+    "    print(chunk, flush=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['lion', 'tiger', 'wolf', 'gorilla', 'panda']"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "await list_chain.ainvoke({\"animal\": \"bear\"})"
+   ]
   }
  ],
  "metadata": {
@@ -176,7 +252,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/index.mdx

@@ -1,5 +1,5 @@
 ---
-sidebar_position: 1
+sidebar_position: 2
 ---
 
 # How to

docs/docs/expression_language/how_to/map.ipynb

@@ -1,56 +1,29 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "e2596041-9b76-4e74-836f-e6235086bbf0",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 0\n",
+    "title: \"RunnableParallel: Manipulating data\"\n",
+    "keywords: [RunnableParallel, RunnableMap, LCEL]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "b022ab74-794d-4c54-ad47-ff9549ddb9d2",
    "metadata": {},
    "source": [
-    "# Parallelize steps\n",
+    "# Manipulating inputs & output\n",
     "\n",
-    "RunnableParallel (aka. RunnableMap) makes 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 RunnableParallel\n",
+    "RunnableParallel can be useful for manipulating the output of one Runnable to match the input format of the next Runnable in a sequence.\n",
     "\n",
-    "model = ChatOpenAI()\n",
-    "joke_chain = ChatPromptTemplate.from_template(\"tell me a joke about {topic}\") | model\n",
-    "poem_chain = (\n",
-    "    ChatPromptTemplate.from_template(\"write a 2-line poem about {topic}\") | model\n",
-    ")\n",
+    "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",
-    "map_chain = RunnableParallel(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."
+    "\n"
    ]
   },
   {
@@ -71,10 +44,12 @@
     }
    ],
    "source": [
+    "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.prompts import ChatPromptTemplate\n",
     "from langchain.vectorstores import FAISS\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "vectorstore = FAISS.from_texts(\n",
     "    [\"harrison worked at kensho\"], embedding=OpenAIEmbeddings()\n",
@@ -86,6 +61,7 @@
     "Question: {question}\n",
     "\"\"\"\n",
     "prompt = ChatPromptTemplate.from_template(template)\n",
+    "model = ChatOpenAI()\n",
     "\n",
     "retrieval_chain = (\n",
     "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
@@ -102,9 +78,133 @@
    "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",
+    "::: {.callout-tip}\n",
+    "Note that when composing a RunnableParallel with another Runnable we don't even need to wrap our dictionary in the RunnableParallel class — the type conversion is handled for us. In the context of a chain, these are equivalent:\n",
+    ":::\n",
     "\n",
-    "Note that when composing a RunnableMap when another Runnable we don't even need to wrap our dictionary in the RunnableMap class — the type conversion is handled for us."
+    "```\n",
+    "{\"context\": retriever, \"question\": RunnablePassthrough()}\n",
+    "```\n",
+    "\n",
+    "```\n",
+    "RunnableParallel({\"context\": retriever, \"question\": RunnablePassthrough()})\n",
+    "```\n",
+    "\n",
+    "```\n",
+    "RunnableParallel(context=retriever, question=RunnablePassthrough())\n",
+    "```\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7c1b8baa-3a80-44f0-bb79-d22f79815d3d",
+   "metadata": {},
+   "source": [
+    "## Using itemgetter as shorthand\n",
+    "\n",
+    "Note that you can use Python's `itemgetter` as shorthand to extract data from the map when combining with `RunnableParallel`. You can find more information about itemgetter in the [Python Documentation](https://docs.python.org/3/library/operator.html#operator.itemgetter). \n",
+    "\n",
+    "In the example below, we use itemgetter to extract specific keys from the map:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "84fc49e1-2daf-4700-ae33-a0a6ed47d5f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Harrison ha lavorato a Kensho.'"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from operator import itemgetter\n",
+    "\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.vectorstores import FAISS\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
+    "\n",
+    "vectorstore = FAISS.from_texts(\n",
+    "    [\"harrison worked at kensho\"], embedding=OpenAIEmbeddings()\n",
+    ")\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",
+    "Answer in the following language: {language}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "\n",
+    "chain = (\n",
+    "    {\n",
+    "        \"context\": itemgetter(\"question\") | retriever,\n",
+    "        \"question\": itemgetter(\"question\"),\n",
+    "        \"language\": itemgetter(\"language\"),\n",
+    "    }\n",
+    "    | prompt\n",
+    "    | model\n",
+    "    | StrOutputParser()\n",
+    ")\n",
+    "\n",
+    "chain.invoke({\"question\": \"where did harrison work\", \"language\": \"italian\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc2f9847-39aa-4fe4-9049-3a8969bc4bce",
+   "metadata": {},
+   "source": [
+    "## Parallelize steps\n",
+    "\n",
+    "RunnableParallel (aka. RunnableMap) makes it easy to execute multiple Runnables in parallel, and to return the output of these Runnables as a map."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "31f18442-f837-463f-bef4-8729368f5f8b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'joke': AIMessage(content=\"Why don't bears wear shoes?\\n\\nBecause they have bear feet!\"),\n",
+       " 'poem': AIMessage(content=\"In the wild's embrace, bear roams free,\\nStrength and grace, a majestic decree.\")}"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain_core.runnables import RunnableParallel\n",
+    "\n",
+    "model = ChatOpenAI()\n",
+    "joke_chain = ChatPromptTemplate.from_template(\"tell me a joke about {topic}\") | model\n",
+    "poem_chain = (\n",
+    "    ChatPromptTemplate.from_template(\"write a 2-line poem about {topic}\") | model\n",
+    ")\n",
+    "\n",
+    "map_chain = RunnableParallel(joke=joke_chain, poem=poem_chain)\n",
+    "\n",
+    "map_chain.invoke({\"topic\": \"bear\"})"
    ]
   },
   {
@@ -114,7 +214,7 @@
    "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."
+    "RunnableParallel 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."
    ]
   },
   {
@@ -194,7 +294,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/message_history.ipynb

@@ -10,11 +10,13 @@
     "The `RunnableWithMessageHistory` let's us add message history to certain types of chains.\n",
     "\n",
     "Specifically, it can be used for any Runnable that takes as input one of\n",
+    "\n",
     "* a sequence of `BaseMessage`\n",
     "* a dict with a key that takes a sequence of `BaseMessage`\n",
     "* a dict with a key that takes the latest message(s) as a string or sequence of `BaseMessage`, and a separate key that takes historical messages\n",
     "\n",
     "And returns as output one of\n",
+    "\n",
     "* a string that can be treated as the contents of an `AIMessage`\n",
     "* a sequence of `BaseMessage`\n",
     "* a dict with a key that contains a sequence of `BaseMessage`\n",
@@ -132,8 +134,8 @@
     "from langchain.chat_models import ChatAnthropic\n",
     "from langchain.memory.chat_message_histories import RedisChatMessageHistory\n",
     "from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
-    "from langchain.schema.chat_history import BaseChatMessageHistory\n",
-    "from langchain.schema.runnable.history import RunnableWithMessageHistory"
+    "from langchain_core.chat_history import BaseChatMessageHistory\n",
+    "from langchain_core.runnables.history import RunnableWithMessageHistory"
    ]
   },
   {
@@ -251,7 +253,10 @@
    "id": "da3d1feb-b4bb-4624-961c-7db2e1180df7",
    "metadata": {},
    "source": [
-    ":::tip [Langsmith trace](https://smith.langchain.com/public/863a003b-7ca8-4b24-be9e-d63ec13c106e/r)\n",
+    ":::tip\n",
+    "\n",
+    "[Langsmith trace](https://smith.langchain.com/public/863a003b-7ca8-4b24-be9e-d63ec13c106e/r)\n",
+    "\n",
     ":::"
    ]
   },
@@ -289,10 +294,10 @@
     }
    ],
    "source": [
-    "from langchain.schema.messages import HumanMessage\n",
-    "from langchain.schema.runnable import RunnableMap\n",
+    "from langchain_core.messages import HumanMessage\n",
+    "from langchain_core.runnables import RunnableParallel\n",
     "\n",
-    "chain = RunnableMap({\"output_message\": ChatAnthropic(model=\"claude-2\")})\n",
+    "chain = RunnableParallel({\"output_message\": ChatAnthropic(model=\"claude-2\")})\n",
     "chain_with_history = RunnableWithMessageHistory(\n",
     "    chain,\n",
     "    lambda session_id: RedisChatMessageHistory(session_id, url=REDIS_URL),\n",
@@ -334,7 +339,10 @@
    "id": "b898d1b1-11e6-4d30-a8dd-cc5e45533611",
    "metadata": {},
    "source": [
-    ":::tip [LangSmith trace](https://smith.langchain.com/public/f6c3e1d1-a49d-4955-a9fa-c6519df74fa7/r)\n",
+    ":::tip\n",
+    "\n",
+    "[LangSmith trace](https://smith.langchain.com/public/f6c3e1d1-a49d-4955-a9fa-c6519df74fa7/r)\n",
+    "\n",
     ":::"
    ]
   },

docs/docs/expression_language/how_to/passthrough.ipynb

@@ -0,0 +1,159 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d35de667-0352-4bfb-a890-cebe7f676fe7",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 1\n",
+    "title: \"RunnablePassthrough: Passing data through\"\n",
+    "keywords: [RunnablePassthrough, RunnableParallel, LCEL]\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b022ab74-794d-4c54-ad47-ff9549ddb9d2",
+   "metadata": {},
+   "source": [
+    "# Passing data through\n",
+    "\n",
+    "RunnablePassthrough allows to pass inputs unchanged or with the addition of extra keys. This typically is used in conjuction with RunnableParallel to assign data to a new key in the map. \n",
+    "\n",
+    "RunnablePassthrough() called on it's own, will simply take the input and pass it through. \n",
+    "\n",
+    "RunnablePassthrough called with assign (`RunnablePassthrough.assign(...)`) will take the input, and will add the extra arguments passed to the assign function. \n",
+    "\n",
+    "See the example below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "03988b8d-d54c-4492-8707-1594372cf093",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'passed': {'num': 1}, 'extra': {'num': 1, 'mult': 3}, 'modified': 2}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n",
+    "\n",
+    "runnable = RunnableParallel(\n",
+    "    passed=RunnablePassthrough(),\n",
+    "    extra=RunnablePassthrough.assign(mult=lambda x: x[\"num\"] * 3),\n",
+    "    modified=lambda x: x[\"num\"] + 1,\n",
+    ")\n",
+    "\n",
+    "runnable.invoke({\"num\": 1})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "702c7acc-cd31-4037-9489-647df192fd7c",
+   "metadata": {},
+   "source": [
+    "As seen above, `passed` key was called with `RunnablePassthrough()` and so it simply passed on `{'num': 1}`. \n",
+    "\n",
+    "In the second line, we used `RunnablePastshrough.assign` with a lambda that multiplies the numerical value by 3. In this cased, `extra` was set with `{'num': 1, 'mult': 3}` which is the original value with the `mult` key added. \n",
+    "\n",
+    "Finally, we also set a third key in the map with `modified` which uses a labmda to set a single value adding 1 to the num, which resulted in `modified` key with the value of `2`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15187a3b-d666-4b9b-a258-672fc51fe0e2",
+   "metadata": {},
+   "source": [
+    "## Retrieval Example\n",
+    "\n",
+    "In the example below, we see a use case where we use RunnablePassthrough along with RunnableMap. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "267d1460-53c1-4fdb-b2c3-b6a1eb7fccff",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Harrison worked at Kensho.'"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain.prompts import ChatPromptTemplate\n",
+    "from langchain.vectorstores import FAISS\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
+    "\n",
+    "vectorstore = FAISS.from_texts(\n",
+    "    [\"harrison worked at kensho\"], embedding=OpenAIEmbeddings()\n",
+    ")\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",
+    "model = ChatOpenAI()\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. In this case, the RunnablePassthrough allows us to pass on the user's question to the prompt and model. \n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/expression_language/how_to/routing.ipynb

@@ -1,5 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 3\n",
+    "title: \"RunnableBranch: Dynamically route logic based on input\"\n",
+    "keywords: [RunnableBranch, LCEL]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "4b47436a",
@@ -42,7 +53,7 @@
    "source": [
     "from langchain.chat_models import ChatAnthropic\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain.schema.output_parser import StrOutputParser"
+    "from langchain_core.output_parsers import StrOutputParser"
    ]
   },
   {
@@ -63,7 +74,7 @@
     "chain = (\n",
     "    PromptTemplate.from_template(\n",
     "        \"\"\"Given the user question below, classify it as either being about `LangChain`, `Anthropic`, or `Other`.\n",
-    "                                     \n",
+    "\n",
     "Do not respond with more than one word.\n",
     "\n",
     "<question>\n",
@@ -153,7 +164,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnableBranch\n",
+    "from langchain_core.runnables import RunnableBranch\n",
     "\n",
     "branch = RunnableBranch(\n",
     "    (lambda x: \"anthropic\" in x[\"topic\"].lower(), anthropic_chain),\n",
@@ -268,7 +279,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnableLambda\n",
+    "from langchain_core.runnables import RunnableLambda\n",
     "\n",
     "full_chain = {\"topic\": chain, \"question\": lambda x: x[\"question\"]} | RunnableLambda(\n",
     "    route\n",
@@ -293,7 +304,7 @@
     }
    ],
    "source": [
-    "full_chain.invoke({\"question\": \"how do I use Anthroipc?\"})"
+    "full_chain.invoke({\"question\": \"how do I use Anthropic?\"})"
    ]
   },
   {

docs/docs/expression_language/index.mdx

@@ -20,7 +20,7 @@ Whenever your LCEL chains have steps that can be executed in parallel (eg if you
 Configure retries and fallbacks for any part of your LCEL chain. This is a great way to make your chains more reliable at scale. We’re currently working on adding streaming support for retries/fallbacks, so you can get the added reliability without any latency cost.
 
 **Access intermediate results**
-For more complex chains it’s often very useful to access the results of intermediate steps even before the final output is produced. This can be used let end-users know something is happening, or even just to debug your chain. You can stream intermediate results, and it’s available on every [LangServe](/docs/langserve) server.
+For more complex chains it’s often very useful to access the results of intermediate steps even before the final output is produced. This can be used to let end-users know something is happening, or even just to debug your chain. You can stream intermediate results, and it’s available on every [LangServe](/docs/langserve) server.
 
 **Input and output schemas**
 Input and output schemas give every LCEL chain Pydantic and JSONSchema schemas inferred from the structure of your chain. This can be used for validation of inputs and outputs, and is an integral part of LangServe.
@@ -30,4 +30,4 @@ As your chains get more and more complex, it becomes increasingly important to u
 With LCEL, **all** steps are automatically logged to [LangSmith](/docs/langsmith/) for maximum observability and debuggability.
 
 **Seamless LangServe deployment integration**
-Any chain created with LCEL can be easily deployed using [LangServe](/docs/langserve).
+Any chain created with LCEL can be easily deployed using [LangServe](/docs/langserve).

docs/docs/expression_language/interface.ipynb

@@ -6,7 +6,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "sidebar_position: 0\n",
+    "sidebar_position: 1\n",
     "title: Interface\n",
     "---"
    ]
@@ -16,7 +16,7 @@
    "id": "9a9acd2e",
    "metadata": {},
    "source": [
-    "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.base.Runnable.html#langchain.schema.runnable.base.Runnable) protocol. The `Runnable` protocol is implemented for most components. \n",
+    "To make it as easy as possible to create custom chains, we've implemented a [\"Runnable\"](https://api.python.langchain.com/en/stable/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable) protocol. The `Runnable` protocol is implemented for most components. \n",
     "This is a standard interface, which makes it easy to define custom chains as well as invoke them in a standard way. \n",
     "The standard interface includes:\n",
     "\n",
@@ -660,9 +660,9 @@
    ],
    "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",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "\n",
     "template = \"\"\"Answer the question based only on the following context:\n",
     "{context}\n",
@@ -920,7 +920,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.schema.runnable import RunnableParallel\n",
+    "from langchain_core.runnables import RunnableParallel\n",
     "\n",
     "chain1 = ChatPromptTemplate.from_template(\"tell me a joke about {topic}\") | model\n",
     "chain2 = (\n",

docs/docs/get_started/installation.mdx

@@ -29,6 +29,20 @@ If you want to install from source, you can do so by cloning the repo and be sur
 pip install -e .
 ```
 
+## LangChain community
+The `langchain-community` package contains third-party integrations. It is automatically installed by `langchain`, but can also be used separately. Install with:
+
+```bash
+pip install langchain-community
+```
+
+## LangChain core
+The `langchain-core` package contains base abstractions that the rest of the LangChain ecosystem uses, along with the LangChain Expression Language. It is automatically installed by `langchain`, but can also be used separately. Install with:
+
+```bash
+pip install langchain-core
+```
+
 ## LangChain experimental
 The `langchain-experimental` package holds experimental LangChain code, intended for research and experimental uses.
 Install with:
@@ -61,4 +75,4 @@ If not using LangChain, install with:
 
 ```bash
 pip install langsmith
-```
+```

docs/docs/get_started/introduction.mdx

@@ -14,7 +14,7 @@ This framework consists of several parts.
 - **[LangServe](/docs/langserve)**: A library for deploying LangChain chains as a REST API.
 - **[LangSmith](/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
 
-![LangChain Diagram](/img/langchain_stack.png)
+![LangChain Diagram](/svg/langchain_stack.svg)
 
 Together, these products simplify the entire application lifecycle:
 - **Develop**: Write your applications in LangChain/LangChain.js. Hit the ground running using Templates for reference.
@@ -29,6 +29,11 @@ The main value props of the LangChain packages are:
 
 Off-the-shelf chains make it easy to get started. Components make it easy to customize existing chains and build new ones.
 
+The LangChain libraries themselves are made up of several different packages.
+- **`langchain-core`**: Base abstractions and LangChain Expression Language.
+- **`langchain-community`**: Third party integrations.
+- **`langchain`**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
+
 ## Get started
 
 [Here’s](/docs/get_started/installation) how to install LangChain, set up your environment, and start building.
@@ -79,7 +84,7 @@ Walkthroughs and techniques for common end-to-end use cases, like:
 ### [Integrations](/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/).
 
-### [Guides](/docs/guides/adapters/openai)
+### [Guides](/docs/guides/guides/debugging)
 Best practices for developing with LangChain.
 
 ### [API reference](https://api.python.langchain.com)

docs/docs/get_started/quickstart.mdx

@@ -11,6 +11,13 @@ In this quickstart we'll show you how to:
 That's a fair amount to cover! Let's dive in.
 
 ## Setup
+
+### Jupyter Notebook
+
+This guide (and most of the other guides in the documentation) use [Jupyter notebooks](https://jupyter.org/) and assume the reader is as well. Jupyter notebooks are perfect for learning how to work with LLM systems because often times things can go wrong (unexpected output, API down, etc) and going through guides in an interactive environment is a great way to better understand them.
+
+You do not NEED to go through the guide in a Jupyter Notebook, but it is recommended. See [here](https://jupyter.org/install) for instructions on how to install.
+
 ### Installation
 
 To install LangChain run:
@@ -31,30 +38,6 @@ import CodeBlock from "@theme/CodeBlock";
 
 For more details, see our [Installation guide](/docs/get_started/installation).
 
-### Environment
-
-Using LangChain will usually require integrations with one or more model providers, data stores, APIs, etc. For this example, we'll use OpenAI's model APIs.
-
-First we'll need to install their Python package:
-
-```bash
-pip install openai
-```
-
-Accessing the API requires an API key, which you can get by creating an account and heading [here](https://platform.openai.com/account/api-keys). Once we have a key we'll want to set it as an environment variable by running:
-
-```bash
-export OPENAI_API_KEY="..."
-```
-
-If you'd prefer not to set an environment variable you can pass the key in directly via the `openai_api_key` named parameter when initiating the OpenAI LLM class:
-
-```python
-from langchain.chat_models import ChatOpenAI
-
-llm = ChatOpenAI(openai_api_key="...")
-```
-
 ### LangSmith
 
 Many of the applications you build with LangChain will contain multiple steps with multiple invocations of LLM calls.
@@ -66,246 +49,416 @@ If you do want to use LangSmith, after you sign up at the link above, make sure
 
 ```shell
 export LANGCHAIN_TRACING_V2="true"
-export LANGCHAIN_API_KEY=...
+export LANGCHAIN_API_KEY="..."
 ```
 
-### LangServe
+## Building with LangChain
 
+LangChain enables building application that connect external sources of data and computation to LLMs.
+In this quickstart, we will walk through a few different ways of doing that.
+We will start with a simple LLM chain, which just relies on information in the prompt template to respond.
+Next, we will build a retrieval chain, which fetches data from a separate database and passes that into the prompt template.
+We will then add in chat history, to create a conversation retrieval chain. This allows you interact in a chat manner with this LLM, so it remembers previous questions.
+Finally, we will build an agent - which utilizes and LLM to determine whether or not it needs to fetch data to answer questions.
+We will cover these at a high level, but there are lot of details to all of these!
+We will link to relevant docs.
+
+## LLM Chain
+
+For this getting started guide, we will provide two options: using OpenAI (a popular model available via API) or using a local open source model.
+
+<Tabs>
+  <TabItem value="openai" label="OpenAI" default>
+
+First we'll need to install their Python package:
+
+```shell
+pip install openai
+```
+
+Accessing the API requires an API key, which you can get by creating an account and heading [here](https://platform.openai.com/account/api-keys). Once we have a key we'll want to set it as an environment variable by running:
+
+```shell
+export OPENAI_API_KEY="..."
+```
+
+We can then initialize the model:
+
+```python
+from langchain.chat_models import ChatOpenAI
+
+llm = ChatOpenAI()
+```
+
+If you'd prefer not to set an environment variable you can pass the key in directly via the `openai_api_key` named parameter when initiating the OpenAI LLM class:
+
+```python
+from langchain.chat_models import ChatOpenAI
+
+llm = ChatOpenAI(openai_api_key="...")
+```
+
+  </TabItem>
+  <TabItem value="local" label="Local">
+
+[Ollama](https://ollama.ai/) allows you to run open-source large language models, such as Llama 2, locally.
+
+First, follow [these instructions](https://github.com/jmorganca/ollama) to set up and run a local Ollama instance:
+
+* [Download](https://ollama.ai/download)
+* Fetch a model via `ollama pull llama2`
+
+Then, make sure the Ollama server is running. After that, you can do:
+```python
+from langchain.llms import Ollama
+llm = Ollama(model="llama2")
+```
+
+  </TabItem>
+</Tabs>
+
+Once you've installed and initialized the LLM of your choice, we can try using it!
+Let's ask it what LangSmith is - this is something that wasn't present in the training data so it shouldn't have a very good response.
+
+```python
+llm.invoke("how can langsmith help with testing?")
+```
+
+We can also guide it's response with a prompt template.
+Prompt templates are used to convert raw user input to a better input to the LLM.
+
+```python
+from langchain.prompts import ChatPromptTemplate
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "You are world class technical documentation writer."),
+    ("user", "{input}")
+])
+```
+
+We can now combine these into a simple LLM chain:
+
+```python
+chain = prompt | llm 
+```
+
+We can now invoke it and ask the same question. It still won't know the answer, but it should respond in a more proper tone for a technical writer!
+
+The output of a ChatModel (and therefore, of this chain) is a message. However, it's often much more convenient to work with strings. Let's add a simple output parser to convert the chat message to a string.
+
+```python
+from langchain_core.output_parsers import StrOutputParser
+
+output_parser = StrOutputParser()
+```
+
+We can now add this to the previous chain:
+
+```python
+chain = prompt | llm | output_parser
+```
+
+We can now invoke it and ask the same question. The answer will now be a string (rather than a ChatMessage).
+
+```python
+chain.invoke({"input": "how can langsmith help with testing?"})
+```
+
+### Diving Deeper
+
+We've now successfully set up a basic LLM chain. We only touched on the basics of prompts, models, and output parsers - for a deeper dive into everything mentioned here, see [this section of documentation](/docs/modules/model_io).
+
+
+## Retrieval Chain
+
+In order to properly answer the original question ("how can langsmith help with testing?"), we need to provide additional context to the LLM.
+We can do this via *retrieval*.
+Retrieval is useful when you have **too much data** to pass to the LLM directly.
+You can then use a retriever to fetch only the most relevant pieces and pass those in.
+
+In this process, we will look up relevant documents from a *Retriever* and then pass them into the prompt.
+A Retriever can be backed by anything - a SQL table, the internet, etc - but in this instance we will populate a vector store and use that as a retriever. For more information on vectorstores, see [this documentation](/docs/modules/data_connection/vectorstores).
+
+First, we need to load the data that we want to index:
+
+
+```python
+from langchain_community.document_loaders import WebBaseLoader
+loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
+
+docs = loader.load()
+```
+
+Next, we need to index it into a vectorstore. This requires a few components, namely an [embedding model](/docs/modules/data_connection/text_embedding) and a [vectorstore](/docs/modules/data_connection/vectorstores).
+
+For embedding models, we once again provide examples for accessing via OpenAI or via local models.
+
+<Tabs>
+  <TabItem value="openai" label="OpenAI" default>
+  
+Make sure you have the openai package installed an the appropriate environment variables set (these are the same as needed for the LLM).
+
+```python
+from langchain_community.embeddings import OpenAIEmbeddings
+
+embeddings = OpenAIEmbeddings()
+```
+
+</TabItem>
+<TabItem value="local" label="Ollama">
+
+Make sure you have Ollama running (same set up as with the LLM).
+
+```python
+from langchain_community.embeddings import OllamaEmbeddings
+
+embeddings = OllamaEmbeddings()
+```
+  </TabItem>
+</Tabs>
+
+Now, we can use this embedding model to ingest documents into a vectorstore.
+We will use a simple local vectorstore, [DocArray InMemorySearch](/docs/integrations/vectorstores/docarray_in_memory), for simplicity's sake.
+
+First we need to install the required packages for that:
+
+```shell
+pip install docarray
+```
+
+Then we can build our index:
+
+```python
+from langchain_community.vectorstores import DocArrayInMemorySearch
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+
+text_splitter = RecursiveCharacterTextSplitter()
+documents = text_splitter.split_documents(docs)
+vector = DocArrayInMemorySearch.from_documents(documents, embeddings)
+```
+
+Now that we have this data indexed in a vectorstore, we will create a retrieval chain.
+This chain will take an incoming question, look up relevant documents, then pass those documents along with the original question into an LLM and ask it to answer the original question.
+
+First, let's set up the chain that takes a question and the retrieved documents and generates an answer.
+
+```python
+from langchain.chains.combine_documents import create_stuff_documents_chain
+
+prompt = ChatPromptTemplate.from_template("""Answer the following question based only on the provided context:
+
+<context>
+{context}
+</context>
+
+Question: {input}""")
+
+document_chain = create_stuff_documents_chain(llm, prompt)
+```
+
+If we wanted to, we could run this ourselves by passing in documents directly:
+
+```python
+from langchain_core.documents import Document
+
+document_chain.invoke({
+    "input": "how can langsmith help with testing?",
+    "context": [Document(page_content="langsmith can let you visualize test results")]
+})
+```
+
+However, we want the documents to first come from the retriever we just set up.
+That way, for a given question we can use the retriever to dynamically select the most relevant documents and pass those in.
+
+```python
+from langchain.chains import create_retrieval_chain
+
+retriever = vector.as_retriever()
+retrieval_chain = create_retrieval_chain(retriever, document_chain)
+```
+
+We can now invoke this chain. This returns a dictionary - the response from the LLM is in the `answer` key
+
+```python
+response = retrieval_chain.invoke({"input": "how can langsmith help with testing?"})
+print(response["answer"])
+
+// LangSmith offers several features that can help with testing:...
+```
+
+This answer should be much more accurate!
+
+### Diving Deeper
+
+We've now successfully set up a basic retrieval chain. We only touched on the basics of retrieval - for a deeper dive into everything mentioned here, see [this section of documentation](/docs/modules/data_connection).
+
+## Conversation Retrieval Chain
+
+The chain we've created so far can only answer single questions. One of the main types of LLM applications that people are building are chat bots. So how do we turn this chain into one that can answer follow up questions?
+
+We can still use the `create_retrieval_chain` function, but we need to change two things:
+
+1. The retrieval method should now not just work on the most recent input, but rather should take the whole history into account.
+2. The final LLM chain should likewise take the whole history into account
+
+**Updating Retrieval**
+
+In order to update retrieval, we will create a new chain. This chain will take in the most recent input (`input`) and the conversation history (`chat_history`) and use an LLM to generate a search query.
+
+```python
+from langchain.chains import create_history_aware_retriever
+from langchain_core.prompts import MessagesPlaceholder
+
+# First we need a prompt that we can pass into an LLM to generate this search query
+
+prompt = ChatPromptTemplate.from_messages([
+    MessagesPlaceholder(variable_name="chat_history"),
+    ("user", "{input}")
+    ("user", "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation")
+])
+retriever_chain = create_history_aware_retriever(llm, retriever, prompt)
+```
+
+We can test this out by passing in an instance where the user is asking a follow up question.
+
+```python
+from langchain_core.messages import HumanMessage, AIMessage
+
+chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
+retrieval_chain.invoke({
+    "chat_history": chat_history,
+    "input": "Tell me how"
+})
+```
+You should see that this returns documents about testing in LangSmith. This is because the LLM generated a new query, combining the chat history with the follow up question.
+
+Now that we have this new retriever, we can create a new chain to continue the conversation with these retrieved documents in mind.
+
+```python
+prompt = ChatPromptTemplate.from_messages([
+    ("system", "Answer the user's questions based on the below context:\n\n{context}"),
+    MessagesPlaceholder(variable_name="chat_history"),
+    ("user", "{input}"),
+])
+document_chain = create_stuff_documents_chain(llm, prompt)
+
+retrieval_chain = create_retrieval_chain(retriever_chain, document_chain)
+```
+
+We can now test this out end-to-end:
+
+```python
+chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
+retrieval_chain.invoke({
+    "chat_history": chat_history,
+    "input": "Tell me how"
+})
+```
+We can see that this gives a coherent answer - we've successfully turned our retrieval chain into a chatbot!
+
+## Agent
+
+We've so far create examples of chains - where each step is known ahead of time.
+The final thing we will create is an agent - where the LLM decides what steps to take.
+
+**NOTE: for this example we will only show how to create an agent using OpenAI models, as local models are not reliable enough yet.**
+
+One of the first things to do when building an agent is to decide what tools it should have access to.
+For this example, we will give the agent access two tools:
+
+1. The retriever we just created. This will let it easily answer questions about LangSmith
+2. A search tool. This will let it easily answer questions that require up to date information.
+
+First, let's set up a tool for the retriever we just created:
+
+```python
+from langchain.tools.retriever import create_retriever_tool
+
+retriever_tool = create_retriever_tool(
+    retriever,
+    "langsmith_search",
+    "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
+)
+```
+
+
+The search tool that we will use is [Tavily](/docs/integrations/retrievers/tavily). This will require an API key (they have generous free tier). After creating it on their platform, you need to set it as an environment variable:
+
+```shell
+export TAVILY_API_KEY=...
+```
+If you do not want to set up an API key, you can skip creating this tool.
+
+```python
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+search = TavilySearchResults()
+```
+
+We can now create a list of the tools we want to work with:
+
+```python
+tools = [retriever_tool, search]
+```
+
+Now that we have the tools, we can create an agent to use them. We will go over this pretty quickly - for a deeper dive into what exactly is going on, check out the [Agent's Getting Started documentation](/docs/modules/agents)
+
+```python
+from langchain.chat_models import ChatOpenAI
+from langchain import hub
+from langchain.agents import create_openai_functions_agent
+from langchain.agents import AgentExecutor
+
+# Get the prompt to use - you can modify this!
+prompt = hub.pull("hwchase17/openai-functions-agent")
+llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+agent = create_openai_functions_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+```
+
+We can now invoke the agent and see how it responds! We can ask it questions about LangSmith:
+
+```python
+agent_executor.invoke({"input": "how can langsmith help with testing?"})
+```
+
+We can ask it about the weather:
+
+```python
+agent_executor.invoke({"input": "what is the weather in SF?"})
+```
+
+We can have conversations with it:
+
+```python
+chat_history = [HumanMessage(content="Can LangSmith help test my LLM applications?"), AIMessage(content="Yes!")]
+agent_executor.invoke({
+    "chat_history": chat_history,
+    "input": "Tell me how"
+})
+```
+
+### Diving Deeper
+
+We've now successfully set up a basic agent. We only touched on the basics of agents - for a deeper dive into everything mentioned here, see [this section of documentation](/docs/modules/agents).
+
+
+## Serving with LangServe
+
+Now that we've built an application, we need to serve it. That's where LangServe comes in.
 LangServe helps developers deploy LangChain chains as a REST API. You do not need to use LangServe to use LangChain, but in this guide we'll show how you can deploy your app with LangServe.
 
+While the first part of this guide was intended to be run in a Jupyter Notebook, we will now move out of that. We will be creating a Python file and then interacting with it from the command line.
+
 Install with:
 ```bash
 pip install "langserve[all]"
 ```
 
-## Building with LangChain
-
-LangChain provides many modules that can be used to build language model applications.
-Modules can be used as standalones in simple applications and they can be composed for more complex use cases.
-Composition is powered by **LangChain Expression Language** (LCEL), which defines a unified `Runnable` interface that many modules implement, making it possible to seamlessly chain components.
-
-The simplest and most common chain contains three things:
-- LLM/Chat Model: 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 Template: 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 Parser: These translate the raw response from the language model to a more workable format, making it easy to use the output downstream.
-
-In this guide we'll cover those three components individually, and then go over how to combine 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 model and/or the prompt, so knowing how to take advantage of this will be a big enabler.
-
-### LLM / Chat Model
-
-There are two types of language models:
-
-- `LLM`: underlying model takes a string as input and returns a string
-- `ChatModel`: underlying model takes a list of messages as input and returns a message
-
-Strings are simple, but what exactly are messages? The base message interface is defined by `BaseMessage`, which has two required attributes:
-
-- `content`: The content of the message. Usually a string.
-- `role`: The entity from which the `BaseMessage` is coming.
-
-LangChain provides several objects to easily distinguish between different roles:
-
-- `HumanMessage`: A `BaseMessage` coming from a human/user.
-- `AIMessage`: A `BaseMessage` coming from an AI/assistant.
-- `SystemMessage`: A `BaseMessage` coming from the system.
-- `FunctionMessage` / `ToolMessage`: A `BaseMessage` containing the output of a function or tool call.
-
-If none of those roles sound right, there is also a `ChatMessage` class where you can specify the role manually.
-
-LangChain provides a common interface that's shared by both `LLM`s and `ChatModel`s.
-However it's useful to understand the difference in order to most effectively construct prompts for a given language model.
-
-The simplest way to call an `LLM` or `ChatModel` is using `.invoke()`, the universal synchronous call method for all LangChain Expression Language (LCEL) objects:
-- `LLM.invoke`: Takes in a string, returns a string.
-- `ChatModel.invoke`: Takes in a list of `BaseMessage`, returns a `BaseMessage`.
-
-The input types for these methods are actually more general than this, but for simplicity here we can assume LLMs only take strings and Chat models only takes lists of messages.
-Check out the "Go deeper" section below to learn more about model invocation.
-
-Let's see how to work with these different types of models and these different types of inputs.
-First, let's import an LLM and a ChatModel.
-
-```python
-from langchain.llms import OpenAI
-from langchain.chat_models import ChatOpenAI
-
-llm = OpenAI()
-chat_model = ChatOpenAI()
-```
-
-`LLM` and `ChatModel` objects are effectively configuration objects.
-You can initialize them with parameters like `temperature` and others, and pass them around.
-
-```python
-from langchain.schema import HumanMessage
-
-text = "What would be a good company name for a company that makes colorful socks?"
-messages = [HumanMessage(content=text)]
-
-llm.invoke(text)
-# >> Feetful of Fun
-
-chat_model.invoke(messages)
-# >> AIMessage(content="Socks O'Color")
-```
-
-<details> <summary>Go deeper</summary>
-
-`LLM.invoke` and `ChatModel.invoke` actually both support as input any of `Union[str, List[BaseMessage], PromptValue]`.
-`PromptValue` is an object that defines it's own custom logic for returning it's inputs either as a string or as messages.
-`LLM`s have logic for coercing any of these into a string, and `ChatModel`s have logic for coercing any of these to messages.
-The fact that `LLM` and `ChatModel` accept the same inputs means that you can directly swap them for one another in most chains without breaking anything,
-though it's of course important to think about how inputs are being coerced and how that may affect model performance.
-To dive deeper on models head to the [Language models](/docs/modules/model_io/models) section.
-
-</details>
-
-### Prompt templates
-
-Most LLM applications do not pass user input directly into an LLM. Usually they will add the user input to a larger piece of text, called a prompt template, that provides additional context on the specific task at hand.
-
-In the previous example, the text we passed to the model contained instructions to generate a company name. For our application, it would be great if the user only had to provide the description of a company/product, without having to worry about giving the model instructions.
-
-PromptTemplates help with exactly this!
-They bundle up all the logic for going from user input into a fully formatted prompt.
-This can start off very simple - for example, a prompt to produce the above string would just be:
-
-```python
-from langchain.prompts import PromptTemplate
-
-prompt = PromptTemplate.from_template("What is a good name for a company that makes {product}?")
-prompt.format(product="colorful socks")
-```
-
-```python
-What is a good name for a company that makes colorful socks?
-```
-
-However, the advantages of using these over raw string formatting are several.
-You can "partial" out variables - e.g. you can format only some of the variables at a time.
-You can compose them together, easily combining different templates into a single prompt.
-For explanations of these functionalities, see the [section on prompts](/docs/modules/model_io/prompts) for more detail.
-
-`PromptTemplate`s can also be used to produce a list of messages.
-In this case, the prompt not only contains information about the content, but also each message (its role, its position in the list, etc.).
-Here, what happens most often is a `ChatPromptTemplate` is a list of `ChatMessageTemplates`.
-Each `ChatMessageTemplate` contains instructions for how to format that `ChatMessage` - its role, and then also its content.
-Let's take a look at this below:
-
-```python
-from langchain.prompts.chat import ChatPromptTemplate
-
-template = "You are a helpful assistant that translates {input_language} to {output_language}."
-human_template = "{text}"
-
-chat_prompt = ChatPromptTemplate.from_messages([
-    ("system", template),
-    ("human", human_template),
-])
-
-chat_prompt.format_messages(input_language="English", output_language="French", text="I love programming.")
-```
-
-```pycon
-[
-    SystemMessage(content="You are a helpful assistant that translates English to French.", additional_kwargs={}),
-    HumanMessage(content="I love programming.")
-]
-```
-
-
-ChatPromptTemplates can also be constructed in other ways - see the [section on prompts](/docs/modules/model_io/prompts) for more detail.
-
-### Output parsers
-
-`OutputParsers` convert the raw output of a language model into a format that can be used downstream.
-There are few main types of `OutputParser`s, including:
-
-- Convert text from `LLM` into structured information (e.g. JSON)
-- Convert a `ChatMessage` into just a string
-- Convert the extra information returned from a call besides the message (like OpenAI function invocation) into a string.
-
-For full information on this, see the [section on output parsers](/docs/modules/model_io/output_parsers).
-
-In this getting started guide, we will write our own output parser - one that converts a comma separated list into a list.
-
-```python
-from langchain.schema import BaseOutputParser
-
-class CommaSeparatedListOutputParser(BaseOutputParser):
-    """Parse the output of an LLM call to a comma-separated list."""
-
-
-    def parse(self, text: str):
-        """Parse the output of an LLM call."""
-        return text.strip().split(", ")
-
-CommaSeparatedListOutputParser().parse("hi, bye")
-# >> ['hi', 'bye']
-```
-
-### Composing with LCEL
-
-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 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!
-
-```python
-from typing import List
-
-from langchain.chat_models import ChatOpenAI
-from langchain.prompts import ChatPromptTemplate
-from langchain.schema import BaseOutputParser
-
-class CommaSeparatedListOutputParser(BaseOutputParser[List[str]]):
-    """Parse the output of an LLM call to a comma-separated list."""
-
-
-    def parse(self, text: str) -> List[str]:
-        """Parse the output of an LLM call."""
-        return text.strip().split(", ")
-
-template = """You are a helpful assistant who generates comma separated lists.
-A user will pass in a category, and you should generate 5 objects in that category in a comma separated list.
-ONLY return a comma separated list, and nothing more."""
-human_template = "{text}"
-
-chat_prompt = ChatPromptTemplate.from_messages([
-    ("system", template),
-    ("human", human_template),
-])
-chain = chat_prompt | ChatOpenAI() | CommaSeparatedListOutputParser()
-chain.invoke({"text": "colors"})
-# >> ['red', 'blue', 'green', 'yellow', 'orange']
-```
-
-Note that we are using the `|` syntax to join these components together.
-This `|` syntax is powered by the LangChain Expression Language (LCEL) and relies on the universal `Runnable` interface that all of these objects implement.
-To learn more about LCEL, read the documentation [here](/docs/expression_language).
-
-## Tracing with LangSmith
-
-Assuming we've set our environment variables as shown in the beginning, all of the model and chain calls we've been making will have been automatically logged to LangSmith.
-Once there, we can use LangSmith to debug and annotate our application traces, then turn them into datasets for evaluating future iterations of the application.
-
-Check out what the trace for the above chain would look like:
-https://smith.langchain.com/public/09370280-4330-4eb4-a7e8-c91817f6aa13/r
-
-For more on LangSmith [head here](/docs/langsmith/).
-
-## Serving with LangServe
-
-Now that we've built an application, we need to serve it. That's where LangServe comes in.
-LangServe helps developers deploy LCEL chains as a REST API.
-The library is integrated with FastAPI and uses pydantic for data validation.
-
 ### Server
 
-To create a server for our application we'll make a `serve.py` file with three things:
-1. The definition of our chain (same as above)
+To create a server for our application we'll make a `serve.py` file. This will contain our logic for serving our application. It consists of three things:
+1. The definition of our chain that we just built above
 2. Our FastAPI app
 3. A definition of a route from which to serve the chain, which is done with `langserve.add_routes`
 
@@ -316,42 +469,73 @@ from typing import List
 from fastapi import FastAPI
 from langchain.prompts import ChatPromptTemplate
 from langchain.chat_models import ChatOpenAI
-from langchain.schema import BaseOutputParser
+from langchain_community.document_loaders import WebBaseLoader
+from langchain_community.embeddings import OpenAIEmbeddings
+from langchain_community.vectorstores import DocArrayInMemorySearch
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.tools.retriever import create_retriever_tool
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain.chat_models import ChatOpenAI
+from langchain import hub
+from langchain.agents import create_openai_functions_agent
+from langchain.agents import AgentExecutor
+from langchain.pydantic_v1 import BaseModel, Field
+from langchain_core.messages import BaseMessage
 from langserve import add_routes
 
-# 1. Chain definition
+# 1. Load Retriever
+loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
+docs = loader.load()
+text_splitter = RecursiveCharacterTextSplitter()
+documents = text_splitter.split_documents(docs)
+embeddings = OpenAIEmbeddings()
+vector = DocArrayInMemorySearch.from_documents(documents, embeddings)
+retriever = vector.as_retriever()
 
-class CommaSeparatedListOutputParser(BaseOutputParser[List[str]]):
-    """Parse the output of an LLM call to a comma-separated list."""
+# 2. Create Tools
+retriever_tool = create_retriever_tool(
+    retriever,
+    "langsmith_search",
+    "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!",
+)
+search = TavilySearchResults()
+tools = [retriever_tool, search]
 
 
-    def parse(self, text: str) -> List[str]:
-        """Parse the output of an LLM call."""
-        return text.strip().split(", ")
+# 3. Create Agent
+prompt = hub.pull("hwchase17/openai-functions-agent")
+llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+agent = create_openai_functions_agent(llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
 
-template = """You are a helpful assistant who generates comma separated lists.
-A user will pass in a category, and you should generate 5 objects in that category in a comma separated list.
-ONLY return a comma separated list, and nothing more."""
-human_template = "{text}"
 
-chat_prompt = ChatPromptTemplate.from_messages([
-    ("system", template),
-    ("human", human_template),
-])
-category_chain = chat_prompt | ChatOpenAI() | CommaSeparatedListOutputParser()
-
-# 2. App definition
+# 4. App definition
 app = FastAPI(
   title="LangChain Server",
   version="1.0",
-  description="A simple api server using Langchain's Runnable interfaces",
+  description="A simple API server using LangChain's Runnable interfaces",
 )
 
-# 3. Adding chain route
+# 5. Adding chain route
+
+# We need to add these input/output schemas because the current AgentExecutor
+# is lacking in schemas.
+
+class Input(BaseModel):
+    input: str
+    chat_history: List[BaseMessage] = Field(
+        ...,
+        extra={"widget": {"type": "chat", "input": "location"}},
+    )
+
+
+class Output(BaseModel):
+    output: str
+
 add_routes(
     app,
-    category_chain,
-    path="/category_chain",
+    agent_executor.with_types(input_type=Input, output_type=Output),
+    path="/agent",
 )
 
 if __name__ == "__main__":
@@ -369,19 +553,18 @@ we should see our chain being served at localhost:8000.
 ### Playground
 
 Every LangServe service comes with a simple built-in UI for configuring and invoking the application with streaming output and visibility into intermediate steps.
-Head to http://localhost:8000/category_chain/playground/ to try it out!
+Head to http://localhost:8000/agent/playground/ to try it out! Pass in the same question as before - "how can langsmith help with testing?" - and it should respond same as before.
 
 ### Client
 
-Now let's set up a client for programmatically interacting with our service. We can easily do this with the `langserve.RemoteRunnable`.
+Now let's set up a client for programmatically interacting with our service. We can easily do this with the `[langserve.RemoteRunnable](/docs/langserve#client)`.
 Using this, we can interact with the served chain as if it were running client-side.
 
 ```python
 from langserve import RemoteRunnable
 
-remote_chain = RemoteRunnable("http://localhost:8000/category_chain/")
-remote_chain.invoke({"text": "colors"})
-# >> ['red', 'blue', 'green', 'yellow', 'orange']
+remote_chain = RemoteRunnable("http://localhost:8000/agent/")
+remote_chain.invoke({"input": "how can langsmith help with testing?"})
 ```
 
 To learn more about the many other features of LangServe [head here](/docs/langserve).
@@ -390,10 +573,12 @@ To learn more about the many other features of LangServe [head here](/docs/langs
 
 We've touched on how to build an application with LangChain, how to trace it with LangSmith, and how to serve it with LangServe.
 There are a lot more features in all three of these than we can cover here.
-To continue on your journey:
+To continue on your journey, we recommend you read the following (in order):
 
-- Read up on [LangChain Expression Language (LCEL)](/docs/expression_language) to learn how to chain these components together
-- [Dive deeper](/docs/modules/model_io) into LLMs, prompts, and output parsers and learn the other [key components](/docs/modules)
+- All of these features are backed by [LangChain Expression Language (LCEL)](/docs/expression_language) - a way to chain these components together. Check out that documentation to better understand how to create custom chains.
+- [Model IO](/docs/modules/model_io) covers more details of prompts, LLMs, and output parsers.
+- [Retrieval](/docs/modules/data_connection) covers more details of everything related to retrieval
+- [Agents](/docs/modules/agents) covers details of everything related to agents
 - Explore common [end-to-end use cases](/docs/use_cases/qa_structured/sql) and [template applications](/docs/templates)
 - [Read up on LangSmith](/docs/langsmith/), the platform for debugging, testing, monitoring and more
 - Learn more about serving your applications with [LangServe](/docs/langserve)

docs/docs/guides/debugging.md

@@ -12,7 +12,7 @@ Platforms with tracing capabilities like [LangSmith](/docs/langsmith/) and [Wand
 
 For anyone building production-grade LLM applications, we highly recommend using a platform like this.
 
-![LangSmith run](/img/run_details.png)
+![LangSmith run](../../static/img/run_details.png)
 
 ## `set_debug` and `set_verbose`
 

docs/docs/guides/evaluation/comparison/pairwise_string.ipynb

@@ -89,6 +89,7 @@
     "- reference (str) – (Only for the labeled_pairwise_string variant) The reference response.\n",
     "\n",
     "They return a dictionary with the following values:\n",
+    "\n",
     "- value: 'A' or 'B', indicating whether `prediction` or `prediction_b` is preferred, respectively\n",
     "- score: Integer 0 or 1 mapped from the 'value', where a score of 1 would mean that the first `prediction` is preferred, and a score of 0 would mean `prediction_b` is preferred.\n",
     "- reasoning: String \"chain of thought reasoning\" from the LLM generated prior to creating the score"
@@ -159,6 +160,7 @@
     "## Defining the Criteria\n",
     "\n",
     "By default, the LLM is instructed to select the 'preferred' response based on helpfulness, relevance, correctness, and depth of thought. You can customize the criteria by passing in a `criteria` argument, where the criteria could take any of the following forms:\n",
+    "\n",
     "- [`Criteria`](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.criteria.eval_chain.Criteria.html#langchain.evaluation.criteria.eval_chain.Criteria) enum or its string value - to use one of the default criteria and their descriptions\n",
     "- [Constitutional principal](https://api.python.langchain.com/en/latest/chains/langchain.chains.constitutional_ai.models.ConstitutionalPrinciple.html#langchain.chains.constitutional_ai.models.ConstitutionalPrinciple) - use one any of the constitutional principles defined in langchain\n",
     "- Dictionary: a list of custom criteria, where the key is the name of the criteria, and the value is the description.\n",

docs/docs/guides/evaluation/index.mdx

@@ -20,6 +20,21 @@ We also are working to share guides and cookbooks that demonstrate how to use th
 
 - [Chain Comparisons](/docs/guides/evaluation/examples/comparisons): This example uses a comparison evaluator to predict the preferred output. It reviews ways to measure confidence intervals to select statistically significant differences in aggregate preference scores across different models or prompts.
 
+
+## LangSmith Evaluation
+
+LangSmith provides an integrated evaluation and tracing framework that allows you to check for regressions, compare systems, and easily identify and fix any sources of errors and performance issues. Check out the docs on [LangSmith Evaluation](https://docs.smith.langchain.com/category/testing--evaluation) and additional [cookbooks](https://docs.smith.langchain.com/category/langsmith-cookbook) for more detailed information on evaluating your applications.
+
+## LangChain benchmarks
+
+Your application quality is a function both of the LLM you choose and the prompting and data retrieval strategies you employ to provide model contexet. We have published a number of benchmark tasks within the [LangChain Benchmarks](https://langchain-ai.github.io/langchain-benchmarks/) package to grade different LLM systems on tasks such as:
+
+- Agent tool use
+- Retrieval-augmented question-answering
+- Structured Extraction 
+
+Check out the docs for examples and leaderboard information.
+
 ## Reference Docs
 
 For detailed information on the available evaluators, including how to instantiate, configure, and customize them, check out the [reference documentation](https://api.python.langchain.com/en/latest/api_reference.html#module-langchain.evaluation) directly.