undo

.github/CONTRIBUTING.md

@@ -70,18 +70,16 @@ Install Poetry: **[documentation on how to install it](https://python-poetry.org
 ❗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
+### Core vs. Experimental
 
-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.
+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:
+For this quickstart, start with langchain core:
 
 ```bash
 cd libs/langchain
@@ -130,24 +128,6 @@ 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.
 
-### 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.
@@ -331,50 +311,15 @@ what you wanted by clicking the `View deployment` or `Visit Preview` buttons on
 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).
 
-## 📕 Releases & Versioning
+## 🏭 Release Process
 
 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.
+a developer and published to [PyPI](https://pypi.org/project/langchain/).
 
-### `langchain-core`
+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).
 
-`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.
-
-## 🌟 Recognition
+### 🌟 Recognition
 
 If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
 If you have a Twitter account you would like us to mention, please let us know in the PR or through another means.

.github/scripts/check_diff.py

@@ -1,44 +0,0 @@
-import json
-import sys
-
-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]
-            dirs_to_run.update(
-                (f"libs/partners/{partner_dir}", "libs/langchain", "libs/experimental")
-            )
-        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/_compile_integration_test.yml

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

.github/workflows/_lint.yml

@@ -85,37 +85,9 @@ jobs:
         with:
           path: |
             ${{ env.WORKDIR }}/.mypy_cache
-          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', env.WORKDIR)) }}
-
+          key: mypy-${{ 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_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
+          make lint

.github/workflows/_pydantic_compatibility.yml

@@ -1,4 +1,4 @@
-name: dependencies
+name: pydantic v1/v2 compatibility
 
 on:
   workflow_call:
@@ -28,7 +28,7 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
-    name: dependencies - Python ${{ matrix.python-version }}
+    name: Pydantic v1/v2 compatibility - Python ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@v4
 
@@ -44,14 +44,6 @@ 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 }}

.github/workflows/_release.yml

@@ -7,18 +7,6 @@ on:
         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
-          - libs/partners/google-genai
 
 env:
   PYTHON_VERSION: "3.10"

.github/workflows/check_diffs.yml

@@ -1,47 +0,0 @@
----
-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_ci.yml

@@ -1,25 +1,21 @@
 ---
-name: langchain CI
+name: libs/langchain CI
 
 on:
-  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
-
+  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/**"
+      - "libs/core/**"
+  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.
@@ -28,39 +24,43 @@ 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 }}-${{ inputs.working-directory }}
+  group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 env:
   POETRY_VERSION: "1.6.1"
+  WORKDIR: "libs/langchain"
 
 jobs:
   lint:
     uses: ./.github/workflows/_lint.yml
     with:
-      working-directory: ${{ inputs.working-directory }}
+      working-directory: libs/langchain
     secrets: inherit
 
   test:
     uses: ./.github/workflows/_test.yml
     with:
-      working-directory: ${{ inputs.working-directory }}
+      working-directory: libs/langchain
     secrets: inherit
 
   compile-integration-tests:
     uses: ./.github/workflows/_compile_integration_test.yml
     with:
-      working-directory: ${{ inputs.working-directory }}
+      working-directory: libs/langchain
     secrets: inherit
 
-  dependencies:
-    uses: ./.github/workflows/_dependencies.yml
+  pydantic-compatibility:
+    uses: ./.github/workflows/_pydantic_compatibility.yml
     with:
-      working-directory: ${{ inputs.working-directory }}
+      working-directory: libs/langchain
     secrets: inherit
 
   extended-tests:
     runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ${{ env.WORKDIR }}
     strategy:
       matrix:
         python-version:
@@ -69,10 +69,6 @@ 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
 
@@ -81,14 +77,19 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
+          working-directory: libs/langchain
           cache-key: extended
 
       - name: Install dependencies
         shell: bash
         run: |
           echo "Running extended tests, installing dependencies with poetry..."
-          poetry install -E extended_testing --with test
+          poetry install -E extended_testing
+
+      - name: Install langchain core editable
+        shell: bash
+        run: |
+          poetry run pip install -e ../core
 
       - name: Run extended tests
         run: make extended_tests

.github/workflows/langchain_cli_ci.yml

@@ -0,0 +1,47 @@
+---
+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

@@ -1,13 +0,0 @@
----
-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_ci.yml

@@ -0,0 +1,52 @@
+---
+name: libs/langchain core 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_core_ci.yml'
+      - 'libs/core/**'
+  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/core"
+
+jobs:
+  lint:
+    uses:
+      ./.github/workflows/_lint.yml
+    with:
+      working-directory: libs/core
+    secrets: inherit
+
+  test:
+    uses:
+      ./.github/workflows/_test.yml
+    with:
+      working-directory: libs/core
+    secrets: inherit
+
+  pydantic-compatibility:
+    uses:
+      ./.github/workflows/_pydantic_compatibility.yml
+    with:
+      working-directory: libs/core
+    secrets: inherit

.github/workflows/langchain_experimental_ci.yml

@@ -0,0 +1,136 @@
+---
+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/**"
+      - "libs/langchain/**"
+      - "libs/core/**"
+  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
+    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
+          poetry run pip install -e ../core
+
+      - 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

@@ -1,13 +0,0 @@
----
-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,7 +52,13 @@ jobs:
         shell: bash
         run: |
           echo "Running scheduled tests, installing dependencies with poetry..."
-          poetry install --with=test_integration,test
+          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
 
       - name: Run tests
         shell: bash
@@ -62,9 +68,7 @@ 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_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 }}
+          AZURE_OPENAI_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_DEPLOYMENT_NAME }}
           FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
         run: |
           make scheduled_tests

.github/workflows/templates_ci.yml

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

.gitignore

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

Makefile

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

README.md

@@ -3,7 +3,8 @@
 ⚡ 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/check_diffs.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/check_diffs.yml)
+[![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)
 [![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)
@@ -44,10 +45,7 @@ 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.
 
-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.
+**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).**
 
 ![LangChain Stack](docs/static/img/langchain_stack.png)
 

cookbook/LLaMA2_sql_chat.ipynb

@@ -164,8 +164,8 @@
     ")\n",
     "\n",
     "# Chain to query\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
     "\n",
     "sql_response = (\n",
     "    RunnablePassthrough.assign(schema=get_schema)\n",
@@ -293,7 +293,7 @@
     "memory = ConversationBufferMemory(return_messages=True)\n",
     "\n",
     "# Chain to query with memory\n",
-    "from langchain_core.runnables import RunnableLambda\n",
+    "from langchain.schema.runnable import RunnableLambda\n",
     "\n",
     "sql_chain = (\n",
     "    RunnablePassthrough.assign(\n",

cookbook/Multi_modal_RAG.ipynb

@@ -200,7 +200,7 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
     "\n",
     "\n",
     "# Generate summaries of text elements\n",
@@ -270,7 +270,7 @@
     "import base64\n",
     "import os\n",
     "\n",
-    "from langchain_core.messages import HumanMessage\n",
+    "from langchain.schema.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_core.runnables import RunnableLambda, RunnablePassthrough\n",
+    "from langchain.schema.runnable 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_core.output_parsers import StrOutputParser"
+    "from langchain.schema.output_parser 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_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.runnable 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_core.output_parsers import StrOutputParser"
+    "from langchain.schema.output_parser 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_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.runnable 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_core.output_parsers import StrOutputParser"
+    "from langchain.schema.output_parser 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_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.runnable 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_core.output_parsers import StrOutputParser\n",
+    "from langchain.schema.output_parser 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_core.messages import HumanMessage\n",
+    "from langchain.schema.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_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.runnable 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_core.runnables import RunnableLambda\n",
+    "from langchain.schema.runnable import RunnableLambda\n",
     "\n",
     "\n",
     "def looks_like_base64(sb):\n",

cookbook/docugami_xml_kg_rag.ipynb

@@ -63,7 +63,7 @@
     "1. Create an access token via the Developer Playground for your workspace. [Detailed instructions](https://help.docugami.com/home/docugami-api).\n",
     "1. Add your documents (PDF \\[scanned or digital\\], DOC or DOCX) to Docugami for processing. There are two ways to do this:\n",
     "    1. Use the simple Docugami web experience. [Detailed instructions](https://help.docugami.com/home/adding-documents).\n",
-    "    1. Use the [Docugami API](https://api-docs.docugami.com), specifically the [documents](https://api-docs.docugami.com/#tag/documents/operation/upload-document) endpoint. You can also use the [docugami python library](https://pypi.org/project/docugami/) as a convenient wrapper.\n",
+    "    1. Use the [Docugami API](https://api-docs.docugami.com), specifically the [documents](https://api-docs.docugami.com/#tag/documents/operation/upload-document) endpoint. Code samples are available for [python](../upload_file/) and [JavaScript](../../js/upload-file/) or you can use the [docugami](https://pypi.org/project/docugami/) python library.\n",
     "\n",
     "Once your documents are in Docugami, they are processed and organized into sets of similar documents, e.g. NDAs, Lease Agreements, and Service Agreements. Docugami is not limited to any particular types of documents, and the clusters created depend on your particular documents. You can [change the docset assignments](https://help.docugami.com/home/working-with-the-doc-sets-view) later if you wish. You can monitor file status in the simple Docugami webapp, or use a [webhook](https://api-docs.docugami.com/#tag/webhooks) to be informed when your documents are done processing.\n",
     "\n",
@@ -476,7 +476,7 @@
     "    HumanMessagePromptTemplate,\n",
     "    SystemMessagePromptTemplate,\n",
     ")\n",
-    "from langchain_core.output_parsers import StrOutputParser"
+    "from langchain.schema.output_parser import StrOutputParser"
    ]
   },
   {
@@ -547,9 +547,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.chroma import Chroma\n",
-    "from langchain_core.documents import Document\n",
     "\n",
     "\n",
     "def build_retriever(text_elements, tables, table_summaries):\n",
@@ -605,7 +605,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
     "\n",
     "system_prompt = SystemMessagePromptTemplate.from_template(\n",
     "    \"You are a helpful assistant that answers questions based on provided context. Your provided context can include text or tables, \"\n",
@@ -916,20 +916,6 @@
    "source": [
     "llama2_chain.invoke(\"What was the learning rate for LLaMA2?\")"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "94826165",
-   "metadata": {},
-   "source": [
-    "## Docugami KG-RAG Template\n",
-    "\n",
-    "Docugami also provides a [langchain template](https://github.com/docugami/langchain-template-docugami-kg-rag) that you can integrate into your langchain projects.\n",
-    "\n",
-    "Here's a walkthrough of how you can do this.\n",
-    "\n",
-    "[![Docugami KG-RAG Walkthrough](https://img.youtube.com/vi/xOHOmL1NFMg/0.jpg)](https://www.youtube.com/watch?v=xOHOmL1NFMg)\n"
-   ]
   }
  ],
  "metadata": {

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_core.pydantic_v1 import BaseModel"
+    "from langchain.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_core.runnables import Runnable\n",
-    "from langchain_core.pydantic_v1 import BaseModel\n",
+    "from langchain.schema.runnable import Runnable\n",
+    "from langchain.pydantic_v1 import BaseModel\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain_core.messages import SystemMessage\n",
-    "from langchain_core.language_models import BaseLanguageModel\n",
+    "from langchain.schema.messages import SystemMessage\n",
+    "from langchain.schema.language_model import BaseLanguageModel\n",
     "\n",
     "_EXTRACTION_TEMPLATE = \"\"\"Extract and save the relevant entities mentioned \\\n",
     "in the following passage together with their properties.\n",

cookbook/multi_modal_QA.ipynb

@@ -92,7 +92,7 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain_core.messages import HumanMessage, SystemMessage"
+    "from langchain.schema.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 separate cookbook highlights `Options 2 and 3` [here](https://github.com/langchain-ai/langchain/blob/master/cookbook/Multi_modal_RAG.ipynb).\n",
+    "A seperate 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_core.messages import HumanMessage, SystemMessage\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\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",
     "\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, display\n",
+    "from IPython.display import Image\n",
     "from steamship import Block, Steamship"
    ]
   },
@@ -180,7 +180,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.3"
   }
  },
  "nbformat": 4,

cookbook/openai_v1_cookbook.ipynb

@@ -29,7 +29,7 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain_core.messages import HumanMessage, SystemMessage"
+    "from langchain.schema.messages import HumanMessage, SystemMessage"
    ]
   },
   {
@@ -252,7 +252,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_core.agents import AgentFinish\n",
+    "from langchain.schema.agent 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,8 +37,7 @@
    "source": [
     "#!pip install qianfan\n",
     "#!pip install bce-python-sdk\n",
-    "#!pip install elasticsearch == 7.11.0\n",
-    "#!pip install sentence-transformers"
+    "#!pip install elasticsearch == 7.11.0"
    ]
   },
   {
@@ -55,10 +54,8 @@
    "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",
@@ -164,22 +161,15 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
    "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.17"
   },
+  "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
     "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
@@ -187,5 +177,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 2
 }

cookbook/rag_fusion.ipynb

@@ -87,7 +87,7 @@
    "outputs": [],
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
-    "from langchain_core.output_parsers import StrOutputParser"
+    "from langchain.schema.output_parser 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 = song_titles[i].replace(\"'\", \"''\")\n",
+    "    title = 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_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
     "\n",
     "db = SQLDatabase.from_uri(\n",
     "    CONNECTION_STRING\n",
@@ -324,7 +324,7 @@
    "source": [
     "import re\n",
     "\n",
-    "from langchain_core.runnables import RunnableLambda\n",
+    "from langchain.schema.runnable import RunnableLambda\n",
     "\n",
     "\n",
     "def replace_brackets(match):\n",
@@ -681,9 +681,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.8.18"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 2
 }

cookbook/rewrite.ipynb

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

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_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.prompt_values import PromptValue"
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.prompt 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_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnableLambda"
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnableLambda"
    ]
   },
   {

cookbook/wikibase_agent.ipynb

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

docs/.local_build.sh

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

docs/api_reference/conf.py

@@ -136,7 +136,7 @@ html_theme_path = ["themes"]
 # redirects dictionary maps from old links to new links
 html_additional_pages = {}
 redirects = {
-    "index": "langchain_api_reference",
+    "index": "api_reference",
 }
 for old_link in redirects:
     html_additional_pages[old_link] = "redirects.html"

docs/api_reference/create_api_rst.py

@@ -1,18 +1,23 @@
 """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"
+CORE_DIR = ROOT_DIR / "libs" / "core" / "langchain_core"
+WRITE_FILE = HERE / "api_reference.rst"
+EXP_WRITE_FILE = HERE / "experimental_api_reference.rst"
+CORE_WRITE_FILE = HERE / "core_api_reference.rst"
+
 
 ClassKind = Literal["TypedDict", "Regular", "Pydantic", "enum"]
 
@@ -191,15 +196,11 @@ def _load_package_modules(
     return modules_by_namespace
 
 
-def _construct_doc(
-    package_namespace: str,
-    members_by_namespace: Dict[str, ModuleMembers],
-    package_version: str,
-) -> str:
+def _construct_doc(pkg: str, members_by_namespace: Dict[str, ModuleMembers]) -> str:
     """Construct the contents of the reference.rst file for the given package.
 
     Args:
-        package_namespace: The package top level namespace
+        pkg: The package name
         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.
@@ -209,7 +210,7 @@ def _construct_doc(
     """
     full_doc = f"""\
 =======================
-``{package_namespace}`` {package_version}
+``{pkg}`` API Reference
 =======================
 
 """
@@ -221,13 +222,13 @@ def _construct_doc(
         functions = _members["functions"]
         if not (classes or functions):
             continue
-        section = f":mod:`{package_namespace}.{module}`"
+        section = f":mod:`{pkg}.{module}`"
         underline = "=" * (len(section) + 1)
         full_doc += f"""\
 {section}
 {underline}
 
-.. automodule:: {package_namespace}.{module}
+.. automodule:: {pkg}.{module}
     :no-members:
     :no-inherited-members:
 
@@ -237,7 +238,7 @@ def _construct_doc(
             full_doc += f"""\
 Classes
 --------------
-.. currentmodule:: {package_namespace}
+.. currentmodule:: {pkg}
 
 .. autosummary::
     :toctree: {module}
@@ -269,7 +270,7 @@ Classes
             full_doc += f"""\
 Functions
 --------------
-.. currentmodule:: {package_namespace}
+.. currentmodule:: {pkg}
 
 .. autosummary::
     :toctree: {module}
@@ -281,71 +282,57 @@ Functions
     return full_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_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 _package_namespace(package_name: str) -> str:
-    return (
-        package_name
-        if package_name == "langchain"
-        else f"langchain_{package_name.replace('-', '_')}"
+def _document_langchain_core() -> None:
+    """Document the langchain_core package."""
+    # Generate core_api_reference.rst
+    core_members = _load_package_modules(CORE_DIR)
+    core_doc = ".. _core_api_reference:\n\n" + _construct_doc(
+        "langchain_core", core_members
+    )
+    with open(CORE_WRITE_FILE, "w") as f:
+        f.write(core_doc)
+
+
+def _document_langchain() -> 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"],
+        }
     )
 
+    lc_doc = ".. _api_reference:\n\n" + _construct_doc("langchain", lc_members)
 
-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"
+    with open(WRITE_FILE, "w") as f:
+        f.write(lc_doc)
 
 
 def main() -> None:
-    """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)
+    """Generate the reference.rst file for each package."""
+    _document_langchain()
+    _document_langchain_experimental()
+    _document_langchain_core()
 
 
 if __name__ == "__main__":

docs/api_reference/requirements.txt

@@ -1,8 +1,6 @@
--e libs/experimental
 -e libs/langchain
+-e libs/experimental
 -e libs/core
--e libs/community
--e libs/partners/google-genai
 pydantic<2
 autodoc_pydantic==1.8.0
 myst_parser
@@ -15,4 +13,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,6 +63,13 @@
             <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

@@ -6,11 +6,6 @@
   {%- set top_container_cls = "sk-landing-container" %}
 {%- endif %}
 
-{# title, link, link_attrs #}
-{%- set drop_down_navigation = [
-  ('Google Generative AI', pathto('google_genai_api_reference'), ''),]
--%}
-
 <nav id="navbar" class="{{ nav_bar_class }} navbar navbar-expand-md navbar-light bg-light py-0">
   <div class="container-fluid {{ top_container_cls }} px-0">
     {%- if logo_url %}
@@ -37,33 +32,22 @@
     <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('langchain_api_reference') }}">LangChain</a>
+          <a class="sk-nav-link nav-link" href="{{ pathto('api_reference') }}">API</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>
+          <a class="sk-nav-link nav-link" href="{{ pathto('experimental_api_reference') }}">Experimental</a>
         </li>
         <li class="nav-item">
-          <a class="sk-nav-link nav-link" href="{{ pathto('experimental_api_reference') }}">Experimental</a>
+          <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>
         </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, link, link_attrs in drop_down_navigation %}
-              <a class="sk-nav-dropdown-item dropdown-item" href="{{ link }}" {{ link_attrs }}>{{ 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/expression_language/cookbook/code_writing.ipynb

@@ -21,7 +21,7 @@
     "from langchain.prompts import (\n",
     "    ChatPromptTemplate,\n",
     ")\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain.schema.output_parser 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/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_core.runnables import RunnableLambda, RunnablePassthrough\n",
+    "from langchain.schema.runnable 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_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.runnable 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. [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",
+    "You may want the output of one component to be processed by 2 or more other components. [RunnableMaps](https://api.python.langchain.com/en/latest/schema/langchain.schema.runnable.base.RunnableMap.html) let you split or fork the chain so multiple components can process the input in parallel. Later, other components can join or merge the results to synthesize a final response. This type of chain creates a computation graph that looks like the following:\n",
     "\n",
     "```text\n",
     "     Input\n",

docs/docs/expression_language/cookbook/prompt_llm_parser.ipynb

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

docs/docs/expression_language/cookbook/prompt_size.ipynb

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

docs/docs/expression_language/cookbook/retrieval.ipynb

@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 10,
    "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.vectorstores import FAISS\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough"
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnableLambda, RunnablePassthrough\n",
+    "from langchain.vectorstores import FAISS"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "id": "bfc47ec1",
    "metadata": {},
    "outputs": [],
@@ -70,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "eae31755",
    "metadata": {},
    "outputs": [],
@@ -85,7 +85,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 18,
    "id": "f3040b0c",
    "metadata": {},
    "outputs": [
@@ -95,7 +95,7 @@
        "'Harrison worked at Kensho.'"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -106,7 +106,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "e1d20c7c",
    "metadata": {},
    "outputs": [],
@@ -134,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "7ee8b2d4",
    "metadata": {},
    "outputs": [
@@ -144,7 +144,7 @@
        "'Harrison ha lavorato a Kensho.'"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -165,19 +165,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 8,
    "id": "3f30c348",
    "metadata": {},
    "outputs": [],
    "source": [
     "from langchain.schema import format_document\n",
-    "from langchain_core.messages import AIMessage, HumanMessage, get_buffer_string\n",
-    "from langchain_core.runnables import RunnableParallel"
+    "from langchain.schema.runnable import RunnableMap"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "id": "64ab1dbf",
    "metadata": {},
    "outputs": [],
@@ -195,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "7d628c97",
    "metadata": {},
    "outputs": [],
@@ -210,7 +209,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "f60a5d0f",
    "metadata": {},
    "outputs": [],
@@ -227,14 +226,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "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, str]]) -> str:\n",
+    "    # chat history is of format:\n",
+    "    # [\n",
+    "    #   (human_message_str, ai_message_str),\n",
+    "    #   ...\n",
+    "    # ]\n",
+    "    # see below for an example of how it's invoked\n",
+    "    buffer = \"\"\n",
+    "    for dialogue_turn in chat_history:\n",
+    "        human = \"Human: \" + dialogue_turn[0]\n",
+    "        ai = \"Assistant: \" + dialogue_turn[1]\n",
+    "        buffer += \"\\n\" + \"\\n\".join([human, ai])\n",
+    "    return buffer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
    "id": "5c32cc89",
    "metadata": {},
    "outputs": [],
    "source": [
-    "_inputs = RunnableParallel(\n",
+    "_inputs = RunnableMap(\n",
     "    standalone_question=RunnablePassthrough.assign(\n",
-    "        chat_history=lambda x: get_buffer_string(x[\"chat_history\"])\n",
+    "        chat_history=lambda x: _format_chat_history(x[\"chat_history\"])\n",
     "    )\n",
     "    | CONDENSE_QUESTION_PROMPT\n",
     "    | ChatOpenAI(temperature=0)\n",
@@ -249,17 +273,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 14,
    "id": "135c8205",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='Harrison was employed at Kensho.')"
+       "AIMessage(content='Harrison was employed at Kensho.', additional_kwargs={}, example=False)"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -275,17 +299,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 15,
    "id": "424e7e7a",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content='Harrison worked at Kensho.')"
+       "AIMessage(content='Harrison worked at Kensho.', additional_kwargs={}, example=False)"
       ]
      },
-     "execution_count": 22,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -294,10 +318,7 @@
     "conversational_qa_chain.invoke(\n",
     "    {\n",
     "        \"question\": \"where did he work?\",\n",
-    "        \"chat_history\": [\n",
-    "            HumanMessage(content=\"Who wrote this notebook?\"),\n",
-    "            AIMessage(content=\"Harrison\"),\n",
-    "        ],\n",
+    "        \"chat_history\": [(\"Who wrote this notebook?\", \"Harrison\")],\n",
     "    }\n",
     ")"
    ]
@@ -314,7 +335,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 16,
    "id": "e31dd17c",
    "metadata": {},
    "outputs": [],
@@ -326,7 +347,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 17,
    "id": "d4bffe94",
    "metadata": {},
    "outputs": [],
@@ -338,7 +359,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 18,
    "id": "733be985",
    "metadata": {},
    "outputs": [],
@@ -352,7 +373,7 @@
     "standalone_question = {\n",
     "    \"standalone_question\": {\n",
     "        \"question\": lambda x: x[\"question\"],\n",
-    "        \"chat_history\": lambda x: get_buffer_string(x[\"chat_history\"]),\n",
+    "        \"chat_history\": lambda x: _format_chat_history(x[\"chat_history\"]),\n",
     "    }\n",
     "    | CONDENSE_QUESTION_PROMPT\n",
     "    | ChatOpenAI(temperature=0)\n",
@@ -379,18 +400,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 19,
    "id": "806e390c",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'answer': AIMessage(content='Harrison was employed at Kensho.'),\n",
-       " 'docs': [Document(page_content='harrison worked at kensho')]}"
+       "{'answer': AIMessage(content='Harrison was employed at Kensho.', additional_kwargs={}, example=False),\n",
+       " 'docs': [Document(page_content='harrison worked at kensho', metadata={})]}"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -403,7 +424,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 20,
    "id": "977399fd",
    "metadata": {},
    "outputs": [],
@@ -416,18 +437,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 21,
    "id": "f94f7de4",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'history': [HumanMessage(content='where did harrison work?'),\n",
-       "  AIMessage(content='Harrison was employed at Kensho.')]}"
+       "{'history': [HumanMessage(content='where did harrison work?', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='Harrison was employed at Kensho.', additional_kwargs={}, example=False)]}"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -435,38 +456,6 @@
    "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": {
@@ -485,7 +474,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.1"
+   "version": "3.9.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_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnablePassthrough\n",
     "\n",
     "model = ChatOpenAI()\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.tools import DuckDuckGoSearchRun\n",
-    "from langchain_core.output_parsers import StrOutputParser"
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.tools import DuckDuckGoSearchRun"
    ]
   },
   {

docs/docs/expression_language/get_started.ipynb

@@ -13,7 +13,6 @@
   },
   {
    "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."
@@ -49,7 +48,7 @@
    "source": [
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
     "\n",
     "prompt = ChatPromptTemplate.from_template(\"tell me a short joke about {topic}\")\n",
     "model = ChatOpenAI()\n",
@@ -78,7 +77,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "aa1b77fa",
    "metadata": {},
    "source": [
     "### 1. Prompt\n",
@@ -89,7 +87,6 @@
   {
    "cell_type": "code",
    "execution_count": 8,
-   "id": "b8656990",
    "metadata": {},
    "outputs": [
     {
@@ -111,7 +108,6 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "id": "e6034488",
    "metadata": {},
    "outputs": [
     {
@@ -132,7 +128,6 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "id": "60565463",
    "metadata": {},
    "outputs": [
     {
@@ -152,7 +147,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "577f0f76",
    "metadata": {},
    "source": [
     "### 2. Model\n",
@@ -163,7 +157,6 @@
   {
    "cell_type": "code",
    "execution_count": 11,
-   "id": "33cf5f72",
    "metadata": {},
    "outputs": [
     {
@@ -184,7 +177,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "327e7db8",
    "metadata": {},
    "source": [
     "If our `model` was an `LLM`, it would output a string."
@@ -193,7 +185,6 @@
   {
    "cell_type": "code",
    "execution_count": 12,
-   "id": "8feb05da",
    "metadata": {},
    "outputs": [
     {
@@ -216,7 +207,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "91847478",
    "metadata": {},
    "source": [
     "### 3. Output parser\n",
@@ -228,7 +218,6 @@
   {
    "cell_type": "code",
    "execution_count": 13,
-   "id": "533e59a8",
    "metadata": {},
    "outputs": [
     {
@@ -248,7 +237,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "9851e842",
    "metadata": {},
    "source": [
     "### 4. Entire Pipeline\n",
@@ -263,7 +251,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "c4873109",
    "metadata": {},
    "source": [
     "```mermaid\n",
@@ -277,7 +264,6 @@
   },
   {
    "cell_type": "markdown",
-   "id": "fe63534d",
    "metadata": {},
    "source": [
     ":::info\n",
@@ -321,14 +307,14 @@
    "outputs": [],
    "source": [
     "# Requires:\n",
-    "# pip install langchain docarray tiktoken\n",
+    "# pip install langchain docarray\n",
     "\n",
     "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 RunnableParallel, RunnablePassthrough\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",
@@ -459,14 +445,12 @@
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "8c2438df-164e-4bbe-b5f4-461695e45b0f",
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ffdde6e-67c9-430d-ac14-28f18f01de04",
    "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."
-   ]
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -485,7 +469,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/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_core.runnables import RunnablePassthrough"
+    "from langchain.schema.runnable import RunnablePassthrough"
    ]
   },
   {

docs/docs/expression_language/how_to/configure.ipynb

@@ -43,7 +43,6 @@
    "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",
@@ -265,7 +264,7 @@
    "source": [
     "from langchain.chat_models import ChatAnthropic, ChatOpenAI\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain_core.runnables import ConfigurableField"
+    "from langchain.schema.runnable import ConfigurableField"
    ]
   },
   {
@@ -595,7 +594,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/fallbacks.ipynb

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

docs/docs/expression_language/how_to/functions.ipynb

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

docs/docs/expression_language/how_to/generators.ipynb

@@ -17,13 +17,6 @@
     "Let's implement a custom output parser for comma-separated lists."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Sync version"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -34,7 +27,7 @@
     "\n",
     "from langchain.chat_models import ChatOpenAI\n",
     "from langchain.prompts.chat import ChatPromptTemplate\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
     "\n",
     "prompt = ChatPromptTemplate.from_template(\n",
     "    \"Write a comma-separated list of 5 animals similar to: {animal}\"\n",
@@ -64,7 +57,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -73,7 +66,7 @@
        "'lion, tiger, wolf, gorilla, panda'"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -159,81 +152,12 @@
     "list_chain.invoke({\"animal\": \"bear\"})"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Async version"
-   ]
-  },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "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\"})"
-   ]
+   "source": []
   }
  ],
  "metadata": {
@@ -252,7 +176,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/map.ipynb

@@ -1,29 +1,56 @@
 {
  "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": [
-    "# Manipulating inputs & output\n",
+    "# Parallelize steps\n",
     "\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",
+    "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",
     "\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",
+    "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",
-    "\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."
    ]
   },
   {
@@ -44,12 +71,10 @@
     }
    ],
    "source": [
-    "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 RunnablePassthrough\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",
@@ -61,7 +86,6 @@
     "Question: {question}\n",
     "\"\"\"\n",
     "prompt = ChatPromptTemplate.from_template(template)\n",
-    "model = ChatOpenAI()\n",
     "\n",
     "retrieval_chain = (\n",
     "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
@@ -78,133 +102,9 @@
    "id": "392cd4c4-e7ed-4ab8-934d-f7a4eca55ee1",
    "metadata": {},
    "source": [
-    "::: {.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",
+    "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",
-    "```\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\"})"
+    "Note that when composing a RunnableMap with another Runnable we don't even need to wrap our dictionary in the RunnableMap class — the type conversion is handled for us."
    ]
   },
   {
@@ -214,7 +114,7 @@
    "source": [
     "## Parallelism\n",
     "\n",
-    "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."
+    "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."
    ]
   },
   {
@@ -294,7 +194,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.6"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/message_history.ipynb

@@ -10,13 +10,11 @@
     "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",
@@ -134,8 +132,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_core.chat_history import BaseChatMessageHistory\n",
-    "from langchain_core.runnables.history import RunnableWithMessageHistory"
+    "from langchain.schema.chat_history import BaseChatMessageHistory\n",
+    "from langchain.schema.runnable.history import RunnableWithMessageHistory"
    ]
   },
   {
@@ -253,10 +251,7 @@
    "id": "da3d1feb-b4bb-4624-961c-7db2e1180df7",
    "metadata": {},
    "source": [
-    ":::tip\n",
-    "\n",
-    "[Langsmith trace](https://smith.langchain.com/public/863a003b-7ca8-4b24-be9e-d63ec13c106e/r)\n",
-    "\n",
+    ":::tip [Langsmith trace](https://smith.langchain.com/public/863a003b-7ca8-4b24-be9e-d63ec13c106e/r)\n",
     ":::"
    ]
   },
@@ -294,10 +289,10 @@
     }
    ],
    "source": [
-    "from langchain_core.messages import HumanMessage\n",
-    "from langchain_core.runnables import RunnableParallel\n",
+    "from langchain.schema.messages import HumanMessage\n",
+    "from langchain.schema.runnable import RunnableMap\n",
     "\n",
-    "chain = RunnableParallel({\"output_message\": ChatAnthropic(model=\"claude-2\")})\n",
+    "chain = RunnableMap({\"output_message\": ChatAnthropic(model=\"claude-2\")})\n",
     "chain_with_history = RunnableWithMessageHistory(\n",
     "    chain,\n",
     "    lambda session_id: RedisChatMessageHistory(session_id, url=REDIS_URL),\n",
@@ -339,10 +334,7 @@
    "id": "b898d1b1-11e6-4d30-a8dd-cc5e45533611",
    "metadata": {},
    "source": [
-    ":::tip\n",
-    "\n",
-    "[LangSmith trace](https://smith.langchain.com/public/f6c3e1d1-a49d-4955-a9fa-c6519df74fa7/r)\n",
-    "\n",
+    ":::tip [LangSmith trace](https://smith.langchain.com/public/f6c3e1d1-a49d-4955-a9fa-c6519df74fa7/r)\n",
     ":::"
    ]
   },

docs/docs/expression_language/how_to/passthrough.ipynb

@@ -1,159 +0,0 @@
-{
- "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,16 +1,5 @@
 {
  "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",
@@ -53,7 +42,7 @@
    "source": [
     "from langchain.chat_models import ChatAnthropic\n",
     "from langchain.prompts import PromptTemplate\n",
-    "from langchain_core.output_parsers import StrOutputParser"
+    "from langchain.schema.output_parser import StrOutputParser"
    ]
   },
   {
@@ -74,7 +63,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",
@@ -164,7 +153,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_core.runnables import RunnableBranch\n",
+    "from langchain.schema.runnable import RunnableBranch\n",
     "\n",
     "branch = RunnableBranch(\n",
     "    (lambda x: \"anthropic\" in x[\"topic\"].lower(), anthropic_chain),\n",
@@ -279,7 +268,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_core.runnables import RunnableLambda\n",
+    "from langchain.schema.runnable import RunnableLambda\n",
     "\n",
     "full_chain = {\"topic\": chain, \"question\": lambda x: x[\"question\"]} | RunnableLambda(\n",
     "    route\n",
@@ -304,7 +293,7 @@
     }
    ],
    "source": [
-    "full_chain.invoke({\"question\": \"how do I use Anthropic?\"})"
+    "full_chain.invoke({\"question\": \"how do I use Anthroipc?\"})"
    ]
   },
   {

docs/docs/expression_language/interface.ipynb

@@ -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/stable/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.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/latest/schema/langchain.schema.runnable.base.Runnable.html#langchain.schema.runnable.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_core.runnables import RunnableParallel\n",
+    "from langchain.schema.runnable 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,20 +29,6 @@ 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:
@@ -75,4 +61,4 @@ If not using LangChain, install with:
 
 ```bash
 pip install langsmith
-```
+```

docs/docs/get_started/introduction.mdx

@@ -29,11 +29,6 @@ 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.

docs/docs/get_started/quickstart.mdx

@@ -344,7 +344,7 @@ category_chain = chat_prompt | ChatOpenAI() | CommaSeparatedListOutputParser()
 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

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](../../static/img/run_details.png)
+![LangSmith run](/img/run_details.png)
 
 ## `set_debug` and `set_verbose`
 

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

@@ -89,7 +89,6 @@
     "- 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"
@@ -160,7 +159,6 @@
     "## 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/string/json.ipynb

@@ -5,13 +5,13 @@
    "id": "465cfbef-5bba-4b3b-b02d-fe2eba39db17",
    "metadata": {},
    "source": [
-    "# JSON Evaluators\n",
+    "# Evaluating Structured Output: JSON Evaluators\n",
     "\n",
-    "Evaluating [extraction](https://python.langchain.com/docs/use_cases/extraction) and function calling applications often comes down to validation that the LLM's string output can be parsed correctly and how it compares to a reference object. The following `JSON` validators provide functionality to check your model's output consistently.\n",
+    "Evaluating [extraction](https://python.langchain.com/docs/use_cases/extraction) and function calling applications often comes down to validation that the LLM's string output can be parsed correctly and how it compares to a reference object. The following JSON validators provide provide functionality to check your model's output in a consistent way.\n",
     "\n",
     "## JsonValidityEvaluator\n",
     "\n",
-    "The `JsonValidityEvaluator` is designed to check the validity of a `JSON` string prediction.\n",
+    "The `JsonValidityEvaluator` is designed to check the validity of a JSON string prediction.\n",
     "\n",
     "### Overview:\n",
     "- **Requires Input?**: No\n",
@@ -377,7 +377,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.2"
   }
  },
  "nbformat": 4,

docs/docs/guides/evaluation/string/string_distance.ipynb

@@ -8,12 +8,9 @@
     "# String Distance\n",
     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/docs/guides/evaluation/string/string_distance.ipynb)\n",
     "\n",
-    ">In information theory, linguistics, and computer science, the [Levenshtein distance (Wikipedia)](https://en.wikipedia.org/wiki/Levenshtein_distance) is a string metric for measuring the difference between two sequences. Informally, the Levenshtein distance between two words is the minimum number of single-character edits (insertions, deletions or substitutions) required to change one word into the other. It is named after the Soviet mathematician Vladimir Levenshtein, who considered this distance in 1965.\n",
+    "One of the simplest ways to compare an LLM or chain's string output against a reference label is by using string distance measurements such as Levenshtein or postfix distance.  This can be used alongside approximate/fuzzy matching criteria for very basic unit testing.\n",
     "\n",
-    "\n",
-    "One of the simplest ways to compare an LLM or chain's string output against a reference label is by using string distance measurements such as `Levenshtein` or `postfix` distance.  This can be used alongside approximate/fuzzy matching criteria for very basic unit testing.\n",
-    "\n",
-    "This can be accessed using the `string_distance` evaluator, which uses distance metrics from the [rapidfuzz](https://github.com/maxbachmann/RapidFuzz) library.\n",
+    "This can be accessed using the `string_distance` evaluator, which uses distance metric's from the [rapidfuzz](https://github.com/maxbachmann/RapidFuzz) library.\n",
     "\n",
     "**Note:** The returned scores are _distances_, meaning lower is typically \"better\".\n",
     "\n",
@@ -216,9 +213,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.2"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

docs/docs/guides/fallbacks.ipynb

@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 18,
    "id": "d3e893bf",
    "metadata": {},
    "outputs": [],
@@ -46,24 +46,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 21,
    "id": "dfdd8bf5",
    "metadata": {},
    "outputs": [],
    "source": [
     "from unittest.mock import patch\n",
     "\n",
-    "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=\"\")"
+    "from openai.error import RateLimitError"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 24,
    "id": "e6fdffc1",
    "metadata": {},
    "outputs": [],
@@ -76,7 +71,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 27,
    "id": "584461ab",
    "metadata": {},
    "outputs": [
@@ -90,10 +85,10 @@
    ],
    "source": [
     "# Let's use just the OpenAI LLm first, to show that we run into an error\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(openai_llm.invoke(\"Why did the chicken cross the road?\"))\n",
-    "    except RateLimitError:\n",
+    "    except:\n",
     "        print(\"Hit error\")"
    ]
   },
@@ -113,10 +108,10 @@
    ],
    "source": [
     "# Now let's try with fallbacks to Anthropic\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(llm.invoke(\"Why did the chicken cross the road?\"))\n",
-    "    except RateLimitError:\n",
+    "    except:\n",
     "        print(\"Hit error\")"
    ]
   },
@@ -155,10 +150,10 @@
     "    ]\n",
     ")\n",
     "chain = prompt | llm\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
+    "with patch(\"openai.ChatCompletion.create\", side_effect=RateLimitError()):\n",
     "    try:\n",
     "        print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
-    "    except RateLimitError:\n",
+    "    except:\n",
     "        print(\"Hit error\")"
    ]
   },
@@ -181,7 +176,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_core.output_parsers import StrOutputParser\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
     "\n",
     "chat_prompt = ChatPromptTemplate.from_messages(\n",
     "    [\n",
@@ -436,7 +431,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/guides/local_llms.ipynb

@@ -32,7 +32,7 @@
     "1. `Base model`: What is the base-model and how was it trained?\n",
     "2. `Fine-tuning approach`: Was the base-model fine-tuned and, if so, what [set of instructions](https://cameronrwolfe.substack.com/p/beyond-llama-the-power-of-open-llms#%C2%A7alpaca-an-instruction-following-llama-model) was used?\n",
     "\n",
-    "![Image description](../../static/img/OSS_LLM_overview.png)\n",
+    "![Image description](/img/OSS_LLM_overview.png)\n",
     "\n",
     "The relative performance of these models can be assessed using several leaderboards, including:\n",
     "\n",
@@ -55,7 +55,7 @@
     "\n",
     "In particular, see [this excellent post](https://finbarr.ca/how-is-llama-cpp-possible/) on the importance of quantization.\n",
     "\n",
-    "![Image description](../../static/img/llama-memory-weights.png)\n",
+    "![Image description](/img/llama-memory-weights.png)\n",
     "\n",
     "With less precision, we radically decrease the memory needed to store the LLM in memory.\n",
     "\n",
@@ -63,13 +63,13 @@
     "\n",
     "A Mac M2 Max is 5-6x faster than a M1 for inference due to the larger GPU memory bandwidth.\n",
     "\n",
-    "![Image description](../../static/img/llama_t_put.png)\n",
+    "![Image description](/img/llama_t_put.png)\n",
     "\n",
     "## Quickstart\n",
     "\n",
     "[`Ollama`](https://ollama.ai/) is one way to easily run inference on macOS.\n",
     " \n",
-    "The instructions [here](https://github.com/jmorganca/ollama?tab=readme-ov-file#ollama) provide details, which we summarize:\n",
+    "The instructions [here](docs/integrations/llms/ollama) provide details, which we summarize:\n",
     " \n",
     "* [Download and run](https://ollama.ai/download) the app\n",
     "* From command line, fetch a model from this [list of options](https://github.com/jmorganca/ollama): e.g., `ollama pull llama2`\n",
@@ -197,10 +197,10 @@
     "\n",
     "### Ollama\n",
     "\n",
-    "With [Ollama](https://github.com/jmorganca/ollama), fetch a model via `ollama pull <model family>:<tag>`:\n",
+    "With [Ollama](docs/integrations/llms/ollama), fetch a model via `ollama pull <model family>:<tag>`:\n",
     "\n",
     "* E.g., for Llama-7b: `ollama pull llama2` will download the most basic version of the model (e.g., smallest # parameters and 4 bit quantization)\n",
-    "* We can also specify a particular version from the [model list](https://github.com/jmorganca/ollama?tab=readme-ov-file#model-library), e.g., `ollama pull llama2:13b`\n",
+    "* We can also specify a particular version from the [model list](https://github.com/jmorganca/ollama), e.g., `ollama pull llama2:13b`\n",
     "* See the full set of parameters on the [API reference page](https://api.python.langchain.com/en/latest/llms/langchain.llms.ollama.Ollama.html)"
    ]
   },
@@ -249,17 +249,14 @@
     "* Meaning: Only one layer of the model will be loaded into GPU memory (1 is often sufficient).\n",
     "\n",
     "`n_batch`: number of tokens the model should process in parallel \n",
-    "\n",
     "* Value: n_batch\n",
     "* Meaning: It's recommended to choose a value between 1 and n_ctx (which in this case is set to 2048)\n",
     "\n",
-    "`n_ctx`: Token context window\n",
-    "\n",
+    "`n_ctx`: Token context window .\n",
     "* Value: 2048\n",
     "* Meaning: The model will consider a window of 2048 tokens at a time\n",
     "\n",
     "`f16_kv`: whether the model should use half-precision for the key/value cache\n",
-    "\n",
     "* Value: True\n",
     "* Meaning: The model will use half-precision, which can be more memory efficient; Metal only supports True."
    ]
@@ -287,8 +284,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.callbacks.manager import CallbackManager\n",
-    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
     "from langchain.llms import LlamaCpp\n",
     "\n",
     "llm = LlamaCpp(\n",
@@ -611,7 +606,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.1"
   }
  },
  "nbformat": 4,

docs/docs/guides/privacy/presidio_data_anonymization/index.ipynb

@@ -8,8 +8,6 @@
     "\n",
     "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/langchain-ai/langchain/blob/master/docs/docs/guides/privacy/presidio_data_anonymization/index.ipynb)\n",
     "\n",
-    ">[Presidio](https://microsoft.github.io/presidio/) (Origin from Latin praesidium ‘protection, garrison’) helps to ensure sensitive data is properly managed and governed. It provides fast identification and anonymization modules for private entities in text and images such as credit card numbers, names, locations, social security numbers, bitcoin wallets, US phone numbers, financial data and more.\n",
-    "\n",
     "## Use case\n",
     "\n",
     "Data anonymization is crucial before passing information to a language model like GPT-4 because it helps protect privacy and maintain confidentiality. If data is not anonymized, sensitive information such as names, addresses, contact numbers, or other identifiers linked to specific individuals could potentially be learned and misused. Hence, by obscuring or removing this personally identifiable information (PII), data can be used freely without compromising individuals' privacy rights or breaching data protection laws and regulations.\n",
@@ -532,7 +530,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/guides/privacy/presidio_data_anonymization/qa_privacy_protection.ipynb

@@ -60,7 +60,7 @@
     "\n",
     " Firstly, the wallet contains my credit card with number 4111 1111 1111 1111, which is registered under my name and linked to my bank account, PL61109010140000071219812874.\n",
     "\n",
-    " Additionally, the wallet had a driver's license - DL No: 999000680 issued to my name. It also houses my Social Security Number, 602-76-4532.\n",
+    " Additionally, the wallet had a driver's license - DL No: 999000680 issued to my name. It also houses my Social Security Number, 602-76-4532. \n",
     "\n",
     " What's more, I had my polish identity card there, with the number ABC123456.\n",
     "\n",
@@ -68,7 +68,7 @@
     "\n",
     " In case any information arises regarding my wallet, please reach out to me on my phone number, 999-888-7777, or through my personal email, johndoe@example.com.\n",
     "\n",
-    " Please consider this information to be highly confidential and respect my privacy.\n",
+    " Please consider this information to be highly confidential and respect my privacy. \n",
     "\n",
     " The bank has been informed about the stolen credit card and necessary actions have been taken from their end. They will be reachable at their official email, support@bankname.com.\n",
     " My representative there is Victoria Cherry (her business phone: 987-654-3210).\n",
@@ -666,12 +666,8 @@
     "\n",
     "from langchain.chat_models.openai import ChatOpenAI\n",
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import (\n",
-    "    RunnableLambda,\n",
-    "    RunnableParallel,\n",
-    "    RunnablePassthrough,\n",
-    ")\n",
+    "from langchain.schema.output_parser import StrOutputParser\n",
+    "from langchain.schema.runnable import RunnableLambda, RunnableMap, RunnablePassthrough\n",
     "\n",
     "# 6. Create anonymizer chain\n",
     "template = \"\"\"Answer the question based only on the following context:\n",
@@ -684,7 +680,7 @@
     "model = ChatOpenAI(temperature=0.3)\n",
     "\n",
     "\n",
-    "_inputs = RunnableParallel(\n",
+    "_inputs = RunnableMap(\n",
     "    question=RunnablePassthrough(),\n",
     "    # It is important to remember about question anonymization\n",
     "    anonymized_question=RunnableLambda(anonymizer.anonymize),\n",
@@ -886,7 +882,7 @@
     "\n",
     "\n",
     "chain_with_deanonymization = (\n",
-    "    RunnableParallel({\"question\": RunnablePassthrough()})\n",
+    "    RunnableMap({\"question\": RunnablePassthrough()})\n",
     "    | {\n",
     "        \"context\": itemgetter(\"question\")\n",
     "        | retriever\n",

docs/docs/guides/pydantic_compatibility.md

@@ -73,7 +73,7 @@ CustomTool(
 **YES**
 
 ```python
-from langchain_core.tools import Tool
+from langchain.tools.base import Tool
 from pydantic.v1 import BaseModel, Field # <-- Uses v1 namespace
 
 class CalculatorInput(BaseModel):
@@ -90,7 +90,7 @@ Tool.from_function( # <-- tool uses v1 namespace
 **NO**
 
 ```python
-from langchain_core.tools import Tool
+from langchain.tools.base import Tool
 from pydantic import BaseModel, Field # <-- Uses v2 namespace
 
 class CalculatorInput(BaseModel):

docs/docs/guides/safety/amazon_comprehend_chain.ipynb

@@ -7,9 +7,7 @@
    "source": [
     "# Amazon Comprehend Moderation Chain\n",
     "\n",
-    ">[Amazon Comprehend](https://aws.amazon.com/comprehend/) is a natural-language processing (NLP) service that uses machine learning to uncover valuable insights and connections in text.\n",
-    "\n",
-    "This notebook shows how to use `Amazon Comprehend` to detect and handle `Personally Identifiable Information` (`PII`) and toxicity.\n",
+    "This notebook shows how to use [Amazon Comprehend](https://aws.amazon.com/comprehend/) to detect and handle `Personally Identifiable Information` (`PII`) and toxicity.\n",
     "\n",
     "## Setting up"
    ]
@@ -1419,7 +1417,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/adapters/openai-old.ipynb

@@ -1,285 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "700a516b",
-   "metadata": {},
-   "source": [
-    "# OpenAI Adapter(Old)\n",
-    "\n",
-    "**Please ensure OpenAI library is less than 1.0.0; otherwise, refer to the newer doc [OpenAI Adapter](./openai).**\n",
-    "\n",
-    "A lot of people get started with OpenAI but want to explore other models. LangChain's integrations with many model providers make this easy to do so. While LangChain has it's own message and model APIs, we've also made it as easy as possible to explore other models by exposing an adapter to adapt LangChain models to the OpenAI api.\n",
-    "\n",
-    "At the moment this only deals with output and does not return other information (token counts, stop reasons, etc)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "6017f26a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import openai\n",
-    "from langchain.adapters import openai as lc_openai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b522ceda",
-   "metadata": {},
-   "source": [
-    "## ChatCompletion.create"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 29,
-   "id": "1d22eb61",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "messages = [{\"role\": \"user\", \"content\": \"hi\"}]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d550d3ad",
-   "metadata": {},
-   "source": [
-    "Original OpenAI call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "012d81ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
-      ]
-     },
-     "execution_count": 15,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "result = openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
-    ")\n",
-    "result[\"choices\"][0][\"message\"].to_dict_recursive()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "db5b5500",
-   "metadata": {},
-   "source": [
-    "LangChain OpenAI wrapper call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "c67a5ac8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lc_result = lc_openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
-    ")\n",
-    "lc_result[\"choices\"][0][\"message\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "034ba845",
-   "metadata": {},
-   "source": [
-    "Swapping out model providers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "f7c94827",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': ' Hello!'}"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lc_result = lc_openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"claude-2\", temperature=0, provider=\"ChatAnthropic\"\n",
-    ")\n",
-    "lc_result[\"choices\"][0][\"message\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cb3f181d",
-   "metadata": {},
-   "source": [
-    "## ChatCompletion.stream"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f7b8cd18",
-   "metadata": {},
-   "source": [
-    "Original OpenAI call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "fd8cb1ea",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'role': 'assistant', 'content': ''}\n",
-      "{'content': 'Hello'}\n",
-      "{'content': '!'}\n",
-      "{'content': ' How'}\n",
-      "{'content': ' can'}\n",
-      "{'content': ' I'}\n",
-      "{'content': ' assist'}\n",
-      "{'content': ' you'}\n",
-      "{'content': ' today'}\n",
-      "{'content': '?'}\n",
-      "{}\n"
-     ]
-    }
-   ],
-   "source": [
-    "for c in openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
-    "):\n",
-    "    print(c[\"choices\"][0][\"delta\"].to_dict_recursive())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0b2a076b",
-   "metadata": {},
-   "source": [
-    "LangChain OpenAI wrapper call"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "id": "9521218c",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'role': 'assistant', 'content': ''}\n",
-      "{'content': 'Hello'}\n",
-      "{'content': '!'}\n",
-      "{'content': ' How'}\n",
-      "{'content': ' can'}\n",
-      "{'content': ' I'}\n",
-      "{'content': ' assist'}\n",
-      "{'content': ' you'}\n",
-      "{'content': ' today'}\n",
-      "{'content': '?'}\n",
-      "{}\n"
-     ]
-    }
-   ],
-   "source": [
-    "for c in lc_openai.ChatCompletion.create(\n",
-    "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
-    "):\n",
-    "    print(c[\"choices\"][0][\"delta\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0fc39750",
-   "metadata": {},
-   "source": [
-    "Swapping out model providers"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "68f0214e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'role': 'assistant', 'content': ' Hello'}\n",
-      "{'content': '!'}\n",
-      "{}\n"
-     ]
-    }
-   ],
-   "source": [
-    "for c in lc_openai.ChatCompletion.create(\n",
-    "    messages=messages,\n",
-    "    model=\"claude-2\",\n",
-    "    temperature=0,\n",
-    "    stream=True,\n",
-    "    provider=\"ChatAnthropic\",\n",
-    "):\n",
-    "    print(c[\"choices\"][0][\"delta\"])"
-   ]
-  }
- ],
- "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.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/integrations/adapters/openai.ipynb

@@ -7,8 +7,6 @@
    "source": [
     "# OpenAI Adapter\n",
     "\n",
-    "**Please ensure OpenAI library is version 1.0.0 or higher; otherwise, refer to the older doc [OpenAI Adapter(Old)](./openai-old).**\n",
-    "\n",
     "A lot of people get started with OpenAI but want to explore other models. LangChain's integrations with many model providers make this easy to do so. While LangChain has it's own message and model APIs, we've also made it as easy as possible to explore other models by exposing an adapter to adapt LangChain models to the OpenAI api.\n",
     "\n",
     "At the moment this only deals with output and does not return other information (token counts, stop reasons, etc)."
@@ -30,12 +28,12 @@
    "id": "b522ceda",
    "metadata": {},
    "source": [
-    "## chat.completions.create"
+    "## ChatCompletion.create"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 29,
    "id": "1d22eb61",
    "metadata": {},
    "outputs": [],
@@ -53,29 +51,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 15,
    "id": "012d81ae",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'content': 'Hello! How can I assist you today?',\n",
-       " 'role': 'assistant',\n",
-       " 'function_call': None,\n",
-       " 'tool_calls': None}"
+       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "result = openai.chat.completions.create(\n",
+    "result = openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
     ")\n",
-    "result.choices[0].message.model_dump()"
+    "result[\"choices\"][0][\"message\"].to_dict_recursive()"
    ]
   },
   {
@@ -88,48 +83,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 17,
    "id": "c67a5ac8",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I help you today?'}"
+       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "lc_result = lc_openai.chat.completions.create(\n",
+    "lc_result = lc_openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0\n",
     ")\n",
-    "\n",
-    "lc_result.choices[0].message  # Attribute access"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "37a6e461-8608-47f6-ac45-12ad753c062a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I help you today?'}"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "lc_result[\"choices\"][0][\"message\"]  # Also compatible with index access"
+    "lc_result[\"choices\"][0][\"message\"]"
    ]
   },
   {
@@ -142,26 +115,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 19,
    "id": "f7c94827",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'role': 'assistant', 'content': 'Hello! How can I assist you today?'}"
+       "{'role': 'assistant', 'content': ' Hello!'}"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "lc_result = lc_openai.chat.completions.create(\n",
+    "lc_result = lc_openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"claude-2\", temperature=0, provider=\"ChatAnthropic\"\n",
     ")\n",
-    "lc_result.choices[0].message"
+    "lc_result[\"choices\"][0][\"message\"]"
    ]
   },
   {
@@ -169,7 +142,7 @@
    "id": "cb3f181d",
    "metadata": {},
    "source": [
-    "## chat.completions.stream"
+    "## ChatCompletion.stream"
    ]
   },
   {
@@ -182,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 24,
    "id": "fd8cb1ea",
    "metadata": {},
    "outputs": [
@@ -190,25 +163,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'content': '', 'function_call': None, 'role': 'assistant', 'tool_calls': None}\n",
-      "{'content': 'Hello', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': '!', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' How', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' can', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' I', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' assist', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' you', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': ' today', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': '?', 'function_call': None, 'role': None, 'tool_calls': None}\n",
-      "{'content': None, 'function_call': None, 'role': None, 'tool_calls': None}\n"
+      "{'role': 'assistant', 'content': ''}\n",
+      "{'content': 'Hello'}\n",
+      "{'content': '!'}\n",
+      "{'content': ' How'}\n",
+      "{'content': ' can'}\n",
+      "{'content': ' I'}\n",
+      "{'content': ' assist'}\n",
+      "{'content': ' you'}\n",
+      "{'content': ' today'}\n",
+      "{'content': '?'}\n",
+      "{}\n"
      ]
     }
    ],
    "source": [
-    "for c in openai.chat.completions.create(\n",
+    "for c in openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
     "):\n",
-    "    print(c.choices[0].delta.model_dump())"
+    "    print(c[\"choices\"][0][\"delta\"].to_dict_recursive())"
    ]
   },
   {
@@ -221,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 30,
    "id": "9521218c",
    "metadata": {},
    "outputs": [
@@ -244,10 +217,10 @@
     }
    ],
    "source": [
-    "for c in lc_openai.chat.completions.create(\n",
+    "for c in lc_openai.ChatCompletion.create(\n",
     "    messages=messages, model=\"gpt-3.5-turbo\", temperature=0, stream=True\n",
     "):\n",
-    "    print(c.choices[0].delta)"
+    "    print(c[\"choices\"][0][\"delta\"])"
    ]
   },
   {
@@ -260,7 +233,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 31,
    "id": "68f0214e",
    "metadata": {},
    "outputs": [
@@ -268,22 +241,14 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'role': 'assistant', 'content': ''}\n",
-      "{'content': 'Hello'}\n",
+      "{'role': 'assistant', 'content': ' Hello'}\n",
       "{'content': '!'}\n",
-      "{'content': ' How'}\n",
-      "{'content': ' can'}\n",
-      "{'content': ' I'}\n",
-      "{'content': ' assist'}\n",
-      "{'content': ' you'}\n",
-      "{'content': ' today'}\n",
-      "{'content': '?'}\n",
       "{}\n"
      ]
     }
    ],
    "source": [
-    "for c in lc_openai.chat.completions.create(\n",
+    "for c in lc_openai.ChatCompletion.create(\n",
     "    messages=messages,\n",
     "    model=\"claude-2\",\n",
     "    temperature=0,\n",
@@ -310,7 +275,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

docs/docs/integrations/callbacks/argilla.ipynb

@@ -7,6 +7,8 @@
    "source": [
     "# Argilla\n",
     "\n",
+    "![Argilla - Open-source data platform for LLMs](https://argilla.io/og.png)\n",
+    "\n",
     ">[Argilla](https://argilla.io/) is an open-source data curation platform for LLMs.\n",
     "> Using Argilla, everyone can build robust language models through faster data curation \n",
     "> using both human and machine feedback. We provide support for each step in the MLOps cycle, \n",
@@ -408,7 +410,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.3"
   },
   "vscode": {
    "interpreter": {

docs/docs/integrations/callbacks/context.ipynb

@@ -7,9 +7,12 @@
    "source": [
     "# Context\n",
     "\n",
-    ">[Context](https://context.ai/) provides user analytics for LLM-powered products and features.\n",
+    "![Context - User Analytics for LLM Powered Products](https://with.context.ai/langchain.png)\n",
     "\n",
-    "With `Context`, you can start understanding your users and improving their experiences in less than 30 minutes.\n"
+    "[Context](https://context.ai/) provides user analytics for LLM powered products and features.\n",
+    "\n",
+    "With Context, you can start understanding your users and improving their experiences in less than 30 minutes.\n",
+    "\n"
    ]
   },
   {
@@ -86,9 +89,11 @@
    "metadata": {},
    "source": [
     "## Usage\n",
-    "### Context callback within a chat model\n",
+    "### Using the Context callback within a chat model\n",
     "\n",
-    "The Context callback handler can be used to directly record transcripts between users and AI assistants."
+    "The Context callback handler can be used to directly record transcripts between users and AI assistants.\n",
+    "\n",
+    "#### Example"
    ]
   },
   {
@@ -127,7 +132,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Context callback within Chains\n",
+    "### Using the Context callback within Chains\n",
     "\n",
     "The Context callback handler can also be used to record the inputs and outputs of chains. Note that intermediate steps of the chain are not recorded - only the starting inputs and final outputs.\n",
     "\n",
@@ -144,7 +149,9 @@
     ">handler = ContextCallbackHandler(token)\n",
     ">chat = ChatOpenAI(temperature=0.9, callbacks=[callback])\n",
     ">chain = LLMChain(llm=chat, prompt=chat_prompt_template, callbacks=[callback])\n",
-    ">```\n"
+    ">```\n",
+    "\n",
+    "#### Example"
    ]
   },
   {
@@ -196,7 +203,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.1"
   },
   "vscode": {
    "interpreter": {

docs/docs/integrations/callbacks/infino.ipynb

@@ -7,14 +7,12 @@
    "source": [
     "# Infino\n",
     "\n",
-    ">[Infino](https://github.com/infinohq/infino) is a scalable telemetry store designed for logs, metrics, and traces. Infino can function as a standalone observability solution or as the storage layer in your observability stack.\n",
-    "\n",
     "This example shows how one can track the following while calling OpenAI and ChatOpenAI models via `LangChain` and [Infino](https://github.com/infinohq/infino):\n",
     "\n",
-    "* prompt input\n",
-    "* response from `ChatGPT` or any other `LangChain` model\n",
-    "* latency\n",
-    "* errors\n",
+    "* prompt input,\n",
+    "* response from `ChatGPT` or any other `LangChain` model,\n",
+    "* latency,\n",
+    "* errors,\n",
     "* number of tokens consumed"
    ]
   },
@@ -456,7 +454,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,

docs/docs/integrations/callbacks/labelstudio.ipynb

@@ -4,9 +4,6 @@
    "cell_type": "markdown",
    "metadata": {
     "collapsed": true,
-    "jupyter": {
-     "outputs_hidden": true
-    },
     "pycharm": {
      "name": "#%% md\n"
     }
@@ -14,14 +11,17 @@
    "source": [
     "# Label Studio\n",
     "\n",
+    "<div>\n",
+    "<img src=\"https://labelstudio-pub.s3.amazonaws.com/lc/open-source-data-labeling-platform.png\" width=\"400\"/>\n",
+    "</div>\n",
     "\n",
-    ">[Label Studio](https://labelstud.io/guide/get_started) is an open-source data labeling platform that provides LangChain with flexibility when it comes to labeling data for fine-tuning large language models (LLMs). It also enables the preparation of custom training data and the collection and evaluation of responses through human feedback.\n",
+    "Label Studio is an open-source data labeling platform that provides LangChain with flexibility when it comes to labeling data for fine-tuning large language models (LLMs). It also enables the preparation of custom training data and the collection and evaluation of responses through human feedback.\n",
     "\n",
-    "In this guide, you will learn how to connect a LangChain pipeline to `Label Studio` to:\n",
+    "In this guide, you will learn how to connect a LangChain pipeline to Label Studio to:\n",
     "\n",
-    "- Aggregate all input prompts, conversations, and responses in a single `Label Studio` project. This consolidates all the data in one place for easier labeling and analysis.\n",
+    "- Aggregate all input prompts, conversations, and responses in a single LabelStudio project. This consolidates all the data in one place for easier labeling and analysis.\n",
     "- Refine prompts and responses to create a dataset for supervised fine-tuning (SFT) and reinforcement learning with human feedback (RLHF) scenarios. The labeled data can be used to further train the LLM to improve its performance.\n",
-    "- Evaluate model responses through human feedback. `Label Studio` provides an interface for humans to review and provide feedback on model responses, allowing evaluation and iteration."
+    "- Evaluate model responses through human feedback. LabelStudio provides an interface for humans to review and provide feedback on model responses, allowing evaluation and iteration."
    ]
   },
   {
@@ -362,9 +362,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "labelops",
    "language": "python",
-   "name": "python3"
+   "name": "labelops"
   },
   "language_info": {
    "codemirror_mode": {
@@ -376,9 +376,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 1
 }

docs/docs/integrations/callbacks/llmonitor.md

@@ -1,6 +1,6 @@
 # LLMonitor
 
->[LLMonitor](https://llmonitor.com?utm_source=langchain&utm_medium=py&utm_campaign=docs) is an open-source observability platform that provides cost and usage analytics, user tracking, tracing and evaluation tools.
+[LLMonitor](https://llmonitor.com?utm_source=langchain&utm_medium=py&utm_campaign=docs) is an open-source observability platform that provides cost and usage analytics, user tracking, tracing and evaluation tools.
 
 <video controls width='100%' >
   <source src='https://llmonitor.com/videos/demo-annotated.mp4'/>

docs/docs/integrations/callbacks/promptlayer.ipynb

@@ -7,13 +7,13 @@
    "source": [
     "# PromptLayer\n",
     "\n",
-    ">[PromptLayer](https://docs.promptlayer.com/introduction) is a platform for prompt engineering. It also helps with the LLM observability to visualize requests, version prompts, and track usage.\n",
-    ">\n",
-    ">While `PromptLayer` does have LLMs that integrate directly with LangChain (e.g. [`PromptLayerOpenAI`](https://python.langchain.com/docs/integrations/llms/promptlayer_openai)), using a callback is the recommended way to integrate `PromptLayer` with LangChain.\n",
+    "![PromptLayer](https://promptlayer.com/text_logo.png)\n",
     "\n",
-    "In this guide, we will go over how to setup the `PromptLayerCallbackHandler`. \n",
+    "[PromptLayer](https://promptlayer.com) is a an LLM observability platform that lets you visualize requests, version prompts, and track usage. In this guide we will go over how to setup the `PromptLayerCallbackHandler`. \n",
     "\n",
-    "See [PromptLayer docs](https://docs.promptlayer.com/languages/langchain) for more information."
+    "While PromptLayer does have LLMs that integrate directly with LangChain (e.g. [`PromptLayerOpenAI`](https://python.langchain.com/docs/integrations/llms/promptlayer_openai)), this callback is the recommended way to integrate PromptLayer with LangChain.\n",
+    "\n",
+    "See [our docs](https://docs.promptlayer.com/languages/langchain) for more information."
    ]
   },
   {
@@ -51,7 +51,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Usage\n",
+    "### Usage\n",
     "\n",
     "Getting started with `PromptLayerCallbackHandler` is fairly simple, it takes two optional arguments:\n",
     "1. `pl_tags` - an optional list of strings that will be tracked as tags on PromptLayer.\n",
@@ -63,7 +63,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Simple OpenAI Example\n",
+    "### Simple OpenAI Example\n",
     "\n",
     "In this simple example we use `PromptLayerCallbackHandler` with `ChatOpenAI`. We add a PromptLayer tag named `chatopenai`"
    ]
@@ -99,7 +99,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## GPT4All Example"
+    "### GPT4All Example"
    ]
   },
   {
@@ -125,9 +125,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Full Featured Example\n",
+    "### Full Featured Example\n",
     "\n",
-    "In this example, we unlock more of the power of `PromptLayer`.\n",
+    "In this example we unlock more of the power of PromptLayer.\n",
     "\n",
     "PromptLayer allows you to visually create, version, and track prompt templates. Using the [Prompt Registry](https://docs.promptlayer.com/features/prompt-registry), we can programmatically fetch the prompt template called `example`.\n",
     "\n",
@@ -182,7 +182,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "base",
    "language": "python",
    "name": "python3"
   },
@@ -196,7 +196,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.8.8 (default, Apr 13 2021, 12:59:45) \n[Clang 10.0.0 ]"
   },
   "vscode": {
    "interpreter": {

docs/docs/integrations/callbacks/sagemaker_tracking.ipynb

@@ -7,16 +7,14 @@
    "source": [
     "# SageMaker Tracking\n",
     "\n",
-    ">[Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a fully managed service that is used to quickly and easily build, train and deploy machine learning (ML) models. \n",
-    "\n",
-    ">[Amazon SageMaker Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments.html) is a capability of `Amazon SageMaker` that lets you organize, track, compare and evaluate ML experiments and model versions.\n",
-    "\n",
-    "This notebook shows how LangChain Callback can be used to log and track prompts and other LLM hyperparameters into `SageMaker Experiments`. Here, we use different scenarios to showcase the capability:\n",
-    "\n",
+    "This notebook shows how LangChain Callback can be used to log and track prompts and other LLM hyperparameters into SageMaker Experiments. Here, we use different scenarios to showcase the capability:\n",
     "* **Scenario 1**: *Single LLM* - A case where a single LLM model is used to generate output based on a given prompt.\n",
     "* **Scenario 2**: *Sequential Chain* - A case where a sequential chain of two LLM models is used.\n",
     "* **Scenario 3**: *Agent with Tools (Chain of Thought)* - A case where multiple tools (search and math) are used in addition to an LLM.\n",
     "\n",
+    "[Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a fully managed service that is used to quickly and easily build, train and deploy machine learning (ML) models. \n",
+    "\n",
+    "[Amazon SageMaker Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments.html) is a capability of Amazon SageMaker that lets you organize, track, compare and evaluate ML experiments and model versions.\n",
     "\n",
     "In this notebook, we will create a single experiment to log the prompts from each scenario."
    ]
@@ -51,7 +49,6 @@
    },
    "source": [
     "First, setup the required API keys\n",
-    "\n",
     "* OpenAI: https://platform.openai.com/account/api-keys (For OpenAI LLM model)\n",
     "* Google SERP API: https://serpapi.com/manage-api-key (For Google Search Tool)"
    ]
@@ -902,9 +899,9 @@
   ],
   "instance_type": "ml.t3.large",
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "conda_pytorch_p310",
    "language": "python",
-   "name": "python3"
+   "name": "conda_pytorch_p310"
   },
   "language_info": {
    "codemirror_mode": {
@@ -916,7 +913,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.10"
   }
  },
  "nbformat": 4,

docs/docs/integrations/callbacks/trubrics.ipynb

@@ -9,13 +9,12 @@
    "source": [
     "# Trubrics\n",
     "\n",
+    "![Trubrics](https://miro.medium.com/v2/resize:fit:720/format:webp/1*AhYbKO-v8F4u3hx2aDIqKg.png)\n",
     "\n",
-    ">[Trubrics](https://trubrics.com) is an LLM user analytics platform that lets you collect, analyse and manage user\n",
-    "prompts & feedback on AI models.\n",
-    ">\n",
-    ">Check out [Trubrics repo](https://github.com/trubrics/trubrics-sdk) for more information on `Trubrics`.\n",
+    "[Trubrics](https://trubrics.com) is an LLM user analytics platform that lets you collect, analyse and manage user\n",
+    "prompts & feedback on AI models. In this guide we will go over how to setup the `TrubricsCallbackHandler`. \n",
     "\n",
-    "In this guide, we will go over how to set up the `TrubricsCallbackHandler`. \n"
+    "Check out [our repo](https://github.com/trubrics/trubrics-sdk) for more information on Trubrics."
    ]
   },
   {
@@ -348,9 +347,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "langchain",
    "language": "python",
-   "name": "python3"
+   "name": "langchain"
   },
   "language_info": {
    "codemirror_mode": {
@@ -362,7 +361,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/anthropic.ipynb

@@ -1,21 +1,11 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "a016701c",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Anthropic\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "bf733a38-db84-4363-89e2-de6735c37230",
    "metadata": {},
    "source": [
-    "# ChatAnthropic\n",
+    "# Anthropic\n",
     "\n",
     "This notebook covers how to get started with Anthropic chat models."
    ]

docs/docs/integrations/chat/anyscale.ipynb

@@ -1,22 +1,12 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "31895fc4",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Anyscale\n",
-    "---"
-   ]
-  },
   {
    "attachments": {},
    "cell_type": "markdown",
    "id": "642fd21c-600a-47a1-be96-6e1438b421a9",
    "metadata": {},
    "source": [
-    "# ChatAnyscale\n",
+    "# Anyscale\n",
     "\n",
     "This notebook demonstrates the use of `langchain.chat_models.ChatAnyscale` for [Anyscale Endpoints](https://endpoints.anyscale.com/).\n",
     "\n",
@@ -43,7 +33,7 @@
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stdin",
      "output_type": "stream",
      "text": [
       " ········\n"

docs/docs/integrations/chat/azure_chat_openai.ipynb

@@ -1,21 +1,11 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "641f8cb0",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Azure OpenAI\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "38f26d7a",
    "metadata": {},
    "source": [
-    "# AzureChatOpenAI\n",
+    "# Azure OpenAI\n",
     "\n",
     ">[Azure OpenAI Service](https://learn.microsoft.com/en-us/azure/ai-services/openai/overview) provides REST API access to OpenAI's powerful language models including the GPT-4, GPT-3.5-Turbo, and Embeddings model series. These models can be easily adapted to your specific task including but not limited to content generation, summarization, semantic search, and natural language to code translation. Users can access the service through REST APIs, Python SDK, or a web-based interface in the Azure OpenAI Studio.\n",
     "\n",

docs/docs/integrations/chat/azureml_chat_endpoint.ipynb

@@ -1,19 +1,10 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Azure ML Endpoint\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# AzureMLChatOnlineEndpoint\n",
+    "# Azure ML Endpoint\n",
     "\n",
     ">[Azure Machine Learning](https://azure.microsoft.com/en-us/products/machine-learning/) is a platform used to build, train, and deploy machine learning models. Users can explore the types of models to deploy in the Model Catalog, which provides Azure Foundation Models and OpenAI Models. `Azure Foundation Models` include various open-source models and popular Hugging Face models. Users can also import models of their liking into AzureML.\n",
     ">\n",

docs/docs/integrations/chat/baichuan.ipynb

@@ -1,19 +1,10 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Baichuan Chat\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# ChatBaichuan\n",
+    "# Baichuan Chat\n",
     "\n",
     "Baichuan chat models API by Baichuan Intelligent Technology. For more information, see [https://platform.baichuan-ai.com/docs/api](https://platform.baichuan-ai.com/docs/api)"
    ]
@@ -72,9 +63,7 @@
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "AIMessage(content='首先，我们需要确定闰年的二月有多少天。闰年的二月有29天。\\n\\n然后，我们可以计算你的月薪：\\n\\n日薪 = 月薪 / (当月天数)\\n\\n所以，你的月薪 = 日薪 * 当月天数\\n\\n将数值代入公式：\\n\\n月薪 = 8元/天 * 29天 = 232元\\n\\n因此，你在闰年的二月的月薪是232元。')"
-      ]
+      "text/plain": "AIMessage(content='首先，我们需要确定闰年的二月有多少天。闰年的二月有29天。\\n\\n然后，我们可以计算你的月薪：\\n\\n日薪 = 月薪 / (当月天数)\\n\\n所以，你的月薪 = 日薪 * 当月天数\\n\\n将数值代入公式：\\n\\n月薪 = 8元/天 * 29天 = 232元\\n\\n因此，你在闰年的二月的月薪是232元。')"
      },
      "execution_count": 3,
      "metadata": {},
@@ -87,23 +76,16 @@
   },
   {
    "cell_type": "markdown",
-   "metadata": {
-    "collapsed": false
-   },
    "source": [
     "## For ChatBaichuan with Streaming"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false
+   }
   },
   {
    "cell_type": "code",
    "execution_count": 5,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-10-17T15:14:25.870044Z",
-     "start_time": "2023-10-17T15:14:25.863381Z"
-    },
-    "collapsed": false
-   },
    "outputs": [],
    "source": [
     "chat = ChatBaichuan(\n",
@@ -111,24 +93,22 @@
     "    baichuan_secret_key=\"YOUR_SECRET_KEY\",\n",
     "    streaming=True,\n",
     ")"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-10-17T15:14:25.870044Z",
+     "start_time": "2023-10-17T15:14:25.863381Z"
+    }
+   }
   },
   {
    "cell_type": "code",
    "execution_count": 6,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2023-10-17T15:14:27.153546Z",
-     "start_time": "2023-10-17T15:14:25.868470Z"
-    },
-    "collapsed": false
-   },
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "AIMessageChunk(content='首先，我们需要确定闰年的二月有多少天。闰年的二月有29天。\\n\\n然后，我们可以计算你的月薪：\\n\\n日薪 = 月薪 / (当月天数)\\n\\n所以，你的月薪 = 日薪 * 当月天数\\n\\n将数值代入公式：\\n\\n月薪 = 8元/天 * 29天 = 232元\\n\\n因此，你在闰年的二月的月薪是232元。')"
-      ]
+      "text/plain": "AIMessageChunk(content='首先，我们需要确定闰年的二月有多少天。闰年的二月有29天。\\n\\n然后，我们可以计算你的月薪：\\n\\n日薪 = 月薪 / (当月天数)\\n\\n所以，你的月薪 = 日薪 * 当月天数\\n\\n将数值代入公式：\\n\\n月薪 = 8元/天 * 29天 = 232元\\n\\n因此，你在闰年的二月的月薪是232元。')"
      },
      "execution_count": 6,
      "metadata": {},
@@ -137,7 +117,14 @@
    ],
    "source": [
     "chat([HumanMessage(content=\"我日薪8块钱，请问在闰年的二月，我月薪多少\")])"
-   ]
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2023-10-17T15:14:27.153546Z",
+     "start_time": "2023-10-17T15:14:25.868470Z"
+    }
+   }
   }
  ],
  "metadata": {

docs/docs/integrations/chat/baidu_qianfan_endpoint.ipynb

@@ -1,20 +1,11 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Baidu Qianfan\n",
-    "---"
-   ]
-  },
   {
    "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# QianfanChatEndpoint\n",
+    "# Baidu Qianfan\n",
     "\n",
     "Baidu AI Cloud Qianfan Platform is a one-stop large model development and service operation platform for enterprise developers. Qianfan not only provides including the model of Wenxin Yiyan (ERNIE-Bot) and the third-party open-source models, but also provides various AI development tools and the whole set of development environment, which facilitates customers to use and develop large model applications easily.\n",
     "\n",
@@ -71,7 +62,7 @@
     "import os\n",
     "\n",
     "from langchain.chat_models import QianfanChatEndpoint\n",
-    "from langchain_core.language_models.chat_models import HumanMessage\n",
+    "from langchain.chat_models.base import HumanMessage\n",
     "\n",
     "os.environ[\"QIANFAN_AK\"] = \"your_ak\"\n",
     "os.environ[\"QIANFAN_SK\"] = \"your_sk\"\n",

docs/docs/integrations/chat/bedrock.ipynb

@@ -1,31 +1,13 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "fbc66410",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Bedrock Chat\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "bf733a38-db84-4363-89e2-de6735c37230",
    "metadata": {},
    "source": [
-    "# BedrockChat\n",
+    "# Bedrock Chat\n",
     "\n",
-    ">[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of \n",
-    "> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, \n",
-    "> `Meta`, `Stability AI`, and `Amazon` via a single API, along with a broad set of capabilities you need to \n",
-    "> build generative AI applications with security, privacy, and responsible AI. Using `Amazon Bedrock`, \n",
-    "> you can easily experiment with and evaluate top FMs for your use case, privately customize them with \n",
-    "> your data using techniques such as fine-tuning and `Retrieval Augmented Generation` (`RAG`), and build \n",
-    "> agents that execute tasks using your enterprise systems and data sources. Since `Amazon Bedrock` is \n",
-    "> serverless, you don't have to manage any infrastructure, and you can securely integrate and deploy \n",
-    "> generative AI capabilities into your applications using the AWS services you are already familiar with.\n"
+    "[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that makes FMs from leading AI startups and Amazon available via an API, so you can choose from a wide range of FMs to find the model that is best suited for your use case"
    ]
   },
   {
@@ -149,7 +131,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/cohere.ipynb

@@ -1,21 +1,11 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "53fbf15f",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Cohere\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "bf733a38-db84-4363-89e2-de6735c37230",
    "metadata": {},
    "source": [
-    "# ChatCohere\n",
+    "# Cohere\n",
     "\n",
     "This notebook covers how to get started with Cohere chat models."
    ]

docs/docs/integrations/chat/ernie.ipynb

@@ -1,19 +1,10 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: Ernie Bot Chat\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# ErnieBotChat\n",
+    "# ERNIE-Bot Chat\n",
     "\n",
     "[ERNIE-Bot](https://cloud.baidu.com/doc/WENXINWORKSHOP/s/jlil56u11) is a large language model developed by Baidu, covering a huge amount of Chinese data.\n",
     "This notebook covers how to get started with ErnieBot chat models.\n",

docs/docs/integrations/chat/everlyai.ipynb

@@ -1,21 +1,11 @@
 {
  "cells": [
-  {
-   "cell_type": "raw",
-   "id": "5e45f35c",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_label: EverlyAI\n",
-    "---"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "642fd21c-600a-47a1-be96-6e1438b421a9",
    "metadata": {},
    "source": [
-    "# ChatEverlyAI\n",
+    "# EverlyAI\n",
     "\n",
     ">[EverlyAI](https://everlyai.xyz) allows you to run your ML models at scale in the cloud. It also provides API access to [several LLM models](https://everlyai.xyz).\n",
     "\n",